# Copyright (c) 2012, 2025, Oracle and/or its affiliates.
|
#
|
# This program is free software; you can redistribute it and/or modify
|
# it under the terms of the GNU General Public License, version 2.0, as
|
# published by the Free Software Foundation.
|
#
|
# This program is designed to work with certain software (including
|
# but not limited to OpenSSL) that is licensed under separate terms,
|
# as designated in a particular file or component or in included license
|
# documentation. The authors of MySQL hereby grant you an
|
# additional permission to link the program and your derivative works
|
# with the separately licensed software that they have either included with
|
# the program or referenced in the documentation.
|
#
|
# Without limiting anything contained in the foregoing, this file,
|
# which is part of MySQL Connector/Python, is also subject to the
|
# Universal FOSS Exception, version 1.0, a copy of which can be found at
|
# http://oss.oracle.com/licenses/universal-foss-exception.
|
#
|
# This program is distributed in the hope that it will be useful, but
|
# WITHOUT ANY WARRANTY; without even the implied warranty of
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
# See the GNU General Public License, version 2.0, for more details.
|
#
|
# You should have received a copy of the GNU General Public License
|
# along with this program; if not, write to the Free Software Foundation, Inc.,
|
# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
"""Module implementing low-level socket communication with MySQL servers."""
|
|
# pylint: disable=overlapping-except
|
|
import socket
|
import struct
|
import warnings
|
import zlib
|
|
from abc import ABC, abstractmethod
|
from collections import deque
|
from typing import Any, Deque, List, Optional, Tuple, Union
|
|
try:
|
import ssl
|
|
TLS_VERSIONS = {
|
"TLSv1": ssl.PROTOCOL_TLSv1,
|
"TLSv1.1": ssl.PROTOCOL_TLSv1_1,
|
"TLSv1.2": ssl.PROTOCOL_TLSv1_2,
|
"TLSv1.3": ssl.PROTOCOL_TLS,
|
}
|
TLS_V1_3_SUPPORTED = hasattr(ssl, "HAS_TLSv1_3") and ssl.HAS_TLSv1_3
|
except ImportError:
|
# If import fails, we don't have SSL support.
|
TLS_V1_3_SUPPORTED = False
|
ssl = None
|
|
from .errors import (
|
ConnectionTimeoutError,
|
InterfaceError,
|
NotSupportedError,
|
OperationalError,
|
ProgrammingError,
|
ReadTimeoutError,
|
WriteTimeoutError,
|
)
|
|
MIN_COMPRESS_LENGTH = 50
|
MAX_PAYLOAD_LENGTH = 2**24 - 1
|
PACKET_HEADER_LENGTH = 4
|
COMPRESSED_PACKET_HEADER_LENGTH = 7
|
|
|
def _strioerror(err: IOError) -> str:
|
"""Reformat the IOError error message.
|
|
This function reformats the IOError error message.
|
"""
|
return str(err) if not err.errno else f"Errno {err.errno}: {err.strerror}"
|
|
|
class NetworkBroker(ABC):
|
"""Broker class interface.
|
|
The network object is a broker used as a delegate by a socket object. Whenever the
|
socket wants to deliver or get packets to or from the MySQL server it needs to rely
|
on its network broker (netbroker).
|
|
The netbroker sends `payloads` and receives `packets`.
|
|
A packet is a bytes sequence, it has a header and body (referred to as payload).
|
The first `PACKET_HEADER_LENGTH` or `COMPRESSED_PACKET_HEADER_LENGTH`
|
(as appropriate) bytes correspond to the `header`, the remaining ones represent the
|
`payload`.
|
|
The maximum payload length allowed to be sent per packet to the server is
|
`MAX_PAYLOAD_LENGTH`. When `send` is called with a payload whose length is greater
|
than `MAX_PAYLOAD_LENGTH` the netbroker breaks it down into packets, so the caller
|
of `send` can provide payloads of arbitrary length.
|
|
Finally, data received by the netbroker comes directly from the server, expect to
|
get a packet for each call to `recv`. The received packet contains a header and
|
payload, the latter respecting `MAX_PAYLOAD_LENGTH`.
|
"""
|
|
@abstractmethod
|
def send(
|
self,
|
sock: socket.socket,
|
address: str,
|
payload: bytes,
|
packet_number: Optional[int] = None,
|
compressed_packet_number: Optional[int] = None,
|
) -> None:
|
"""Send `payload` to the MySQL server.
|
|
If provided a payload whose length is greater than `MAX_PAYLOAD_LENGTH`, it is
|
broken down into packets.
|
|
Args:
|
sock: Object holding the socket connection.
|
address: Socket's location.
|
payload: Packet's body to send.
|
packet_number: Sequence id (packet ID) to attach to the header when sending
|
plain packets.
|
compressed_packet_number: Same as `packet_number` but used when sending
|
compressed packets.
|
|
Raises:
|
:class:`OperationalError`: If something goes wrong while sending packets to
|
the MySQL server.
|
"""
|
|
@abstractmethod
|
def recv(self, sock: socket.socket, address: str) -> bytearray:
|
"""Get the next available packet from the MySQL server.
|
|
Args:
|
sock: Object holding the socket connection.
|
address: Socket's location.
|
|
Returns:
|
packet: A packet from the MySQL server.
|
|
Raises:
|
:class:`OperationalError`: If something goes wrong while receiving packets
|
from the MySQL server.
|
:class:`InterfaceError`: If something goes wrong while receiving packets
|
from the MySQL server.
|
"""
|
|
|
class NetworkBrokerPlain(NetworkBroker):
|
"""Broker class for MySQL socket communication."""
|
|
def __init__(self) -> None:
|
self._pktnr: int = -1 # packet number
|
|
def _set_next_pktnr(self) -> None:
|
"""Increment packet id."""
|
self._pktnr = (self._pktnr + 1) % 256
|
|
def _send_pkt(self, sock: socket.socket, address: str, pkt: bytes) -> None:
|
"""Write packet to the comm channel."""
|
try:
|
sock.sendall(pkt)
|
except (socket.timeout, TimeoutError) as err:
|
raise WriteTimeoutError(errno=3024) from err
|
except IOError as err:
|
raise OperationalError(
|
errno=2055, values=(address, _strioerror(err))
|
) from err
|
except AttributeError as err:
|
raise OperationalError(errno=2006) from err
|
|
def _recv_chunk(self, sock: socket.socket, size: int = 0) -> bytearray:
|
"""Read `size` bytes from the comm channel."""
|
pkt = bytearray(size)
|
pkt_view = memoryview(pkt)
|
while size:
|
read = sock.recv_into(pkt_view, size)
|
if read == 0 and size > 0:
|
raise InterfaceError(errno=2013)
|
pkt_view = pkt_view[read:]
|
size -= read
|
return pkt
|
|
def send(
|
self,
|
sock: socket.socket,
|
address: str,
|
payload: bytes,
|
packet_number: Optional[int] = None,
|
compressed_packet_number: Optional[int] = None,
|
) -> None:
|
"""Send payload to the MySQL server.
|
|
If provided a payload whose length is greater than `MAX_PAYLOAD_LENGTH`, it is
|
broken down into packets.
|
"""
|
if packet_number is None:
|
self._set_next_pktnr()
|
else:
|
self._pktnr = packet_number
|
|
# If the payload is larger than or equal to MAX_PAYLOAD_LENGTH
|
# the length is set to 2^24 - 1 (ff ff ff) and additional
|
# packets are sent with the rest of the payload until the
|
# payload of a packet is less than MAX_PAYLOAD_LENGTH.
|
if len(payload) >= MAX_PAYLOAD_LENGTH:
|
offset = 0
|
for _ in range(len(payload) // MAX_PAYLOAD_LENGTH):
|
# payload_len, sequence_id, payload
|
self._send_pkt(
|
sock,
|
address,
|
b"\xff\xff\xff"
|
+ struct.pack("<B", self._pktnr)
|
+ payload[offset : offset + MAX_PAYLOAD_LENGTH],
|
)
|
self._set_next_pktnr()
|
offset += MAX_PAYLOAD_LENGTH
|
payload = payload[offset:]
|
self._send_pkt(
|
sock,
|
address,
|
struct.pack("<I", len(payload))[0:3]
|
+ struct.pack("<B", self._pktnr)
|
+ payload,
|
)
|
|
def recv(self, sock: socket.socket, address: str) -> bytearray:
|
"""Receive `one` packet from the MySQL server."""
|
try:
|
# Read the header of the MySQL packet
|
header = self._recv_chunk(sock, size=PACKET_HEADER_LENGTH)
|
|
# Pull the payload length and sequence id
|
payload_len, self._pktnr = (
|
struct.unpack("<I", header[0:3] + b"\x00")[0],
|
header[3],
|
)
|
|
# Read the payload, and return packet
|
return header + self._recv_chunk(sock, size=payload_len)
|
except (socket.timeout, TimeoutError) as err:
|
raise ReadTimeoutError(errno=3024, msg=err.strerror) from err
|
except IOError as err:
|
raise OperationalError(
|
errno=2055, values=(address, _strioerror(err))
|
) from err
|
|
|
class NetworkBrokerCompressed(NetworkBrokerPlain):
|
"""Broker class for MySQL socket communication."""
|
|
def __init__(self) -> None:
|
super().__init__()
|
self._compressed_pktnr = -1
|
self._queue_read: Deque[bytearray] = deque()
|
|
@staticmethod
|
def _prepare_packets(payload: bytes, pktnr: int) -> List[bytes]:
|
"""Prepare a payload for sending to the MySQL server."""
|
pkts = []
|
|
# If the payload is larger than or equal to MAX_PAYLOAD_LENGTH
|
# the length is set to 2^24 - 1 (ff ff ff) and additional
|
# packets are sent with the rest of the payload until the
|
# payload of a packet is less than MAX_PAYLOAD_LENGTH.
|
if len(payload) >= MAX_PAYLOAD_LENGTH:
|
offset = 0
|
for _ in range(len(payload) // MAX_PAYLOAD_LENGTH):
|
# payload length + sequence id + payload
|
pkts.append(
|
b"\xff\xff\xff"
|
+ struct.pack("<B", pktnr)
|
+ payload[offset : offset + MAX_PAYLOAD_LENGTH]
|
)
|
pktnr = (pktnr + 1) % 256
|
offset += MAX_PAYLOAD_LENGTH
|
payload = payload[offset:]
|
pkts.append(
|
struct.pack("<I", len(payload))[0:3] + struct.pack("<B", pktnr) + payload
|
)
|
return pkts
|
|
def _set_next_compressed_pktnr(self) -> None:
|
"""Increment packet id."""
|
self._compressed_pktnr = (self._compressed_pktnr + 1) % 256
|
|
def _send_pkt(self, sock: socket.socket, address: str, pkt: bytes) -> None:
|
"""Compress packet and write it to the comm channel."""
|
compressed_pkt = zlib.compress(pkt)
|
pkt = (
|
struct.pack("<I", len(compressed_pkt))[0:3]
|
+ struct.pack("<B", self._compressed_pktnr)
|
+ struct.pack("<I", len(pkt))[0:3]
|
+ compressed_pkt
|
)
|
return super()._send_pkt(sock, address, pkt)
|
|
def send(
|
self,
|
sock: socket.socket,
|
address: str,
|
payload: bytes,
|
packet_number: Optional[int] = None,
|
compressed_packet_number: Optional[int] = None,
|
) -> None:
|
"""Send `payload` as compressed packets to the MySQL server.
|
|
If provided a payload whose length is greater than `MAX_PAYLOAD_LENGTH`, it is
|
broken down into packets.
|
"""
|
# get next packet numbers
|
if packet_number is None:
|
self._set_next_pktnr()
|
else:
|
self._pktnr = packet_number
|
if compressed_packet_number is None:
|
self._set_next_compressed_pktnr()
|
else:
|
self._compressed_pktnr = compressed_packet_number
|
|
payload_prep = bytearray(b"").join(self._prepare_packets(payload, self._pktnr))
|
if len(payload) >= MAX_PAYLOAD_LENGTH - PACKET_HEADER_LENGTH:
|
# sending a MySQL payload of the size greater or equal to 2^24 - 5
|
# via compression leads to at least one extra compressed packet
|
# WHY? let's say len(payload) is MAX_PAYLOAD_LENGTH - 3; when preparing
|
# the payload, a header of size PACKET_HEADER_LENGTH is pre-appended
|
# to the payload. This means that len(payload_prep) is
|
# MAX_PAYLOAD_LENGTH - 3 + PACKET_HEADER_LENGTH = MAX_PAYLOAD_LENGTH + 1
|
# surpassing the maximum allowed payload size per packet.
|
offset = 0
|
|
# send several MySQL packets
|
for _ in range(len(payload_prep) // MAX_PAYLOAD_LENGTH):
|
self._send_pkt(
|
sock, address, payload_prep[offset : offset + MAX_PAYLOAD_LENGTH]
|
)
|
self._set_next_compressed_pktnr()
|
offset += MAX_PAYLOAD_LENGTH
|
self._send_pkt(sock, address, payload_prep[offset:])
|
else:
|
# send one MySQL packet
|
# For small packets it may be too costly to compress the packet.
|
# Usually payloads less than 50 bytes (MIN_COMPRESS_LENGTH)
|
# aren't compressed (see MySQL source code Documentation).
|
if len(payload) > MIN_COMPRESS_LENGTH:
|
# perform compression
|
self._send_pkt(sock, address, payload_prep)
|
else:
|
# skip compression
|
super()._send_pkt(
|
sock,
|
address,
|
struct.pack("<I", len(payload_prep))[0:3]
|
+ struct.pack("<B", self._compressed_pktnr)
|
+ struct.pack("<I", 0)[0:3]
|
+ payload_prep,
|
)
|
|
def _recv_compressed_pkt(
|
self, sock: socket.socket, compressed_pll: int, uncompressed_pll: int
|
) -> None:
|
"""Handle reading of a compressed packet."""
|
# compressed_pll stands for compressed payload length.
|
# Recalling that if uncompressed payload length == 0, the packet
|
# comes in uncompressed, so no decompression is needed.
|
compressed_pkt = super()._recv_chunk(sock, size=compressed_pll)
|
pkt = (
|
compressed_pkt
|
if uncompressed_pll == 0
|
else bytearray(zlib.decompress(compressed_pkt))
|
)
|
|
offset = 0
|
while offset < len(pkt):
|
# pll stands for payload length
|
pll = struct.unpack(
|
"<I", pkt[offset : offset + PACKET_HEADER_LENGTH - 1] + b"\x00"
|
)[0]
|
if PACKET_HEADER_LENGTH + pll > len(pkt) - offset:
|
# More bytes need to be consumed
|
# Read the header of the next MySQL packet
|
header = super()._recv_chunk(sock, size=COMPRESSED_PACKET_HEADER_LENGTH)
|
|
# compressed payload length, sequence id, uncompressed payload length
|
(
|
compressed_pll,
|
self._compressed_pktnr,
|
uncompressed_pll,
|
) = (
|
struct.unpack("<I", header[0:3] + b"\x00")[0],
|
header[3],
|
struct.unpack("<I", header[4:7] + b"\x00")[0],
|
)
|
compressed_pkt = super()._recv_chunk(sock, size=compressed_pll)
|
|
# recalling that if uncompressed payload length == 0, the packet
|
# comes in uncompressed, so no decompression is needed.
|
pkt += (
|
compressed_pkt
|
if uncompressed_pll == 0
|
else zlib.decompress(compressed_pkt)
|
)
|
|
self._queue_read.append(pkt[offset : offset + PACKET_HEADER_LENGTH + pll])
|
offset += PACKET_HEADER_LENGTH + pll
|
|
def recv(self, sock: socket.socket, address: str) -> bytearray:
|
"""Receive `one` or `several` packets from the MySQL server, enqueue them, and
|
return the packet at the head.
|
"""
|
if not self._queue_read:
|
try:
|
# Read the header of the next MySQL packet
|
header = super()._recv_chunk(sock, size=COMPRESSED_PACKET_HEADER_LENGTH)
|
|
# compressed payload length, sequence id, uncompressed payload length
|
(
|
compressed_pll,
|
self._compressed_pktnr,
|
uncompressed_pll,
|
) = (
|
struct.unpack("<I", header[0:3] + b"\x00")[0],
|
header[3],
|
struct.unpack("<I", header[4:7] + b"\x00")[0],
|
)
|
self._recv_compressed_pkt(sock, compressed_pll, uncompressed_pll)
|
except (socket.timeout, TimeoutError) as err:
|
raise ReadTimeoutError(errno=3024) from err
|
except IOError as err:
|
raise OperationalError(
|
errno=2055, values=(address, _strioerror(err))
|
) from err
|
|
if not self._queue_read:
|
return None
|
|
pkt = self._queue_read.popleft()
|
self._pktnr = pkt[3]
|
|
return pkt
|
|
|
class MySQLSocket(ABC):
|
"""MySQL socket communication interface.
|
|
Examples:
|
Subclasses: network.MySQLTCPSocket and network.MySQLUnixSocket.
|
"""
|
|
def __init__(self) -> None:
|
"""Network layer where transactions are made with plain (uncompressed) packets
|
is enabled by default.
|
"""
|
# holds the socket connection
|
self.sock: Optional[socket.socket] = None
|
self._connection_timeout: Optional[int] = None
|
self.server_host: Optional[str] = None
|
self._netbroker: NetworkBroker = NetworkBrokerPlain()
|
|
def switch_to_compressed_mode(self) -> None:
|
"""Enable network layer where transactions are made with compressed packets."""
|
self._netbroker = NetworkBrokerCompressed()
|
|
def shutdown(self) -> None:
|
"""Shut down the socket before closing it."""
|
try:
|
self.sock.shutdown(socket.SHUT_RDWR)
|
self.sock.close()
|
except (AttributeError, OSError):
|
pass
|
|
def close_connection(self) -> None:
|
"""Close the socket."""
|
try:
|
self.sock.close()
|
except (AttributeError, OSError):
|
pass
|
|
def __del__(self) -> None:
|
self.shutdown()
|
|
def set_connection_timeout(self, timeout: Optional[int]) -> None:
|
"""Set the connection timeout."""
|
self._connection_timeout = timeout
|
if self.sock:
|
self.sock.settimeout(timeout)
|
|
def switch_to_ssl(self, ssl_context: Any, host: str) -> None:
|
"""Upgrade an existing connection to TLS.
|
|
Args:
|
ssl_context (ssl.SSLContext): The SSL Context to be used.
|
host (str): Server host name.
|
|
Returns:
|
None.
|
|
Raises:
|
ProgrammingError: If the transport does not expose the socket instance.
|
NotSupportedError: If Python installation has no SSL support.
|
"""
|
# Ensure that self.sock is already created
|
assert self.sock is not None
|
|
if self.sock.family == 1: # socket.AF_UNIX
|
raise ProgrammingError("SSL is not supported when using Unix sockets")
|
|
if ssl is None:
|
raise NotSupportedError("Python installation has no SSL support")
|
|
try:
|
self.sock = ssl_context.wrap_socket(self.sock, server_hostname=host)
|
except NameError as err:
|
raise NotSupportedError("Python installation has no SSL support") from err
|
except (ssl.SSLError, IOError) as err:
|
raise InterfaceError(
|
errno=2055, values=(self.address, _strioerror(err))
|
) from err
|
except ssl.CertificateError as err:
|
raise InterfaceError(str(err)) from err
|
except NotImplementedError as err:
|
raise InterfaceError(str(err)) from err
|
|
def build_ssl_context(
|
self,
|
ssl_ca: Optional[str] = None,
|
ssl_cert: Optional[str] = None,
|
ssl_key: Optional[str] = None,
|
ssl_verify_cert: Optional[bool] = False,
|
ssl_verify_identity: Optional[bool] = False,
|
tls_versions: Optional[List[str]] = None,
|
tls_cipher_suites: Optional[List[str]] = None,
|
) -> Any:
|
"""Build a SSLContext.
|
|
Args:
|
ssl_ca: Certificate authority, opptional.
|
ssl_cert: SSL certificate, optional.
|
ssl_key: Private key, optional.
|
ssl_verify_cert: Verify the SSL certificate if `True`.
|
ssl_verify_identity: Verify host identity if `True`.
|
tls_versions: TLS protocol versions, optional.
|
tls_cipher_suites: Set of steps that helps to establish a secure connection.
|
|
Returns:
|
ssl_context (ssl.SSLContext): An SSL Context ready be used.
|
|
Raises:
|
NotSupportedError: Python installation has no SSL support.
|
InterfaceError: Socket undefined or invalid ssl data.
|
"""
|
tls_version: Optional[str] = None
|
|
if not self.sock:
|
raise InterfaceError(errno=2048)
|
|
if ssl is None:
|
raise NotSupportedError("Python installation has no SSL support")
|
|
if tls_versions is None:
|
tls_versions = []
|
|
if tls_cipher_suites is None:
|
tls_cipher_suites = []
|
|
try:
|
if tls_versions:
|
tls_versions.sort(reverse=True)
|
tls_version = tls_versions[0]
|
ssl_protocol = TLS_VERSIONS[tls_version]
|
context = ssl.SSLContext(ssl_protocol)
|
|
if tls_version == "TLSv1.3":
|
if "TLSv1.2" not in tls_versions:
|
context.options |= ssl.OP_NO_TLSv1_2
|
if "TLSv1.1" not in tls_versions:
|
context.options |= ssl.OP_NO_TLSv1_1
|
if "TLSv1" not in tls_versions:
|
context.options |= ssl.OP_NO_TLSv1
|
else:
|
# `check_hostname` is True by default
|
context = ssl.create_default_context()
|
|
context.check_hostname = ssl_verify_identity
|
|
if ssl_verify_cert:
|
context.verify_mode = ssl.CERT_REQUIRED
|
elif ssl_verify_identity:
|
context.verify_mode = ssl.CERT_OPTIONAL
|
else:
|
context.verify_mode = ssl.CERT_NONE
|
|
context.load_default_certs()
|
|
if ssl_ca:
|
try:
|
context.load_verify_locations(ssl_ca)
|
except (IOError, ssl.SSLError) as err:
|
raise InterfaceError(f"Invalid CA Certificate: {err}") from err
|
if ssl_cert:
|
try:
|
context.load_cert_chain(ssl_cert, ssl_key)
|
except (IOError, ssl.SSLError) as err:
|
raise InterfaceError(f"Invalid Certificate/Key: {err}") from err
|
|
# TLSv1.3 ciphers cannot be disabled with `SSLContext.set_ciphers(...)`,
|
# see https://docs.python.org/3/library/ssl.html#ssl.SSLContext.set_ciphers.
|
if tls_cipher_suites and tls_version == "TLSv1.2":
|
context.set_ciphers(":".join(tls_cipher_suites))
|
|
return context
|
except NameError as err:
|
raise NotSupportedError("Python installation has no SSL support") from err
|
except (
|
IOError,
|
NotImplementedError,
|
ssl.CertificateError,
|
ssl.SSLError,
|
) as err:
|
raise InterfaceError(str(err)) from err
|
|
def send(
|
self,
|
payload: bytes,
|
packet_number: Optional[int] = None,
|
compressed_packet_number: Optional[int] = None,
|
write_timeout: Optional[int] = None,
|
) -> None:
|
"""Send `payload` to the MySQL server.
|
|
NOTE: if `payload` is an instance of `bytearray`, then `payload` might be
|
changed by this method - `bytearray` is similar to passing a variable by
|
reference.
|
|
If you're sure you won't read `payload` after invoking `send()`,
|
then you can use `bytearray.` Otherwise, you must use `bytes`.
|
"""
|
try:
|
if (
|
not self._connection_timeout and self.sock is not None
|
): # can't update the timeout during connection phase
|
self.sock.settimeout(float(write_timeout) if write_timeout else None)
|
except OSError as _:
|
# Ignore the OSError as the socket might not be setup properly
|
pass
|
self._netbroker.send(
|
self.sock,
|
self.address,
|
payload,
|
packet_number=packet_number,
|
compressed_packet_number=compressed_packet_number,
|
)
|
|
def recv(self, read_timeout: Optional[int] = None) -> bytearray:
|
"""Get packet from the MySQL server comm channel."""
|
try:
|
if (
|
not self._connection_timeout and self.sock is not None
|
): # can't update the timeout during connection phase
|
self.sock.settimeout(float(read_timeout) if read_timeout else None)
|
except OSError as _:
|
# Ignore the OSError as the socket might not be setup properly
|
pass
|
return self._netbroker.recv(self.sock, self.address)
|
|
@abstractmethod
|
def open_connection(self) -> None:
|
"""Open the socket."""
|
|
@property
|
@abstractmethod
|
def address(self) -> str:
|
"""Get the location of the socket."""
|
|
|
class MySQLUnixSocket(MySQLSocket):
|
"""MySQL socket class using UNIX sockets.
|
|
Opens a connection through the UNIX socket of the MySQL Server.
|
"""
|
|
def __init__(self, unix_socket: str = "/tmp/mysql.sock") -> None:
|
super().__init__()
|
self.unix_socket: str = unix_socket
|
self._address: str = unix_socket
|
|
@property
|
def address(self) -> str:
|
return self._address
|
|
def open_connection(self) -> None:
|
try:
|
self.sock = socket.socket(
|
# pylint: disable=no-member
|
socket.AF_UNIX,
|
socket.SOCK_STREAM,
|
)
|
self.sock.settimeout(self._connection_timeout)
|
self.sock.connect(self.unix_socket)
|
except (socket.timeout, TimeoutError) as err:
|
raise ConnectionTimeoutError(
|
errno=2002,
|
values=(
|
self.address,
|
_strioerror(err),
|
),
|
) from err
|
except IOError as err:
|
raise InterfaceError(
|
errno=2002, values=(self.address, _strioerror(err))
|
) from err
|
except Exception as err:
|
raise InterfaceError(str(err)) from err
|
|
def switch_to_ssl(
|
self, *args: Any, **kwargs: Any # pylint: disable=unused-argument
|
) -> None:
|
"""Switch the socket to use SSL."""
|
warnings.warn(
|
"SSL is disabled when using unix socket connections",
|
Warning,
|
)
|
|
|
class MySQLTCPSocket(MySQLSocket):
|
"""MySQL socket class using TCP/IP.
|
|
Opens a TCP/IP connection to the MySQL Server.
|
"""
|
|
def __init__(
|
self,
|
host: str = "127.0.0.1",
|
port: int = 3306,
|
force_ipv6: bool = False,
|
) -> None:
|
super().__init__()
|
self.server_host: str = host
|
self.server_port: int = port
|
self.force_ipv6: bool = force_ipv6
|
self._family: int = 0
|
self._address: str = f"{host}:{port}"
|
|
@property
|
def address(self) -> str:
|
return self._address
|
|
def open_connection(self) -> None:
|
"""Open the TCP/IP connection to the MySQL server."""
|
# pylint: disable=no-member
|
# Get address information
|
addrinfo: Tuple[
|
socket.AddressFamily,
|
socket.SocketKind,
|
int,
|
str,
|
Union[tuple[str, int], tuple[str, int, int, int], tuple[int, bytes]],
|
] = (None, None, None, None, None)
|
try:
|
addrinfos = socket.getaddrinfo(
|
self.server_host,
|
self.server_port,
|
0,
|
socket.SOCK_STREAM,
|
socket.SOL_TCP,
|
)
|
# If multiple results we favor IPv4, unless IPv6 was forced.
|
for info in addrinfos:
|
if self.force_ipv6 and info[0] == socket.AF_INET6:
|
addrinfo = info
|
break
|
if info[0] == socket.AF_INET:
|
addrinfo = info
|
break
|
if self.force_ipv6 and addrinfo[0] is None:
|
raise InterfaceError(f"No IPv6 address found for {self.server_host}")
|
if addrinfo[0] is None:
|
addrinfo = addrinfos[0]
|
except IOError as err:
|
raise InterfaceError(
|
errno=2003,
|
values=(self.server_host, self.server_port, _strioerror(err)),
|
) from err
|
|
(self._family, socktype, proto, _, sockaddr) = addrinfo
|
|
# Instantiate the socket and connect
|
try:
|
self.sock = socket.socket(self._family, socktype, proto)
|
self.sock.settimeout(self._connection_timeout)
|
self.sock.connect(sockaddr)
|
except (socket.timeout, TimeoutError) as err:
|
raise ConnectionTimeoutError(
|
errno=2003,
|
values=(
|
self.server_host,
|
self.server_port,
|
_strioerror(err),
|
),
|
) from err
|
except IOError as err:
|
raise InterfaceError(
|
errno=2003,
|
values=(self.server_host, self.server_port, _strioerror(err)),
|
) from err
|
except Exception as err:
|
raise InterfaceError(str(err)) from err
|
