o 0׾g @szdZddlmZddlZddlmZddlZddlZddlZddl Z ddl m Z ddl m Z ddl mZddl Z ddlmZdd lmZdd lmZdd lmZee d d ZdZgdZdZdZdZejdZe dddDddej!DBZ"de"vsJiZ#dZ$dZ%ddde&e'e%ffZ(e$e(e%fe#d<d Z)d!Z*ddde&e'e*ffZ+e)e+e*fe#d"<d#Z,d$Z-d%Z.d&d'Z/Gd(d)d)e0Z1Gd*d+d+e2Z3Gd,d-d-e4Z5z ddl6Z6e6j7Z8Wne9ydd.l:m;Z;Gd/d0d0e;j<Z=d1d2Z8YnwGd3d4d4e4Z>Gd5d6d6e4Z?Gd7d8d8e4Z@Gd9d:d:eAZBGd;d<dd>eCZDGd?d@d@eZEdAdBZFeGdCkr;eFdSdS)Da A pure-Python, gevent-friendly WSGI server implementing HTTP/1.1. The server is provided in :class:`WSGIServer`, but most of the actual WSGI work is handled by :class:`WSGIHandler` --- a new instance is created for each request. The server can be customized to use different subclasses of :class:`WSGIHandler`. .. important:: This server is intended primarily for development and testing, and secondarily for other "safe" scenarios where it will not be exposed to potentially malicious input. The code has not been security audited, and is not intended for direct exposure to the public Internet. For production usage on the Internet, either choose a production-strength server such as gunicorn, or put a reverse proxy between gevent and the Internet. .. versionchanged:: 23.9.0 Complies more closely with the HTTP specification for chunked transfer encoding. In particular, we are much stricter about trailers, and trailers that are invalid (too long or featuring disallowed characters) forcibly close the connection to the client *after* the results have been sent. Trailers otherwise continue to be ignored and are not available to the WSGI application. )absolute_importN)BytesIO)datetime)unquote)socket) StreamServer) GreenletExit)reraise)partiallatin-1)encodingT) WSGIServer WSGIHandlerLoggingLogAdapterEnviron SecureEnvironWSGISecureEnvironi )MonTueWedThuFriSatSun) NJanFebMarAprMayJunJulAugSepOctNovDecasciiccs|]}|dVqdS)r&Nencode.0cr,W/var/www/html/backend_erp/backend_erp_env/lib/python3.10/site-packages/gevent/pywsgi.py [sr.z!#$%&'*+-.^_`|~0123456789cCsh|]}|dqS)r&r'r)r,r,r- ]sr/Az500 Internal Server ErrorsInternal Server Error)z Content-Typez text/plain) ConnectionclosezContent-Lengthz400 Bad RequestsKHTTP/1.1 414 Request URI Too Long Connection: close Content-length: 0 sBHTTP/1.1 400 Bad Request Connection: close Content-length: 0 sHTTP/1.1 100 Continue c CsHt|\ }}}}}}}}} dt||t|||||f} | d} | S)Nz#%s, %02d %3s %4d %02d:%02d:%02d GMTr )timegmtime _WEEKDAYNAME _MONTHNAMEr() timestampyearmonthdayhhmmsswd_y_zvaluer,r,r-format_date_timezs rEc@s eZdZdS)_InvalidClientInputN)__name__ __module__ __qualname__r,r,r,r-rFsrFc@seZdZddZdS)_InvalidClientRequestcCst||||_dSN) ValueError__init__formatted_message)selfmessager,r,r-rMs  z_InvalidClientRequest.__init__N)rGrHrIrMr,r,r,r-rJs rJc@seZdZdZdddZddZdd Zdd d Zd d ZddZ dddZ dddZ d ddZ d ddZ d ddZddZddZeZdS)!Inputrfilecontent_lengthrposition chunked_input chunk_length_chunked_input_errorNFcCs.||_||_||_d|_||_d|_d|_dS)NrFrR)rOrSrTrrVr,r,r-rMs zInput.__init__cCsH|jrdS|jdur |j|jpdks|jr" |d}|sdSqdSdS)Nr@)rXrrUrTrVread)rOdr,r,r-_discards  zInput._discardcCs$|jdur|jtd|_dSdSrK)rsendall_CONTINUE_RESPONSErOr,r,r-_send_100_continues   zInput._send_100_continuecCs|r|jj}n|jj}|j}|durdS|||j}|dur$|}n||kr*|}|s.dSz||}Wn*ty^|s>d}t||kr\|ds\||t 7}t||kr\|drKYnw|jt|7_t||kr|ru|drw|st d|jf|S)N z;unexpected end of file while reading request at position %s) rSreadliner\rTrbrU OverflowErrorlenendswithMAX_REQUEST_LINEIOError)rOlength use_readlinereaderrTleftr\r,r,r-_do_reads<      zInput._do_readcCst} |d}|sd|_td|dvrn|tvr#d|_td||||dkr5d|_tdq|dkrYd }|tkrR|d}|d krJn|d7}|tks@d|_td |d kr||j|dd t | d}|d krz| |rz | |st|SdS) NrZTzEOF before chunk end reached) ;z Non-hex datazChunk-size too large.rqrrpzToo large chunk extension newline_only) rr\rXrF_HEXwritetellri_Input__read_chunk_size_crlfintgetvalue_Input__read_chunk_trailer)rOrSbufchariresultr,r,r-__read_chunk_lengthsF$       zInput.__read_chunk_lengthcCsd}d}d}|tkr?|d}|dkr|j|dd | Sd}|dkr*|dkr*d}|s7|tvr7td|f|d7}|tks d|_td ) NrTFrZrprs:zInvalid token character: %rzToo large chunk trailer)rir\rx_ALLOWED_TOKEN_CHARSrFrX)rOrSr~emptyseen_field_namer}r,r,r-__read_chunk_trailerPs$  zInput.__read_chunk_trailercCsT|s|d}|dkrd|_td|f|d}|dkr(d|_td|fdS)NrZrpTzLine didn't end in CRLF: %rrdzLine didn't end in LF: %r)r\rXrF)rOrSrtr}r,r,r-__read_chunk_size_crlfps  zInput.__read_chunk_size_crlfc Cs|j}||dkr dS|r|jj}n|jj}g}|jdkr|j|j}|dur/||kr/|}|dkru||}|sCd|_d|_tdt|}| ||j|7_|j|jkr^| ||durk||8}|dkrkn|rt|ddkrtnn | ||_d|_|jdksd |S)NrrcTz1unexpected end of file while parsing chunked datarY ) rSrbrer\rWrUrXrjrgappendrx_Input__read_chunk_lengthjoin) rOrkrlrSrmresponse maxreadlendatadatalenr,r,r- _chunked_read|sD        !zInput._chunked_readcCs.|dur |dkr d}|jr||S||S)NrrVrro)rOrkr,r,r-r\s   z Input.readcCs4|dur |dkr d}|jr||dS|j|ddS)NrT)rlr)rOsizer,r,r-res  zInput.readlinecCst|SrK)list)rOhintr,r,r- readlinesszInput.readlinescCs|SrKr,rar,r,r-__iter__zInput.__iter__cCs|}|st|SrK)re StopIterationrOliner,r,r-nextsz Input.next)NF)FrK)rGrHrI __slots__rMr^rbrorr{rxrr\rerrr__next__r,r,r,r-rQs    3b 1  rQ)clientcs>eZdZfddZd ddZeddZedd ZZS) OldMessagec s"ttj|jdi|d|_dS)Nr4r,)superr HTTPMessagerMstatus)rOkwargs __class__r,r-rMs zOldMessage.__init__NcCs |||SrKget)rOnamedefaultr,r,r- getheader zOldMessage.getheaderccs$|jD] \}}d||fVqdS)Nz%s: %s )_headers)rOkeyrDr,r,r-headersszOldMessage.headerscCs |dS)Nz content-typerrar,r,r- typeheaders zOldMessage.typeheaderrK) rGrHrIrMrpropertyrr __classcell__r,r,rr-rs   rcGs8z tj|td}W|Stjyt}d|_Y|Sw)N)_classz Line too long)r parse_headersr LineTooLongr)fpargsretr,r,r-headers_factorysrc@seZdZdZdZddZdZdZdZdZ dZ dZ dZ dZ dZdZdZdZdZdZdZdZdZdZdZeeZdZdZdZd:dd Zd d Z d d Z!ddZ"e#e$j%Z&ddZ'ddZ(ddZ)ddZ*ddZ+ddZ,e-fddZ.e/Z0ddZ1d d!Z2d:d"d#Z3d$d%Z4d&d'Z5d(d)Z6d*d+Z7e8j9e8j:fZ;ze;e8jd.d/Z?d0d1Z@d2d3ZAd4d5ZBd6d7ZCd8d9ZDdS);ra/ Handles HTTP requests from a socket, creates the WSGI environment, and interacts with the WSGI application. This is the default value of :attr:`WSGIServer.handler_class`. This class may be subclassed carefully, and that class set on a :class:`WSGIServer` instance through a keyword argument at construction time. Instances are constructed with the same arguments as passed to the server's :meth:`WSGIServer.handle` method followed by the server itself. The application and environment are obtained from the server. HTTP/1.1cGst|SrK)r)rOrr,r,r- MessageClasszWSGIHandler.MessageClassNFrcCs6||_||_||_|dur|dd|_dS||_dS)NrbrY)rclient_addressservermakefilerS)rOsockaddressrrSr,r,r-rM"s  zWSGIHandler.__init__cCsz~|jdur6t|_d|_|}|durn|durq|\|_}|j||jdkr1t|_| W|jdurht|jdd}z|rWz | dW| n| w|j Wn tj ygYnw|j dd|j dd|j dddS|jdurt|jdd}z|rz | dW| n| w|j Wn tj yYnw|j dd|j dd|j ddw) a The main request handling method, called by the server. This method runs a request handling loop, calling :meth:`handle_one_request` until all requests on the connection have been handled (that is, it implements keep-alive). NrT_sockr[rrS wsgi_input)rr6 time_start time_finishhandle_one_requestrr_ log_requestgetattrrecvr2error__dict__pop)rOr response_bodyrr,r,r-handle0sX          zWSGIHandler.handlecCsX|j}|ds dStdd|dddD}|ddks(|d ks(|d kr*dSd S) NzHTTP/Fcs|]}t|VqdSrK)ry)r*xr,r,r-r.`z2WSGIHandler._check_http_version...rZr)r )rT)request_version startswithtuplesplit)rO version_strversionr,r,r-_check_http_version\s  zWSGIHandler._check_http_versioncCs||_|j}t|dkr$|\|_|_|_|s#td|fn't|dkrD|\|_|_|jdkr@td|j|j|fd|_ntd|f| |j d|_ |j j r`td |j j f|j d d d kr{z|j d =Wn tyzYnw|j d }|durt|}|dkrtd|f|r|jdvrtd||_|jdkr|j dd }|dk|_dS|jdkr|j dd}|dk|_dSd|_dS)a+ Parse the incoming request. Parses various headers into ``self.headers`` using :attr:`MessageClass`. Other attributes that are set upon a successful return of this method include ``self.content_length`` and ``self.close_connection``. :param str raw_requestline: A native :class:`str` representing the request line. A processed version of this will be stored into ``self.requestline``. :raises ValueError: If the request is invalid. This error will not be logged as a traceback (because it's a client issue, not a server problem). :return: A boolean value indicating whether the request was successfully parsed. This method should either return a true value or have raised a ValueError with details about the parsing error. .. versionchanged:: 1.1b6 Raise the previously documented :exc:`ValueError` in more cases instead of returning a false value; this allows subclasses more opportunity to customize behaviour. zInvalid http version: %rrGETz4Expected GET method; Got command=%r; path=%r; raw=%rzHTTP/0.9zInvalid HTTP method: %rrzInvalid headers status: %rztransfer-encodingr4chunkedcontent-lengthNzInvalid Content-Length: %r)HEADzUnexpected Content-Lengthrr1r2HTTP/1.0z keep-aliveT)rstrip requestlinerrgcommandpathrrrJrrSrrrlowerKeyErrorryrTclose_connection)rOraw_requestlinewordsrTconntyper,r,r- read_requestesT              zWSGIHandler.read_requestcGs|s|}nz||}Wnty|d||f}Ynwz d|j|f}Wn ty1Ynwz |jj|dWdStyL|YdSw)Nz%r %rz%s: %s ) Exception_print_unexpected_excrr error_logrv)rOmsgrrPr,r,r- log_errors$    zWSGIHandler.log_errorcCs|jt}|d}|S)a$ Read and return the HTTP request line. Under both Python 2 and 3, this should return the native ``str`` type; under Python 3, this probably means the bytes read from the network need to be decoded (using the ISO-8859-1 charset, aka latin-1). r )rSreridecoderr,r,r-read_requestlines zWSGIHandler.read_requestlinec Cs|jjrdSz||_t|jtr|jd|_Wn tjy%YdSw|js+dSd|_ t |jt kr9dt fSz | |jsEdtfWSWnty]}z ||WYd}~Sd}~ww||_|jj|_||jrqdS|jjrwdSdS)a Handles one HTTP request using ``self.socket`` and ``self.rfile``. Each invocation of this method will do several things, including (but not limited to): - Read the request line using :meth:`read_requestline`; - Read the rest of the request, including headers, with :meth:`read_request`; - Construct a new WSGI environment in ``self.environ`` using :meth:`get_environ`; - Store the application in ``self.application``, retrieving it from the server; - Handle the remainder of the request, including invoking the application, with :meth:`handle_one_response` There are several possible return values to indicate the state of the client connection: - ``None`` The client connection is already closed or should be closed because the WSGI application or client set the ``Connection: close`` header. The request handling loop should terminate and perform cleanup steps. - (status, body) An HTTP status and body tuple. The request was in error, as detailed by the status and body. The request handling loop should terminate, close the connection, and perform cleanup steps. Note that the ``body`` is the complete contents to send to the client, including all headers and the initial status line. - ``True`` The literal ``True`` value. The request was successfully handled and the response sent to the client by :meth:`handle_one_response`. The connection remains open to process more requests and the connection handling loop should call this method again. This is the typical return value. .. seealso:: :meth:`handle` .. versionchanged:: 1.1b6 Funnel exceptions having to do with invalid HTTP requests through :meth:`_handle_client_error` to allow subclasses to customize. Note that this is experimental and may change in the future. Nr r414400T)rSclosedrr isinstancebytesrrrresponse_lengthrgri_REQUEST_TOO_LONG_RESPONSEr_BAD_REQUEST_RESPONSEr_handle_client_error get_environenvironr applicationhandle_one_responserrOexr,r,r-rs>+      zWSGIHandler.handle_one_requestcCs8|jdddkr dS|jdddkrdSdS)Nr1r4upgradeTUpgrade websocketF)rrrrar,r,r-_connection_upgrade_requested.s z)WSGIHandler._connection_upgrade_requestedcCs|jdur|jdttf|jdk|_|jdvrY|jdur[t|j drDt dd|j D}t |}| d}|jd|fdS|j oL|j d k|_|jr]|jd dSdSdSdS) NsDateei0__len__csrrK)rg)r*chunkr,r,r-r.?rz/WSGIHandler.finalize_headers..r sContent-Lengthr)sTransfer-Encodingschunked) provided_dateresponse_headersrrEr6codeconnection_upgradedprovided_content_lengthhasattrrsumstrr(rresponse_use_chunked)rO total_len total_len_strr,r,r-finalize_headers5s$       zWSGIHandler.finalize_headersc Csbz|j|Wntjy%}zd||_|jdkr |j |_d}~ww|jt|7_dS)Nzsocket error: %sr)rr_rrrrrg)rOrrr,r,r-_sendallKs   zWSGIHandler._sendallcCsN|sdS|jr dt|}||}||7}|d7}||dS||dS)Ns%x  )rrgr)rOr _bytearray header_strtowriter,r,r-_writeUs zWSGIHandler._writecCsP|jdvr|r|d|j|jr||dS|js!|d||dS)Nr z!The %s response must have no bodyz-The application did not call start_response())rApplicationError headers_sentrr_write_with_headersrOrr,r,r-rvks zWSGIHandler.writecCsxd|_|td}||j7}|d7}|jD]\}}||7}|d7}||7}|d7}q|d7}||||dS)NTs HTTP/1.1 rs: )r r bytearrayrrrr)rOrrheaderrDr,r,r-r!zs   zWSGIHandler._write_with_headersc Cs|rz |jr t|Wd}nd}wg}d}d}zF|D]A\}}t|ts)td||t|ts4td||d|vs>> environ = SecureEnviron(key='value') >>> environ # doctest: +ELLIPSIS >> environ.whitelist_keys = {'key'} >>> environ {'key': 'value'} A non-whitelisted key (*only*, to avoid doctest issues) is masked:: >>> environ['secure'] = 'secret'; del environ['key'] >>> environ {'secure': ''} We can turn it off entirely for the instance:: >>> environ.secure_repr = False >>> environ {'secure': 'secret'} We can also customize it at the class level (here we use a new class to be explicit and to avoid polluting the true default values; we would set this class to be the ``environ_class`` of the server):: >>> class MyEnviron(SecureEnviron): ... default_whitelist_keys = ('key',) ... >>> environ = MyEnviron({'key': 'value'}) >>> environ {'key': 'value'} .. versionadded:: 1.2a1 Tr,) secure_reprwhitelist_keysprint_masked_keyscCs$|tjvrtt|d|St|)Ndefault_)rrrtyperlryr,r,r-rzs zSecureEnviron.__getattr__csjr@jjr6fddD}t|}s4t|tkr4|dddtt|}|SdttfStS)Ncs.i|]}|vs r||vr|ndqS)zr,)r*k print_maskedrO whitelistr,r- s  z*SecureEnviron.__repr__..rYz, (hidden keys: %d)}z,)rrrr,rgidr__repr__)rOsafe safe_reprr,rr-rs  zSecureEnviron.__repr__N) rGrHrIrddefault_secure_reprdefault_whitelist_keysdefault_print_masked_keysrrzr__str__r,r,r,r-rs;rc@seZdZdZdZdZdS)ra Specializes the default list of whitelisted keys to a few common WSGI variables. Example:: >>> environ = WSGISecureEnviron(REMOTE_ADDR='::1', HTTP_AUTHORIZATION='secret') >>> environ {'REMOTE_ADDR': '::1', (hidden keys: 1)} >>> import pprint >>> pprint.pprint(environ) {'REMOTE_ADDR': '::1', (hidden keys: 1)} >>> print(pprint.pformat(environ)) {'REMOTE_ADDR': '::1', (hidden keys: 1)} )rZr[ HTTP_HOSTFN)rGrHrIrdrrr,r,r,r-rsrc@seZdZdZeZdZdZeZ e Z dde j ddej dddddddd Z  dd d Zdd dZddZddZddZddZddZdS)r a A WSGI server based on :class:`StreamServer` that supports HTTPS. :keyword log: If given, an object with a ``write`` method to which request (access) logs will be written. If not given, defaults to :obj:`sys.stderr`. You may pass ``None`` to disable request logging. You may use a wrapper, around e.g., :mod:`logging`, to support objects that don't implement a ``write`` method. (If you pass a :class:`~logging.Logger` instance, or in general something that provides a ``log`` method but not a ``write`` method, such a wrapper will automatically be created and it will be logged to at the :data:`~logging.INFO` level.) :keyword error_log: If given, a file-like object with ``write``, ``writelines`` and ``flush`` methods to which error logs will be written. If not given, defaults to :obj:`sys.stderr`. You may pass ``None`` to disable error logging (not recommended). You may use a wrapper, around e.g., :mod:`logging`, to support objects that don't implement the proper methods. This parameter will become the value for ``wsgi.errors`` in the WSGI environment (if not already set). (As with *log*, wrappers for :class:`~logging.Logger` instances and the like will be created automatically and logged to at the :data:`~logging.ERROR` level.) .. seealso:: :class:`LoggingLogAdapter` See important warnings before attempting to use :mod:`logging`. .. versionchanged:: 1.1a3 Added the ``error_log`` parameter, and set ``wsgi.errors`` in the WSGI environment to this value. .. versionchanged:: 1.1a3 Add support for passing :class:`logging.Logger` objects to the ``log`` and ``error_log`` arguments. .. versionchanged:: 20.6.0 Passing a ``handle`` kwarg to the constructor is now officially deprecated. NzCGI/1.1zgevent/%d.%d Python/%d.%drr4)rZrF)GATEWAY_INTERFACESERVER_SOFTWARErUz wsgi.versionzwsgi.multithreadwsgi.multiprocessz wsgi.run_oncerc Ksd| vrddl} | jdtddtj||f||d| |dur$||_|dur+||_d dd } | ||_| |d |_| || dS) NrrzMPassing 'handle' kwarg to WSGIServer is deprecated. Did you mean application?r) stacklevel)backlogspawnrucSs>|dkrtjS|durtSt|dst|drt||S|S)Nrrvr1)r>stderrrmrr)lrwr,r,r- _make_log_s z&WSGIServer.__init__.._make_log(r) warningswarnDeprecationWarningrrMr handler_classr1r set_environset_max_accept) rOlistenerrrrr1rrrssl_argsrrr,r,r-rMEs      zWSGIServer.__init__cCs||dur||_t|dd}||j|_|jrd|jd<nd|jd<|dur,|j||jddur<|j|jd<dSdS)Nrhttpszwsgi.url_schemehttpz wsgi.errors)rr environ_classbase_env ssl_enabledupdaterr)rOrenviron_updater,r,r-rms    zWSGIServer.set_environcCs|jdr d|_dSdS)NrrZ)rr max_acceptrar,r,r-r|s  zWSGIServer.set_max_acceptcCs ||jSrK)rrrar,r,r-rrzWSGIServer.get_environcCst||dSrK)r init_socketupdate_environrar,r,r-rs  zWSGIServer.init_socketcCs|j}t|trCd|jvr6z t|d}Wntjy&t|d}Ynwt|ts1|d}||jd<|j dt|ddS|j dd|j dddS)z Called before the first request is handled to fill in WSGI environment values. This includes getting the correct server name and port. SERVER_NAMErr& SERVER_PORTrZr4N) rrrrrgetfqdnrrr setdefault)rOrrr,r,r-rs     zWSGIServer.update_environcCs||||}|dS)z Create an instance of :attr:`handler_class` to handle the request. This method blocks until the handler returns. N)rr)rOrrhandlerr,r,r-rs zWSGIServer.handle)NNrrrNNrK)rGrHrIrdrrr1rrrrrCgevent version_infor>rrMrrrrrrr,r,r,r-r s41  ( r c Csddlm}|ddl}ddl}|}|jddd|jdddd d |}|j d \}}| |}t ||}|j } t | |} | dS) Nr)monkeyappz2dotted name of WSGI app callable [module:callable])helpz-bz--bindzThe socket to bindz:8080)rrrO)rr patch_allargparse importlibArgumentParser add_argument parse_argsrr import_modulerbindr serve_forever) rrrparserr module_nameapp_namemodulerrrr,r,r-_mains     r__main__)Hrd __future__rrhiorstringr>r6rJr urllib.parserrr gevent.serverr gevent.hubrgevent._compatr functoolsr r`_no_undoc_members__all__rir8r9 hexdigitsr(ru frozenset ascii_lettersrr?_INTERNAL_ERROR_STATUS_INTERNAL_ERROR_BODYrrg_INTERNAL_ERROR_HEADERS_BAD_REQUEST_STATUS_BAD_REQUEST_BODY_BAD_REQUEST_HEADERSrrr`rErjrFrLrJr|rQ mimetoolsMessager ImportErrorrrrrrrmrrrrrr rrGr,r,r,r-s                5    &R\5