VibuSrSSKrSSKrSSKJr SSKJr \"SS9r S r S r S r "S S \5r"SS\R5r"SS\5r"SS\5r"SS\R&\5r"SS\5r"SS\5r"SS\5r"SS\5rg!\a "SS\5rNf=f!\ a \"5r Nf=f)asAt its heart, Python can be viewed as an extension of the C programming language. Springing from the most popular systems programming language has made Python itself a great language for systems programming. One key to success in this domain is Python's very serviceable :mod:`socket` module and its :class:`socket.socket` type. The ``socketutils`` module provides natural next steps to the ``socket`` builtin: straightforward, tested building blocks for higher-level protocols. The :class:`BufferedSocket` wraps an ordinary socket, providing a layer of intuitive buffering for both sending and receiving. This facilitates parsing messages from streams, i.e., all sockets with type ``SOCK_STREAM``. The BufferedSocket enables receiving until the next relevant token, up to a certain size, or until the connection is closed. For all of these, it provides consistent APIs to size limiting, as well as timeouts that are compatible with multiple concurrency paradigms. Use it to parse the next one-off text or binary socket protocol you encounter. This module also provides the :class:`NetstringSocket`, a pure-Python implementation of `the Netstring protocol`_, built on top of the :class:`BufferedSocket`, serving as a ready-made, production-grade example. Special thanks to `Kurt Rose`_ for his original authorship and all his contributions on this module. Also thanks to `Daniel J. Bernstein`_, the original author of `Netstring`_. .. _the Netstring protocol: https://en.wikipedia.org/wiki/Netstring .. _Kurt Rose: https://github.com/doublereedkurt .. _Daniel J. Bernstein: https://cr.yp.to/ .. _Netstring: https://cr.yp.to/proto/netstrings.txt N)RLockc$\rSrSrSrSrSrSrg)rKz/Dummy reentrant lock for builds without threadscgNselfs f/home/james-whalen/.local/share/pipx/venvs/semgrep/lib/python3.13/site-packages/boltons/socketutils.py __enter__RLock.__enter__M cgrr)r exctypeexcinstexctbs r __exit__RLock.__exit__PrrrN)__name__ __module__ __qualname____firstlineno____doc__r r__static_attributes__rrr rrKs9  rr) make_sentinel_UNSET)var_name il c\rSrSrSr\\\4SjrSrSr Sr Sr Sr S r S \4S jr\4S jr\\4S jr\\S4Sjr\4SjrS \4SjrS \4SjrSrSrSrSrS!SjrSr\S5r\S5r\S5rSrSr Sr!S r"g)"BufferedSocket`a, Mainly provides recv_until and recv_size. recv, send, sendall, and peek all function as similarly as possible to the built-in socket API. This type has been tested against both the built-in socket type as well as those from gevent and eventlet. It also features support for sockets with timeouts set to 0 (aka nonblocking), provided the caller is prepared to handle the EWOULDBLOCK exceptions. Args: sock (socket): The connected socket to be wrapped. timeout (float): The default timeout for sends and recvs, in seconds. Set to ``None`` for no timeout, and 0 for nonblocking. Defaults to *sock*'s own timeout if already set, and 10 seconds otherwise. maxsize (int): The default maximum number of bytes to be received into the buffer before it is considered full and raises an exception. Defaults to 32 kilobytes. recvsize (int): The number of bytes to recv for every lower-level :meth:`socket.recv` call. Defaults to *maxsize*. *timeout* and *maxsize* can both be overridden on individual socket operations. All ``recv`` methods return bytestrings (:class:`bytes`) and can raise :exc:`socket.error`. :exc:`Timeout`, :exc:`ConnectionClosed`, and :exc:`MessageTooLong` all inherit from :exc:`socket.error` and exist to provide better error messages. Received bytes are always buffered, even if an exception is raised. Use :meth:`BufferedSocket.getrecvbuffer` to retrieve partial recvs. BufferedSocket does not replace the built-in socket by any means. While the overlapping parts of the API are kept parallel to the built-in :class:`socket.socket`, BufferedSocket does not inherit from socket, and most socket functionality is only available on the underlying socket. :meth:`socket.getpeername`, :meth:`socket.getsockname`, :meth:`socket.fileno`, and others are only available on the underlying socket that is wrapped. Use the ``BufferedSocket.sock`` attribute to access it. See the examples for more information on how to use BufferedSockets with built-in sockets. The BufferedSocket is threadsafe, but consider the semantics of your protocol before accessing a single socket from multiple threads. Similarly, once the BufferedSocket is constructed, avoid using the underlying socket directly. Only use it for operations unrelated to messages, e.g., :meth:`socket.getpeername`. cXlSUl/Ul[U5UlU[ LaGURR 5c [UlO:URR 5UlOUcX lO[U5UlU[ LaURUl O[U5Ul [5Ul [5Ul g)Nr)sockrbufsbufintmaxsizer gettimeoutDEFAULT_TIMEOUTtimeoutfloat _recvsizer _send_lock _recv_lock)r r$r+r(recvsizes r __init__BufferedSocket.__init__s   7| f yy##%-. #yy335 & $W~ v !\\DN ]DN''rcXlg)z> 'g&& '_$ s0A(D9?%D9.D9 %D/D9 D66D99 EcUR [UR5U:aURSUsSSS5 $URXS9nX0R-UlSSS5 U$!,(df  W$=f)aReturns *size* bytes from the socket and/or internal buffer. Bytes are retained in BufferedSocket's internal recv buffer. To only see bytes in the recv buffer, use :meth:`getrecvbuffer`. Args: size (int): The exact number of bytes to peek at timeout (float): The timeout for this operation. Can be 0 for nonblocking and None for no timeout. Defaults to the value set in the constructor of BufferedSocket. If the appropriate number of bytes cannot be fetched from the buffer and socket before *timeout* expires, then a :exc:`Timeout` will be raised. If the connection is closed, a :exc:`ConnectionClosed` will be raised. Nr4)r/rLr% recv_size)r rPr+rRs r peekBufferedSocket.peeksk __499~%yy$'_>>$>8Dyy(DI   _  s(A+"A++ A:c~UR U[La URnUc[nUR US-U5nX0R -Ul[ U[UR 55n[U5e![a UR SsoPlOf=fSSS5 U$!,(df  W$=f)zReceive until the connection is closed, up to *maxsize* bytes. If more than *maxsize* bytes are received, raises :exc:`MessageTooLong`. Nr) r/rr(_RECV_LARGE_MAXSIZErVr%minrLMessageTooLongConnectionClosed)r r+r(recvd size_readrSs r recv_closeBufferedSocket.recv_closes__& ,,- 0w{G< "II- TYY8 $Y// $ 0!%CY 0 _ s.B-A?=B-?BB-BB-- B<FcdUR U[La URnUc[nU[La URn[ U5nUR n[UR5n[R"5nSn U(dURU5 URXU5n U S:waU(aX- n U n OX-n O[ U5U:a [X15eU(aGU[R"5U- - n U S::a[R"5eURU 5 URUR5n U (d[ U5U4nSU-n[!U5eUR#U 5 [ U 5*U- S-n M[%USU 5[%X{S5snUlSSS5 U$![Ra/ [%U5UlS[ U5<SU<3n['X/5e[(a [%U5Ulef=f!,(df  W$=f) aReceive until *delimiter* is found, *maxsize* bytes have been read, or *timeout* is exceeded. Args: delimiter (bytes): One or more bytes to be searched for in the socket stream. timeout (float): The timeout for this operation. Can be 0 for nonblocking and None for no timeout. Defaults to the value set in the constructor of BufferedSocket. maxsize (int): The maximum size for the internal buffer. Defaults to the value set in the constructor. with_delimiter (bool): Whether or not to include the delimiter in the output. ``False`` by default, but ``True`` is useful in cases where one is simply forwarding the messages. ``recv_until`` will raise the following exceptions: * :exc:`Timeout` if more than *timeout* seconds expire. * :exc:`ConnectionClosed` if the underlying socket is closed by the sending end. * :exc:`MessageTooLong` if the delimiter is not found in the first *maxsize* bytes. * :exc:`socket.error` if operating in nonblocking mode (*timeout* equal to 0), or if some unexpected socket error occurs, such as operating on a closed socket. NrrZr;zCconnection closed after reading %s bytes without finding symbol: %rread z" bytes without finding delimiter: )r/rr(r[r+rLr$ bytearrayr%timer6findr]rNrMr-r^extendbytesrO Exception)r delimiterr+r(with_delimiter len_delimiterr$r_startfind_offset_startoffset rbuf_offset cur_timeoutnxtargsmsgvals r recv_untilBufferedSocket.recv_untils<__& ,,-& ,, NM99Ddii(EIIKE ! ( "ZZ gNF|)"3F*0K*0*@KUg-,W@@&-u1D&E &#-"(.."22 4))DNN3C #E I6 =?C D.s33LL%),S M(AA(E%/@#5&>2E% :M4NNCcd >> ,!%L e*i1g++ !%L  ]_d s2BH +GH  C G!H AHH  H/c8UR U[La URn/nSn[R"5nURR U5 UR =(d% URRUR5nU(aU[U5- nXA:aOURU5 U(aQU[R"5U- - nUS::a[R"5eURR U5 URRUR5nU(aMSU<SU<S3n[U5eXA- n U (aUS U *Xi*S solO USsolURU 5 S S S 5 SRW5$![Ra- SRU5UlSU<SU<S3n[X(5e[a SRU5Ulef=f!,(df  N=f) a)Read off of the internal buffer, then off the socket, until *size* bytes have been read. Args: size (int): number of bytes to read before returning. timeout (float): The timeout for this operation. Can be 0 for nonblocking and None for no timeout. Defaults to the value set in the constructor of BufferedSocket. If the appropriate number of bytes cannot be fetched from the buffer and socket before *timeout* expires, then a :exc:`Timeout` will be raised. If the connection is closed, a :exc:`ConnectionClosed` will be raised. rr;z connection closed after reading z of z requested bytesrrez bytesN)r/rr+rgr$r6r%rMr-rLappendrNr^rGrOrk) r rPr+chunks total_bytesrortrsrv extra_byteslasts r rVBufferedSocket.recv_sizeps__& ,,FK   $$W-iiA499>>$..#A3s8+K"*MM#&&-u1D&E &#-"(.."22 ,,[9))..8Cc(3D:C*3//&,K"%m |"4c,-6Hi"%si MM$ KLxx>> ,HHV, /:DAg++ HHV,  9_s7H BF'*H +BF'F'6H 'A!HH  Hc `UR U[La URnU(a [S5eURnUR U5 [ U5S:a.SRUVs/sH oU(dM UPM sn5/USS&URRU5 [R"5SpvUS(aURRUS5nXx- nUSUSUS'U(aQU[R"5U- - n U S::a[R"5eURRU 5 US(aMSSS5 U$s snf![Ra [US[ US5-5ef=f!,(df  W$=f)aSend the contents of the internal send buffer, as well as *data*, to the receiving end of the connection. Returns the total number of bytes sent. If no exception is raised, all of *data* was sent and the internal send buffer is empty. Args: data (bytes): The bytes to send. flags (int): Kept for API compatibility with sockets. Only the default 0 is valid. timeout (float): The timeout for this operation. Can be 0 for nonblocking and None for no timeout. Defaults to the value set in the constructor of BufferedSocket. Will raise :exc:`Timeout` if the send operation fails to complete before *timeout*. In the event of an exception, use :meth:`BufferedSocket.getsendbuffer` to see which data was unsent. znon-zero flags not supportedrZrNrr;z%s bytes unsent)r.rr+rKr&r{rLrGr$r6rgsendrNrO) r rRrQr+r&sro total_sentsentrss r rBufferedSocket.sendsl&__& ,, !?@@99D KK 4y1}88$:1Q$:;<Q II  ) $ Q: I1g99>>$q'2D&J"1gdenDG&-u1D&E &#-"(.."22 ,,[91gg.%;>> Ig'83tAw<'GHH I+_.s7A#F0 E& >E& AA-A>- A; 7A>> B cUR UR URRU5 SSS5 SSS5 g!,(df  N=f!,(df  g=f)aConvenience method which passes through to the wrapped socket's :meth:`~socket.shutdown`. Semantics vary by platform, so no special internal handling is done with the buffers. This method exists to facilitate the most common usage, wherein a full ``shutdown`` is followed by a :meth:`~BufferedSocket.close`. Developers requiring more support, please open `an issue`_. .. _an issue: https://github.com/mahmoud/boltons/issues N)r/r.r$shutdown)r hows r rBufferedSocket.shutdownAsH__ ""3'! !_ s! AAA A A A&) r/r-r.r(r%rr&r$r+r)#rrrrrrDEFAULT_MAXSIZEr1r6r)r=rArDrHrMrWrarxrVrrrrrrrrpropertyrrrrrrrrrr r!r!`s1d&,(6"41  ' !&&P"(."(0-3F"'Pd'-5 n !&*X#$V/  ' '+;     " rr!c\rSrSrSrSrg)ErroriTzA subclass of :exc:`socket.error` from which all other ``socketutils`` exceptions inherit. When using :class:`BufferedSocket` and other ``socketutils`` types, generally you want to catch one of the specific exception types below, or :exc:`socket.error`. rNrrrrrrrrr rrT  rrc\rSrSrSrSrg)r^i_a<Raised when receiving and the connection is unexpectedly closed from the sending end. Raised from :class:`BufferedSocket`'s :meth:`~BufferedSocket.peek`, :meth:`~BufferedSocket.recv_until`, and :meth:`~BufferedSocket.recv_size`, and never from its :meth:`~BufferedSocket.recv` or :meth:`~BufferedSocket.recv_close`. rNrrrr r^r^_rrr^c0^\rSrSrSrSU4SjjrSrU=r$)r]ijzRaised from :meth:`BufferedSocket.recv_until` and :meth:`BufferedSocket.recv_closed` when more than *maxsize* bytes are read without encountering the delimiter or a closed connection, respectively. cb>SnUb USU<S3- nUb USU<3- n[[U] U5 g)Nzmessage exceeded maximum sizez. z bytes readz. Delimiter not found: )superr]r1)r bytes_readrlrv __class__s r r1MessageTooLong.__init__ps=-  !  4 4C  )= =C nd,S1rr)NNrrrrrr1r __classcell__rs@r r]r]js 22rr]c0^\rSrSrSrSU4SjjrSrU=r$)rOiyzInheriting from :exc:`socket.timeout`, Timeout is used to indicate when a socket operation did not complete within the time specified. Raised from any of :class:`BufferedSocket`'s ``recv`` methods. cj>SnUb USUS--- nU(aUSU-- n[[U] U5 g)Nzsocket operation timed outz after %sms.i )rrOr1)r r+extrarvrs r r1Timeout.__init__sA*   >Wt^4 4C  3; C gt%c*rr)rrs@r rOrOys ++rrOcR\rSrSrSr\\4SjrSrSr Sr Sr \ \ 4Sjr S rS rg ) NetstringSocketiz Reads and writes using the netstring protocol. More info: https://en.wikipedia.org/wiki/Netstring Even more info: http://cr.yp.to/proto/netstrings.txt ct[U5UlX lX0l[ [ U55S-UlgNrZ)r!bsockr+r(rLstr_msgsize_maxsize)r r$r+r(s r r1NetstringSocket.__init__s.#D)   #CL 1A 5rc6URR5$r)rrr s r rNetstringSocket.filenoszz  ""rcXlgrr4r5s r r6NetstringSocket.settimeouts rc<XlURU5Ulgr)r(_calc_msgsize_maxsizerr@s r rANetstringSocket.setmaxsizes $ : :7 Crc0[[U55S-$r)rLrr@s r r%NetstringSocket._calc_msgsize_maxsizes3w< 1$$rcU[La URnU[LaURnURnOUR U5nUR R SUUS9n[U5nXR:a [XR5eUR RU5nUR RS5S:wa [S5eU$![a [SU-5ef=f)N:)r+r(z4netstring message size must be valid integer, not %rrZ,z#expected trailing ',' after message)rr+r(rrrrxr'rKNetstringInvalidSizeNetstringMessageTooLongrVrMNetstringProtocolError)r r+r(msgsize_maxsize size_prefixrPpayloads r read_nsNetstringSocket.read_nss f llG f llG"33O"88AOjj++D4;4C,E  I{#D >)$8 8**&&t, ::??1  %()NO O I&(:[[U] U5 gr)rrr1)r rvrs r r1NetstringInvalidSize.__init__s "D237rrrrs@r rrs 88rrc,^\rSrSrSrU4SjrSrU=r$)riaNetstringMessageTooLong is raised when the size prefix contains a valid integer, but that integer is larger than the :class:`NetstringSocket`'s configured *maxsize*. When this exception is raised, it's recommended to simply close the connection instead of trying to recover. c@>SU<SU<3n[[U] U5 g)Nz5netstring message length exceeds configured maxsize: z > )rrr1)r rPr(rvrs r r1 NetstringMessageTooLong.__init__s! %t5c:rrrrs@r rrs;;rr)rrgrN threadingrrkobject typeutilsrr ImportErrorr*rr[r!errorrr^r]r+rOrrrrrrr rsB"H  ' H -F oVoh FLL  u  2U 2 +fnne +:f:z U 81 8 ;4 ;} XFs"B B5B21B25 CC