[Python-checkins] cpython (merge default -> default): Merge
guido.van.rossum
python-checkins at python.org
Sat Jun 23 00:18:52 CEST 2012
http://hg.python.org/cpython/rev/a55912db5941
changeset: 77593:a55912db5941
parent: 77592:2cbbc015d8a2
parent: 77591:574c45f26280
user: Guido van Rossum <guido at python.org>
date: Fri Jun 22 15:18:38 2012 -0700
summary:
Merge
files:
Doc/library/shutil.rst | 24 +
Doc/library/ssl.rst | 16 +
Doc/library/sys.rst | 16 +
Doc/library/time.rst | 2 +-
Include/dictobject.h | 1 +
Include/floatobject.h | 2 +
Include/frameobject.h | 2 +
Include/listobject.h | 1 +
Include/methodobject.h | 5 +
Include/object.h | 8 +
Include/objimpl.h | 4 +-
Include/setobject.h | 1 +
Include/tupleobject.h | 3 +
Lib/datetime.py | 6 +-
Lib/shutil.py | 49 +-
Lib/test/datetimetester.py | 6 +-
Lib/test/test_capi.py | 38 +-
Lib/test/test_reprlib.py | 4 +-
Lib/test/test_shutil.py | 55 +-
Lib/test/test_ssl.py | 45 +-
Lib/test/test_sys.py | 6 +
Misc/NEWS | 11 +
Modules/_datetimemodule.c | 41 +-
Modules/_ssl.c | 262 ++-
Modules/_ssl_data.h | 1653 ++++++++++++++++++++++++
Modules/_threadmodule.c | 38 +-
Objects/classobject.c | 9 +
Objects/dictobject.c | 9 +
Objects/floatobject.c | 10 +
Objects/frameobject.c | 10 +
Objects/listobject.c | 9 +
Objects/methodobject.c | 9 +
Objects/object.c | 12 +
Objects/obmalloc.c | 81 +-
Objects/setobject.c | 10 +
Objects/tupleobject.c | 16 +
PCbuild/debug.props | 3 +
Python/pythonrun.c | 2 +-
Python/sysmodule.c | 23 +
Tools/scripts/diff.py | 16 +-
Tools/ssl/make_ssl_data.py | 68 +
41 files changed, 2413 insertions(+), 173 deletions(-)
diff --git a/Doc/library/shutil.rst b/Doc/library/shutil.rst
--- a/Doc/library/shutil.rst
+++ b/Doc/library/shutil.rst
@@ -247,6 +247,30 @@
.. versionadded:: 3.3
+.. function:: which(cmd, mode=os.F_OK | os.X_OK, path=None)
+
+ Return the path to an executable which would be run if the given *cmd*
+ was called. If no *cmd* would be called, return ``None``.
+
+ *mode* is a permission mask passed a to :func:`os.access`, by default
+ determining if the file exists and executable.
+
+ When no *path* is specified, the results of :func:`os.environ` are
+ used, returning either the "PATH" value or a fallback of :attr:`os.defpath`.
+
+ On Windows, the current directory is always prepended to the *path*
+ whether or not you use the default or provide your own, which
+ is the behavior the command shell uses when finding executables.
+ Additionaly, when finding the *cmd* in the *path*, the
+ ``PATHEXT`` environment variable is checked. For example, if you
+ call ``shutil.which("python")``, :func:`which` will search
+ ``PATHEXT`` to know that it should look for ``python.exe`` within
+ the *path* directories.
+
+ >>> print(shutil.which("python"))
+ 'c:\\python33\\python.exe'
+
+ .. versionadded:: 3.3
.. exception:: Error
diff --git a/Doc/library/ssl.rst b/Doc/library/ssl.rst
--- a/Doc/library/ssl.rst
+++ b/Doc/library/ssl.rst
@@ -59,6 +59,22 @@
.. versionchanged:: 3.3
:exc:`SSLError` used to be a subtype of :exc:`socket.error`.
+ .. attribute:: library
+
+ A string mnemonic designating the OpenSSL submodule in which the error
+ occurred, such as ``SSL``, ``PEM`` or ``X509``. The range of possible
+ values depends on the OpenSSL version.
+
+ .. versionadded:: 3.3
+
+ .. attribute:: reason
+
+ A string mnemonic designating the reason this error occurred, for
+ example ``CERTIFICATE_VERIFY_FAILED``. The range of possible
+ values depends on the OpenSSL version.
+
+ .. versionadded:: 3.3
+
.. exception:: SSLZeroReturnError
A subclass of :exc:`SSLError` raised when trying to read or write and
diff --git a/Doc/library/sys.rst b/Doc/library/sys.rst
--- a/Doc/library/sys.rst
+++ b/Doc/library/sys.rst
@@ -106,6 +106,22 @@
This function should be used for internal and specialized purposes only.
+.. function:: _debugmallocstats()
+
+ Print low-level information to stderr about the state of CPython's memory
+ allocator.
+
+ If Python is configured --with-pydebug, it also performs some expensive
+ internal consistency checks.
+
+ .. versionadded:: 3.3
+
+ .. impl-detail::
+
+ This function is specific to CPython. The exact output format is not
+ defined here, and may change.
+
+
.. data:: dllhandle
Integer specifying the handle of the Python DLL. Availability: Windows.
diff --git a/Doc/library/time.rst b/Doc/library/time.rst
--- a/Doc/library/time.rst
+++ b/Doc/library/time.rst
@@ -545,7 +545,7 @@
+-------+-------------------+---------------------------------+
| N/A | :attr:`tm_zone` | abbreviation of timezone name |
+-------+-------------------+---------------------------------+
- | N/A | :attr:`tm_gmtoff` | offset from UTC in seconds |
+ | N/A | :attr:`tm_gmtoff` | offset east of UTC in seconds |
+-------+-------------------+---------------------------------+
Note that unlike the C structure, the month value is a range of [1, 12], not
diff --git a/Include/dictobject.h b/Include/dictobject.h
--- a/Include/dictobject.h
+++ b/Include/dictobject.h
@@ -111,6 +111,7 @@
#ifndef Py_LIMITED_API
int _PyObjectDict_SetItem(PyTypeObject *tp, PyObject **dictptr, PyObject *name, PyObject *value);
PyObject *_PyDict_LoadGlobal(PyDictObject *, PyDictObject *, PyObject *);
+PyAPI_FUNC(void) _PyDict_DebugMallocStats(FILE *out);
#endif
#ifdef __cplusplus
diff --git a/Include/floatobject.h b/Include/floatobject.h
--- a/Include/floatobject.h
+++ b/Include/floatobject.h
@@ -110,6 +110,8 @@
/* free list api */
PyAPI_FUNC(int) PyFloat_ClearFreeList(void);
+PyAPI_FUNC(void) _PyFloat_DebugMallocStats(FILE* out);
+
/* Format the object based on the format_spec, as defined in PEP 3101
(Advanced String Formatting). */
PyAPI_FUNC(int) _PyFloat_FormatAdvancedWriter(
diff --git a/Include/frameobject.h b/Include/frameobject.h
--- a/Include/frameobject.h
+++ b/Include/frameobject.h
@@ -79,6 +79,8 @@
PyAPI_FUNC(int) PyFrame_ClearFreeList(void);
+PyAPI_FUNC(void) _PyFrame_DebugMallocStats(FILE *out);
+
/* Return the line of code the frame is currently executing. */
PyAPI_FUNC(int) PyFrame_GetLineNumber(PyFrameObject *);
diff --git a/Include/listobject.h b/Include/listobject.h
--- a/Include/listobject.h
+++ b/Include/listobject.h
@@ -64,6 +64,7 @@
PyAPI_FUNC(PyObject *) _PyList_Extend(PyListObject *, PyObject *);
PyAPI_FUNC(int) PyList_ClearFreeList(void);
+PyAPI_FUNC(void) _PyList_DebugMallocStats(FILE *out);
#endif
/* Macro, trading safety for speed */
diff --git a/Include/methodobject.h b/Include/methodobject.h
--- a/Include/methodobject.h
+++ b/Include/methodobject.h
@@ -82,6 +82,11 @@
PyAPI_FUNC(int) PyCFunction_ClearFreeList(void);
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(void) _PyCFunction_DebugMallocStats(FILE *out);
+PyAPI_FUNC(void) _PyMethod_DebugMallocStats(FILE *out);
+#endif
+
#ifdef __cplusplus
}
#endif
diff --git a/Include/object.h b/Include/object.h
--- a/Include/object.h
+++ b/Include/object.h
@@ -977,6 +977,14 @@
else \
_PyTrash_deposit_object((PyObject*)op);
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(void)
+_PyDebugAllocatorStats(FILE *out, const char *block_name, int num_blocks,
+ size_t sizeof_block);
+PyAPI_FUNC(void)
+_PyObject_DebugTypeStats(FILE *out);
+#endif /* ifndef Py_LIMITED_API */
+
#ifdef __cplusplus
}
#endif
diff --git a/Include/objimpl.h b/Include/objimpl.h
--- a/Include/objimpl.h
+++ b/Include/objimpl.h
@@ -101,13 +101,15 @@
/* Macros */
#ifdef WITH_PYMALLOC
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(void) _PyObject_DebugMallocStats(FILE *out);
+#endif /* #ifndef Py_LIMITED_API */
#ifdef PYMALLOC_DEBUG /* WITH_PYMALLOC && PYMALLOC_DEBUG */
PyAPI_FUNC(void *) _PyObject_DebugMalloc(size_t nbytes);
PyAPI_FUNC(void *) _PyObject_DebugRealloc(void *p, size_t nbytes);
PyAPI_FUNC(void) _PyObject_DebugFree(void *p);
PyAPI_FUNC(void) _PyObject_DebugDumpAddress(const void *p);
PyAPI_FUNC(void) _PyObject_DebugCheckAddress(const void *p);
-PyAPI_FUNC(void) _PyObject_DebugMallocStats(void);
PyAPI_FUNC(void *) _PyObject_DebugMallocApi(char api, size_t nbytes);
PyAPI_FUNC(void *) _PyObject_DebugReallocApi(char api, void *p, size_t nbytes);
PyAPI_FUNC(void) _PyObject_DebugFreeApi(char api, void *p);
diff --git a/Include/setobject.h b/Include/setobject.h
--- a/Include/setobject.h
+++ b/Include/setobject.h
@@ -101,6 +101,7 @@
PyAPI_FUNC(int) _PySet_Update(PyObject *set, PyObject *iterable);
PyAPI_FUNC(int) PySet_ClearFreeList(void);
+PyAPI_FUNC(void) _PySet_DebugMallocStats(FILE *out);
#endif
#ifdef __cplusplus
diff --git a/Include/tupleobject.h b/Include/tupleobject.h
--- a/Include/tupleobject.h
+++ b/Include/tupleobject.h
@@ -63,6 +63,9 @@
#endif
PyAPI_FUNC(int) PyTuple_ClearFreeList(void);
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(void) _PyTuple_DebugMallocStats(FILE *out);
+#endif /* Py_LIMITED_API */
#ifdef __cplusplus
}
diff --git a/Lib/datetime.py b/Lib/datetime.py
--- a/Lib/datetime.py
+++ b/Lib/datetime.py
@@ -1510,13 +1510,13 @@
# implied by tm_isdst.
delta = local - datetime(*_time.gmtime(ts)[:6])
dst = _time.daylight and localtm.tm_isdst > 0
- gmtoff = _time.altzone if dst else _time.timezone
- if delta == timedelta(seconds=-gmtoff):
+ gmtoff = -(_time.altzone if dst else _time.timezone)
+ if delta == timedelta(seconds=gmtoff):
tz = timezone(delta, _time.tzname[dst])
else:
tz = timezone(delta)
else:
- tz = timezone(timedelta(seconds=-gmtoff), zone)
+ tz = timezone(timedelta(seconds=gmtoff), zone)
elif not isinstance(tz, tzinfo):
raise TypeError("tz argument must be an instance of tzinfo")
diff --git a/Lib/shutil.py b/Lib/shutil.py
--- a/Lib/shutil.py
+++ b/Lib/shutil.py
@@ -36,7 +36,7 @@
"register_archive_format", "unregister_archive_format",
"get_unpack_formats", "register_unpack_format",
"unregister_unpack_format", "unpack_archive",
- "ignore_patterns", "chown"]
+ "ignore_patterns", "chown", "which"]
# disk_usage is added later, if available on the platform
class Error(EnvironmentError):
@@ -961,3 +961,50 @@
lines = size.lines
return os.terminal_size((columns, lines))
+
+def which(cmd, mode=os.F_OK | os.X_OK, path=None):
+ """Given a file, mode, and a path string, return the path whichs conform
+ to the given mode on the path."""
+ # Check that a given file can be accessed with the correct mode.
+ # Additionally check that `file` is not a directory, as on Windows
+ # directories pass the os.access check.
+ def _access_check(fn, mode):
+ if (os.path.exists(fn) and os.access(fn, mode)
+ and not os.path.isdir(fn)):
+ return True
+ return False
+
+ # Short circuit. If we're given a full path which matches the mode
+ # and it exists, we're done here.
+ if _access_check(cmd, mode):
+ return cmd
+
+ path = (path or os.environ.get("PATH", os.defpath)).split(os.pathsep)
+
+ if sys.platform == "win32":
+ # The current directory takes precedence on Windows.
+ if not os.curdir in path:
+ path.insert(0, os.curdir)
+
+ # PATHEXT is necessary to check on Windows.
+ pathext = os.environ.get("PATHEXT", "").split(os.pathsep)
+ # See if the given file matches any of the expected path extensions.
+ # This will allow us to short circuit when given "python.exe".
+ matches = [cmd for ext in pathext if cmd.lower().endswith(ext.lower())]
+ # If it does match, only test that one, otherwise we have to try others.
+ files = [cmd + ext.lower() for ext in pathext] if not matches else [cmd]
+ else:
+ # On other platforms you don't have things like PATHEXT to tell you
+ # what file suffixes are executable, so just pass on cmd as-is.
+ files = [cmd]
+
+ seen = set()
+ for dir in path:
+ dir = os.path.normcase(dir)
+ if not dir in seen:
+ seen.add(dir)
+ for thefile in files:
+ name = os.path.join(dir, thefile)
+ if _access_check(name, mode):
+ return name
+ return None
diff --git a/Lib/test/datetimetester.py b/Lib/test/datetimetester.py
--- a/Lib/test/datetimetester.py
+++ b/Lib/test/datetimetester.py
@@ -3278,16 +3278,18 @@
self.assertEqual(dt.astimezone(None), dt)
self.assertEqual(dt.astimezone(), dt)
+ # Note that offset in TZ variable has the opposite sign to that
+ # produced by %z directive.
@support.run_with_tz('EST+05EDT,M3.2.0,M11.1.0')
def test_astimezone_default_eastern(self):
dt = self.theclass(2012, 11, 4, 6, 30, tzinfo=timezone.utc)
local = dt.astimezone()
self.assertEqual(dt, local)
- self.assertEqual(local.strftime("%z %Z"), "+0500 EST")
+ self.assertEqual(local.strftime("%z %Z"), "-0500 EST")
dt = self.theclass(2012, 11, 4, 5, 30, tzinfo=timezone.utc)
local = dt.astimezone()
self.assertEqual(dt, local)
- self.assertEqual(local.strftime("%z %Z"), "+0400 EDT")
+ self.assertEqual(local.strftime("%z %Z"), "-0400 EDT")
def test_aware_subtract(self):
cls = self.theclass
diff --git a/Lib/test/test_capi.py b/Lib/test/test_capi.py
--- a/Lib/test/test_capi.py
+++ b/Lib/test/test_capi.py
@@ -222,36 +222,38 @@
in Python/getargs.c, but neglected to update our poor friend
skipitem() in the same file. (If so, shame on you!)
- This function brute-force tests all** ASCII characters (1 to 127
- inclusive) as format units, checking to see that
- PyArg_ParseTupleAndKeywords() return consistent errors both when
- the unit is attempted to be used and when it is skipped. If the
- format unit doesn't exist, we'll get one of two specific error
- messages (one for used, one for skipped); if it does exist we
- *won't* get that error--we'll get either no error or some other
- error. If we get the "does not exist" error for one test and
- not for the other, there's a mismatch, and the test fails.
+ With a few exceptions**, this function brute-force tests all
+ printable ASCII*** characters (32 to 126 inclusive) as format units,
+ checking to see that PyArg_ParseTupleAndKeywords() return consistent
+ errors both when the unit is attempted to be used and when it is
+ skipped. If the format unit doesn't exist, we'll get one of two
+ specific error messages (one for used, one for skipped); if it does
+ exist we *won't* get that error--we'll get either no error or some
+ other error. If we get the specific "does not exist" error for one
+ test and not for the other, there's a mismatch, and the test fails.
- ** Okay, it actually skips some ASCII characters. Some characters
- have special funny semantics, and it would be difficult to
- accomodate them here.
+ ** Some format units have special funny semantics and it would
+ be difficult to accomodate them here. Since these are all
+ well-established and properly skipped in skipitem() we can
+ get away with not testing them--this test is really intended
+ to catch *new* format units.
+
+ *** Python C source files must be ASCII. Therefore it's impossible
+ to have non-ASCII format units.
+
"""
empty_tuple = ()
tuple_1 = (0,)
dict_b = {'b':1}
keywords = ["a", "b"]
- # Python C source files must be ASCII,
- # therefore we'll never have a format unit > 127
- for i in range(1, 128):
+ for i in range(32, 127):
c = chr(i)
- # skip non-printable characters, no one is insane enough to define
- # one as a format unit
# skip parentheses, the error reporting is inconsistent about them
# skip 'e', it's always a two-character code
# skip '|' and '$', they don't represent arguments anyway
- if (not c.isprintable()) or (c in '()e|$'):
+ if c in '()e|$':
continue
# test the format unit when not skipped
diff --git a/Lib/test/test_reprlib.py b/Lib/test/test_reprlib.py
--- a/Lib/test/test_reprlib.py
+++ b/Lib/test/test_reprlib.py
@@ -10,7 +10,7 @@
import importlib
import unittest
-from test.support import run_unittest, create_empty_file
+from test.support import run_unittest, create_empty_file, verbose
from reprlib import repr as r # Don't shadow builtin repr
from reprlib import Repr
from reprlib import recursive_repr
@@ -248,6 +248,8 @@
# (see http://msdn.microsoft.com/en-us/library/windows/desktop/aa365247%28v=vs.85%29.aspx#maxpath)
self.skipTest("test paths too long (%d characters) for Windows' 260 character limit"
% cached_path_len)
+ elif os.name == 'nt' and verbose:
+ print("len(cached_path_len) =", len(cached_path_len))
def test_module(self):
self._check_path_limitations(self.pkgname)
diff --git a/Lib/test/test_shutil.py b/Lib/test/test_shutil.py
--- a/Lib/test/test_shutil.py
+++ b/Lib/test/test_shutil.py
@@ -1128,6 +1128,59 @@
self.assertEqual(['foo'], os.listdir(rv))
+class TestWhich(unittest.TestCase):
+
+ def setUp(self):
+ self.temp_dir = tempfile.mkdtemp()
+ # Give the temp_file an ".exe" suffix for all.
+ # It's needed on Windows and not harmful on other platforms.
+ self.temp_file = tempfile.NamedTemporaryFile(dir=self.temp_dir,
+ suffix=".exe")
+ os.chmod(self.temp_file.name, stat.S_IXUSR)
+ self.addCleanup(self.temp_file.close)
+ self.dir, self.file = os.path.split(self.temp_file.name)
+
+ def test_basic(self):
+ # Given an EXE in a directory, it should be returned.
+ rv = shutil.which(self.file, path=self.dir)
+ self.assertEqual(rv, self.temp_file.name)
+
+ def test_full_path_short_circuit(self):
+ # When given the fully qualified path to an executable that exists,
+ # it should be returned.
+ rv = shutil.which(self.temp_file.name, path=self.temp_dir)
+ self.assertEqual(self.temp_file.name, rv)
+
+ def test_non_matching_mode(self):
+ # Set the file read-only and ask for writeable files.
+ os.chmod(self.temp_file.name, stat.S_IREAD)
+ rv = shutil.which(self.file, path=self.dir, mode=os.W_OK)
+ self.assertIsNone(rv)
+
+ def test_relative(self):
+ old_cwd = os.getcwd()
+ base_dir, tail_dir = os.path.split(self.dir)
+ os.chdir(base_dir)
+ try:
+ rv = shutil.which(self.file, path=tail_dir)
+ self.assertEqual(rv, os.path.join(tail_dir, self.file))
+ finally:
+ os.chdir(old_cwd)
+
+ def test_nonexistent_file(self):
+ # Return None when no matching executable file is found on the path.
+ rv = shutil.which("foo.exe", path=self.dir)
+ self.assertIsNone(rv)
+
+ @unittest.skipUnless(sys.platform == "win32",
+ "pathext check is Windows-only")
+ def test_pathext_checking(self):
+ # Ask for the file without the ".exe" extension, then ensure that
+ # it gets found properly with the extension.
+ rv = shutil.which(self.temp_file.name[:-4], path=self.dir)
+ self.assertEqual(self.temp_file.name, rv)
+
+
class TestMove(unittest.TestCase):
def setUp(self):
@@ -1460,7 +1513,7 @@
def test_main():
support.run_unittest(TestShutil, TestMove, TestCopyFile,
- TermsizeTests)
+ TermsizeTests, TestWhich)
if __name__ == '__main__':
test_main()
diff --git a/Lib/test/test_ssl.py b/Lib/test/test_ssl.py
--- a/Lib/test/test_ssl.py
+++ b/Lib/test/test_ssl.py
@@ -552,7 +552,7 @@
with self.assertRaises(FileNotFoundError) as cm:
ctx.load_dh_params(WRONGCERT)
self.assertEqual(cm.exception.errno, errno.ENOENT)
- with self.assertRaisesRegex(ssl.SSLError, "PEM routines"):
+ with self.assertRaises(ssl.SSLError) as cm:
ctx.load_dh_params(CERTFILE)
@skip_if_broken_ubuntu_ssl
@@ -590,6 +590,47 @@
self.assertRaises(ValueError, ctx.set_ecdh_curve, b"foo")
+class SSLErrorTests(unittest.TestCase):
+
+ def test_str(self):
+ # The str() of a SSLError doesn't include the errno
+ e = ssl.SSLError(1, "foo")
+ self.assertEqual(str(e), "foo")
+ self.assertEqual(e.errno, 1)
+ # Same for a subclass
+ e = ssl.SSLZeroReturnError(1, "foo")
+ self.assertEqual(str(e), "foo")
+ self.assertEqual(e.errno, 1)
+
+ def test_lib_reason(self):
+ # Test the library and reason attributes
+ ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
+ with self.assertRaises(ssl.SSLError) as cm:
+ ctx.load_dh_params(CERTFILE)
+ self.assertEqual(cm.exception.library, 'PEM')
+ self.assertEqual(cm.exception.reason, 'NO_START_LINE')
+ s = str(cm.exception)
+ self.assertTrue(s.startswith("[PEM: NO_START_LINE] no start line"), s)
+
+ def test_subclass(self):
+ # Check that the appropriate SSLError subclass is raised
+ # (this only tests one of them)
+ ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
+ with socket.socket() as s:
+ s.bind(("127.0.0.1", 0))
+ s.listen(5)
+ with socket.socket() as c:
+ c.connect(s.getsockname())
+ c.setblocking(False)
+ c = ctx.wrap_socket(c, False, do_handshake_on_connect=False)
+ with self.assertRaises(ssl.SSLWantReadError) as cm:
+ c.do_handshake()
+ s = str(cm.exception)
+ self.assertTrue(s.startswith("The operation did not complete (read)"), s)
+ # For compatibility
+ self.assertEqual(cm.exception.errno, ssl.SSL_ERROR_WANT_READ)
+
+
class NetworkedTests(unittest.TestCase):
def test_connect(self):
@@ -1931,7 +1972,7 @@
if not os.path.exists(filename):
raise support.TestFailed("Can't read certificate file %r" % filename)
- tests = [ContextTests, BasicSocketTests]
+ tests = [ContextTests, BasicSocketTests, SSLErrorTests]
if support.is_resource_enabled('network'):
tests.append(NetworkedTests)
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -603,6 +603,12 @@
self.assertEqual(sys.implementation.name,
sys.implementation.name.lower())
+ def test_debugmallocstats(self):
+ # Test sys._debugmallocstats()
+ from test.script_helper import assert_python_ok
+ args = ['-c', 'import sys; sys._debugmallocstats()']
+ ret, out, err = assert_python_ok(*args)
+ self.assertIn(b"free PyDictObjects", err)
class SizeofTest(unittest.TestCase):
diff --git a/Misc/NEWS b/Misc/NEWS
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -42,6 +42,14 @@
- Issue: #15138: base64.urlsafe_{en,de}code() are now 3-4x faster.
+- Issue #444582: Add shutil.which, for finding programs on the system path.
+ Original patch by Erik Demaine, with later iterations by Jan Killian
+ and Brian Curtin.
+
+- Issue #14837: SSL errors now have ``library`` and ``reason`` attributes
+ describing precisely what happened and in which OpenSSL submodule. The
+ str() of a SSLError is also enhanced accordingly.
+
- Issue #9527: datetime.astimezone() method will now supply a class
timezone instance corresponding to the system local timezone when
called with no arguments.
@@ -149,6 +157,9 @@
- Issue #14963: Convert contextlib.ExitStack.__exit__ to use an iterative
algorithm (Patch by Alon Horev)
+- Issue #14785: Add sys._debugmallocstats() to help debug low-level memory
+ allocation issues
+
C-API
-----
diff --git a/Modules/_datetimemodule.c b/Modules/_datetimemodule.c
--- a/Modules/_datetimemodule.c
+++ b/Modules/_datetimemodule.c
@@ -809,14 +809,16 @@
}
if (GET_TD_MICROSECONDS(offset) != 0 || GET_TD_SECONDS(offset) % 60 != 0) {
PyErr_Format(PyExc_ValueError, "offset must be a timedelta"
- " representing a whole number of minutes");
+ " representing a whole number of minutes,"
+ " not %R.", offset);
return NULL;
}
if ((GET_TD_DAYS(offset) == -1 && GET_TD_SECONDS(offset) == 0) ||
GET_TD_DAYS(offset) < -1 || GET_TD_DAYS(offset) >= 1) {
PyErr_Format(PyExc_ValueError, "offset must be a timedelta"
" strictly between -timedelta(hours=24) and"
- " timedelta(hours=24).");
+ " timedelta(hours=24),"
+ " not %R.", offset);
return NULL;
}
@@ -4686,12 +4688,11 @@
}
static PyObject *
-local_timezone(PyObject *utc_time)
+local_timezone(PyDateTime_DateTime *utc_time)
{
PyObject *result = NULL;
struct tm *timep;
time_t timestamp;
- long offset;
PyObject *delta;
PyObject *one_second;
PyObject *seconds;
@@ -4716,21 +4717,18 @@
return NULL;
timep = localtime(×tamp);
#ifdef HAVE_STRUCT_TM_TM_ZONE
- offset = timep->tm_gmtoff;
zone = timep->tm_zone;
- delta = new_delta(0, -offset, 0, 0);
+ delta = new_delta(0, timep->tm_gmtoff, 0, 1);
#else /* HAVE_STRUCT_TM_TM_ZONE */
{
PyObject *local_time;
- Py_INCREF(utc_time->tzinfo);
local_time = new_datetime(timep->tm_year + 1900, timep->tm_mon + 1,
timep->tm_mday, timep->tm_hour, timep->tm_min,
- timep->tm_sec, utc_time->tzinfo);
- if (local_time == NULL) {
- Py_DECREF(utc_time->tzinfo);
+ timep->tm_sec, DATE_GET_MICROSECOND(utc_time),
+ utc_time->tzinfo);
+ if (local_time == NULL)
goto error;
- }
- delta = datetime_subtract(local_time, utc_time);
+ delta = datetime_subtract(local_time, (PyObject*)utc_time);
/* XXX: before relying on tzname, we should compare delta
to the offset implied by timezone/altzone */
if (daylight && timep->tm_isdst >= 0)
@@ -4752,10 +4750,10 @@
return result;
}
-static PyObject *
+static PyDateTime_DateTime *
datetime_astimezone(PyDateTime_DateTime *self, PyObject *args, PyObject *kw)
{
- PyObject *result;
+ PyDateTime_DateTime *result;
PyObject *offset;
PyObject *temp;
PyObject *tzinfo = Py_None;
@@ -4775,7 +4773,7 @@
/* Conversion to self's own time zone is a NOP. */
if (self->tzinfo == tzinfo) {
Py_INCREF(self);
- return (PyObject *)self;
+ return self;
}
/* Convert self to UTC. */
@@ -4791,14 +4789,14 @@
}
/* result = self - offset */
- result = add_datetime_timedelta(self,
- (PyDateTime_Delta *)offset, -1);
+ result = (PyDateTime_DateTime *)add_datetime_timedelta(self,
+ (PyDateTime_Delta *)offset, -1);
Py_DECREF(offset);
if (result == NULL)
return NULL;
/* Attach new tzinfo and let fromutc() do the rest. */
- temp = ((PyDateTime_DateTime *)result)->tzinfo;
+ temp = result->tzinfo;
if (tzinfo == Py_None) {
tzinfo = local_timezone(result);
if (tzinfo == NULL) {
@@ -4808,11 +4806,12 @@
}
else
Py_INCREF(tzinfo);
- ((PyDateTime_DateTime *)result)->tzinfo = tzinfo;
+ result->tzinfo = tzinfo;
Py_DECREF(temp);
- temp = result;
- result = _PyObject_CallMethodId(tzinfo, &PyId_fromutc, "O", temp);
+ temp = (PyObject *)result;
+ result = (PyDateTime_DateTime *)
+ _PyObject_CallMethodId(tzinfo, &PyId_fromutc, "O", temp);
Py_DECREF(temp);
return result;
diff --git a/Modules/_ssl.c b/Modules/_ssl.c
--- a/Modules/_ssl.c
+++ b/Modules/_ssl.c
@@ -76,6 +76,16 @@
PY_SSL_VERSION_TLS1
};
+struct py_ssl_error_code {
+ const char *mnemonic;
+ int library, reason;
+};
+
+struct py_ssl_library_code {
+ const char *library;
+ int code;
+};
+
/* Include symbols from _socket module */
#include "socketmodule.h"
@@ -97,6 +107,9 @@
#include "openssl/err.h"
#include "openssl/rand.h"
+/* Include generated data (error codes) */
+#include "_ssl_data.h"
+
/* SSL error object */
static PyObject *PySSLErrorObject;
static PyObject *PySSLZeroReturnErrorObject;
@@ -105,6 +118,11 @@
static PyObject *PySSLSyscallErrorObject;
static PyObject *PySSLEOFErrorObject;
+/* Error mappings */
+static PyObject *err_codes_to_names;
+static PyObject *err_names_to_codes;
+static PyObject *lib_codes_to_names;
+
#ifdef WITH_THREAD
/* serves as a flag to see whether we've initialized the SSL thread support. */
@@ -202,22 +220,134 @@
#define ERRSTR1(x,y,z) (x ":" y ": " z)
#define ERRSTR(x) ERRSTR1("_ssl.c", STRINGIFY2(__LINE__), x)
-/* XXX It might be helpful to augment the error message generated
- below with the name of the SSL function that generated the error.
- I expect it's obvious most of the time.
-*/
+
+/*
+ * SSL errors.
+ */
+
+PyDoc_STRVAR(SSLError_doc,
+"An error occurred in the SSL implementation.");
+
+PyDoc_STRVAR(SSLZeroReturnError_doc,
+"SSL/TLS session closed cleanly.");
+
+PyDoc_STRVAR(SSLWantReadError_doc,
+"Non-blocking SSL socket needs to read more data\n"
+"before the requested operation can be completed.");
+
+PyDoc_STRVAR(SSLWantWriteError_doc,
+"Non-blocking SSL socket needs to write more data\n"
+"before the requested operation can be completed.");
+
+PyDoc_STRVAR(SSLSyscallError_doc,
+"System error when attempting SSL operation.");
+
+PyDoc_STRVAR(SSLEOFError_doc,
+"SSL/TLS connection terminated abruptly.");
+
+static PyObject *
+SSLError_str(PyOSErrorObject *self)
+{
+ if (self->strerror != NULL && PyUnicode_Check(self->strerror)) {
+ Py_INCREF(self->strerror);
+ return self->strerror;
+ }
+ else
+ return PyObject_Str(self->args);
+}
+
+static PyType_Slot sslerror_type_slots[] = {
+ {Py_tp_base, NULL}, /* Filled out in module init as it's not a constant */
+ {Py_tp_doc, SSLError_doc},
+ {Py_tp_str, SSLError_str},
+ {0, 0},
+};
+
+static PyType_Spec sslerror_type_spec = {
+ "ssl.SSLError",
+ sizeof(PyOSErrorObject),
+ 0,
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+ sslerror_type_slots
+};
+
+static void
+fill_and_set_sslerror(PyObject *type, int ssl_errno, const char *errstr,
+ int lineno, unsigned long errcode)
+{
+ PyObject *err_value = NULL, *reason_obj = NULL, *lib_obj = NULL;
+ PyObject *init_value, *msg, *key;
+ _Py_IDENTIFIER(reason);
+ _Py_IDENTIFIER(library);
+
+ if (errcode != 0) {
+ int lib, reason;
+
+ lib = ERR_GET_LIB(errcode);
+ reason = ERR_GET_REASON(errcode);
+ key = Py_BuildValue("ii", lib, reason);
+ if (key == NULL)
+ goto fail;
+ reason_obj = PyDict_GetItem(err_codes_to_names, key);
+ Py_DECREF(key);
+ if (reason_obj == NULL) {
+ /* XXX if reason < 100, it might reflect a library number (!!) */
+ PyErr_Clear();
+ }
+ key = PyLong_FromLong(lib);
+ if (key == NULL)
+ goto fail;
+ lib_obj = PyDict_GetItem(lib_codes_to_names, key);
+ Py_DECREF(key);
+ if (lib_obj == NULL) {
+ PyErr_Clear();
+ }
+ if (errstr == NULL)
+ errstr = ERR_reason_error_string(errcode);
+ }
+ if (errstr == NULL)
+ errstr = "unknown error";
+
+ if (reason_obj && lib_obj)
+ msg = PyUnicode_FromFormat("[%S: %S] %s (_ssl.c:%d)",
+ lib_obj, reason_obj, errstr, lineno);
+ else if (lib_obj)
+ msg = PyUnicode_FromFormat("[%S] %s (_ssl.c:%d)",
+ lib_obj, errstr, lineno);
+ else
+ msg = PyUnicode_FromFormat("%s (_ssl.c:%d)", errstr, lineno);
+
+ if (msg == NULL)
+ goto fail;
+ init_value = Py_BuildValue("iN", ssl_errno, msg);
+ err_value = PyObject_CallObject(type, init_value);
+ Py_DECREF(init_value);
+ if (err_value == NULL)
+ goto fail;
+ if (reason_obj == NULL)
+ reason_obj = Py_None;
+ if (_PyObject_SetAttrId(err_value, &PyId_reason, reason_obj))
+ goto fail;
+ if (lib_obj == NULL)
+ lib_obj = Py_None;
+ if (_PyObject_SetAttrId(err_value, &PyId_library, lib_obj))
+ goto fail;
+ PyErr_SetObject(type, err_value);
+fail:
+ Py_XDECREF(err_value);
+}
static PyObject *
PySSL_SetError(PySSLSocket *obj, int ret, char *filename, int lineno)
{
- PyObject *v;
PyObject *type = PySSLErrorObject;
- char buf[2048];
- char *errstr;
+ char *errstr = NULL;
int err;
enum py_ssl_error p = PY_SSL_ERROR_NONE;
+ unsigned long e = 0;
assert(ret <= 0);
+ e = ERR_peek_last_error();
if (obj->ssl != NULL) {
err = SSL_get_error(obj->ssl, ret);
@@ -248,7 +378,6 @@
break;
case SSL_ERROR_SYSCALL:
{
- unsigned long e = ERR_get_error();
if (e == 0) {
PySocketSockObject *s
= (PySocketSockObject *) PyWeakref_GetObject(obj->Socket);
@@ -260,9 +389,9 @@
/* underlying BIO reported an I/O error */
Py_INCREF(s);
ERR_clear_error();
- v = s->errorhandler();
+ s->errorhandler();
Py_DECREF(s);
- return v;
+ return NULL;
} else { /* possible? */
p = PY_SSL_ERROR_SYSCALL;
type = PySSLSyscallErrorObject;
@@ -270,60 +399,43 @@
}
} else {
p = PY_SSL_ERROR_SYSCALL;
- /* XXX Protected by global interpreter lock */
- errstr = ERR_error_string(e, NULL);
}
break;
}
case SSL_ERROR_SSL:
{
- unsigned long e = ERR_get_error();
p = PY_SSL_ERROR_SSL;
- if (e != 0)
- /* XXX Protected by global interpreter lock */
- errstr = ERR_error_string(e, NULL);
- else { /* possible? */
+ if (e == 0)
+ /* possible? */
errstr = "A failure in the SSL library occurred";
- }
break;
}
default:
p = PY_SSL_ERROR_INVALID_ERROR_CODE;
errstr = "Invalid error code";
}
- } else {
- errstr = ERR_error_string(ERR_peek_last_error(), NULL);
}
- PyOS_snprintf(buf, sizeof(buf), "_ssl.c:%d: %s", lineno, errstr);
+ fill_and_set_sslerror(type, p, errstr, lineno, e);
ERR_clear_error();
- v = Py_BuildValue("(is)", p, buf);
- if (v != NULL) {
- PyErr_SetObject(type, v);
- Py_DECREF(v);
- }
return NULL;
}
static PyObject *
_setSSLError (char *errstr, int errcode, char *filename, int lineno) {
- char buf[2048];
- PyObject *v;
-
- if (errstr == NULL) {
+ if (errstr == NULL)
errcode = ERR_peek_last_error();
- errstr = ERR_error_string(errcode, NULL);
- }
- PyOS_snprintf(buf, sizeof(buf), "_ssl.c:%d: %s", lineno, errstr);
+ else
+ errcode = 0;
+ fill_and_set_sslerror(PySSLErrorObject, errcode, errstr, lineno, errcode);
ERR_clear_error();
- v = Py_BuildValue("(is)", errcode, buf);
- if (v != NULL) {
- PyErr_SetObject(PySSLErrorObject, v);
- Py_DECREF(v);
- }
return NULL;
}
+/*
+ * SSL objects
+ */
+
static PySSLSocket *
newPySSLSocket(SSL_CTX *ctx, PySocketSockObject *sock,
enum py_ssl_server_or_client socket_type,
@@ -2520,27 +2632,6 @@
*major = libver & 0xFF;
}
-PyDoc_STRVAR(SSLError_doc,
-"An error occurred in the SSL implementation.");
-
-PyDoc_STRVAR(SSLZeroReturnError_doc,
-"SSL/TLS session closed cleanly.");
-
-PyDoc_STRVAR(SSLWantReadError_doc,
-"Non-blocking SSL socket needs to read more data\n"
-"before the requested operation can be completed.");
-
-PyDoc_STRVAR(SSLWantWriteError_doc,
-"Non-blocking SSL socket needs to write more data\n"
-"before the requested operation can be completed.");
-
-PyDoc_STRVAR(SSLSyscallError_doc,
-"System error when attempting SSL operation.");
-
-PyDoc_STRVAR(SSLEOFError_doc,
-"SSL/TLS connection terminated abruptly.");
-
-
PyMODINIT_FUNC
PyInit__ssl(void)
{
@@ -2548,6 +2639,8 @@
unsigned long libver;
unsigned int major, minor, fix, patch, status;
PySocketModule_APIObject *socket_api;
+ struct py_ssl_error_code *errcode;
+ struct py_ssl_library_code *libcode;
if (PyType_Ready(&PySSLContext_Type) < 0)
return NULL;
@@ -2577,12 +2670,11 @@
OpenSSL_add_all_algorithms();
/* Add symbols to module dict */
- PySSLErrorObject = PyErr_NewExceptionWithDoc("ssl.SSLError",
- SSLError_doc,
- PyExc_OSError,
- NULL);
+ sslerror_type_slots[0].pfunc = PyExc_OSError;
+ PySSLErrorObject = PyType_FromSpec(&sslerror_type_spec);
if (PySSLErrorObject == NULL)
return NULL;
+
PySSLZeroReturnErrorObject = PyErr_NewExceptionWithDoc(
"ssl.SSLZeroReturnError", SSLZeroReturnError_doc,
PySSLErrorObject, NULL);
@@ -2705,6 +2797,50 @@
Py_INCREF(r);
PyModule_AddObject(m, "HAS_NPN", r);
+ /* Mappings for error codes */
+ err_codes_to_names = PyDict_New();
+ err_names_to_codes = PyDict_New();
+ if (err_codes_to_names == NULL || err_names_to_codes == NULL)
+ return NULL;
+ errcode = error_codes;
+ while (errcode->mnemonic != NULL) {
+ PyObject *mnemo, *key;
+ mnemo = PyUnicode_FromString(errcode->mnemonic);
+ key = Py_BuildValue("ii", errcode->library, errcode->reason);
+ if (mnemo == NULL || key == NULL)
+ return NULL;
+ if (PyDict_SetItem(err_codes_to_names, key, mnemo))
+ return NULL;
+ if (PyDict_SetItem(err_names_to_codes, mnemo, key))
+ return NULL;
+ Py_DECREF(key);
+ Py_DECREF(mnemo);
+ errcode++;
+ }
+ if (PyModule_AddObject(m, "err_codes_to_names", err_codes_to_names))
+ return NULL;
+ if (PyModule_AddObject(m, "err_names_to_codes", err_names_to_codes))
+ return NULL;
+
+ lib_codes_to_names = PyDict_New();
+ if (lib_codes_to_names == NULL)
+ return NULL;
+ libcode = library_codes;
+ while (libcode->library != NULL) {
+ PyObject *mnemo, *key;
+ key = PyLong_FromLong(libcode->code);
+ mnemo = PyUnicode_FromString(libcode->library);
+ if (key == NULL || mnemo == NULL)
+ return NULL;
+ if (PyDict_SetItem(lib_codes_to_names, key, mnemo))
+ return NULL;
+ Py_DECREF(key);
+ Py_DECREF(mnemo);
+ libcode++;
+ }
+ if (PyModule_AddObject(m, "lib_codes_to_names", lib_codes_to_names))
+ return NULL;
+
/* OpenSSL version */
/* SSLeay() gives us the version of the library linked against,
which could be different from the headers version.
diff --git a/Modules/_ssl_data.h b/Modules/_ssl_data.h
new file mode 100644
--- /dev/null
+++ b/Modules/_ssl_data.h
@@ -0,0 +1,1653 @@
+/* File generated by Tools/ssl/make_ssl_data.py */
+/* Generated on 2012-05-16T23:56:40.981382 */
+
+static struct py_ssl_library_code library_codes[] = {
+ {"PEM", ERR_LIB_PEM},
+ {"SSL", ERR_LIB_SSL},
+ {"X509", ERR_LIB_X509},
+ { NULL }
+};
+
+static struct py_ssl_error_code error_codes[] = {
+ #ifdef PEM_R_BAD_BASE64_DECODE
+ {"BAD_BASE64_DECODE", ERR_LIB_PEM, PEM_R_BAD_BASE64_DECODE},
+ #else
+ {"BAD_BASE64_DECODE", ERR_LIB_PEM, 100},
+ #endif
+ #ifdef PEM_R_BAD_DECRYPT
+ {"BAD_DECRYPT", ERR_LIB_PEM, PEM_R_BAD_DECRYPT},
+ #else
+ {"BAD_DECRYPT", ERR_LIB_PEM, 101},
+ #endif
+ #ifdef PEM_R_BAD_END_LINE
+ {"BAD_END_LINE", ERR_LIB_PEM, PEM_R_BAD_END_LINE},
+ #else
+ {"BAD_END_LINE", ERR_LIB_PEM, 102},
+ #endif
+ #ifdef PEM_R_BAD_IV_CHARS
+ {"BAD_IV_CHARS", ERR_LIB_PEM, PEM_R_BAD_IV_CHARS},
+ #else
+ {"BAD_IV_CHARS", ERR_LIB_PEM, 103},
+ #endif
+ #ifdef PEM_R_BAD_MAGIC_NUMBER
+ {"BAD_MAGIC_NUMBER", ERR_LIB_PEM, PEM_R_BAD_MAGIC_NUMBER},
+ #else
+ {"BAD_MAGIC_NUMBER", ERR_LIB_PEM, 116},
+ #endif
+ #ifdef PEM_R_BAD_PASSWORD_READ
+ {"BAD_PASSWORD_READ", ERR_LIB_PEM, PEM_R_BAD_PASSWORD_READ},
+ #else
+ {"BAD_PASSWORD_READ", ERR_LIB_PEM, 104},
+ #endif
+ #ifdef PEM_R_BAD_VERSION_NUMBER
+ {"BAD_VERSION_NUMBER", ERR_LIB_PEM, PEM_R_BAD_VERSION_NUMBER},
+ #else
+ {"BAD_VERSION_NUMBER", ERR_LIB_PEM, 117},
+ #endif
+ #ifdef PEM_R_BIO_WRITE_FAILURE
+ {"BIO_WRITE_FAILURE", ERR_LIB_PEM, PEM_R_BIO_WRITE_FAILURE},
+ #else
+ {"BIO_WRITE_FAILURE", ERR_LIB_PEM, 118},
+ #endif
+ #ifdef PEM_R_CIPHER_IS_NULL
+ {"CIPHER_IS_NULL", ERR_LIB_PEM, PEM_R_CIPHER_IS_NULL},
+ #else
+ {"CIPHER_IS_NULL", ERR_LIB_PEM, 127},
+ #endif
+ #ifdef PEM_R_ERROR_CONVERTING_PRIVATE_KEY
+ {"ERROR_CONVERTING_PRIVATE_KEY", ERR_LIB_PEM, PEM_R_ERROR_CONVERTING_PRIVATE_KEY},
+ #else
+ {"ERROR_CONVERTING_PRIVATE_KEY", ERR_LIB_PEM, 115},
+ #endif
+ #ifdef PEM_R_EXPECTING_PRIVATE_KEY_BLOB
+ {"EXPECTING_PRIVATE_KEY_BLOB", ERR_LIB_PEM, PEM_R_EXPECTING_PRIVATE_KEY_BLOB},
+ #else
+ {"EXPECTING_PRIVATE_KEY_BLOB", ERR_LIB_PEM, 119},
+ #endif
+ #ifdef PEM_R_EXPECTING_PUBLIC_KEY_BLOB
+ {"EXPECTING_PUBLIC_KEY_BLOB", ERR_LIB_PEM, PEM_R_EXPECTING_PUBLIC_KEY_BLOB},
+ #else
+ {"EXPECTING_PUBLIC_KEY_BLOB", ERR_LIB_PEM, 120},
+ #endif
+ #ifdef PEM_R_INCONSISTENT_HEADER
+ {"INCONSISTENT_HEADER", ERR_LIB_PEM, PEM_R_INCONSISTENT_HEADER},
+ #else
+ {"INCONSISTENT_HEADER", ERR_LIB_PEM, 121},
+ #endif
+ #ifdef PEM_R_KEYBLOB_HEADER_PARSE_ERROR
+ {"KEYBLOB_HEADER_PARSE_ERROR", ERR_LIB_PEM, PEM_R_KEYBLOB_HEADER_PARSE_ERROR},
+ #else
+ {"KEYBLOB_HEADER_PARSE_ERROR", ERR_LIB_PEM, 122},
+ #endif
+ #ifdef PEM_R_KEYBLOB_TOO_SHORT
+ {"KEYBLOB_TOO_SHORT", ERR_LIB_PEM, PEM_R_KEYBLOB_TOO_SHORT},
+ #else
+ {"KEYBLOB_TOO_SHORT", ERR_LIB_PEM, 123},
+ #endif
+ #ifdef PEM_R_NOT_DEK_INFO
+ {"NOT_DEK_INFO", ERR_LIB_PEM, PEM_R_NOT_DEK_INFO},
+ #else
+ {"NOT_DEK_INFO", ERR_LIB_PEM, 105},
+ #endif
+ #ifdef PEM_R_NOT_ENCRYPTED
+ {"NOT_ENCRYPTED", ERR_LIB_PEM, PEM_R_NOT_ENCRYPTED},
+ #else
+ {"NOT_ENCRYPTED", ERR_LIB_PEM, 106},
+ #endif
+ #ifdef PEM_R_NOT_PROC_TYPE
+ {"NOT_PROC_TYPE", ERR_LIB_PEM, PEM_R_NOT_PROC_TYPE},
+ #else
+ {"NOT_PROC_TYPE", ERR_LIB_PEM, 107},
+ #endif
+ #ifdef PEM_R_NO_START_LINE
+ {"NO_START_LINE", ERR_LIB_PEM, PEM_R_NO_START_LINE},
+ #else
+ {"NO_START_LINE", ERR_LIB_PEM, 108},
+ #endif
+ #ifdef PEM_R_PROBLEMS_GETTING_PASSWORD
+ {"PROBLEMS_GETTING_PASSWORD", ERR_LIB_PEM, PEM_R_PROBLEMS_GETTING_PASSWORD},
+ #else
+ {"PROBLEMS_GETTING_PASSWORD", ERR_LIB_PEM, 109},
+ #endif
+ #ifdef PEM_R_PUBLIC_KEY_NO_RSA
+ {"PUBLIC_KEY_NO_RSA", ERR_LIB_PEM, PEM_R_PUBLIC_KEY_NO_RSA},
+ #else
+ {"PUBLIC_KEY_NO_RSA", ERR_LIB_PEM, 110},
+ #endif
+ #ifdef PEM_R_PVK_DATA_TOO_SHORT
+ {"PVK_DATA_TOO_SHORT", ERR_LIB_PEM, PEM_R_PVK_DATA_TOO_SHORT},
+ #else
+ {"PVK_DATA_TOO_SHORT", ERR_LIB_PEM, 124},
+ #endif
+ #ifdef PEM_R_PVK_TOO_SHORT
+ {"PVK_TOO_SHORT", ERR_LIB_PEM, PEM_R_PVK_TOO_SHORT},
+ #else
+ {"PVK_TOO_SHORT", ERR_LIB_PEM, 125},
+ #endif
+ #ifdef PEM_R_READ_KEY
+ {"READ_KEY", ERR_LIB_PEM, PEM_R_READ_KEY},
+ #else
+ {"READ_KEY", ERR_LIB_PEM, 111},
+ #endif
+ #ifdef PEM_R_SHORT_HEADER
+ {"SHORT_HEADER", ERR_LIB_PEM, PEM_R_SHORT_HEADER},
+ #else
+ {"SHORT_HEADER", ERR_LIB_PEM, 112},
+ #endif
+ #ifdef PEM_R_UNSUPPORTED_CIPHER
+ {"UNSUPPORTED_CIPHER", ERR_LIB_PEM, PEM_R_UNSUPPORTED_CIPHER},
+ #else
+ {"UNSUPPORTED_CIPHER", ERR_LIB_PEM, 113},
+ #endif
+ #ifdef PEM_R_UNSUPPORTED_ENCRYPTION
+ {"UNSUPPORTED_ENCRYPTION", ERR_LIB_PEM, PEM_R_UNSUPPORTED_ENCRYPTION},
+ #else
+ {"UNSUPPORTED_ENCRYPTION", ERR_LIB_PEM, 114},
+ #endif
+ #ifdef PEM_R_UNSUPPORTED_KEY_COMPONENTS
+ {"UNSUPPORTED_KEY_COMPONENTS", ERR_LIB_PEM, PEM_R_UNSUPPORTED_KEY_COMPONENTS},
+ #else
+ {"UNSUPPORTED_KEY_COMPONENTS", ERR_LIB_PEM, 126},
+ #endif
+ #ifdef SSL_R_APP_DATA_IN_HANDSHAKE
+ {"APP_DATA_IN_HANDSHAKE", ERR_LIB_SSL, SSL_R_APP_DATA_IN_HANDSHAKE},
+ #else
+ {"APP_DATA_IN_HANDSHAKE", ERR_LIB_SSL, 100},
+ #endif
+ #ifdef SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT
+ {"ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT", ERR_LIB_SSL, SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT},
+ #else
+ {"ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT", ERR_LIB_SSL, 272},
+ #endif
+ #ifdef SSL_R_BAD_ALERT_RECORD
+ {"BAD_ALERT_RECORD", ERR_LIB_SSL, SSL_R_BAD_ALERT_RECORD},
+ #else
+ {"BAD_ALERT_RECORD", ERR_LIB_SSL, 101},
+ #endif
+ #ifdef SSL_R_BAD_AUTHENTICATION_TYPE
+ {"BAD_AUTHENTICATION_TYPE", ERR_LIB_SSL, SSL_R_BAD_AUTHENTICATION_TYPE},
+ #else
+ {"BAD_AUTHENTICATION_TYPE", ERR_LIB_SSL, 102},
+ #endif
+ #ifdef SSL_R_BAD_CHANGE_CIPHER_SPEC
+ {"BAD_CHANGE_CIPHER_SPEC", ERR_LIB_SSL, SSL_R_BAD_CHANGE_CIPHER_SPEC},
+ #else
+ {"BAD_CHANGE_CIPHER_SPEC", ERR_LIB_SSL, 103},
+ #endif
+ #ifdef SSL_R_BAD_CHECKSUM
+ {"BAD_CHECKSUM", ERR_LIB_SSL, SSL_R_BAD_CHECKSUM},
+ #else
+ {"BAD_CHECKSUM", ERR_LIB_SSL, 104},
+ #endif
+ #ifdef SSL_R_BAD_DATA_RETURNED_BY_CALLBACK
+ {"BAD_DATA_RETURNED_BY_CALLBACK", ERR_LIB_SSL, SSL_R_BAD_DATA_RETURNED_BY_CALLBACK},
+ #else
+ {"BAD_DATA_RETURNED_BY_CALLBACK", ERR_LIB_SSL, 106},
+ #endif
+ #ifdef SSL_R_BAD_DECOMPRESSION
+ {"BAD_DECOMPRESSION", ERR_LIB_SSL, SSL_R_BAD_DECOMPRESSION},
+ #else
+ {"BAD_DECOMPRESSION", ERR_LIB_SSL, 107},
+ #endif
+ #ifdef SSL_R_BAD_DH_G_LENGTH
+ {"BAD_DH_G_LENGTH", ERR_LIB_SSL, SSL_R_BAD_DH_G_LENGTH},
+ #else
+ {"BAD_DH_G_LENGTH", ERR_LIB_SSL, 108},
+ #endif
+ #ifdef SSL_R_BAD_DH_PUB_KEY_LENGTH
+ {"BAD_DH_PUB_KEY_LENGTH", ERR_LIB_SSL, SSL_R_BAD_DH_PUB_KEY_LENGTH},
+ #else
+ {"BAD_DH_PUB_KEY_LENGTH", ERR_LIB_SSL, 109},
+ #endif
+ #ifdef SSL_R_BAD_DH_P_LENGTH
+ {"BAD_DH_P_LENGTH", ERR_LIB_SSL, SSL_R_BAD_DH_P_LENGTH},
+ #else
+ {"BAD_DH_P_LENGTH", ERR_LIB_SSL, 110},
+ #endif
+ #ifdef SSL_R_BAD_DIGEST_LENGTH
+ {"BAD_DIGEST_LENGTH", ERR_LIB_SSL, SSL_R_BAD_DIGEST_LENGTH},
+ #else
+ {"BAD_DIGEST_LENGTH", ERR_LIB_SSL, 111},
+ #endif
+ #ifdef SSL_R_BAD_DSA_SIGNATURE
+ {"BAD_DSA_SIGNATURE", ERR_LIB_SSL, SSL_R_BAD_DSA_SIGNATURE},
+ #else
+ {"BAD_DSA_SIGNATURE", ERR_LIB_SSL, 112},
+ #endif
+ #ifdef SSL_R_BAD_ECC_CERT
+ {"BAD_ECC_CERT", ERR_LIB_SSL, SSL_R_BAD_ECC_CERT},
+ #else
+ {"BAD_ECC_CERT", ERR_LIB_SSL, 304},
+ #endif
+ #ifdef SSL_R_BAD_ECDSA_SIGNATURE
+ {"BAD_ECDSA_SIGNATURE", ERR_LIB_SSL, SSL_R_BAD_ECDSA_SIGNATURE},
+ #else
+ {"BAD_ECDSA_SIGNATURE", ERR_LIB_SSL, 305},
+ #endif
+ #ifdef SSL_R_BAD_ECPOINT
+ {"BAD_ECPOINT", ERR_LIB_SSL, SSL_R_BAD_ECPOINT},
+ #else
+ {"BAD_ECPOINT", ERR_LIB_SSL, 306},
+ #endif
+ #ifdef SSL_R_BAD_HANDSHAKE_LENGTH
+ {"BAD_HANDSHAKE_LENGTH", ERR_LIB_SSL, SSL_R_BAD_HANDSHAKE_LENGTH},
+ #else
+ {"BAD_HANDSHAKE_LENGTH", ERR_LIB_SSL, 332},
+ #endif
+ #ifdef SSL_R_BAD_HELLO_REQUEST
+ {"BAD_HELLO_REQUEST", ERR_LIB_SSL, SSL_R_BAD_HELLO_REQUEST},
+ #else
+ {"BAD_HELLO_REQUEST", ERR_LIB_SSL, 105},
+ #endif
+ #ifdef SSL_R_BAD_LENGTH
+ {"BAD_LENGTH", ERR_LIB_SSL, SSL_R_BAD_LENGTH},
+ #else
+ {"BAD_LENGTH", ERR_LIB_SSL, 271},
+ #endif
+ #ifdef SSL_R_BAD_MAC_DECODE
+ {"BAD_MAC_DECODE", ERR_LIB_SSL, SSL_R_BAD_MAC_DECODE},
+ #else
+ {"BAD_MAC_DECODE", ERR_LIB_SSL, 113},
+ #endif
+ #ifdef SSL_R_BAD_MAC_LENGTH
+ {"BAD_MAC_LENGTH", ERR_LIB_SSL, SSL_R_BAD_MAC_LENGTH},
+ #else
+ {"BAD_MAC_LENGTH", ERR_LIB_SSL, 333},
+ #endif
+ #ifdef SSL_R_BAD_MESSAGE_TYPE
+ {"BAD_MESSAGE_TYPE", ERR_LIB_SSL, SSL_R_BAD_MESSAGE_TYPE},
+ #else
+ {"BAD_MESSAGE_TYPE", ERR_LIB_SSL, 114},
+ #endif
+ #ifdef SSL_R_BAD_PACKET_LENGTH
+ {"BAD_PACKET_LENGTH", ERR_LIB_SSL, SSL_R_BAD_PACKET_LENGTH},
+ #else
+ {"BAD_PACKET_LENGTH", ERR_LIB_SSL, 115},
+ #endif
+ #ifdef SSL_R_BAD_PROTOCOL_VERSION_NUMBER
+ {"BAD_PROTOCOL_VERSION_NUMBER", ERR_LIB_SSL, SSL_R_BAD_PROTOCOL_VERSION_NUMBER},
+ #else
+ {"BAD_PROTOCOL_VERSION_NUMBER", ERR_LIB_SSL, 116},
+ #endif
+ #ifdef SSL_R_BAD_PSK_IDENTITY_HINT_LENGTH
+ {"BAD_PSK_IDENTITY_HINT_LENGTH", ERR_LIB_SSL, SSL_R_BAD_PSK_IDENTITY_HINT_LENGTH},
+ #else
+ {"BAD_PSK_IDENTITY_HINT_LENGTH", ERR_LIB_SSL, 316},
+ #endif
+ #ifdef SSL_R_BAD_RESPONSE_ARGUMENT
+ {"BAD_RESPONSE_ARGUMENT", ERR_LIB_SSL, SSL_R_BAD_RESPONSE_ARGUMENT},
+ #else
+ {"BAD_RESPONSE_ARGUMENT", ERR_LIB_SSL, 117},
+ #endif
+ #ifdef SSL_R_BAD_RSA_DECRYPT
+ {"BAD_RSA_DECRYPT", ERR_LIB_SSL, SSL_R_BAD_RSA_DECRYPT},
+ #else
+ {"BAD_RSA_DECRYPT", ERR_LIB_SSL, 118},
+ #endif
+ #ifdef SSL_R_BAD_RSA_ENCRYPT
+ {"BAD_RSA_ENCRYPT", ERR_LIB_SSL, SSL_R_BAD_RSA_ENCRYPT},
+ #else
+ {"BAD_RSA_ENCRYPT", ERR_LIB_SSL, 119},
+ #endif
+ #ifdef SSL_R_BAD_RSA_E_LENGTH
+ {"BAD_RSA_E_LENGTH", ERR_LIB_SSL, SSL_R_BAD_RSA_E_LENGTH},
+ #else
+ {"BAD_RSA_E_LENGTH", ERR_LIB_SSL, 120},
+ #endif
+ #ifdef SSL_R_BAD_RSA_MODULUS_LENGTH
+ {"BAD_RSA_MODULUS_LENGTH", ERR_LIB_SSL, SSL_R_BAD_RSA_MODULUS_LENGTH},
+ #else
+ {"BAD_RSA_MODULUS_LENGTH", ERR_LIB_SSL, 121},
+ #endif
+ #ifdef SSL_R_BAD_RSA_SIGNATURE
+ {"BAD_RSA_SIGNATURE", ERR_LIB_SSL, SSL_R_BAD_RSA_SIGNATURE},
+ #else
+ {"BAD_RSA_SIGNATURE", ERR_LIB_SSL, 122},
+ #endif
+ #ifdef SSL_R_BAD_SIGNATURE
+ {"BAD_SIGNATURE", ERR_LIB_SSL, SSL_R_BAD_SIGNATURE},
+ #else
+ {"BAD_SIGNATURE", ERR_LIB_SSL, 123},
+ #endif
+ #ifdef SSL_R_BAD_SSL_FILETYPE
+ {"BAD_SSL_FILETYPE", ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE},
+ #else
+ {"BAD_SSL_FILETYPE", ERR_LIB_SSL, 124},
+ #endif
+ #ifdef SSL_R_BAD_SSL_SESSION_ID_LENGTH
+ {"BAD_SSL_SESSION_ID_LENGTH", ERR_LIB_SSL, SSL_R_BAD_SSL_SESSION_ID_LENGTH},
+ #else
+ {"BAD_SSL_SESSION_ID_LENGTH", ERR_LIB_SSL, 125},
+ #endif
+ #ifdef SSL_R_BAD_STATE
+ {"BAD_STATE", ERR_LIB_SSL, SSL_R_BAD_STATE},
+ #else
+ {"BAD_STATE", ERR_LIB_SSL, 126},
+ #endif
+ #ifdef SSL_R_BAD_WRITE_RETRY
+ {"BAD_WRITE_RETRY", ERR_LIB_SSL, SSL_R_BAD_WRITE_RETRY},
+ #else
+ {"BAD_WRITE_RETRY", ERR_LIB_SSL, 127},
+ #endif
+ #ifdef SSL_R_BIO_NOT_SET
+ {"BIO_NOT_SET", ERR_LIB_SSL, SSL_R_BIO_NOT_SET},
+ #else
+ {"BIO_NOT_SET", ERR_LIB_SSL, 128},
+ #endif
+ #ifdef SSL_R_BLOCK_CIPHER_PAD_IS_WRONG
+ {"BLOCK_CIPHER_PAD_IS_WRONG", ERR_LIB_SSL, SSL_R_BLOCK_CIPHER_PAD_IS_WRONG},
+ #else
+ {"BLOCK_CIPHER_PAD_IS_WRONG", ERR_LIB_SSL, 129},
+ #endif
+ #ifdef SSL_R_BN_LIB
+ {"BN_LIB", ERR_LIB_SSL, SSL_R_BN_LIB},
+ #else
+ {"BN_LIB", ERR_LIB_SSL, 130},
+ #endif
+ #ifdef SSL_R_CA_DN_LENGTH_MISMATCH
+ {"CA_DN_LENGTH_MISMATCH", ERR_LIB_SSL, SSL_R_CA_DN_LENGTH_MISMATCH},
+ #else
+ {"CA_DN_LENGTH_MISMATCH", ERR_LIB_SSL, 131},
+ #endif
+ #ifdef SSL_R_CA_DN_TOO_LONG
+ {"CA_DN_TOO_LONG", ERR_LIB_SSL, SSL_R_CA_DN_TOO_LONG},
+ #else
+ {"CA_DN_TOO_LONG", ERR_LIB_SSL, 132},
+ #endif
+ #ifdef SSL_R_CCS_RECEIVED_EARLY
+ {"CCS_RECEIVED_EARLY", ERR_LIB_SSL, SSL_R_CCS_RECEIVED_EARLY},
+ #else
+ {"CCS_RECEIVED_EARLY", ERR_LIB_SSL, 133},
+ #endif
+ #ifdef SSL_R_CERTIFICATE_VERIFY_FAILED
+ {"CERTIFICATE_VERIFY_FAILED", ERR_LIB_SSL, SSL_R_CERTIFICATE_VERIFY_FAILED},
+ #else
+ {"CERTIFICATE_VERIFY_FAILED", ERR_LIB_SSL, 134},
+ #endif
+ #ifdef SSL_R_CERT_LENGTH_MISMATCH
+ {"CERT_LENGTH_MISMATCH", ERR_LIB_SSL, SSL_R_CERT_LENGTH_MISMATCH},
+ #else
+ {"CERT_LENGTH_MISMATCH", ERR_LIB_SSL, 135},
+ #endif
+ #ifdef SSL_R_CHALLENGE_IS_DIFFERENT
+ {"CHALLENGE_IS_DIFFERENT", ERR_LIB_SSL, SSL_R_CHALLENGE_IS_DIFFERENT},
+ #else
+ {"CHALLENGE_IS_DIFFERENT", ERR_LIB_SSL, 136},
+ #endif
+ #ifdef SSL_R_CIPHER_CODE_WRONG_LENGTH
+ {"CIPHER_CODE_WRONG_LENGTH", ERR_LIB_SSL, SSL_R_CIPHER_CODE_WRONG_LENGTH},
+ #else
+ {"CIPHER_CODE_WRONG_LENGTH", ERR_LIB_SSL, 137},
+ #endif
+ #ifdef SSL_R_CIPHER_OR_HASH_UNAVAILABLE
+ {"CIPHER_OR_HASH_UNAVAILABLE", ERR_LIB_SSL, SSL_R_CIPHER_OR_HASH_UNAVAILABLE},
+ #else
+ {"CIPHER_OR_HASH_UNAVAILABLE", ERR_LIB_SSL, 138},
+ #endif
+ #ifdef SSL_R_CIPHER_TABLE_SRC_ERROR
+ {"CIPHER_TABLE_SRC_ERROR", ERR_LIB_SSL, SSL_R_CIPHER_TABLE_SRC_ERROR},
+ #else
+ {"CIPHER_TABLE_SRC_ERROR", ERR_LIB_SSL, 139},
+ #endif
+ #ifdef SSL_R_CLIENTHELLO_TLSEXT
+ {"CLIENTHELLO_TLSEXT", ERR_LIB_SSL, SSL_R_CLIENTHELLO_TLSEXT},
+ #else
+ {"CLIENTHELLO_TLSEXT", ERR_LIB_SSL, 226},
+ #endif
+ #ifdef SSL_R_COMPRESSED_LENGTH_TOO_LONG
+ {"COMPRESSED_LENGTH_TOO_LONG", ERR_LIB_SSL, SSL_R_COMPRESSED_LENGTH_TOO_LONG},
+ #else
+ {"COMPRESSED_LENGTH_TOO_LONG", ERR_LIB_SSL, 140},
+ #endif
+ #ifdef SSL_R_COMPRESSION_DISABLED
+ {"COMPRESSION_DISABLED", ERR_LIB_SSL, SSL_R_COMPRESSION_DISABLED},
+ #else
+ {"COMPRESSION_DISABLED", ERR_LIB_SSL, 343},
+ #endif
+ #ifdef SSL_R_COMPRESSION_FAILURE
+ {"COMPRESSION_FAILURE", ERR_LIB_SSL, SSL_R_COMPRESSION_FAILURE},
+ #else
+ {"COMPRESSION_FAILURE", ERR_LIB_SSL, 141},
+ #endif
+ #ifdef SSL_R_COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE
+ {"COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE", ERR_LIB_SSL, SSL_R_COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE},
+ #else
+ {"COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE", ERR_LIB_SSL, 307},
+ #endif
+ #ifdef SSL_R_COMPRESSION_LIBRARY_ERROR
+ {"COMPRESSION_LIBRARY_ERROR", ERR_LIB_SSL, SSL_R_COMPRESSION_LIBRARY_ERROR},
+ #else
+ {"COMPRESSION_LIBRARY_ERROR", ERR_LIB_SSL, 142},
+ #endif
+ #ifdef SSL_R_CONNECTION_ID_IS_DIFFERENT
+ {"CONNECTION_ID_IS_DIFFERENT", ERR_LIB_SSL, SSL_R_CONNECTION_ID_IS_DIFFERENT},
+ #else
+ {"CONNECTION_ID_IS_DIFFERENT", ERR_LIB_SSL, 143},
+ #endif
+ #ifdef SSL_R_CONNECTION_TYPE_NOT_SET
+ {"CONNECTION_TYPE_NOT_SET", ERR_LIB_SSL, SSL_R_CONNECTION_TYPE_NOT_SET},
+ #else
+ {"CONNECTION_TYPE_NOT_SET", ERR_LIB_SSL, 144},
+ #endif
+ #ifdef SSL_R_COOKIE_MISMATCH
+ {"COOKIE_MISMATCH", ERR_LIB_SSL, SSL_R_COOKIE_MISMATCH},
+ #else
+ {"COOKIE_MISMATCH", ERR_LIB_SSL, 308},
+ #endif
+ #ifdef SSL_R_DATA_BETWEEN_CCS_AND_FINISHED
+ {"DATA_BETWEEN_CCS_AND_FINISHED", ERR_LIB_SSL, SSL_R_DATA_BETWEEN_CCS_AND_FINISHED},
+ #else
+ {"DATA_BETWEEN_CCS_AND_FINISHED", ERR_LIB_SSL, 145},
+ #endif
+ #ifdef SSL_R_DATA_LENGTH_TOO_LONG
+ {"DATA_LENGTH_TOO_LONG", ERR_LIB_SSL, SSL_R_DATA_LENGTH_TOO_LONG},
+ #else
+ {"DATA_LENGTH_TOO_LONG", ERR_LIB_SSL, 146},
+ #endif
+ #ifdef SSL_R_DECRYPTION_FAILED
+ {"DECRYPTION_FAILED", ERR_LIB_SSL, SSL_R_DECRYPTION_FAILED},
+ #else
+ {"DECRYPTION_FAILED", ERR_LIB_SSL, 147},
+ #endif
+ #ifdef SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC
+ {"DECRYPTION_FAILED_OR_BAD_RECORD_MAC", ERR_LIB_SSL, SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC},
+ #else
+ {"DECRYPTION_FAILED_OR_BAD_RECORD_MAC", ERR_LIB_SSL, 281},
+ #endif
+ #ifdef SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG
+ {"DH_PUBLIC_VALUE_LENGTH_IS_WRONG", ERR_LIB_SSL, SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG},
+ #else
+ {"DH_PUBLIC_VALUE_LENGTH_IS_WRONG", ERR_LIB_SSL, 148},
+ #endif
+ #ifdef SSL_R_DIGEST_CHECK_FAILED
+ {"DIGEST_CHECK_FAILED", ERR_LIB_SSL, SSL_R_DIGEST_CHECK_FAILED},
+ #else
+ {"DIGEST_CHECK_FAILED", ERR_LIB_SSL, 149},
+ #endif
+ #ifdef SSL_R_DTLS_MESSAGE_TOO_BIG
+ {"DTLS_MESSAGE_TOO_BIG", ERR_LIB_SSL, SSL_R_DTLS_MESSAGE_TOO_BIG},
+ #else
+ {"DTLS_MESSAGE_TOO_BIG", ERR_LIB_SSL, 334},
+ #endif
+ #ifdef SSL_R_DUPLICATE_COMPRESSION_ID
+ {"DUPLICATE_COMPRESSION_ID", ERR_LIB_SSL, SSL_R_DUPLICATE_COMPRESSION_ID},
+ #else
+ {"DUPLICATE_COMPRESSION_ID", ERR_LIB_SSL, 309},
+ #endif
+ #ifdef SSL_R_ECC_CERT_NOT_FOR_KEY_AGREEMENT
+ {"ECC_CERT_NOT_FOR_KEY_AGREEMENT", ERR_LIB_SSL, SSL_R_ECC_CERT_NOT_FOR_KEY_AGREEMENT},
+ #else
+ {"ECC_CERT_NOT_FOR_KEY_AGREEMENT", ERR_LIB_SSL, 317},
+ #endif
+ #ifdef SSL_R_ECC_CERT_NOT_FOR_SIGNING
+ {"ECC_CERT_NOT_FOR_SIGNING", ERR_LIB_SSL, SSL_R_ECC_CERT_NOT_FOR_SIGNING},
+ #else
+ {"ECC_CERT_NOT_FOR_SIGNING", ERR_LIB_SSL, 318},
+ #endif
+ #ifdef SSL_R_ECC_CERT_SHOULD_HAVE_RSA_SIGNATURE
+ {"ECC_CERT_SHOULD_HAVE_RSA_SIGNATURE", ERR_LIB_SSL, SSL_R_ECC_CERT_SHOULD_HAVE_RSA_SIGNATURE},
+ #else
+ {"ECC_CERT_SHOULD_HAVE_RSA_SIGNATURE", ERR_LIB_SSL, 322},
+ #endif
+ #ifdef SSL_R_ECC_CERT_SHOULD_HAVE_SHA1_SIGNATURE
+ {"ECC_CERT_SHOULD_HAVE_SHA1_SIGNATURE", ERR_LIB_SSL, SSL_R_ECC_CERT_SHOULD_HAVE_SHA1_SIGNATURE},
+ #else
+ {"ECC_CERT_SHOULD_HAVE_SHA1_SIGNATURE", ERR_LIB_SSL, 323},
+ #endif
+ #ifdef SSL_R_ECGROUP_TOO_LARGE_FOR_CIPHER
+ {"ECGROUP_TOO_LARGE_FOR_CIPHER", ERR_LIB_SSL, SSL_R_ECGROUP_TOO_LARGE_FOR_CIPHER},
+ #else
+ {"ECGROUP_TOO_LARGE_FOR_CIPHER", ERR_LIB_SSL, 310},
+ #endif
+ #ifdef SSL_R_ENCRYPTED_LENGTH_TOO_LONG
+ {"ENCRYPTED_LENGTH_TOO_LONG", ERR_LIB_SSL, SSL_R_ENCRYPTED_LENGTH_TOO_LONG},
+ #else
+ {"ENCRYPTED_LENGTH_TOO_LONG", ERR_LIB_SSL, 150},
+ #endif
+ #ifdef SSL_R_ERROR_GENERATING_TMP_RSA_KEY
+ {"ERROR_GENERATING_TMP_RSA_KEY", ERR_LIB_SSL, SSL_R_ERROR_GENERATING_TMP_RSA_KEY},
+ #else
+ {"ERROR_GENERATING_TMP_RSA_KEY", ERR_LIB_SSL, 282},
+ #endif
+ #ifdef SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST
+ {"ERROR_IN_RECEIVED_CIPHER_LIST", ERR_LIB_SSL, SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST},
+ #else
+ {"ERROR_IN_RECEIVED_CIPHER_LIST", ERR_LIB_SSL, 151},
+ #endif
+ #ifdef SSL_R_EXCESSIVE_MESSAGE_SIZE
+ {"EXCESSIVE_MESSAGE_SIZE", ERR_LIB_SSL, SSL_R_EXCESSIVE_MESSAGE_SIZE},
+ #else
+ {"EXCESSIVE_MESSAGE_SIZE", ERR_LIB_SSL, 152},
+ #endif
+ #ifdef SSL_R_EXTRA_DATA_IN_MESSAGE
+ {"EXTRA_DATA_IN_MESSAGE", ERR_LIB_SSL, SSL_R_EXTRA_DATA_IN_MESSAGE},
+ #else
+ {"EXTRA_DATA_IN_MESSAGE", ERR_LIB_SSL, 153},
+ #endif
+ #ifdef SSL_R_GOT_A_FIN_BEFORE_A_CCS
+ {"GOT_A_FIN_BEFORE_A_CCS", ERR_LIB_SSL, SSL_R_GOT_A_FIN_BEFORE_A_CCS},
+ #else
+ {"GOT_A_FIN_BEFORE_A_CCS", ERR_LIB_SSL, 154},
+ #endif
+ #ifdef SSL_R_HTTPS_PROXY_REQUEST
+ {"HTTPS_PROXY_REQUEST", ERR_LIB_SSL, SSL_R_HTTPS_PROXY_REQUEST},
+ #else
+ {"HTTPS_PROXY_REQUEST", ERR_LIB_SSL, 155},
+ #endif
+ #ifdef SSL_R_HTTP_REQUEST
+ {"HTTP_REQUEST", ERR_LIB_SSL, SSL_R_HTTP_REQUEST},
+ #else
+ {"HTTP_REQUEST", ERR_LIB_SSL, 156},
+ #endif
+ #ifdef SSL_R_ILLEGAL_PADDING
+ {"ILLEGAL_PADDING", ERR_LIB_SSL, SSL_R_ILLEGAL_PADDING},
+ #else
+ {"ILLEGAL_PADDING", ERR_LIB_SSL, 283},
+ #endif
+ #ifdef SSL_R_INCONSISTENT_COMPRESSION
+ {"INCONSISTENT_COMPRESSION", ERR_LIB_SSL, SSL_R_INCONSISTENT_COMPRESSION},
+ #else
+ {"INCONSISTENT_COMPRESSION", ERR_LIB_SSL, 340},
+ #endif
+ #ifdef SSL_R_INVALID_CHALLENGE_LENGTH
+ {"INVALID_CHALLENGE_LENGTH", ERR_LIB_SSL, SSL_R_INVALID_CHALLENGE_LENGTH},
+ #else
+ {"INVALID_CHALLENGE_LENGTH", ERR_LIB_SSL, 158},
+ #endif
+ #ifdef SSL_R_INVALID_COMMAND
+ {"INVALID_COMMAND", ERR_LIB_SSL, SSL_R_INVALID_COMMAND},
+ #else
+ {"INVALID_COMMAND", ERR_LIB_SSL, 280},
+ #endif
+ #ifdef SSL_R_INVALID_COMPRESSION_ALGORITHM
+ {"INVALID_COMPRESSION_ALGORITHM", ERR_LIB_SSL, SSL_R_INVALID_COMPRESSION_ALGORITHM},
+ #else
+ {"INVALID_COMPRESSION_ALGORITHM", ERR_LIB_SSL, 341},
+ #endif
+ #ifdef SSL_R_INVALID_PURPOSE
+ {"INVALID_PURPOSE", ERR_LIB_SSL, SSL_R_INVALID_PURPOSE},
+ #else
+ {"INVALID_PURPOSE", ERR_LIB_SSL, 278},
+ #endif
+ #ifdef SSL_R_INVALID_STATUS_RESPONSE
+ {"INVALID_STATUS_RESPONSE", ERR_LIB_SSL, SSL_R_INVALID_STATUS_RESPONSE},
+ #else
+ {"INVALID_STATUS_RESPONSE", ERR_LIB_SSL, 328},
+ #endif
+ #ifdef SSL_R_INVALID_TICKET_KEYS_LENGTH
+ {"INVALID_TICKET_KEYS_LENGTH", ERR_LIB_SSL, SSL_R_INVALID_TICKET_KEYS_LENGTH},
+ #else
+ {"INVALID_TICKET_KEYS_LENGTH", ERR_LIB_SSL, 325},
+ #endif
+ #ifdef SSL_R_INVALID_TRUST
+ {"INVALID_TRUST", ERR_LIB_SSL, SSL_R_INVALID_TRUST},
+ #else
+ {"INVALID_TRUST", ERR_LIB_SSL, 279},
+ #endif
+ #ifdef SSL_R_KEY_ARG_TOO_LONG
+ {"KEY_ARG_TOO_LONG", ERR_LIB_SSL, SSL_R_KEY_ARG_TOO_LONG},
+ #else
+ {"KEY_ARG_TOO_LONG", ERR_LIB_SSL, 284},
+ #endif
+ #ifdef SSL_R_KRB5
+ {"KRB5", ERR_LIB_SSL, SSL_R_KRB5},
+ #else
+ {"KRB5", ERR_LIB_SSL, 285},
+ #endif
+ #ifdef SSL_R_KRB5_C_CC_PRINC
+ {"KRB5_C_CC_PRINC", ERR_LIB_SSL, SSL_R_KRB5_C_CC_PRINC},
+ #else
+ {"KRB5_C_CC_PRINC", ERR_LIB_SSL, 286},
+ #endif
+ #ifdef SSL_R_KRB5_C_GET_CRED
+ {"KRB5_C_GET_CRED", ERR_LIB_SSL, SSL_R_KRB5_C_GET_CRED},
+ #else
+ {"KRB5_C_GET_CRED", ERR_LIB_SSL, 287},
+ #endif
+ #ifdef SSL_R_KRB5_C_INIT
+ {"KRB5_C_INIT", ERR_LIB_SSL, SSL_R_KRB5_C_INIT},
+ #else
+ {"KRB5_C_INIT", ERR_LIB_SSL, 288},
+ #endif
+ #ifdef SSL_R_KRB5_C_MK_REQ
+ {"KRB5_C_MK_REQ", ERR_LIB_SSL, SSL_R_KRB5_C_MK_REQ},
+ #else
+ {"KRB5_C_MK_REQ", ERR_LIB_SSL, 289},
+ #endif
+ #ifdef SSL_R_KRB5_S_BAD_TICKET
+ {"KRB5_S_BAD_TICKET", ERR_LIB_SSL, SSL_R_KRB5_S_BAD_TICKET},
+ #else
+ {"KRB5_S_BAD_TICKET", ERR_LIB_SSL, 290},
+ #endif
+ #ifdef SSL_R_KRB5_S_INIT
+ {"KRB5_S_INIT", ERR_LIB_SSL, SSL_R_KRB5_S_INIT},
+ #else
+ {"KRB5_S_INIT", ERR_LIB_SSL, 291},
+ #endif
+ #ifdef SSL_R_KRB5_S_RD_REQ
+ {"KRB5_S_RD_REQ", ERR_LIB_SSL, SSL_R_KRB5_S_RD_REQ},
+ #else
+ {"KRB5_S_RD_REQ", ERR_LIB_SSL, 292},
+ #endif
+ #ifdef SSL_R_KRB5_S_TKT_EXPIRED
+ {"KRB5_S_TKT_EXPIRED", ERR_LIB_SSL, SSL_R_KRB5_S_TKT_EXPIRED},
+ #else
+ {"KRB5_S_TKT_EXPIRED", ERR_LIB_SSL, 293},
+ #endif
+ #ifdef SSL_R_KRB5_S_TKT_NYV
+ {"KRB5_S_TKT_NYV", ERR_LIB_SSL, SSL_R_KRB5_S_TKT_NYV},
+ #else
+ {"KRB5_S_TKT_NYV", ERR_LIB_SSL, 294},
+ #endif
+ #ifdef SSL_R_KRB5_S_TKT_SKEW
+ {"KRB5_S_TKT_SKEW", ERR_LIB_SSL, SSL_R_KRB5_S_TKT_SKEW},
+ #else
+ {"KRB5_S_TKT_SKEW", ERR_LIB_SSL, 295},
+ #endif
+ #ifdef SSL_R_LENGTH_MISMATCH
+ {"LENGTH_MISMATCH", ERR_LIB_SSL, SSL_R_LENGTH_MISMATCH},
+ #else
+ {"LENGTH_MISMATCH", ERR_LIB_SSL, 159},
+ #endif
+ #ifdef SSL_R_LENGTH_TOO_SHORT
+ {"LENGTH_TOO_SHORT", ERR_LIB_SSL, SSL_R_LENGTH_TOO_SHORT},
+ #else
+ {"LENGTH_TOO_SHORT", ERR_LIB_SSL, 160},
+ #endif
+ #ifdef SSL_R_LIBRARY_BUG
+ {"LIBRARY_BUG", ERR_LIB_SSL, SSL_R_LIBRARY_BUG},
+ #else
+ {"LIBRARY_BUG", ERR_LIB_SSL, 274},
+ #endif
+ #ifdef SSL_R_LIBRARY_HAS_NO_CIPHERS
+ {"LIBRARY_HAS_NO_CIPHERS", ERR_LIB_SSL, SSL_R_LIBRARY_HAS_NO_CIPHERS},
+ #else
+ {"LIBRARY_HAS_NO_CIPHERS", ERR_LIB_SSL, 161},
+ #endif
+ #ifdef SSL_R_MESSAGE_TOO_LONG
+ {"MESSAGE_TOO_LONG", ERR_LIB_SSL, SSL_R_MESSAGE_TOO_LONG},
+ #else
+ {"MESSAGE_TOO_LONG", ERR_LIB_SSL, 296},
+ #endif
+ #ifdef SSL_R_MISSING_DH_DSA_CERT
+ {"MISSING_DH_DSA_CERT", ERR_LIB_SSL, SSL_R_MISSING_DH_DSA_CERT},
+ #else
+ {"MISSING_DH_DSA_CERT", ERR_LIB_SSL, 162},
+ #endif
+ #ifdef SSL_R_MISSING_DH_KEY
+ {"MISSING_DH_KEY", ERR_LIB_SSL, SSL_R_MISSING_DH_KEY},
+ #else
+ {"MISSING_DH_KEY", ERR_LIB_SSL, 163},
+ #endif
+ #ifdef SSL_R_MISSING_DH_RSA_CERT
+ {"MISSING_DH_RSA_CERT", ERR_LIB_SSL, SSL_R_MISSING_DH_RSA_CERT},
+ #else
+ {"MISSING_DH_RSA_CERT", ERR_LIB_SSL, 164},
+ #endif
+ #ifdef SSL_R_MISSING_DSA_SIGNING_CERT
+ {"MISSING_DSA_SIGNING_CERT", ERR_LIB_SSL, SSL_R_MISSING_DSA_SIGNING_CERT},
+ #else
+ {"MISSING_DSA_SIGNING_CERT", ERR_LIB_SSL, 165},
+ #endif
+ #ifdef SSL_R_MISSING_EXPORT_TMP_DH_KEY
+ {"MISSING_EXPORT_TMP_DH_KEY", ERR_LIB_SSL, SSL_R_MISSING_EXPORT_TMP_DH_KEY},
+ #else
+ {"MISSING_EXPORT_TMP_DH_KEY", ERR_LIB_SSL, 166},
+ #endif
+ #ifdef SSL_R_MISSING_EXPORT_TMP_RSA_KEY
+ {"MISSING_EXPORT_TMP_RSA_KEY", ERR_LIB_SSL, SSL_R_MISSING_EXPORT_TMP_RSA_KEY},
+ #else
+ {"MISSING_EXPORT_TMP_RSA_KEY", ERR_LIB_SSL, 167},
+ #endif
+ #ifdef SSL_R_MISSING_RSA_CERTIFICATE
+ {"MISSING_RSA_CERTIFICATE", ERR_LIB_SSL, SSL_R_MISSING_RSA_CERTIFICATE},
+ #else
+ {"MISSING_RSA_CERTIFICATE", ERR_LIB_SSL, 168},
+ #endif
+ #ifdef SSL_R_MISSING_RSA_ENCRYPTING_CERT
+ {"MISSING_RSA_ENCRYPTING_CERT", ERR_LIB_SSL, SSL_R_MISSING_RSA_ENCRYPTING_CERT},
+ #else
+ {"MISSING_RSA_ENCRYPTING_CERT", ERR_LIB_SSL, 169},
+ #endif
+ #ifdef SSL_R_MISSING_RSA_SIGNING_CERT
+ {"MISSING_RSA_SIGNING_CERT", ERR_LIB_SSL, SSL_R_MISSING_RSA_SIGNING_CERT},
+ #else
+ {"MISSING_RSA_SIGNING_CERT", ERR_LIB_SSL, 170},
+ #endif
+ #ifdef SSL_R_MISSING_TMP_DH_KEY
+ {"MISSING_TMP_DH_KEY", ERR_LIB_SSL, SSL_R_MISSING_TMP_DH_KEY},
+ #else
+ {"MISSING_TMP_DH_KEY", ERR_LIB_SSL, 171},
+ #endif
+ #ifdef SSL_R_MISSING_TMP_ECDH_KEY
+ {"MISSING_TMP_ECDH_KEY", ERR_LIB_SSL, SSL_R_MISSING_TMP_ECDH_KEY},
+ #else
+ {"MISSING_TMP_ECDH_KEY", ERR_LIB_SSL, 311},
+ #endif
+ #ifdef SSL_R_MISSING_TMP_RSA_KEY
+ {"MISSING_TMP_RSA_KEY", ERR_LIB_SSL, SSL_R_MISSING_TMP_RSA_KEY},
+ #else
+ {"MISSING_TMP_RSA_KEY", ERR_LIB_SSL, 172},
+ #endif
+ #ifdef SSL_R_MISSING_TMP_RSA_PKEY
+ {"MISSING_TMP_RSA_PKEY", ERR_LIB_SSL, SSL_R_MISSING_TMP_RSA_PKEY},
+ #else
+ {"MISSING_TMP_RSA_PKEY", ERR_LIB_SSL, 173},
+ #endif
+ #ifdef SSL_R_MISSING_VERIFY_MESSAGE
+ {"MISSING_VERIFY_MESSAGE", ERR_LIB_SSL, SSL_R_MISSING_VERIFY_MESSAGE},
+ #else
+ {"MISSING_VERIFY_MESSAGE", ERR_LIB_SSL, 174},
+ #endif
+ #ifdef SSL_R_NON_SSLV2_INITIAL_PACKET
+ {"NON_SSLV2_INITIAL_PACKET", ERR_LIB_SSL, SSL_R_NON_SSLV2_INITIAL_PACKET},
+ #else
+ {"NON_SSLV2_INITIAL_PACKET", ERR_LIB_SSL, 175},
+ #endif
+ #ifdef SSL_R_NO_CERTIFICATES_RETURNED
+ {"NO_CERTIFICATES_RETURNED", ERR_LIB_SSL, SSL_R_NO_CERTIFICATES_RETURNED},
+ #else
+ {"NO_CERTIFICATES_RETURNED", ERR_LIB_SSL, 176},
+ #endif
+ #ifdef SSL_R_NO_CERTIFICATE_ASSIGNED
+ {"NO_CERTIFICATE_ASSIGNED", ERR_LIB_SSL, SSL_R_NO_CERTIFICATE_ASSIGNED},
+ #else
+ {"NO_CERTIFICATE_ASSIGNED", ERR_LIB_SSL, 177},
+ #endif
+ #ifdef SSL_R_NO_CERTIFICATE_RETURNED
+ {"NO_CERTIFICATE_RETURNED", ERR_LIB_SSL, SSL_R_NO_CERTIFICATE_RETURNED},
+ #else
+ {"NO_CERTIFICATE_RETURNED", ERR_LIB_SSL, 178},
+ #endif
+ #ifdef SSL_R_NO_CERTIFICATE_SET
+ {"NO_CERTIFICATE_SET", ERR_LIB_SSL, SSL_R_NO_CERTIFICATE_SET},
+ #else
+ {"NO_CERTIFICATE_SET", ERR_LIB_SSL, 179},
+ #endif
+ #ifdef SSL_R_NO_CERTIFICATE_SPECIFIED
+ {"NO_CERTIFICATE_SPECIFIED", ERR_LIB_SSL, SSL_R_NO_CERTIFICATE_SPECIFIED},
+ #else
+ {"NO_CERTIFICATE_SPECIFIED", ERR_LIB_SSL, 180},
+ #endif
+ #ifdef SSL_R_NO_CIPHERS_AVAILABLE
+ {"NO_CIPHERS_AVAILABLE", ERR_LIB_SSL, SSL_R_NO_CIPHERS_AVAILABLE},
+ #else
+ {"NO_CIPHERS_AVAILABLE", ERR_LIB_SSL, 181},
+ #endif
+ #ifdef SSL_R_NO_CIPHERS_PASSED
+ {"NO_CIPHERS_PASSED", ERR_LIB_SSL, SSL_R_NO_CIPHERS_PASSED},
+ #else
+ {"NO_CIPHERS_PASSED", ERR_LIB_SSL, 182},
+ #endif
+ #ifdef SSL_R_NO_CIPHERS_SPECIFIED
+ {"NO_CIPHERS_SPECIFIED", ERR_LIB_SSL, SSL_R_NO_CIPHERS_SPECIFIED},
+ #else
+ {"NO_CIPHERS_SPECIFIED", ERR_LIB_SSL, 183},
+ #endif
+ #ifdef SSL_R_NO_CIPHER_LIST
+ {"NO_CIPHER_LIST", ERR_LIB_SSL, SSL_R_NO_CIPHER_LIST},
+ #else
+ {"NO_CIPHER_LIST", ERR_LIB_SSL, 184},
+ #endif
+ #ifdef SSL_R_NO_CIPHER_MATCH
+ {"NO_CIPHER_MATCH", ERR_LIB_SSL, SSL_R_NO_CIPHER_MATCH},
+ #else
+ {"NO_CIPHER_MATCH", ERR_LIB_SSL, 185},
+ #endif
+ #ifdef SSL_R_NO_CLIENT_CERT_METHOD
+ {"NO_CLIENT_CERT_METHOD", ERR_LIB_SSL, SSL_R_NO_CLIENT_CERT_METHOD},
+ #else
+ {"NO_CLIENT_CERT_METHOD", ERR_LIB_SSL, 331},
+ #endif
+ #ifdef SSL_R_NO_CLIENT_CERT_RECEIVED
+ {"NO_CLIENT_CERT_RECEIVED", ERR_LIB_SSL, SSL_R_NO_CLIENT_CERT_RECEIVED},
+ #else
+ {"NO_CLIENT_CERT_RECEIVED", ERR_LIB_SSL, 186},
+ #endif
+ #ifdef SSL_R_NO_COMPRESSION_SPECIFIED
+ {"NO_COMPRESSION_SPECIFIED", ERR_LIB_SSL, SSL_R_NO_COMPRESSION_SPECIFIED},
+ #else
+ {"NO_COMPRESSION_SPECIFIED", ERR_LIB_SSL, 187},
+ #endif
+ #ifdef SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER
+ {"NO_GOST_CERTIFICATE_SENT_BY_PEER", ERR_LIB_SSL, SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER},
+ #else
+ {"NO_GOST_CERTIFICATE_SENT_BY_PEER", ERR_LIB_SSL, 330},
+ #endif
+ #ifdef SSL_R_NO_METHOD_SPECIFIED
+ {"NO_METHOD_SPECIFIED", ERR_LIB_SSL, SSL_R_NO_METHOD_SPECIFIED},
+ #else
+ {"NO_METHOD_SPECIFIED", ERR_LIB_SSL, 188},
+ #endif
+ #ifdef SSL_R_NO_PRIVATEKEY
+ {"NO_PRIVATEKEY", ERR_LIB_SSL, SSL_R_NO_PRIVATEKEY},
+ #else
+ {"NO_PRIVATEKEY", ERR_LIB_SSL, 189},
+ #endif
+ #ifdef SSL_R_NO_PRIVATE_KEY_ASSIGNED
+ {"NO_PRIVATE_KEY_ASSIGNED", ERR_LIB_SSL, SSL_R_NO_PRIVATE_KEY_ASSIGNED},
+ #else
+ {"NO_PRIVATE_KEY_ASSIGNED", ERR_LIB_SSL, 190},
+ #endif
+ #ifdef SSL_R_NO_PROTOCOLS_AVAILABLE
+ {"NO_PROTOCOLS_AVAILABLE", ERR_LIB_SSL, SSL_R_NO_PROTOCOLS_AVAILABLE},
+ #else
+ {"NO_PROTOCOLS_AVAILABLE", ERR_LIB_SSL, 191},
+ #endif
+ #ifdef SSL_R_NO_PUBLICKEY
+ {"NO_PUBLICKEY", ERR_LIB_SSL, SSL_R_NO_PUBLICKEY},
+ #else
+ {"NO_PUBLICKEY", ERR_LIB_SSL, 192},
+ #endif
+ #ifdef SSL_R_NO_RENEGOTIATION
+ {"NO_RENEGOTIATION", ERR_LIB_SSL, SSL_R_NO_RENEGOTIATION},
+ #else
+ {"NO_RENEGOTIATION", ERR_LIB_SSL, 339},
+ #endif
+ #ifdef SSL_R_NO_REQUIRED_DIGEST
+ {"NO_REQUIRED_DIGEST", ERR_LIB_SSL, SSL_R_NO_REQUIRED_DIGEST},
+ #else
+ {"NO_REQUIRED_DIGEST", ERR_LIB_SSL, 324},
+ #endif
+ #ifdef SSL_R_NO_SHARED_CIPHER
+ {"NO_SHARED_CIPHER", ERR_LIB_SSL, SSL_R_NO_SHARED_CIPHER},
+ #else
+ {"NO_SHARED_CIPHER", ERR_LIB_SSL, 193},
+ #endif
+ #ifdef SSL_R_NO_VERIFY_CALLBACK
+ {"NO_VERIFY_CALLBACK", ERR_LIB_SSL, SSL_R_NO_VERIFY_CALLBACK},
+ #else
+ {"NO_VERIFY_CALLBACK", ERR_LIB_SSL, 194},
+ #endif
+ #ifdef SSL_R_NULL_SSL_CTX
+ {"NULL_SSL_CTX", ERR_LIB_SSL, SSL_R_NULL_SSL_CTX},
+ #else
+ {"NULL_SSL_CTX", ERR_LIB_SSL, 195},
+ #endif
+ #ifdef SSL_R_NULL_SSL_METHOD_PASSED
+ {"NULL_SSL_METHOD_PASSED", ERR_LIB_SSL, SSL_R_NULL_SSL_METHOD_PASSED},
+ #else
+ {"NULL_SSL_METHOD_PASSED", ERR_LIB_SSL, 196},
+ #endif
+ #ifdef SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED
+ {"OLD_SESSION_CIPHER_NOT_RETURNED", ERR_LIB_SSL, SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED},
+ #else
+ {"OLD_SESSION_CIPHER_NOT_RETURNED", ERR_LIB_SSL, 197},
+ #endif
+ #ifdef SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED
+ {"OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED", ERR_LIB_SSL, SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED},
+ #else
+ {"OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED", ERR_LIB_SSL, 344},
+ #endif
+ #ifdef SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE
+ {"ONLY_TLS_ALLOWED_IN_FIPS_MODE", ERR_LIB_SSL, SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE},
+ #else
+ {"ONLY_TLS_ALLOWED_IN_FIPS_MODE", ERR_LIB_SSL, 297},
+ #endif
+ #ifdef SSL_R_OPAQUE_PRF_INPUT_TOO_LONG
+ {"OPAQUE_PRF_INPUT_TOO_LONG", ERR_LIB_SSL, SSL_R_OPAQUE_PRF_INPUT_TOO_LONG},
+ #else
+ {"OPAQUE_PRF_INPUT_TOO_LONG", ERR_LIB_SSL, 327},
+ #endif
+ #ifdef SSL_R_PACKET_LENGTH_TOO_LONG
+ {"PACKET_LENGTH_TOO_LONG", ERR_LIB_SSL, SSL_R_PACKET_LENGTH_TOO_LONG},
+ #else
+ {"PACKET_LENGTH_TOO_LONG", ERR_LIB_SSL, 198},
+ #endif
+ #ifdef SSL_R_PARSE_TLSEXT
+ {"PARSE_TLSEXT", ERR_LIB_SSL, SSL_R_PARSE_TLSEXT},
+ #else
+ {"PARSE_TLSEXT", ERR_LIB_SSL, 227},
+ #endif
+ #ifdef SSL_R_PATH_TOO_LONG
+ {"PATH_TOO_LONG", ERR_LIB_SSL, SSL_R_PATH_TOO_LONG},
+ #else
+ {"PATH_TOO_LONG", ERR_LIB_SSL, 270},
+ #endif
+ #ifdef SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE
+ {"PEER_DID_NOT_RETURN_A_CERTIFICATE", ERR_LIB_SSL, SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE},
+ #else
+ {"PEER_DID_NOT_RETURN_A_CERTIFICATE", ERR_LIB_SSL, 199},
+ #endif
+ #ifdef SSL_R_PEER_ERROR
+ {"PEER_ERROR", ERR_LIB_SSL, SSL_R_PEER_ERROR},
+ #else
+ {"PEER_ERROR", ERR_LIB_SSL, 200},
+ #endif
+ #ifdef SSL_R_PEER_ERROR_CERTIFICATE
+ {"PEER_ERROR_CERTIFICATE", ERR_LIB_SSL, SSL_R_PEER_ERROR_CERTIFICATE},
+ #else
+ {"PEER_ERROR_CERTIFICATE", ERR_LIB_SSL, 201},
+ #endif
+ #ifdef SSL_R_PEER_ERROR_NO_CERTIFICATE
+ {"PEER_ERROR_NO_CERTIFICATE", ERR_LIB_SSL, SSL_R_PEER_ERROR_NO_CERTIFICATE},
+ #else
+ {"PEER_ERROR_NO_CERTIFICATE", ERR_LIB_SSL, 202},
+ #endif
+ #ifdef SSL_R_PEER_ERROR_NO_CIPHER
+ {"PEER_ERROR_NO_CIPHER", ERR_LIB_SSL, SSL_R_PEER_ERROR_NO_CIPHER},
+ #else
+ {"PEER_ERROR_NO_CIPHER", ERR_LIB_SSL, 203},
+ #endif
+ #ifdef SSL_R_PEER_ERROR_UNSUPPORTED_CERTIFICATE_TYPE
+ {"PEER_ERROR_UNSUPPORTED_CERTIFICATE_TYPE", ERR_LIB_SSL, SSL_R_PEER_ERROR_UNSUPPORTED_CERTIFICATE_TYPE},
+ #else
+ {"PEER_ERROR_UNSUPPORTED_CERTIFICATE_TYPE", ERR_LIB_SSL, 204},
+ #endif
+ #ifdef SSL_R_PRE_MAC_LENGTH_TOO_LONG
+ {"PRE_MAC_LENGTH_TOO_LONG", ERR_LIB_SSL, SSL_R_PRE_MAC_LENGTH_TOO_LONG},
+ #else
+ {"PRE_MAC_LENGTH_TOO_LONG", ERR_LIB_SSL, 205},
+ #endif
+ #ifdef SSL_R_PROBLEMS_MAPPING_CIPHER_FUNCTIONS
+ {"PROBLEMS_MAPPING_CIPHER_FUNCTIONS", ERR_LIB_SSL, SSL_R_PROBLEMS_MAPPING_CIPHER_FUNCTIONS},
+ #else
+ {"PROBLEMS_MAPPING_CIPHER_FUNCTIONS", ERR_LIB_SSL, 206},
+ #endif
+ #ifdef SSL_R_PROTOCOL_IS_SHUTDOWN
+ {"PROTOCOL_IS_SHUTDOWN", ERR_LIB_SSL, SSL_R_PROTOCOL_IS_SHUTDOWN},
+ #else
+ {"PROTOCOL_IS_SHUTDOWN", ERR_LIB_SSL, 207},
+ #endif
+ #ifdef SSL_R_PSK_IDENTITY_NOT_FOUND
+ {"PSK_IDENTITY_NOT_FOUND", ERR_LIB_SSL, SSL_R_PSK_IDENTITY_NOT_FOUND},
+ #else
+ {"PSK_IDENTITY_NOT_FOUND", ERR_LIB_SSL, 223},
+ #endif
+ #ifdef SSL_R_PSK_NO_CLIENT_CB
+ {"PSK_NO_CLIENT_CB", ERR_LIB_SSL, SSL_R_PSK_NO_CLIENT_CB},
+ #else
+ {"PSK_NO_CLIENT_CB", ERR_LIB_SSL, 224},
+ #endif
+ #ifdef SSL_R_PSK_NO_SERVER_CB
+ {"PSK_NO_SERVER_CB", ERR_LIB_SSL, SSL_R_PSK_NO_SERVER_CB},
+ #else
+ {"PSK_NO_SERVER_CB", ERR_LIB_SSL, 225},
+ #endif
+ #ifdef SSL_R_PUBLIC_KEY_ENCRYPT_ERROR
+ {"PUBLIC_KEY_ENCRYPT_ERROR", ERR_LIB_SSL, SSL_R_PUBLIC_KEY_ENCRYPT_ERROR},
+ #else
+ {"PUBLIC_KEY_ENCRYPT_ERROR", ERR_LIB_SSL, 208},
+ #endif
+ #ifdef SSL_R_PUBLIC_KEY_IS_NOT_RSA
+ {"PUBLIC_KEY_IS_NOT_RSA", ERR_LIB_SSL, SSL_R_PUBLIC_KEY_IS_NOT_RSA},
+ #else
+ {"PUBLIC_KEY_IS_NOT_RSA", ERR_LIB_SSL, 209},
+ #endif
+ #ifdef SSL_R_PUBLIC_KEY_NOT_RSA
+ {"PUBLIC_KEY_NOT_RSA", ERR_LIB_SSL, SSL_R_PUBLIC_KEY_NOT_RSA},
+ #else
+ {"PUBLIC_KEY_NOT_RSA", ERR_LIB_SSL, 210},
+ #endif
+ #ifdef SSL_R_READ_BIO_NOT_SET
+ {"READ_BIO_NOT_SET", ERR_LIB_SSL, SSL_R_READ_BIO_NOT_SET},
+ #else
+ {"READ_BIO_NOT_SET", ERR_LIB_SSL, 211},
+ #endif
+ #ifdef SSL_R_READ_TIMEOUT_EXPIRED
+ {"READ_TIMEOUT_EXPIRED", ERR_LIB_SSL, SSL_R_READ_TIMEOUT_EXPIRED},
+ #else
+ {"READ_TIMEOUT_EXPIRED", ERR_LIB_SSL, 312},
+ #endif
+ #ifdef SSL_R_READ_WRONG_PACKET_TYPE
+ {"READ_WRONG_PACKET_TYPE", ERR_LIB_SSL, SSL_R_READ_WRONG_PACKET_TYPE},
+ #else
+ {"READ_WRONG_PACKET_TYPE", ERR_LIB_SSL, 212},
+ #endif
+ #ifdef SSL_R_RECORD_LENGTH_MISMATCH
+ {"RECORD_LENGTH_MISMATCH", ERR_LIB_SSL, SSL_R_RECORD_LENGTH_MISMATCH},
+ #else
+ {"RECORD_LENGTH_MISMATCH", ERR_LIB_SSL, 213},
+ #endif
+ #ifdef SSL_R_RECORD_TOO_LARGE
+ {"RECORD_TOO_LARGE", ERR_LIB_SSL, SSL_R_RECORD_TOO_LARGE},
+ #else
+ {"RECORD_TOO_LARGE", ERR_LIB_SSL, 214},
+ #endif
+ #ifdef SSL_R_RECORD_TOO_SMALL
+ {"RECORD_TOO_SMALL", ERR_LIB_SSL, SSL_R_RECORD_TOO_SMALL},
+ #else
+ {"RECORD_TOO_SMALL", ERR_LIB_SSL, 298},
+ #endif
+ #ifdef SSL_R_RENEGOTIATE_EXT_TOO_LONG
+ {"RENEGOTIATE_EXT_TOO_LONG", ERR_LIB_SSL, SSL_R_RENEGOTIATE_EXT_TOO_LONG},
+ #else
+ {"RENEGOTIATE_EXT_TOO_LONG", ERR_LIB_SSL, 335},
+ #endif
+ #ifdef SSL_R_RENEGOTIATION_ENCODING_ERR
+ {"RENEGOTIATION_ENCODING_ERR", ERR_LIB_SSL, SSL_R_RENEGOTIATION_ENCODING_ERR},
+ #else
+ {"RENEGOTIATION_ENCODING_ERR", ERR_LIB_SSL, 336},
+ #endif
+ #ifdef SSL_R_RENEGOTIATION_MISMATCH
+ {"RENEGOTIATION_MISMATCH", ERR_LIB_SSL, SSL_R_RENEGOTIATION_MISMATCH},
+ #else
+ {"RENEGOTIATION_MISMATCH", ERR_LIB_SSL, 337},
+ #endif
+ #ifdef SSL_R_REQUIRED_CIPHER_MISSING
+ {"REQUIRED_CIPHER_MISSING", ERR_LIB_SSL, SSL_R_REQUIRED_CIPHER_MISSING},
+ #else
+ {"REQUIRED_CIPHER_MISSING", ERR_LIB_SSL, 215},
+ #endif
+ #ifdef SSL_R_REQUIRED_COMPRESSSION_ALGORITHM_MISSING
+ {"REQUIRED_COMPRESSSION_ALGORITHM_MISSING", ERR_LIB_SSL, SSL_R_REQUIRED_COMPRESSSION_ALGORITHM_MISSING},
+ #else
+ {"REQUIRED_COMPRESSSION_ALGORITHM_MISSING", ERR_LIB_SSL, 342},
+ #endif
+ #ifdef SSL_R_REUSE_CERT_LENGTH_NOT_ZERO
+ {"REUSE_CERT_LENGTH_NOT_ZERO", ERR_LIB_SSL, SSL_R_REUSE_CERT_LENGTH_NOT_ZERO},
+ #else
+ {"REUSE_CERT_LENGTH_NOT_ZERO", ERR_LIB_SSL, 216},
+ #endif
+ #ifdef SSL_R_REUSE_CERT_TYPE_NOT_ZERO
+ {"REUSE_CERT_TYPE_NOT_ZERO", ERR_LIB_SSL, SSL_R_REUSE_CERT_TYPE_NOT_ZERO},
+ #else
+ {"REUSE_CERT_TYPE_NOT_ZERO", ERR_LIB_SSL, 217},
+ #endif
+ #ifdef SSL_R_REUSE_CIPHER_LIST_NOT_ZERO
+ {"REUSE_CIPHER_LIST_NOT_ZERO", ERR_LIB_SSL, SSL_R_REUSE_CIPHER_LIST_NOT_ZERO},
+ #else
+ {"REUSE_CIPHER_LIST_NOT_ZERO", ERR_LIB_SSL, 218},
+ #endif
+ #ifdef SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING
+ {"SCSV_RECEIVED_WHEN_RENEGOTIATING", ERR_LIB_SSL, SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING},
+ #else
+ {"SCSV_RECEIVED_WHEN_RENEGOTIATING", ERR_LIB_SSL, 345},
+ #endif
+ #ifdef SSL_R_SERVERHELLO_TLSEXT
+ {"SERVERHELLO_TLSEXT", ERR_LIB_SSL, SSL_R_SERVERHELLO_TLSEXT},
+ #else
+ {"SERVERHELLO_TLSEXT", ERR_LIB_SSL, 275},
+ #endif
+ #ifdef SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED
+ {"SESSION_ID_CONTEXT_UNINITIALIZED", ERR_LIB_SSL, SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED},
+ #else
+ {"SESSION_ID_CONTEXT_UNINITIALIZED", ERR_LIB_SSL, 277},
+ #endif
+ #ifdef SSL_R_SHORT_READ
+ {"SHORT_READ", ERR_LIB_SSL, SSL_R_SHORT_READ},
+ #else
+ {"SHORT_READ", ERR_LIB_SSL, 219},
+ #endif
+ #ifdef SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE
+ {"SIGNATURE_FOR_NON_SIGNING_CERTIFICATE", ERR_LIB_SSL, SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE},
+ #else
+ {"SIGNATURE_FOR_NON_SIGNING_CERTIFICATE", ERR_LIB_SSL, 220},
+ #endif
+ #ifdef SSL_R_SSL23_DOING_SESSION_ID_REUSE
+ {"SSL23_DOING_SESSION_ID_REUSE", ERR_LIB_SSL, SSL_R_SSL23_DOING_SESSION_ID_REUSE},
+ #else
+ {"SSL23_DOING_SESSION_ID_REUSE", ERR_LIB_SSL, 221},
+ #endif
+ #ifdef SSL_R_SSL2_CONNECTION_ID_TOO_LONG
+ {"SSL2_CONNECTION_ID_TOO_LONG", ERR_LIB_SSL, SSL_R_SSL2_CONNECTION_ID_TOO_LONG},
+ #else
+ {"SSL2_CONNECTION_ID_TOO_LONG", ERR_LIB_SSL, 299},
+ #endif
+ #ifdef SSL_R_SSL3_EXT_INVALID_ECPOINTFORMAT
+ {"SSL3_EXT_INVALID_ECPOINTFORMAT", ERR_LIB_SSL, SSL_R_SSL3_EXT_INVALID_ECPOINTFORMAT},
+ #else
+ {"SSL3_EXT_INVALID_ECPOINTFORMAT", ERR_LIB_SSL, 321},
+ #endif
+ #ifdef SSL_R_SSL3_EXT_INVALID_SERVERNAME
+ {"SSL3_EXT_INVALID_SERVERNAME", ERR_LIB_SSL, SSL_R_SSL3_EXT_INVALID_SERVERNAME},
+ #else
+ {"SSL3_EXT_INVALID_SERVERNAME", ERR_LIB_SSL, 319},
+ #endif
+ #ifdef SSL_R_SSL3_EXT_INVALID_SERVERNAME_TYPE
+ {"SSL3_EXT_INVALID_SERVERNAME_TYPE", ERR_LIB_SSL, SSL_R_SSL3_EXT_INVALID_SERVERNAME_TYPE},
+ #else
+ {"SSL3_EXT_INVALID_SERVERNAME_TYPE", ERR_LIB_SSL, 320},
+ #endif
+ #ifdef SSL_R_SSL3_SESSION_ID_TOO_LONG
+ {"SSL3_SESSION_ID_TOO_LONG", ERR_LIB_SSL, SSL_R_SSL3_SESSION_ID_TOO_LONG},
+ #else
+ {"SSL3_SESSION_ID_TOO_LONG", ERR_LIB_SSL, 300},
+ #endif
+ #ifdef SSL_R_SSL3_SESSION_ID_TOO_SHORT
+ {"SSL3_SESSION_ID_TOO_SHORT", ERR_LIB_SSL, SSL_R_SSL3_SESSION_ID_TOO_SHORT},
+ #else
+ {"SSL3_SESSION_ID_TOO_SHORT", ERR_LIB_SSL, 222},
+ #endif
+ #ifdef SSL_R_SSLV3_ALERT_BAD_CERTIFICATE
+ {"SSLV3_ALERT_BAD_CERTIFICATE", ERR_LIB_SSL, SSL_R_SSLV3_ALERT_BAD_CERTIFICATE},
+ #else
+ {"SSLV3_ALERT_BAD_CERTIFICATE", ERR_LIB_SSL, 1042},
+ #endif
+ #ifdef SSL_R_SSLV3_ALERT_BAD_RECORD_MAC
+ {"SSLV3_ALERT_BAD_RECORD_MAC", ERR_LIB_SSL, SSL_R_SSLV3_ALERT_BAD_RECORD_MAC},
+ #else
+ {"SSLV3_ALERT_BAD_RECORD_MAC", ERR_LIB_SSL, 1020},
+ #endif
+ #ifdef SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED
+ {"SSLV3_ALERT_CERTIFICATE_EXPIRED", ERR_LIB_SSL, SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED},
+ #else
+ {"SSLV3_ALERT_CERTIFICATE_EXPIRED", ERR_LIB_SSL, 1045},
+ #endif
+ #ifdef SSL_R_SSLV3_ALERT_CERTIFICATE_REVOKED
+ {"SSLV3_ALERT_CERTIFICATE_REVOKED", ERR_LIB_SSL, SSL_R_SSLV3_ALERT_CERTIFICATE_REVOKED},
+ #else
+ {"SSLV3_ALERT_CERTIFICATE_REVOKED", ERR_LIB_SSL, 1044},
+ #endif
+ #ifdef SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN
+ {"SSLV3_ALERT_CERTIFICATE_UNKNOWN", ERR_LIB_SSL, SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN},
+ #else
+ {"SSLV3_ALERT_CERTIFICATE_UNKNOWN", ERR_LIB_SSL, 1046},
+ #endif
+ #ifdef SSL_R_SSLV3_ALERT_DECOMPRESSION_FAILURE
+ {"SSLV3_ALERT_DECOMPRESSION_FAILURE", ERR_LIB_SSL, SSL_R_SSLV3_ALERT_DECOMPRESSION_FAILURE},
+ #else
+ {"SSLV3_ALERT_DECOMPRESSION_FAILURE", ERR_LIB_SSL, 1030},
+ #endif
+ #ifdef SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE
+ {"SSLV3_ALERT_HANDSHAKE_FAILURE", ERR_LIB_SSL, SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE},
+ #else
+ {"SSLV3_ALERT_HANDSHAKE_FAILURE", ERR_LIB_SSL, 1040},
+ #endif
+ #ifdef SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER
+ {"SSLV3_ALERT_ILLEGAL_PARAMETER", ERR_LIB_SSL, SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER},
+ #else
+ {"SSLV3_ALERT_ILLEGAL_PARAMETER", ERR_LIB_SSL, 1047},
+ #endif
+ #ifdef SSL_R_SSLV3_ALERT_NO_CERTIFICATE
+ {"SSLV3_ALERT_NO_CERTIFICATE", ERR_LIB_SSL, SSL_R_SSLV3_ALERT_NO_CERTIFICATE},
+ #else
+ {"SSLV3_ALERT_NO_CERTIFICATE", ERR_LIB_SSL, 1041},
+ #endif
+ #ifdef SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE
+ {"SSLV3_ALERT_UNEXPECTED_MESSAGE", ERR_LIB_SSL, SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE},
+ #else
+ {"SSLV3_ALERT_UNEXPECTED_MESSAGE", ERR_LIB_SSL, 1010},
+ #endif
+ #ifdef SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE
+ {"SSLV3_ALERT_UNSUPPORTED_CERTIFICATE", ERR_LIB_SSL, SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE},
+ #else
+ {"SSLV3_ALERT_UNSUPPORTED_CERTIFICATE", ERR_LIB_SSL, 1043},
+ #endif
+ #ifdef SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION
+ {"SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION", ERR_LIB_SSL, SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION},
+ #else
+ {"SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION", ERR_LIB_SSL, 228},
+ #endif
+ #ifdef SSL_R_SSL_HANDSHAKE_FAILURE
+ {"SSL_HANDSHAKE_FAILURE", ERR_LIB_SSL, SSL_R_SSL_HANDSHAKE_FAILURE},
+ #else
+ {"SSL_HANDSHAKE_FAILURE", ERR_LIB_SSL, 229},
+ #endif
+ #ifdef SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS
+ {"SSL_LIBRARY_HAS_NO_CIPHERS", ERR_LIB_SSL, SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS},
+ #else
+ {"SSL_LIBRARY_HAS_NO_CIPHERS", ERR_LIB_SSL, 230},
+ #endif
+ #ifdef SSL_R_SSL_SESSION_ID_CALLBACK_FAILED
+ {"SSL_SESSION_ID_CALLBACK_FAILED", ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_CALLBACK_FAILED},
+ #else
+ {"SSL_SESSION_ID_CALLBACK_FAILED", ERR_LIB_SSL, 301},
+ #endif
+ #ifdef SSL_R_SSL_SESSION_ID_CONFLICT
+ {"SSL_SESSION_ID_CONFLICT", ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_CONFLICT},
+ #else
+ {"SSL_SESSION_ID_CONFLICT", ERR_LIB_SSL, 302},
+ #endif
+ #ifdef SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG
+ {"SSL_SESSION_ID_CONTEXT_TOO_LONG", ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG},
+ #else
+ {"SSL_SESSION_ID_CONTEXT_TOO_LONG", ERR_LIB_SSL, 273},
+ #endif
+ #ifdef SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH
+ {"SSL_SESSION_ID_HAS_BAD_LENGTH", ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH},
+ #else
+ {"SSL_SESSION_ID_HAS_BAD_LENGTH", ERR_LIB_SSL, 303},
+ #endif
+ #ifdef SSL_R_SSL_SESSION_ID_IS_DIFFERENT
+ {"SSL_SESSION_ID_IS_DIFFERENT", ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_IS_DIFFERENT},
+ #else
+ {"SSL_SESSION_ID_IS_DIFFERENT", ERR_LIB_SSL, 231},
+ #endif
+ #ifdef SSL_R_TLSV1_ALERT_ACCESS_DENIED
+ {"TLSV1_ALERT_ACCESS_DENIED", ERR_LIB_SSL, SSL_R_TLSV1_ALERT_ACCESS_DENIED},
+ #else
+ {"TLSV1_ALERT_ACCESS_DENIED", ERR_LIB_SSL, 1049},
+ #endif
+ #ifdef SSL_R_TLSV1_ALERT_DECODE_ERROR
+ {"TLSV1_ALERT_DECODE_ERROR", ERR_LIB_SSL, SSL_R_TLSV1_ALERT_DECODE_ERROR},
+ #else
+ {"TLSV1_ALERT_DECODE_ERROR", ERR_LIB_SSL, 1050},
+ #endif
+ #ifdef SSL_R_TLSV1_ALERT_DECRYPTION_FAILED
+ {"TLSV1_ALERT_DECRYPTION_FAILED", ERR_LIB_SSL, SSL_R_TLSV1_ALERT_DECRYPTION_FAILED},
+ #else
+ {"TLSV1_ALERT_DECRYPTION_FAILED", ERR_LIB_SSL, 1021},
+ #endif
+ #ifdef SSL_R_TLSV1_ALERT_DECRYPT_ERROR
+ {"TLSV1_ALERT_DECRYPT_ERROR", ERR_LIB_SSL, SSL_R_TLSV1_ALERT_DECRYPT_ERROR},
+ #else
+ {"TLSV1_ALERT_DECRYPT_ERROR", ERR_LIB_SSL, 1051},
+ #endif
+ #ifdef SSL_R_TLSV1_ALERT_EXPORT_RESTRICTION
+ {"TLSV1_ALERT_EXPORT_RESTRICTION", ERR_LIB_SSL, SSL_R_TLSV1_ALERT_EXPORT_RESTRICTION},
+ #else
+ {"TLSV1_ALERT_EXPORT_RESTRICTION", ERR_LIB_SSL, 1060},
+ #endif
+ #ifdef SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY
+ {"TLSV1_ALERT_INSUFFICIENT_SECURITY", ERR_LIB_SSL, SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY},
+ #else
+ {"TLSV1_ALERT_INSUFFICIENT_SECURITY", ERR_LIB_SSL, 1071},
+ #endif
+ #ifdef SSL_R_TLSV1_ALERT_INTERNAL_ERROR
+ {"TLSV1_ALERT_INTERNAL_ERROR", ERR_LIB_SSL, SSL_R_TLSV1_ALERT_INTERNAL_ERROR},
+ #else
+ {"TLSV1_ALERT_INTERNAL_ERROR", ERR_LIB_SSL, 1080},
+ #endif
+ #ifdef SSL_R_TLSV1_ALERT_NO_RENEGOTIATION
+ {"TLSV1_ALERT_NO_RENEGOTIATION", ERR_LIB_SSL, SSL_R_TLSV1_ALERT_NO_RENEGOTIATION},
+ #else
+ {"TLSV1_ALERT_NO_RENEGOTIATION", ERR_LIB_SSL, 1100},
+ #endif
+ #ifdef SSL_R_TLSV1_ALERT_PROTOCOL_VERSION
+ {"TLSV1_ALERT_PROTOCOL_VERSION", ERR_LIB_SSL, SSL_R_TLSV1_ALERT_PROTOCOL_VERSION},
+ #else
+ {"TLSV1_ALERT_PROTOCOL_VERSION", ERR_LIB_SSL, 1070},
+ #endif
+ #ifdef SSL_R_TLSV1_ALERT_RECORD_OVERFLOW
+ {"TLSV1_ALERT_RECORD_OVERFLOW", ERR_LIB_SSL, SSL_R_TLSV1_ALERT_RECORD_OVERFLOW},
+ #else
+ {"TLSV1_ALERT_RECORD_OVERFLOW", ERR_LIB_SSL, 1022},
+ #endif
+ #ifdef SSL_R_TLSV1_ALERT_UNKNOWN_CA
+ {"TLSV1_ALERT_UNKNOWN_CA", ERR_LIB_SSL, SSL_R_TLSV1_ALERT_UNKNOWN_CA},
+ #else
+ {"TLSV1_ALERT_UNKNOWN_CA", ERR_LIB_SSL, 1048},
+ #endif
+ #ifdef SSL_R_TLSV1_ALERT_USER_CANCELLED
+ {"TLSV1_ALERT_USER_CANCELLED", ERR_LIB_SSL, SSL_R_TLSV1_ALERT_USER_CANCELLED},
+ #else
+ {"TLSV1_ALERT_USER_CANCELLED", ERR_LIB_SSL, 1090},
+ #endif
+ #ifdef SSL_R_TLSV1_BAD_CERTIFICATE_HASH_VALUE
+ {"TLSV1_BAD_CERTIFICATE_HASH_VALUE", ERR_LIB_SSL, SSL_R_TLSV1_BAD_CERTIFICATE_HASH_VALUE},
+ #else
+ {"TLSV1_BAD_CERTIFICATE_HASH_VALUE", ERR_LIB_SSL, 1114},
+ #endif
+ #ifdef SSL_R_TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE
+ {"TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE", ERR_LIB_SSL, SSL_R_TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE},
+ #else
+ {"TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE", ERR_LIB_SSL, 1113},
+ #endif
+ #ifdef SSL_R_TLSV1_CERTIFICATE_UNOBTAINABLE
+ {"TLSV1_CERTIFICATE_UNOBTAINABLE", ERR_LIB_SSL, SSL_R_TLSV1_CERTIFICATE_UNOBTAINABLE},
+ #else
+ {"TLSV1_CERTIFICATE_UNOBTAINABLE", ERR_LIB_SSL, 1111},
+ #endif
+ #ifdef SSL_R_TLSV1_UNRECOGNIZED_NAME
+ {"TLSV1_UNRECOGNIZED_NAME", ERR_LIB_SSL, SSL_R_TLSV1_UNRECOGNIZED_NAME},
+ #else
+ {"TLSV1_UNRECOGNIZED_NAME", ERR_LIB_SSL, 1112},
+ #endif
+ #ifdef SSL_R_TLSV1_UNSUPPORTED_EXTENSION
+ {"TLSV1_UNSUPPORTED_EXTENSION", ERR_LIB_SSL, SSL_R_TLSV1_UNSUPPORTED_EXTENSION},
+ #else
+ {"TLSV1_UNSUPPORTED_EXTENSION", ERR_LIB_SSL, 1110},
+ #endif
+ #ifdef SSL_R_TLS_CLIENT_CERT_REQ_WITH_ANON_CIPHER
+ {"TLS_CLIENT_CERT_REQ_WITH_ANON_CIPHER", ERR_LIB_SSL, SSL_R_TLS_CLIENT_CERT_REQ_WITH_ANON_CIPHER},
+ #else
+ {"TLS_CLIENT_CERT_REQ_WITH_ANON_CIPHER", ERR_LIB_SSL, 232},
+ #endif
+ #ifdef SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST
+ {"TLS_INVALID_ECPOINTFORMAT_LIST", ERR_LIB_SSL, SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST},
+ #else
+ {"TLS_INVALID_ECPOINTFORMAT_LIST", ERR_LIB_SSL, 157},
+ #endif
+ #ifdef SSL_R_TLS_PEER_DID_NOT_RESPOND_WITH_CERTIFICATE_LIST
+ {"TLS_PEER_DID_NOT_RESPOND_WITH_CERTIFICATE_LIST", ERR_LIB_SSL, SSL_R_TLS_PEER_DID_NOT_RESPOND_WITH_CERTIFICATE_LIST},
+ #else
+ {"TLS_PEER_DID_NOT_RESPOND_WITH_CERTIFICATE_LIST", ERR_LIB_SSL, 233},
+ #endif
+ #ifdef SSL_R_TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG
+ {"TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG", ERR_LIB_SSL, SSL_R_TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG},
+ #else
+ {"TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG", ERR_LIB_SSL, 234},
+ #endif
+ #ifdef SSL_R_TRIED_TO_USE_UNSUPPORTED_CIPHER
+ {"TRIED_TO_USE_UNSUPPORTED_CIPHER", ERR_LIB_SSL, SSL_R_TRIED_TO_USE_UNSUPPORTED_CIPHER},
+ #else
+ {"TRIED_TO_USE_UNSUPPORTED_CIPHER", ERR_LIB_SSL, 235},
+ #endif
+ #ifdef SSL_R_UNABLE_TO_DECODE_DH_CERTS
+ {"UNABLE_TO_DECODE_DH_CERTS", ERR_LIB_SSL, SSL_R_UNABLE_TO_DECODE_DH_CERTS},
+ #else
+ {"UNABLE_TO_DECODE_DH_CERTS", ERR_LIB_SSL, 236},
+ #endif
+ #ifdef SSL_R_UNABLE_TO_DECODE_ECDH_CERTS
+ {"UNABLE_TO_DECODE_ECDH_CERTS", ERR_LIB_SSL, SSL_R_UNABLE_TO_DECODE_ECDH_CERTS},
+ #else
+ {"UNABLE_TO_DECODE_ECDH_CERTS", ERR_LIB_SSL, 313},
+ #endif
+ #ifdef SSL_R_UNABLE_TO_EXTRACT_PUBLIC_KEY
+ {"UNABLE_TO_EXTRACT_PUBLIC_KEY", ERR_LIB_SSL, SSL_R_UNABLE_TO_EXTRACT_PUBLIC_KEY},
+ #else
+ {"UNABLE_TO_EXTRACT_PUBLIC_KEY", ERR_LIB_SSL, 237},
+ #endif
+ #ifdef SSL_R_UNABLE_TO_FIND_DH_PARAMETERS
+ {"UNABLE_TO_FIND_DH_PARAMETERS", ERR_LIB_SSL, SSL_R_UNABLE_TO_FIND_DH_PARAMETERS},
+ #else
+ {"UNABLE_TO_FIND_DH_PARAMETERS", ERR_LIB_SSL, 238},
+ #endif
+ #ifdef SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS
+ {"UNABLE_TO_FIND_ECDH_PARAMETERS", ERR_LIB_SSL, SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS},
+ #else
+ {"UNABLE_TO_FIND_ECDH_PARAMETERS", ERR_LIB_SSL, 314},
+ #endif
+ #ifdef SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS
+ {"UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS", ERR_LIB_SSL, SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS},
+ #else
+ {"UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS", ERR_LIB_SSL, 239},
+ #endif
+ #ifdef SSL_R_UNABLE_TO_FIND_SSL_METHOD
+ {"UNABLE_TO_FIND_SSL_METHOD", ERR_LIB_SSL, SSL_R_UNABLE_TO_FIND_SSL_METHOD},
+ #else
+ {"UNABLE_TO_FIND_SSL_METHOD", ERR_LIB_SSL, 240},
+ #endif
+ #ifdef SSL_R_UNABLE_TO_LOAD_SSL2_MD5_ROUTINES
+ {"UNABLE_TO_LOAD_SSL2_MD5_ROUTINES", ERR_LIB_SSL, SSL_R_UNABLE_TO_LOAD_SSL2_MD5_ROUTINES},
+ #else
+ {"UNABLE_TO_LOAD_SSL2_MD5_ROUTINES", ERR_LIB_SSL, 241},
+ #endif
+ #ifdef SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES
+ {"UNABLE_TO_LOAD_SSL3_MD5_ROUTINES", ERR_LIB_SSL, SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES},
+ #else
+ {"UNABLE_TO_LOAD_SSL3_MD5_ROUTINES", ERR_LIB_SSL, 242},
+ #endif
+ #ifdef SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES
+ {"UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES", ERR_LIB_SSL, SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES},
+ #else
+ {"UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES", ERR_LIB_SSL, 243},
+ #endif
+ #ifdef SSL_R_UNEXPECTED_MESSAGE
+ {"UNEXPECTED_MESSAGE", ERR_LIB_SSL, SSL_R_UNEXPECTED_MESSAGE},
+ #else
+ {"UNEXPECTED_MESSAGE", ERR_LIB_SSL, 244},
+ #endif
+ #ifdef SSL_R_UNEXPECTED_RECORD
+ {"UNEXPECTED_RECORD", ERR_LIB_SSL, SSL_R_UNEXPECTED_RECORD},
+ #else
+ {"UNEXPECTED_RECORD", ERR_LIB_SSL, 245},
+ #endif
+ #ifdef SSL_R_UNINITIALIZED
+ {"UNINITIALIZED", ERR_LIB_SSL, SSL_R_UNINITIALIZED},
+ #else
+ {"UNINITIALIZED", ERR_LIB_SSL, 276},
+ #endif
+ #ifdef SSL_R_UNKNOWN_ALERT_TYPE
+ {"UNKNOWN_ALERT_TYPE", ERR_LIB_SSL, SSL_R_UNKNOWN_ALERT_TYPE},
+ #else
+ {"UNKNOWN_ALERT_TYPE", ERR_LIB_SSL, 246},
+ #endif
+ #ifdef SSL_R_UNKNOWN_CERTIFICATE_TYPE
+ {"UNKNOWN_CERTIFICATE_TYPE", ERR_LIB_SSL, SSL_R_UNKNOWN_CERTIFICATE_TYPE},
+ #else
+ {"UNKNOWN_CERTIFICATE_TYPE", ERR_LIB_SSL, 247},
+ #endif
+ #ifdef SSL_R_UNKNOWN_CIPHER_RETURNED
+ {"UNKNOWN_CIPHER_RETURNED", ERR_LIB_SSL, SSL_R_UNKNOWN_CIPHER_RETURNED},
+ #else
+ {"UNKNOWN_CIPHER_RETURNED", ERR_LIB_SSL, 248},
+ #endif
+ #ifdef SSL_R_UNKNOWN_CIPHER_TYPE
+ {"UNKNOWN_CIPHER_TYPE", ERR_LIB_SSL, SSL_R_UNKNOWN_CIPHER_TYPE},
+ #else
+ {"UNKNOWN_CIPHER_TYPE", ERR_LIB_SSL, 249},
+ #endif
+ #ifdef SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE
+ {"UNKNOWN_KEY_EXCHANGE_TYPE", ERR_LIB_SSL, SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE},
+ #else
+ {"UNKNOWN_KEY_EXCHANGE_TYPE", ERR_LIB_SSL, 250},
+ #endif
+ #ifdef SSL_R_UNKNOWN_PKEY_TYPE
+ {"UNKNOWN_PKEY_TYPE", ERR_LIB_SSL, SSL_R_UNKNOWN_PKEY_TYPE},
+ #else
+ {"UNKNOWN_PKEY_TYPE", ERR_LIB_SSL, 251},
+ #endif
+ #ifdef SSL_R_UNKNOWN_PROTOCOL
+ {"UNKNOWN_PROTOCOL", ERR_LIB_SSL, SSL_R_UNKNOWN_PROTOCOL},
+ #else
+ {"UNKNOWN_PROTOCOL", ERR_LIB_SSL, 252},
+ #endif
+ #ifdef SSL_R_UNKNOWN_REMOTE_ERROR_TYPE
+ {"UNKNOWN_REMOTE_ERROR_TYPE", ERR_LIB_SSL, SSL_R_UNKNOWN_REMOTE_ERROR_TYPE},
+ #else
+ {"UNKNOWN_REMOTE_ERROR_TYPE", ERR_LIB_SSL, 253},
+ #endif
+ #ifdef SSL_R_UNKNOWN_SSL_VERSION
+ {"UNKNOWN_SSL_VERSION", ERR_LIB_SSL, SSL_R_UNKNOWN_SSL_VERSION},
+ #else
+ {"UNKNOWN_SSL_VERSION", ERR_LIB_SSL, 254},
+ #endif
+ #ifdef SSL_R_UNKNOWN_STATE
+ {"UNKNOWN_STATE", ERR_LIB_SSL, SSL_R_UNKNOWN_STATE},
+ #else
+ {"UNKNOWN_STATE", ERR_LIB_SSL, 255},
+ #endif
+ #ifdef SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED
+ {"UNSAFE_LEGACY_RENEGOTIATION_DISABLED", ERR_LIB_SSL, SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED},
+ #else
+ {"UNSAFE_LEGACY_RENEGOTIATION_DISABLED", ERR_LIB_SSL, 338},
+ #endif
+ #ifdef SSL_R_UNSUPPORTED_CIPHER
+ {"UNSUPPORTED_CIPHER", ERR_LIB_SSL, SSL_R_UNSUPPORTED_CIPHER},
+ #else
+ {"UNSUPPORTED_CIPHER", ERR_LIB_SSL, 256},
+ #endif
+ #ifdef SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM
+ {"UNSUPPORTED_COMPRESSION_ALGORITHM", ERR_LIB_SSL, SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM},
+ #else
+ {"UNSUPPORTED_COMPRESSION_ALGORITHM", ERR_LIB_SSL, 257},
+ #endif
+ #ifdef SSL_R_UNSUPPORTED_DIGEST_TYPE
+ {"UNSUPPORTED_DIGEST_TYPE", ERR_LIB_SSL, SSL_R_UNSUPPORTED_DIGEST_TYPE},
+ #else
+ {"UNSUPPORTED_DIGEST_TYPE", ERR_LIB_SSL, 326},
+ #endif
+ #ifdef SSL_R_UNSUPPORTED_ELLIPTIC_CURVE
+ {"UNSUPPORTED_ELLIPTIC_CURVE", ERR_LIB_SSL, SSL_R_UNSUPPORTED_ELLIPTIC_CURVE},
+ #else
+ {"UNSUPPORTED_ELLIPTIC_CURVE", ERR_LIB_SSL, 315},
+ #endif
+ #ifdef SSL_R_UNSUPPORTED_PROTOCOL
+ {"UNSUPPORTED_PROTOCOL", ERR_LIB_SSL, SSL_R_UNSUPPORTED_PROTOCOL},
+ #else
+ {"UNSUPPORTED_PROTOCOL", ERR_LIB_SSL, 258},
+ #endif
+ #ifdef SSL_R_UNSUPPORTED_SSL_VERSION
+ {"UNSUPPORTED_SSL_VERSION", ERR_LIB_SSL, SSL_R_UNSUPPORTED_SSL_VERSION},
+ #else
+ {"UNSUPPORTED_SSL_VERSION", ERR_LIB_SSL, 259},
+ #endif
+ #ifdef SSL_R_UNSUPPORTED_STATUS_TYPE
+ {"UNSUPPORTED_STATUS_TYPE", ERR_LIB_SSL, SSL_R_UNSUPPORTED_STATUS_TYPE},
+ #else
+ {"UNSUPPORTED_STATUS_TYPE", ERR_LIB_SSL, 329},
+ #endif
+ #ifdef SSL_R_WRITE_BIO_NOT_SET
+ {"WRITE_BIO_NOT_SET", ERR_LIB_SSL, SSL_R_WRITE_BIO_NOT_SET},
+ #else
+ {"WRITE_BIO_NOT_SET", ERR_LIB_SSL, 260},
+ #endif
+ #ifdef SSL_R_WRONG_CIPHER_RETURNED
+ {"WRONG_CIPHER_RETURNED", ERR_LIB_SSL, SSL_R_WRONG_CIPHER_RETURNED},
+ #else
+ {"WRONG_CIPHER_RETURNED", ERR_LIB_SSL, 261},
+ #endif
+ #ifdef SSL_R_WRONG_MESSAGE_TYPE
+ {"WRONG_MESSAGE_TYPE", ERR_LIB_SSL, SSL_R_WRONG_MESSAGE_TYPE},
+ #else
+ {"WRONG_MESSAGE_TYPE", ERR_LIB_SSL, 262},
+ #endif
+ #ifdef SSL_R_WRONG_NUMBER_OF_KEY_BITS
+ {"WRONG_NUMBER_OF_KEY_BITS", ERR_LIB_SSL, SSL_R_WRONG_NUMBER_OF_KEY_BITS},
+ #else
+ {"WRONG_NUMBER_OF_KEY_BITS", ERR_LIB_SSL, 263},
+ #endif
+ #ifdef SSL_R_WRONG_SIGNATURE_LENGTH
+ {"WRONG_SIGNATURE_LENGTH", ERR_LIB_SSL, SSL_R_WRONG_SIGNATURE_LENGTH},
+ #else
+ {"WRONG_SIGNATURE_LENGTH", ERR_LIB_SSL, 264},
+ #endif
+ #ifdef SSL_R_WRONG_SIGNATURE_SIZE
+ {"WRONG_SIGNATURE_SIZE", ERR_LIB_SSL, SSL_R_WRONG_SIGNATURE_SIZE},
+ #else
+ {"WRONG_SIGNATURE_SIZE", ERR_LIB_SSL, 265},
+ #endif
+ #ifdef SSL_R_WRONG_SSL_VERSION
+ {"WRONG_SSL_VERSION", ERR_LIB_SSL, SSL_R_WRONG_SSL_VERSION},
+ #else
+ {"WRONG_SSL_VERSION", ERR_LIB_SSL, 266},
+ #endif
+ #ifdef SSL_R_WRONG_VERSION_NUMBER
+ {"WRONG_VERSION_NUMBER", ERR_LIB_SSL, SSL_R_WRONG_VERSION_NUMBER},
+ #else
+ {"WRONG_VERSION_NUMBER", ERR_LIB_SSL, 267},
+ #endif
+ #ifdef SSL_R_X509_LIB
+ {"X509_LIB", ERR_LIB_SSL, SSL_R_X509_LIB},
+ #else
+ {"X509_LIB", ERR_LIB_SSL, 268},
+ #endif
+ #ifdef SSL_R_X509_VERIFICATION_SETUP_PROBLEMS
+ {"X509_VERIFICATION_SETUP_PROBLEMS", ERR_LIB_SSL, SSL_R_X509_VERIFICATION_SETUP_PROBLEMS},
+ #else
+ {"X509_VERIFICATION_SETUP_PROBLEMS", ERR_LIB_SSL, 269},
+ #endif
+ #ifdef X509_R_BAD_X509_FILETYPE
+ {"BAD_X509_FILETYPE", ERR_LIB_X509, X509_R_BAD_X509_FILETYPE},
+ #else
+ {"BAD_X509_FILETYPE", ERR_LIB_X509, 100},
+ #endif
+ #ifdef X509_R_BASE64_DECODE_ERROR
+ {"BASE64_DECODE_ERROR", ERR_LIB_X509, X509_R_BASE64_DECODE_ERROR},
+ #else
+ {"BASE64_DECODE_ERROR", ERR_LIB_X509, 118},
+ #endif
+ #ifdef X509_R_CANT_CHECK_DH_KEY
+ {"CANT_CHECK_DH_KEY", ERR_LIB_X509, X509_R_CANT_CHECK_DH_KEY},
+ #else
+ {"CANT_CHECK_DH_KEY", ERR_LIB_X509, 114},
+ #endif
+ #ifdef X509_R_CERT_ALREADY_IN_HASH_TABLE
+ {"CERT_ALREADY_IN_HASH_TABLE", ERR_LIB_X509, X509_R_CERT_ALREADY_IN_HASH_TABLE},
+ #else
+ {"CERT_ALREADY_IN_HASH_TABLE", ERR_LIB_X509, 101},
+ #endif
+ #ifdef X509_R_ERR_ASN1_LIB
+ {"ERR_ASN1_LIB", ERR_LIB_X509, X509_R_ERR_ASN1_LIB},
+ #else
+ {"ERR_ASN1_LIB", ERR_LIB_X509, 102},
+ #endif
+ #ifdef X509_R_INVALID_DIRECTORY
+ {"INVALID_DIRECTORY", ERR_LIB_X509, X509_R_INVALID_DIRECTORY},
+ #else
+ {"INVALID_DIRECTORY", ERR_LIB_X509, 113},
+ #endif
+ #ifdef X509_R_INVALID_FIELD_NAME
+ {"INVALID_FIELD_NAME", ERR_LIB_X509, X509_R_INVALID_FIELD_NAME},
+ #else
+ {"INVALID_FIELD_NAME", ERR_LIB_X509, 119},
+ #endif
+ #ifdef X509_R_INVALID_TRUST
+ {"INVALID_TRUST", ERR_LIB_X509, X509_R_INVALID_TRUST},
+ #else
+ {"INVALID_TRUST", ERR_LIB_X509, 123},
+ #endif
+ #ifdef X509_R_KEY_TYPE_MISMATCH
+ {"KEY_TYPE_MISMATCH", ERR_LIB_X509, X509_R_KEY_TYPE_MISMATCH},
+ #else
+ {"KEY_TYPE_MISMATCH", ERR_LIB_X509, 115},
+ #endif
+ #ifdef X509_R_KEY_VALUES_MISMATCH
+ {"KEY_VALUES_MISMATCH", ERR_LIB_X509, X509_R_KEY_VALUES_MISMATCH},
+ #else
+ {"KEY_VALUES_MISMATCH", ERR_LIB_X509, 116},
+ #endif
+ #ifdef X509_R_LOADING_CERT_DIR
+ {"LOADING_CERT_DIR", ERR_LIB_X509, X509_R_LOADING_CERT_DIR},
+ #else
+ {"LOADING_CERT_DIR", ERR_LIB_X509, 103},
+ #endif
+ #ifdef X509_R_LOADING_DEFAULTS
+ {"LOADING_DEFAULTS", ERR_LIB_X509, X509_R_LOADING_DEFAULTS},
+ #else
+ {"LOADING_DEFAULTS", ERR_LIB_X509, 104},
+ #endif
+ #ifdef X509_R_METHOD_NOT_SUPPORTED
+ {"METHOD_NOT_SUPPORTED", ERR_LIB_X509, X509_R_METHOD_NOT_SUPPORTED},
+ #else
+ {"METHOD_NOT_SUPPORTED", ERR_LIB_X509, 124},
+ #endif
+ #ifdef X509_R_NO_CERT_SET_FOR_US_TO_VERIFY
+ {"NO_CERT_SET_FOR_US_TO_VERIFY", ERR_LIB_X509, X509_R_NO_CERT_SET_FOR_US_TO_VERIFY},
+ #else
+ {"NO_CERT_SET_FOR_US_TO_VERIFY", ERR_LIB_X509, 105},
+ #endif
+ #ifdef X509_R_PUBLIC_KEY_DECODE_ERROR
+ {"PUBLIC_KEY_DECODE_ERROR", ERR_LIB_X509, X509_R_PUBLIC_KEY_DECODE_ERROR},
+ #else
+ {"PUBLIC_KEY_DECODE_ERROR", ERR_LIB_X509, 125},
+ #endif
+ #ifdef X509_R_PUBLIC_KEY_ENCODE_ERROR
+ {"PUBLIC_KEY_ENCODE_ERROR", ERR_LIB_X509, X509_R_PUBLIC_KEY_ENCODE_ERROR},
+ #else
+ {"PUBLIC_KEY_ENCODE_ERROR", ERR_LIB_X509, 126},
+ #endif
+ #ifdef X509_R_SHOULD_RETRY
+ {"SHOULD_RETRY", ERR_LIB_X509, X509_R_SHOULD_RETRY},
+ #else
+ {"SHOULD_RETRY", ERR_LIB_X509, 106},
+ #endif
+ #ifdef X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN
+ {"UNABLE_TO_FIND_PARAMETERS_IN_CHAIN", ERR_LIB_X509, X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN},
+ #else
+ {"UNABLE_TO_FIND_PARAMETERS_IN_CHAIN", ERR_LIB_X509, 107},
+ #endif
+ #ifdef X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY
+ {"UNABLE_TO_GET_CERTS_PUBLIC_KEY", ERR_LIB_X509, X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY},
+ #else
+ {"UNABLE_TO_GET_CERTS_PUBLIC_KEY", ERR_LIB_X509, 108},
+ #endif
+ #ifdef X509_R_UNKNOWN_KEY_TYPE
+ {"UNKNOWN_KEY_TYPE", ERR_LIB_X509, X509_R_UNKNOWN_KEY_TYPE},
+ #else
+ {"UNKNOWN_KEY_TYPE", ERR_LIB_X509, 117},
+ #endif
+ #ifdef X509_R_UNKNOWN_NID
+ {"UNKNOWN_NID", ERR_LIB_X509, X509_R_UNKNOWN_NID},
+ #else
+ {"UNKNOWN_NID", ERR_LIB_X509, 109},
+ #endif
+ #ifdef X509_R_UNKNOWN_PURPOSE_ID
+ {"UNKNOWN_PURPOSE_ID", ERR_LIB_X509, X509_R_UNKNOWN_PURPOSE_ID},
+ #else
+ {"UNKNOWN_PURPOSE_ID", ERR_LIB_X509, 121},
+ #endif
+ #ifdef X509_R_UNKNOWN_TRUST_ID
+ {"UNKNOWN_TRUST_ID", ERR_LIB_X509, X509_R_UNKNOWN_TRUST_ID},
+ #else
+ {"UNKNOWN_TRUST_ID", ERR_LIB_X509, 120},
+ #endif
+ #ifdef X509_R_UNSUPPORTED_ALGORITHM
+ {"UNSUPPORTED_ALGORITHM", ERR_LIB_X509, X509_R_UNSUPPORTED_ALGORITHM},
+ #else
+ {"UNSUPPORTED_ALGORITHM", ERR_LIB_X509, 111},
+ #endif
+ #ifdef X509_R_WRONG_LOOKUP_TYPE
+ {"WRONG_LOOKUP_TYPE", ERR_LIB_X509, X509_R_WRONG_LOOKUP_TYPE},
+ #else
+ {"WRONG_LOOKUP_TYPE", ERR_LIB_X509, 112},
+ #endif
+ #ifdef X509_R_WRONG_TYPE
+ {"WRONG_TYPE", ERR_LIB_X509, X509_R_WRONG_TYPE},
+ #else
+ {"WRONG_TYPE", ERR_LIB_X509, 122},
+ #endif
+ { NULL }
+};
diff --git a/Modules/_threadmodule.c b/Modules/_threadmodule.c
--- a/Modules/_threadmodule.c
+++ b/Modules/_threadmodule.c
@@ -23,6 +23,7 @@
PyObject_HEAD
PyThread_type_lock lock_lock;
PyObject *in_weakreflist;
+ char locked; /* for sanity checking */
} lockobject;
static void
@@ -32,9 +33,8 @@
PyObject_ClearWeakRefs((PyObject *) self);
if (self->lock_lock != NULL) {
/* Unlock the lock so it's safe to free it */
- PyThread_acquire_lock(self->lock_lock, 0);
- PyThread_release_lock(self->lock_lock);
-
+ if (self->locked)
+ PyThread_release_lock(self->lock_lock);
PyThread_free_lock(self->lock_lock);
}
PyObject_Del(self);
@@ -62,9 +62,13 @@
do {
- Py_BEGIN_ALLOW_THREADS
- r = PyThread_acquire_lock_timed(lock, microseconds, 1);
- Py_END_ALLOW_THREADS
+ /* first a simple non-blocking try without releasing the GIL */
+ r = PyThread_acquire_lock_timed(lock, 0, 0);
+ if (r == PY_LOCK_FAILURE && microseconds != 0) {
+ Py_BEGIN_ALLOW_THREADS
+ r = PyThread_acquire_lock_timed(lock, microseconds, 1);
+ Py_END_ALLOW_THREADS
+ }
if (r == PY_LOCK_INTR) {
/* Run signal handlers if we were interrupted. Propagate
@@ -135,6 +139,8 @@
return NULL;
}
+ if (r == PY_LOCK_ACQUIRED)
+ self->locked = 1;
return PyBool_FromLong(r == PY_LOCK_ACQUIRED);
}
@@ -153,13 +159,13 @@
lock_PyThread_release_lock(lockobject *self)
{
/* Sanity check: the lock must be locked */
- if (PyThread_acquire_lock(self->lock_lock, 0)) {
- PyThread_release_lock(self->lock_lock);
+ if (!self->locked) {
PyErr_SetString(ThreadError, "release unlocked lock");
return NULL;
}
PyThread_release_lock(self->lock_lock);
+ self->locked = 0;
Py_INCREF(Py_None);
return Py_None;
}
@@ -175,11 +181,7 @@
static PyObject *
lock_locked_lock(lockobject *self)
{
- if (PyThread_acquire_lock(self->lock_lock, 0)) {
- PyThread_release_lock(self->lock_lock);
- return PyBool_FromLong(0L);
- }
- return PyBool_FromLong(1L);
+ return PyBool_FromLong((long)self->locked);
}
PyDoc_STRVAR(locked_doc,
@@ -313,14 +315,7 @@
self->rlock_count = count;
Py_RETURN_TRUE;
}
-
- if (self->rlock_count > 0 ||
- !PyThread_acquire_lock(self->rlock_lock, 0)) {
- if (microseconds == 0) {
- Py_RETURN_FALSE;
- }
- r = acquire_timed(self->rlock_lock, microseconds);
- }
+ r = acquire_timed(self->rlock_lock, microseconds);
if (r == PY_LOCK_ACQUIRED) {
assert(self->rlock_count == 0);
self->rlock_owner = tid;
@@ -548,6 +543,7 @@
if (self == NULL)
return NULL;
self->lock_lock = PyThread_allocate_lock();
+ self->locked = 0;
self->in_weakreflist = NULL;
if (self->lock_lock == NULL) {
Py_DECREF(self);
diff --git a/Objects/classobject.c b/Objects/classobject.c
--- a/Objects/classobject.c
+++ b/Objects/classobject.c
@@ -400,6 +400,15 @@
(void)PyMethod_ClearFreeList();
}
+/* Print summary info about the state of the optimized allocator */
+void
+_PyMethod_DebugMallocStats(FILE *out)
+{
+ _PyDebugAllocatorStats(out,
+ "free PyMethodObject",
+ numfree, sizeof(PyMethodObject));
+}
+
/* ------------------------------------------------------------------------
* instance method
*/
diff --git a/Objects/dictobject.c b/Objects/dictobject.c
--- a/Objects/dictobject.c
+++ b/Objects/dictobject.c
@@ -255,6 +255,15 @@
return ret;
}
+/* Print summary info about the state of the optimized allocator */
+void
+_PyDict_DebugMallocStats(FILE *out)
+{
+ _PyDebugAllocatorStats(out,
+ "free PyDictObject", numfree, sizeof(PyDictObject));
+}
+
+
void
PyDict_Fini(void)
{
diff --git a/Objects/floatobject.c b/Objects/floatobject.c
--- a/Objects/floatobject.c
+++ b/Objects/floatobject.c
@@ -1933,6 +1933,16 @@
(void)PyFloat_ClearFreeList();
}
+/* Print summary info about the state of the optimized allocator */
+void
+_PyFloat_DebugMallocStats(FILE *out)
+{
+ _PyDebugAllocatorStats(out,
+ "free PyFloatObject",
+ numfree, sizeof(PyFloatObject));
+}
+
+
/*----------------------------------------------------------------------------
* _PyFloat_{Pack,Unpack}{4,8}. See floatobject.h.
*/
diff --git a/Objects/frameobject.c b/Objects/frameobject.c
--- a/Objects/frameobject.c
+++ b/Objects/frameobject.c
@@ -955,3 +955,13 @@
Py_XDECREF(builtin_object);
builtin_object = NULL;
}
+
+/* Print summary info about the state of the optimized allocator */
+void
+_PyFrame_DebugMallocStats(FILE *out)
+{
+ _PyDebugAllocatorStats(out,
+ "free PyFrameObject",
+ numfree, sizeof(PyFrameObject));
+}
+
diff --git a/Objects/listobject.c b/Objects/listobject.c
--- a/Objects/listobject.c
+++ b/Objects/listobject.c
@@ -117,6 +117,15 @@
PyList_ClearFreeList();
}
+/* Print summary info about the state of the optimized allocator */
+void
+_PyList_DebugMallocStats(FILE *out)
+{
+ _PyDebugAllocatorStats(out,
+ "free PyListObject",
+ numfree, sizeof(PyListObject));
+}
+
PyObject *
PyList_New(Py_ssize_t size)
{
diff --git a/Objects/methodobject.c b/Objects/methodobject.c
--- a/Objects/methodobject.c
+++ b/Objects/methodobject.c
@@ -338,6 +338,15 @@
(void)PyCFunction_ClearFreeList();
}
+/* Print summary info about the state of the optimized allocator */
+void
+_PyCFunction_DebugMallocStats(FILE *out)
+{
+ _PyDebugAllocatorStats(out,
+ "free PyCFunction",
+ numfree, sizeof(PyCFunction));
+}
+
/* PyCFunction_New() is now just a macro that calls PyCFunction_NewEx(),
but it's part of the API so we need to keep a function around that
existing C extensions can call.
diff --git a/Objects/object.c b/Objects/object.c
--- a/Objects/object.c
+++ b/Objects/object.c
@@ -1852,6 +1852,18 @@
PyMem_FREE(p);
}
+void
+_PyObject_DebugTypeStats(FILE *out)
+{
+ _PyCFunction_DebugMallocStats(out);
+ _PyDict_DebugMallocStats(out);
+ _PyFloat_DebugMallocStats(out);
+ _PyFrame_DebugMallocStats(out);
+ _PyList_DebugMallocStats(out);
+ _PyMethod_DebugMallocStats(out);
+ _PySet_DebugMallocStats(out);
+ _PyTuple_DebugMallocStats(out);
+}
/* These methods are used to control infinite recursion in repr, str, print,
etc. Container objects that may recursively contain themselves,
diff --git a/Objects/obmalloc.c b/Objects/obmalloc.c
--- a/Objects/obmalloc.c
+++ b/Objects/obmalloc.c
@@ -523,12 +523,10 @@
/* Number of arenas allocated that haven't been free()'d. */
static size_t narenas_currently_allocated = 0;
-#ifdef PYMALLOC_DEBUG
/* Total number of times malloc() called to allocate an arena. */
static size_t ntimes_arena_allocated = 0;
/* High water mark (max value ever seen) for narenas_currently_allocated. */
static size_t narenas_highwater = 0;
-#endif
/* Allocate a new arena. If we run out of memory, return NULL. Else
* allocate a new arena, and return the address of an arena_object
@@ -545,7 +543,7 @@
#ifdef PYMALLOC_DEBUG
if (Py_GETENV("PYTHONMALLOCSTATS"))
- _PyObject_DebugMallocStats();
+ _PyObject_DebugMallocStats(stderr);
#endif
if (unused_arena_objects == NULL) {
uint i;
@@ -613,11 +611,9 @@
arenaobj->address = (uptr)address;
++narenas_currently_allocated;
-#ifdef PYMALLOC_DEBUG
++ntimes_arena_allocated;
if (narenas_currently_allocated > narenas_highwater)
narenas_highwater = narenas_currently_allocated;
-#endif
arenaobj->freepools = NULL;
/* pool_address <- first pool-aligned address in the arena
nfreepools <- number of whole pools that fit after alignment */
@@ -1723,17 +1719,19 @@
}
}
+#endif /* PYMALLOC_DEBUG */
+
static size_t
-printone(const char* msg, size_t value)
+printone(FILE *out, const char* msg, size_t value)
{
int i, k;
char buf[100];
size_t origvalue = value;
- fputs(msg, stderr);
+ fputs(msg, out);
for (i = (int)strlen(msg); i < 35; ++i)
- fputc(' ', stderr);
- fputc('=', stderr);
+ fputc(' ', out);
+ fputc('=', out);
/* Write the value with commas. */
i = 22;
@@ -1754,17 +1752,33 @@
while (i >= 0)
buf[i--] = ' ';
- fputs(buf, stderr);
+ fputs(buf, out);
return origvalue;
}
-/* Print summary info to stderr about the state of pymalloc's structures.
+void
+_PyDebugAllocatorStats(FILE *out,
+ const char *block_name, int num_blocks, size_t sizeof_block)
+{
+ char buf1[128];
+ char buf2[128];
+ PyOS_snprintf(buf1, sizeof(buf1),
+ "%d %ss * %zd bytes each",
+ num_blocks, block_name, sizeof_block);
+ PyOS_snprintf(buf2, sizeof(buf2),
+ "%48s ", buf1);
+ (void)printone(out, buf2, num_blocks * sizeof_block);
+}
+
+#ifdef WITH_PYMALLOC
+
+/* Print summary info to "out" about the state of pymalloc's structures.
* In Py_DEBUG mode, also perform some expensive internal consistency
* checks.
*/
void
-_PyObject_DebugMallocStats(void)
+_PyObject_DebugMallocStats(FILE *out)
{
uint i;
const uint numclasses = SMALL_REQUEST_THRESHOLD >> ALIGNMENT_SHIFT;
@@ -1793,7 +1807,7 @@
size_t total;
char buf[128];
- fprintf(stderr, "Small block threshold = %d, in %u size classes.\n",
+ fprintf(out, "Small block threshold = %d, in %u size classes.\n",
SMALL_REQUEST_THRESHOLD, numclasses);
for (i = 0; i < numclasses; ++i)
@@ -1847,10 +1861,10 @@
}
assert(narenas == narenas_currently_allocated);
- fputc('\n', stderr);
+ fputc('\n', out);
fputs("class size num pools blocks in use avail blocks\n"
"----- ---- --------- ------------- ------------\n",
- stderr);
+ out);
for (i = 0; i < numclasses; ++i) {
size_t p = numpools[i];
@@ -1861,7 +1875,7 @@
assert(b == 0 && f == 0);
continue;
}
- fprintf(stderr, "%5u %6u "
+ fprintf(out, "%5u %6u "
"%11" PY_FORMAT_SIZE_T "u "
"%15" PY_FORMAT_SIZE_T "u "
"%13" PY_FORMAT_SIZE_T "u\n",
@@ -1871,35 +1885,36 @@
pool_header_bytes += p * POOL_OVERHEAD;
quantization += p * ((POOL_SIZE - POOL_OVERHEAD) % size);
}
- fputc('\n', stderr);
- (void)printone("# times object malloc called", serialno);
-
- (void)printone("# arenas allocated total", ntimes_arena_allocated);
- (void)printone("# arenas reclaimed", ntimes_arena_allocated - narenas);
- (void)printone("# arenas highwater mark", narenas_highwater);
- (void)printone("# arenas allocated current", narenas);
+ fputc('\n', out);
+#ifdef PYMALLOC_DEBUG
+ (void)printone(out, "# times object malloc called", serialno);
+#endif
+ (void)printone(out, "# arenas allocated total", ntimes_arena_allocated);
+ (void)printone(out, "# arenas reclaimed", ntimes_arena_allocated - narenas);
+ (void)printone(out, "# arenas highwater mark", narenas_highwater);
+ (void)printone(out, "# arenas allocated current", narenas);
PyOS_snprintf(buf, sizeof(buf),
"%" PY_FORMAT_SIZE_T "u arenas * %d bytes/arena",
narenas, ARENA_SIZE);
- (void)printone(buf, narenas * ARENA_SIZE);
+ (void)printone(out, buf, narenas * ARENA_SIZE);
- fputc('\n', stderr);
+ fputc('\n', out);
- total = printone("# bytes in allocated blocks", allocated_bytes);
- total += printone("# bytes in available blocks", available_bytes);
+ total = printone(out, "# bytes in allocated blocks", allocated_bytes);
+ total += printone(out, "# bytes in available blocks", available_bytes);
PyOS_snprintf(buf, sizeof(buf),
"%u unused pools * %d bytes", numfreepools, POOL_SIZE);
- total += printone(buf, (size_t)numfreepools * POOL_SIZE);
+ total += printone(out, buf, (size_t)numfreepools * POOL_SIZE);
- total += printone("# bytes lost to pool headers", pool_header_bytes);
- total += printone("# bytes lost to quantization", quantization);
- total += printone("# bytes lost to arena alignment", arena_alignment);
- (void)printone("Total", total);
+ total += printone(out, "# bytes lost to pool headers", pool_header_bytes);
+ total += printone(out, "# bytes lost to quantization", quantization);
+ total += printone(out, "# bytes lost to arena alignment", arena_alignment);
+ (void)printone(out, "Total", total);
}
-#endif /* PYMALLOC_DEBUG */
+#endif /* #ifdef WITH_PYMALLOC */
#ifdef Py_USING_MEMORY_DEBUGGER
/* Make this function last so gcc won't inline it since the definition is
diff --git a/Objects/setobject.c b/Objects/setobject.c
--- a/Objects/setobject.c
+++ b/Objects/setobject.c
@@ -1133,6 +1133,16 @@
Py_CLEAR(emptyfrozenset);
}
+/* Print summary info about the state of the optimized allocator */
+void
+_PySet_DebugMallocStats(FILE *out)
+{
+ _PyDebugAllocatorStats(out,
+ "free PySetObject",
+ numfree, sizeof(PySetObject));
+}
+
+
static PyObject *
set_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c
--- a/Objects/tupleobject.c
+++ b/Objects/tupleobject.c
@@ -45,6 +45,22 @@
}
#endif
+/* Print summary info about the state of the optimized allocator */
+void
+_PyTuple_DebugMallocStats(FILE *out)
+{
+#if PyTuple_MAXSAVESIZE > 0
+ int i;
+ char buf[128];
+ for (i = 1; i < PyTuple_MAXSAVESIZE; i++) {
+ PyOS_snprintf(buf, sizeof(buf),
+ "free %d-sized PyTupleObject", i);
+ _PyDebugAllocatorStats(out,
+ buf,
+ numfree[i], _PyObject_VAR_SIZE(&PyTuple_Type, i));
+ }
+#endif
+}
PyObject *
PyTuple_New(register Py_ssize_t size)
diff --git a/PCbuild/debug.props b/PCbuild/debug.props
--- a/PCbuild/debug.props
+++ b/PCbuild/debug.props
@@ -12,6 +12,9 @@
<ClCompile>
<PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
+ <ResourceCompile>
+ <PreprocessorDefinitions>_DEBUG</PreprocessorDefinitions>
+ </ResourceCompile>
</ItemDefinitionGroup>
<ItemGroup>
<BuildMacro Include="PyDebugExt">
diff --git a/Python/pythonrun.c b/Python/pythonrun.c
--- a/Python/pythonrun.c
+++ b/Python/pythonrun.c
@@ -642,7 +642,7 @@
#endif /* Py_TRACE_REFS */
#ifdef PYMALLOC_DEBUG
if (Py_GETENV("PYTHONMALLOCSTATS"))
- _PyObject_DebugMallocStats();
+ _PyObject_DebugMallocStats(stderr);
#endif
call_ll_exitfuncs();
diff --git a/Python/sysmodule.c b/Python/sysmodule.c
--- a/Python/sysmodule.c
+++ b/Python/sysmodule.c
@@ -997,6 +997,27 @@
extern "C" {
#endif
+static PyObject *
+sys_debugmallocstats(PyObject *self, PyObject *args)
+{
+#ifdef WITH_PYMALLOC
+ _PyObject_DebugMallocStats(stderr);
+ fputc('\n', stderr);
+#endif
+ _PyObject_DebugTypeStats(stderr);
+
+ Py_RETURN_NONE;
+}
+PyDoc_STRVAR(debugmallocstats_doc,
+"_debugmallocstats()\n\
+\n\
+Print summary info to stderr about the state of\n\
+pymalloc's structures.\n\
+\n\
+In Py_DEBUG mode, also perform some expensive internal consistency\n\
+checks.\n\
+");
+
#ifdef Py_TRACE_REFS
/* Defined in objects.c because it uses static globals if that file */
extern PyObject *_Py_GetObjects(PyObject *, PyObject *);
@@ -1093,6 +1114,8 @@
{"settrace", sys_settrace, METH_O, settrace_doc},
{"gettrace", sys_gettrace, METH_NOARGS, gettrace_doc},
{"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc},
+ {"_debugmallocstats", sys_debugmallocstats, METH_VARARGS,
+ debugmallocstats_doc},
{NULL, NULL} /* sentinel */
};
diff --git a/Tools/scripts/diff.py b/Tools/scripts/diff.py
--- a/Tools/scripts/diff.py
+++ b/Tools/scripts/diff.py
@@ -9,6 +9,12 @@
"""
import sys, os, time, difflib, optparse
+from datetime import datetime, timezone
+
+def file_mtime(path):
+ t = datetime.fromtimestamp(os.stat(path).st_mtime,
+ timezone.utc)
+ return t.astimezone().isoformat()
def main():
@@ -30,10 +36,12 @@
n = options.lines
fromfile, tofile = args
- fromdate = time.ctime(os.stat(fromfile).st_mtime)
- todate = time.ctime(os.stat(tofile).st_mtime)
- fromlines = open(fromfile, 'U').readlines()
- tolines = open(tofile, 'U').readlines()
+ fromdate = file_mtime(fromfile)
+ todate = file_mtime(tofile)
+ with open(fromfile, 'U') as ff:
+ fromlines = ff.readlines()
+ with open(tofile, 'U') as tf:
+ tolines = tf.readlines()
if options.u:
diff = difflib.unified_diff(fromlines, tolines, fromfile, tofile, fromdate, todate, n=n)
diff --git a/Tools/ssl/make_ssl_data.py b/Tools/ssl/make_ssl_data.py
new file mode 100644
--- /dev/null
+++ b/Tools/ssl/make_ssl_data.py
@@ -0,0 +1,68 @@
+#! /usr/bin/env python3
+
+"""
+This script should be called *manually* when we want to upgrade SSLError
+`library` and `reason` mnemnonics to a more recent OpenSSL version.
+
+It takes two arguments:
+- the path to the OpenSSL include files' directory
+ (e.g. openssl-1.0.1-beta3/include/openssl/)
+- the path to the C file to be generated
+ (probably Modules/_ssl_data.h)
+"""
+
+import datetime
+import os
+import re
+import sys
+
+
+def parse_error_codes(h_file, prefix):
+ pat = re.compile(r"#define\W+(%s([\w]+))\W+(\d+)\b" % re.escape(prefix))
+ codes = []
+ with open(h_file, "r", encoding="latin1") as f:
+ for line in f:
+ match = pat.search(line)
+ if match:
+ code, name, num = match.groups()
+ num = int(num)
+ codes.append((code, name, num))
+ return codes
+
+if __name__ == "__main__":
+ openssl_inc = sys.argv[1]
+ outfile = sys.argv[2]
+ use_stdout = outfile == '-'
+ f = sys.stdout if use_stdout else open(outfile, "w")
+ error_libraries = (
+ # (library code, mnemonic, error prefix, header file)
+ ('ERR_LIB_PEM', 'PEM', 'PEM_R_', 'pem.h'),
+ ('ERR_LIB_SSL', 'SSL', 'SSL_R_', 'ssl.h'),
+ ('ERR_LIB_X509', 'X509', 'X509_R_', 'x509.h'),
+ )
+ def w(l):
+ f.write(l + "\n")
+ w("/* File generated by Tools/ssl/make_ssl_data.py */")
+ w("/* Generated on %s */" % datetime.datetime.now().isoformat())
+ w("")
+
+ w("static struct py_ssl_library_code library_codes[] = {")
+ for libcode, mnemo, _, _ in error_libraries:
+ w(' {"%s", %s},' % (mnemo, libcode))
+ w(' { NULL }')
+ w('};')
+ w("")
+
+ w("static struct py_ssl_error_code error_codes[] = {")
+ for libcode, _, prefix, h_file in error_libraries:
+ codes = parse_error_codes(os.path.join(openssl_inc, h_file), prefix)
+ for code, name, num in sorted(codes):
+ w(' #ifdef %s' % (code))
+ w(' {"%s", %s, %s},' % (name, libcode, code))
+ w(' #else')
+ w(' {"%s", %s, %d},' % (name, libcode, num))
+ w(' #endif')
+ w(' { NULL }')
+ w('};')
+ if not use_stdout:
+ f.close()
--
Repository URL: http://hg.python.org/cpython
More information about the Python-checkins
mailing list