Estructura inicial funcional con documentación en el README.md de la FastAPI
This commit is contained in:
167
env/lib/python3.12/site-packages/smbprotocol/transport.py
vendored
Normal file
167
env/lib/python3.12/site-packages/smbprotocol/transport.py
vendored
Normal file
@@ -0,0 +1,167 @@
|
||||
# Copyright: (c) 2019, Jordan Borean (@jborean93) <jborean93@gmail.com>
|
||||
# MIT License (see LICENSE or https://opensource.org/licenses/MIT)
|
||||
|
||||
import errno
|
||||
import logging
|
||||
import select
|
||||
import socket
|
||||
import struct
|
||||
import threading
|
||||
import timeit
|
||||
from collections import OrderedDict
|
||||
|
||||
from smbprotocol.structure import BytesField, IntField, Structure
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class DirectTCPPacket(Structure):
|
||||
"""
|
||||
[MS-SMB2] v53.0 2017-09-15
|
||||
|
||||
2.1 Transport
|
||||
The Directory TCP transport packet header MUST have the following
|
||||
structure.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self.fields = OrderedDict(
|
||||
[
|
||||
(
|
||||
"stream_protocol_length",
|
||||
IntField(
|
||||
size=4,
|
||||
little_endian=False,
|
||||
default=lambda s: len(s["smb2_message"]),
|
||||
),
|
||||
),
|
||||
(
|
||||
"smb2_message",
|
||||
BytesField(
|
||||
size=lambda s: s["stream_protocol_length"].get_value(),
|
||||
),
|
||||
),
|
||||
]
|
||||
)
|
||||
super().__init__()
|
||||
|
||||
|
||||
class Tcp:
|
||||
MAX_SIZE = 16777215
|
||||
|
||||
def __init__(self, server, port, timeout=None):
|
||||
self.server = server
|
||||
self.port = port
|
||||
self.timeout = timeout
|
||||
self.connected = False
|
||||
self._sock = None
|
||||
self._sock_lock = threading.Lock()
|
||||
self._close_lock = threading.Lock()
|
||||
|
||||
def connect(self):
|
||||
with self._sock_lock:
|
||||
if not self.connected:
|
||||
log.info("Connecting to DirectTcp socket")
|
||||
try:
|
||||
self._sock = socket.create_connection((self.server, self.port), timeout=self.timeout)
|
||||
except (OSError, socket.gaierror) as err:
|
||||
raise ValueError(f"Failed to connect to '{self.server}:{self.port}': {err}") from err
|
||||
self._sock.settimeout(None) # Make sure the socket is in blocking mode.
|
||||
self.connected = True
|
||||
|
||||
def close(self):
|
||||
with self._sock_lock:
|
||||
if self.connected:
|
||||
log.info("Disconnecting DirectTcp socket")
|
||||
|
||||
# Sending shutdown first will tell the recv thread (for both select and recv) that the socket has data
|
||||
# which returns b'' meaning it was closed.
|
||||
try:
|
||||
self._sock.shutdown(socket.SHUT_RDWR)
|
||||
except OSError as e: # pragma: no cover
|
||||
# Avoid collecting coverage here to avoid CI failing due to race condition differences
|
||||
if e.errno != errno.ENOTCONN:
|
||||
raise
|
||||
|
||||
# This is even more special, we cannot close the socket if we are in the middle of a select or recv().
|
||||
# Doing so causes either a timeout (bad!) or bad fd descriptor (somewhat bad). By shutting down the
|
||||
# socket first then waiting until recv() has exited the critical select/recv section we can ensure we
|
||||
# gracefully handle client side socket closures both here and our recv thread without any extra waits
|
||||
# or exceptions.
|
||||
with self._close_lock:
|
||||
self._sock.close()
|
||||
self.connected = False
|
||||
|
||||
def send(self, header):
|
||||
b_msg = header
|
||||
data_length = len(b_msg)
|
||||
if data_length > self.MAX_SIZE:
|
||||
raise ValueError(
|
||||
f"Data to be sent over Direct TCP size {data_length} exceeds the max length allowed {self.MAX_SIZE}"
|
||||
)
|
||||
|
||||
tcp_packet = DirectTCPPacket()
|
||||
tcp_packet["smb2_message"] = b_msg
|
||||
|
||||
data = tcp_packet.pack()
|
||||
|
||||
with self._sock_lock:
|
||||
while data:
|
||||
sent = self._sock.send(data)
|
||||
data = data[sent:]
|
||||
|
||||
def recv(self, timeout):
|
||||
# We don't need a lock for recv as the receiver is called from 1 thread.
|
||||
b_packet_size, timeout = self._recv(4, timeout)
|
||||
if not b_packet_size:
|
||||
return b""
|
||||
|
||||
packet_size = struct.unpack(">L", b_packet_size)[0]
|
||||
|
||||
return self._recv(packet_size, timeout)[0]
|
||||
|
||||
def _recv(self, length, timeout):
|
||||
buffer = bytearray(length)
|
||||
offset = 0
|
||||
while offset < length:
|
||||
read_len = length - offset
|
||||
log.debug(f"Socket recv({read_len}) (total {length})")
|
||||
|
||||
start_time = timeit.default_timer()
|
||||
|
||||
with self._close_lock:
|
||||
if not self.connected:
|
||||
# The socket was closed - need the no cover to avoid CI failing on race condition differences
|
||||
return None, timeout # pragma: no cover
|
||||
|
||||
read = select.select([self._sock], [], [], max(timeout, 1))[0]
|
||||
elapsed = timeit.default_timer() - start_time
|
||||
timeout = timeout - elapsed
|
||||
if not read:
|
||||
raise TimeoutError(f"recv idle for {elapsed:.1f}s ({offset}/{length} bytes)")
|
||||
|
||||
try:
|
||||
b_data = self._sock.recv(read_len)
|
||||
except OSError as e:
|
||||
# Windows will raise this error if the socket has been shutdown, Linux return returns an empty byte
|
||||
# string so we just replicate that.
|
||||
if e.errno not in [errno.ESHUTDOWN, errno.ECONNRESET, errno.ECONNABORTED]:
|
||||
# Avoid collecting coverage here to avoid CI failing due to race condition differences
|
||||
raise # pragma: no cover
|
||||
log.warning(
|
||||
"socket aborted by peer (%s), treating as EOF",
|
||||
errno.errorcode.get(e.errno, e.errno),
|
||||
)
|
||||
b_data = b""
|
||||
|
||||
read_len = len(b_data)
|
||||
log.debug(f"Socket recv() returned {read_len} bytes (total {length})")
|
||||
|
||||
if read_len == 0:
|
||||
self.close()
|
||||
return None, timeout # The socket has been shutdown
|
||||
|
||||
buffer[offset : offset + read_len] = b_data
|
||||
offset += read_len
|
||||
|
||||
return bytes(buffer), timeout
|
||||
Reference in New Issue
Block a user