vez      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~/Safe NoneVThe output tray.... all data is sorted according to the priority assigned here ...."System priorities: 0 for data frames -1 for header and other HTTP/2 low level -2 for go-away frame. The deliverer is expected to close the connection inmmediately after. - something_else for the PingFrame (have to look it put)6Stream Ordinary priorities are assigned by the worker.Safe3579NSequence of steps to get a StreamWorker. This class is independent of things like the finer details concerning the frames and the streams.]Todo: although this shows a common pattern, I'm not sure how having a class here helps....iA StreamWorker: a conduit that takes input tokens and answers with output tokens. It can perform I/O. Safe0NoneSafe;N*Monomorphic encapsulation of a Disruptible]This is an entity that can be disrupted and closed. Good to force shutdown in some places.Safe%How to know if we can split somewhereInput left-oversGenerator action*Packet and leftovers, if we could get them%How to know if we can split somewhereInput left-oversGenerator actionPacket bytes and left-overs. SafeNone !"04IN<Since SockAddr is not hashable, we need our own. TODO: IPv6.NoneCCallbacks used by client applications to get notified about interesting events happening at a connection level, or to get asked about things (e.g, about if it is proper to accept a connection). These are used from CoreServerCInvoked after the connection is accepted, and after it is finished. .SOCKS5 Connections, and where are they handled$Connection ID for SOCKS5 Connections'The command sent by the client/>A nonce which is always equal to five... or we are in troubles>  !"#$%&'()*+,-./0123456789:;<=>?:  !"#$%&'()*+,-./0123456789:;<=>?: !"#;:<3456789?=>+,-.'()*/0$%&2  1   !"#$%&'()*+,-./0123456789:;<=>?!NoneC!Match any 16 bit big endian word.!Match any 32 bit big endian word.(Match a specific 16-bit big-endian word."NoneC#Safe@CThe protocol version used. Here we distinguish only between HTTP 1.1 and HTTP2@AB@AB@ABNone+;NC#A set of functions describing how to do I/O in a session. There is one rule for IOCallbacks: only one user of it. That is, only one can write, only one can read concurrently. We don't protect for anything else, so concurrent read and writes would result in terrible things happening.Eput some data in the channelFget exactly this much data from the channel. This function can be used by HTTP/2 since lengths are pretty well built inside the protocoll itself. An exception of type NoMoreDataException can be raised from here inside if the channel is closed. This is done to notify the caller that there is no more data. The alternative would be to return an empty string, but that looks more hazardous for the caller.Gepull data from the channel, as much as the TCP stack wants to provide. we have no option but use this one when talking HTTP/1.1, where the best way to know the length is to scan until a Content-Length is found. This will also raise NoMoreDataException when there is no more data. Notice that with argument False, this may return an empty string.H1this is called when we wish to close the channel.ICallback that the session calls to realease resources associated with the channels. Take into account that your callback should be able to deal with non-clean shutdowns also, for example, if the connection to the remote peer is severed suddenly.JnGeneric implementation of PullAction from BestEffortPullAction, where we keep around any leftovers data ...K Callback type to pull data from a channel. The same as to PushAction applies to exceptions thrown from there. The first argument is the number of bytes to pull from the medium. Barring exceptions, we always know how many bytes we are expecting with HTTP/2.LCallback type to pull data from a channel in a best-effort basis. When the first argument is True, the data-providing backend can block if the input buffers are empty and await for new data. Otherwise, it will return immediately with an empty ByteStringMgCallback type to push data to a channel. Part of this interface is the abstract exception type IOProblem. Throw an instance of it from here to notify the session that the connection has been broken. There is no way to signal "normal termination", since HTTP/2's normal termination can be observed at a higher level when a GO_AWAY frame is seen.OsThe type of this function is also PullActionWrapping -> PullAction There should be only one reader concurrently.Q%Some context related to a connectionPlainText wrapperTbThe agent putting and retrieving data in this side of the channel should behave as a TLS clientUbThe agent putting and retrieving data in this side of the channel should behave as a TLS serverVDData exchanged through this channel begins with a SOCKS5 negotiationW@Data exchanged through this channel is the data of a TLS sessionX1Data exchanged through this channel is plain textYAn object a which is IOChannelsZThis method should only be invoked once for the a instance. It will block/wait for any handshakes to complete, and only then return a usable set of callbacks.`An Attendant is an entity that can speak a protocol, given the presented I/O callbacks. It's work is to spawn a set of threads to handle a client's session, and then return to the caller. It shouldn'r busy the calling thread.)CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`aCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`aMKL`ICDEFGH^]\[YZXWUTVQRSa_JNOPCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`aNone79CIN bCallbacks used by client applications to get notified about interesting events happening at a connection level, or to get asked about things (e.g, about if it is proper to accept a connection). These are used from CoreServerdCInvoked after the connection is accepted, and after it is finished.eConnection eventsfHNew connection. The second member says how many live connections are nowgAn ALPN negotiation failedhA connection ended.iA connection numberkQClass to have different kinds of TLS backends. Included here and enabled through 'enable-botan' is support for using Botan as a backend. HTTP/2 requires TLS 1.2 and ALPN, so older versions of many TLS libraries are not suitable.l<newTLSContextFromMemory cert_data key_data protocol_selector creates a new context, provided certificate data. The certificate data must be in X509 format. The private key should be in PKCS8 format without password.n5Returns the protocoll finally selected for a session.pCallback function to select a protocol during the ALPN negotiation phase. Given a list of ALPN identifiers, if something is suitable, return it.q,Singleton type. Used in conjunction with an MVar&. If the MVar is full, the fuction "tlsServeWithALPNAndFinishOnRequestI knows that it should finish at its earliest convenience and call the  CloseAction for any open sessions.t#Default connections callback. EmptybcdefghijklmnewTLSContextFromMemory cert_filename key_filename protocol_selector ^ Same as before, but using filename instead of certificates loaded into memory.nopqrstbcdefghijklmnopqrstqrpklmnoijefghbcdst bcdefghijklmnopqrstNone !"04INulCallbacks that you can provide your sessions to notify you of interesting things happening in the server.w)Used to report errors during this sessionx1Used to report delivery of individual data framesyUsed to notify the session manager of new sessions, so that the session manager registers them (in a weak map) if need comeszDCallback to be invoked when a client establishes a new session. The first parameter is the address of the client, and the second parameter is a controller that can be used to reduce the number of connections from time to time, the third parameter is a key on which the second paramter should be made a weak pointer|An object with information about a new session, wrapped in a weak pointer. At the time the newSessionCallback_SC is invoked, the reference inside the weak pointer is guranteed to be alive. It may die later though.Used by the session engine to report delivery of each data frame. Keep this callback very light, it runs in the main sending thread. It is called as f session_id stream_id ordinal when_deliveredClean-cut of sessionsGSessions follow this class, so that they can be rescinded on inactivity]Used by this session engine to report an error at some component, in a particular session.Components at an individual session. Used to report where in the session an error was produced. This interface is likely to change in the future, as we add more metadata to exceptions2Information used to identify a particular session.Get/set a numeric Id from a Y. For example, to get the session id with this, import `Control.Lens.(^.)` and then do 3 session_id = session_coordinates ^. sessionId This is a temporal interface, but an useful one nonetheless. By setting some values here to True, second-transfer will add some headers to inbound requests, and some headers to outbound requests.MThis interface is deprecated in favor of the AwareWorker functionality....VAdds a second-transfer-eh--used-protocol header to inbound requests. Default: False?Configuration information you can provide to the session maker.Session callbacksxSize to use when splitting data in data frames, to be sent. TODO: An equivalent maxRecvSize should be defined here...Should we enable PUSH in sessions? Notice that the client can still disable PUSH at will. Also users of the library can decide not to use it. This just puts another layer ...=The number to use for the first pushed stream. Should be evenMax amount of bytes to try to send in one go. The session will send less data if less is available, otherwise it will send slightly more than this amount, depending on packet boundaries. This is used to avoid TCP and TLS fragmentation at the network layerMax number of packets to hold in the output tray. A high number means that more memory is used by the packets have a higher chance of going out in a favourable order.*Don't insert any extra-headers by default.SCreates a default sessions context. Modify as needed using the lenses interfaces5uvwxyz{|}~4uvwxyz{|}~4uvwxy|}~z{uvwxyz{|}~None+;N   None!"Configuration structure)Number of admissible connections per peerCallback to be used when a connection to a peer is lost. | High water mark. When the number of connections go higher than this number, some of them are pruned. 9State structure. Will live for the entire server lifetime FPrunes any connections over the limit of connections allowed per host. Expects the connection list to be locked. Drops the death connections and returns a list with the entries for the ones which are still alive. 2Drops the oldest connections without activity ....         $None79IN Safe+;NBException to denote that something failed with the SOCKS5 protocol'This exception will be raised inside a CoherentWorker when the underlying stream is cancelled (STREAM_RESET in HTTP/2). Do any necessary cleanup in a handler, or simply use the fact that the exception is asynchronously delivered to your CoherentWorker Haskell thread, giving you an opportunity to interrupt any blocked operations.fThis is raised by the IOCallbacks when the endpoint is not willing to return or to accept more datarA concrete case of the above exception. Throw one of this if you don't want to implement your own type. Use  in catch signatures.)Throw exceptions derived from this (e.g, > below) to have the HTTP/2 session to terminate gracefully.Thrown with HTTP 1.1 over HTTP1.1 sessions when the response body or the request body doesn't include a Content-Length header field, given that should have included itEUsed by the ReverseProxy to signal an error from the upstream/GatewayAbstract exception. It is an error if an exception of this type bubbles to this library, but we will do our best to handle it gracefully in the Session engines. All internal error precursors at the workers can thus inherit from here to have a fallback option in case they forget to handle the error. It should also be used for the case of streaming requests that are interrupted by the upstream server. This exception inherits from HTTP11ExceptionAbstract exception. All HTTP/1.1 related exceptions derive from here. Notice that this includes a lot of logical errors and they can be raised when handling HTTP/2 sessions as wellNThrown when the HTTP/2 connection prefix doesn't match the expected prefix.BAbstract exception. Thrown when encoding/decoding of a frame failsConcrete Exception. Used internally to signal that the server broke the connection. This is a public exception that clients of the library will see when acting as an HTTP client.EReasons for a remote server interrupting a connectionn of this clientCorresponds to NO_ERROR;A request was done after the session was previously closed.This one happens when one of the IO channels is closed and a BlockedIndefinitelyOnMVar bubbles up. It should only happen in the test suite, as the OpenSSL_TLS channel uses a specialized exception type. If you see it in the wild, it is a bug.Any other reasonConcrete exception. Used internally to signal that the client violated the protocol. Clients of the library shall never see this exception.:Abstract exception. All HTTP/2 exceptions derive from here5Use the traditional idiom if you need to derive from , this is one of the helpers5Use the traditional idiom if you need to derive from , this is one of the helpersSimple utility function that ignores an exception. Good to work on threads when we know stuff. It takes as a first parameter a proxy./Simple utility function that reports exceptions3Just report all unhandled and un-ignored exceptionsI !"#$%&'()*+,-./01234//6 !"#$%&'()*+,-./01234 None!"C#IOCallbacks around an active socketThis function wraps an active socket (e.g., one where it is possible to send and receive data) in something with a set of active callbacks 56789:56789: NoneCGSimple alias to SocketIOCallbacks where we expect encrypted contentsCreates a listening socket at the provided network address (potentially a local interface) and the given port number. It returns the socket. This result can be used by the function tcpServe below/Same as above, but it takes a pre-built addressSimple TCP server. You must give a very short action, as the action is run straight in the calling thread. For a typical server, you would be doing a forkIO in the provided action. Do prefer to use tcpItcli directly.Itcli is a word made from ITerate-on-CLIents.. This function makes an iterated listen...Convenience function to create a TLS server. You are in charge of actually setting up the TLS session, this only receives a type tagged with the IO thing... Notice that the action should be short before actually forking towards something doing the rest of the conversation. If you do the TLS handshake in this thread, you will be in trouble when more than one client try to handshake simultaeneusly... ibidem if one of the clients blocks the handshake. ;<= ;<= None+;IN6A coupling between two IOCallbacks. It is breakable...OConnects two IO callbacks so that data received in one is sent to the other.Sends the data coming from the source to the IOCallbacks. No exceptions are handled here. This consumes the thread until it finishes. The iocallbacks is not closed. >?@ABCDEFGHIJKLMNOPQRSTU>?@ABCDEFGHIJKLMNOPQRSTUNoneCV\Simple alias to SocketIOCallbacks where we expect encrypted contents over a SOCKS5 SocketWForwards a set of IOCallbacks (actually, it is exactly the same passed in) after the SOCKS5 negotiation, if the negotiation succeeds and the indicated "host" is approved by the first parameter. Quite simple.XJForwards a set of IOCallbacks (actually, it is exactly the same passed in) after the SOCKS5 negotiation, if the negotiation succeeds and the indicated "host" is approved by the first parameter. If the approver returns false, this function will try to actually connect to the host and let the software act as a true proxy.tlsSOCKS5Serve approver listening_socket onsocks5_action The approver should return True for host names that are served by this software (otherwise the connection will be closed, just for now, in the close future we will implement a way to forward requests to external Internet hosts.) Pass a bound and listening TCP socket where you expect a SOCKS5 exchange to have to tke place. And pass an action that can do something with the callbacks. The passed-in action is expected to fork a thread and return inmediately.YZV[\]^WX_`abcdYZV[\]^WX_`abcdNone4INContains information that applies to all sessions created in the program. Use the lenses interface to access members of this struct.JTODO: members of this record should be renamed to the "suffix" convention.BRead-only configuration information passed-in at construction time!MVar with enumerator for sessions             %None:uvwxyz{|}~    None 79IN[ Opaque hold typeA simple AliasgConvenience function to open a port and listen there for connections and select protocols and so on.&Use a previously given network addressThe prefork way requires a first step where we create the sockets and then we listen on them... This function is identical otherwise to the one without _Prepare. The real thing is done by the one with _Do below...8Actually listen, possibly at the other side of the fork.efghi j klmnxThis is a simple proxy type from Typeable that is used to select the type of TLS backend to use during the invocationControl and log connections)String with contents of certificate chain#String with contents of PKCS #8 keyName of the network interface%List of attendants and their handlersPort to listen for connectionsxThis is a simple proxy type from Typeable that is used to select the type of TLS backend to use during the invocation'Control and regulate SOCKS5 connections)String with contents of certificate chain#String with contents of PKCS #8 keyAddress to bind to%List of attendants and their handlersxThis is a simple proxy type from Typeable that is used to select the type of TLS backend to use during the invocation'Control and regulate SOCKS5 connections)String with contents of certificate chain#String with contents of PKCS #8 keyAddress to bind to-Will-be list of attendants and their handlers xThis is a simple proxy type from Typeable that is used to select the type of TLS backend to use during the invocation(Log and control of the inner TLS session(Log and control the outer SOCKS5 session)String with contents of certificate chain#String with contents of PKCS #8 keyAddress to bind to&List of attendants and their handlers,Names of "internal" hosts%Should I forward connection requests? xThis is a simple proxy type from Typeable that is used to select the type of TLS backend to use during the invocation(Log and control of the inner TLS session(Log and control the outer SOCKS5 session)String with contents of certificate chain#String with contents of PKCS #8 keyAddress to bind to:List of attendants and their handlers, as it will be builtNames of "internal" hosts%Should I forward connection requests?xThis is a simple proxy type from Typeable that is used to select the type of TLS backend to use during the invocation4Functions to log and control behaviour of the server-PEM-encoded certificate chain, in this string4PEM-encoded, un-encrypted PKCS #8 key in this string+An entity that is used to fork new handlersThe fork-handling functionality%List of attendants and their handlers      efghi j klmn&NoneC opqrstuvwxyz oqrstuvwxy opqrstuvwxyzNone +3579N'Data related to the requestRThe HTTP/2 stream id. Or the serial number of the request in an HTTP/1.1 session.A number uniquely identifying the session. This number is unique and the same for each TPC connection that a client opens using a given protocol.TMonotonic time close to when the request was first seen in the processing pipeline.%Which protocol is serving the request;For new connections, probably a list of announced protocols Atuple with something like the IPv4 number for the requesting host!This is a Source conduit (see Haskell Data.Conduit library from Michael Snoyman) that you can use to retrieve the data sent by the peer piece-wise."^Has kind * -> * Used to allow for registered cleanup functions to be safely called, even#specially in the event of a BrowserUser hanging-up the connection before the worker has finished doing its work. Alleviates the need for handling async. execeptions.#rList of headers. The first part of each tuple is the header name (be sure to conform to the HTTP/2 convention of using lowercase) and the second part is the headers contents. This list needs to include the special :method, :scheme, :authority and :path pseudo-headers for requests; and :status (with a plain numeric value represented in ascii digits) for responses.$The complete header%The value part of a header&The name part of a header'A request is a set of headers and a request body.... which will normally be empty, except for POST and PUT requests. But this library enforces none of that.2A pushed stream, represented by a list of request headers, a list of response headers, and the usual response body (which may include final footers (not implemented yet)).7A source-like conduit with the data returned in the response. The return value of the conduit is a list of footers. For now that list can be anything (even bottom), I'm not handling it just yet.8%A list of pushed streams. Notice that a list of IO computations is required here. These computations only happen when and if the streams are pushed to the client. The lazy nature of Haskell helps to avoid unneeded computations if the streams are not going to be sent to the client.9Finalization headers:Finalization headers. If you don't know what they are, chances are that you don't need to worry about them for now. The support in this library for those are at best sketchy.>ySometimes a response needs to be handled a bit specially, for example by reporting delivery details back to the worker@CA callback to be called whenever a data-packet for this stream is .AIn certain circunstances a stream can use an internal priority, not given by the browser and the protocol. Lowest values here are given more priority. Default (when Nothing) is given zero. Cases with negative numbers also work.BzThere are situations when it is desirable to close a stream or the entire connection. Use this member to indicate that.CValid priority effects_In certain circunstances a stream can use an internal priority, not given by the browser and the protocol. Lowest values here are given more priority. Default (when Nothing) is given zero. Cases with negative numbers also work. Since higher numbers mean *lower* priority, we often call this number *calm*, so that higher numbers mean higher calm.Notice that SecondTransfer still assigns "system priorities" to frames which are used before the priorities computed by this mechanism.DLeaves on default prioritiesE5Assigns a uniform priority to all data in this streamFStarts with the given priority, and as the sender crosses each byte boundary in the first part of the pair, the calm is raised (e.g., the priority is lowered), by the positive number given as second part of the pairGTypes of interrupt effects that can be signaled by aware workers. These include whole connection shutdowns and stream resets. In all the cases, the reason given will be NO_ERROR.HClose and send GoAway after this stream finishes deliveryIClose and send GoAway withoutj delivering this stream. This implies that other fields of the PrincipalStream record will be ignored.JFirst argument is the ordinal of this data frame, second an approximation of when the frame was delivered, according to the monotonic clock. Do not linger in this call, it may delay some important threadN+You use this type to answer a request. The #U are thus response headers and they should contain the :status pseudo-header. The 8E is a list of pushed streams... they will be pushed to the client.XA tuple representing the data alone usually needed to create a response. That is, the headers (including HTTP/2 :path, :authority, etc) and maybe an input data stream for requests that include it, that is, POST and PUT.YA tuple representing the data alone that you usually need to give as a response, that is, the headers in the response (including the HTTP/2 :status), any pushed streams, a stream with the response data and the footers.ZA CoherentWorker is a simplified callback that you can implement to handle requests. Then you can convert it to an AwareWorker with `.[<Main type of this library. You implement one of these for your server. This is a callback that the library calls as soon as it has all the headers of a request. For GET requests that's the entire request basically, but for POST and PUT requests this is just before the data starts arriving to the server.It is important that you consume the data in the cases where there is an input stream, otherwise the memory is lost for the duration of the request, and a malicious client can use that.rAlso, notice that when handling requests your worker can be interrupted with an asynchronous exception of type StreamCancelledException#, if the peer cancels the stream`*Convert between the two types of callback.c"Gets a single header from the listdIf you want to skip the footers, i.e., they are empty, use this function to convert an ordinary Source to a DataAndConclusion.M !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLM{NOPQRSTUVWXYZ[\]^_`abcdL !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdLcd&%$#:'()*+9 >?@AB["NOPQRS8234567Z!YXJGHICDEF;<=^_\KLM]01/,-.TVUWb`a0 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLM{NOPQRSTUVWXYZ[\]^_`abcdNonen@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd@ABNoneeIf you are not processing the potential POST input in a request, use this consumer to drop the data to oblivion. Otherwise it will remain in an internal queue until the client closes the stream, and if the client doesn't want to do so....efefefefNone0CINjAbstract data-type. Use p to get one of these from #;. The underlying representation admits better asymptotics.kOHTTP headers are case-insensitive, so we can use lowercase versions everywherel!Checks that headers are lowercasenLooks for a given header|5Expands a header value with zeros into something else}fTransforms a header value so that characters outside the valid ascii range are replaced by nothingsp O(n*log n) Builds the editor from a list.qO(n)c Takes the HeaderEditor back to Headers. Notice that these headers are good for both HTTP 1.1 and HTTPW2, as combined headers won't be merged. It will even work for Cookie headers.rQreplaceHeaderValue headers header_name maybe_header_value looks for header_name. If header_name is found and maybe_header_value is nothing, it returns a new headers list with the header deleted. If header_name is found and header_value is Just new_value, it returns a new list with the header containing the new value. If header_name is not in headers and maybe_header_value is Nothing, it returns the original headers list. If header_name is not in headers and maybe_header_value is Just new_value, it returns a new list where the last element is (header_name, new_value)sheaderLens header_name represents a lens into the headers, and you can use it then to add, alter and() remove headers. It uses the same semantics than rtReplaces a "host" HTTP/1.1 header by an ":authority" HTTP/2 header. The list is expected to be already in lowercase, so nothing will happen if there the header name portion is "Host" instead of "host".Notice that having a HostQ header in an HTTP/2 message is perfectly valid in certain circumstances, check  7https://http2.github.io/http2-spec/#rfc.section.8.1.2.3Section 8.1.2.3 of the spec for details.ubCombines ":authority" and "host", giving priority to the first. This is used when proxying HTTP 2 to HTTP>1.1. It leaves whichever header of highest priority is presentv$Given a header editor, introduces a DateB header. This function has a side-effect: to get the current timew8Remove connection-specific headers as required by HTTP/2x@Fusion values for a specific header, using a provided separator.+ghij~klmno|}pqrstuvwxyz{#ghijklmnopqrstuvwxyz{klmnj#pqsrtvouwxghiy{z#ghij~klmno|}pqrstuvwxyz{'None Stop condition when parsing the body. Tons and tons of messages in the internet go without a Content-Length header, in those cases there is a long chain of conditions to determine the message length, and at the end of those, there is CloseConnection.There is a content-length header, and a lengthJWe expect the connection to be closed by the peer when the stream finishes5It's a chunked transfer, use the corresponding parser3Terrible things have happened, close the connectionWas the parser complete?DNo, not even headers are done. Use the returned value to continueHeaders were completed. For some HTTP methods that's all there is, and that's what this case represents. The second argument is a left-overs string, that should be completed with any other data requiredFor requests with a body. The second argument is a condition to stop receiving the body, the third is leftovers from parsing the headers.?Some requests are ill-formed. We can check those cases here.Converts a list of headers to a request head. Invoke with the request data. Don't forget to clean the headers first. NOTICE that this function doesn't add the rn extra-token for the empty line at the end of headers.7*(NoneIN2Used to report metrics of the session for Http/1.1|&Session attendant that speaks HTTP/1.1EThis attendant should be OK with keep-alive, but not with pipelining.|||None79}Request. This is an old-fashioned HTTP request, with less data than that defined at CoherentWorker: just headers and perhaps a request streaming body. As in other places in this library, we expect method and path to be given as pseudo-headers3Response. Status should be given as a pseudo-headercSomething that can talk to a HTTP 1.1 server by using a connection and sending the request to it}~}~}~}~None79INTakes an IOCallbacks and serializes a request (encoded HTTP/2 style in headers and streams) on top of the callback, waits for the results, and returns the response. Notice that this proxy may fail for any reason, do take measures and handle exceptions. Also, must headers manipulations (e.g. removing the Connection header) are left to the upper layers. And this doesn't include managing any kind of pipelining in the http/1.1 connection, however, close is not done, so keep-alive (not pipelineing) should be OK.None)None+;INSignals that the Session sends to the Framer concerning normal operation, including high-priority data to send (in priority trains, already formatted), and a command to start the output machinery for a new streamQCommands that the sessions sends to the framer which concern the whole session  *None4INTTakes frames from the Framer and starts streams mini-workers to make sense of them.XTODO: Really limit the number of streams that a single client is allowed to have active.TTODO: Some ill clients can break this thread with exceptions. Make these paths a bitInvokes the Coherent worker, and interacts with the rest of the session and the Framer so that data is sent and received by the peer following the protocol.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|5uvwxy  68?QRp       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|+None*+35 }!Either we are server and have an  AwareWorker!, or we are client and have a  ClientState~tThis is a special "mark" priority that when used causes the connection to be closed. It is used because is clean.gWraps a session, provided that we get who will be taking care of the session and the session context.)All the output frames come this way firstSometimes the browser gives capacity before we even have seen the first data frame going back from here from the server, so the flow control command place should be started first...Handles only Data frames.qA thread in charge of doing flow control transmission....This Reads payload data and formats it to DataFrames...&There is one of these for each stream.This function will read from an MVar (and block on that), and will write to the output tray (and occassionally also block on that, if the output tray doesn't have enough space).Puts output wagons in the tray. This function blocks if there is not enough space in the tray and the system priority is not negative. For negative system priority, the packets are always queued, so that then can be sent as soon as possible.xThis prioritizes DATA packets, in some rudimentary way. This code will be replaced in due time for something compliant.System priority: -20 : the prefix, absolutely most important guy -15 : A request to close the connection -10 : PING frame -1 : All packets except data packets 0 : data packets./Blocks if there is not enough space in the tray0Blocks if there is not enough space in the tray.Pushes a GoAway frame with the highest priority, so that everything else will be overrided (except perhaps any header trains that are already being sent.)cIn charge of actually sending the frames, in a special thread (create said thread in the caller).qThis thread invokes the data push action, so IOCallbacks problems will bubble as exceptions through this thread.As long as all the pipes connecting components of the system are bound, terminating this function and it's thread should propagate as blocked-indefinitely errors to all the other threads to pipes.F}~Generator action*Packet and leftovers, if we could get them}2 }~,None-None6None.None C http2Attendant :: AwareWorker -> AttendantCallbacks -> IO () Given a [q, this function wraps it with flow control, multiplexing, and state maintenance needed to run an HTTP/2 session.4Notice that this function is using HTTP/2 over TLS.NoneNone||/$(c) Alcides Viamontes Esquivel, 2015BSDalcidesv@zunzun.se experimentalPOSIXNone`!#$%&'2789:NZ[be|#&%$'9Z[N827!:`|be001234556789:;<==>>?@ABCDEFGHHIJKKLMNOPQRSTUVWXYYZ[\\]^_`abcdefg#h#i#jkklmnopqrstuvwxxyz{|}~                                                        !"#$$%&'()*+,-./01123456789:;;<=>?@ABCDEFFGHIJKLMNOPQRSTUUVWXYZ[\]^_`abcdefghijklmmnopqrstuvwxyz{|}~(. 3!!!!!!!!!!!!!!!!""""""q                $              ! " # $ % & ' ( ) * + , -  . / 0 1 2 3 4 5  6 7 7 8 9 : ; < = = > ? @ A B   C D E F G HIJKLIMNOPQRSTUVVWXYZ[\&]&]&^&_&`&a&b&c&d&e&f&ghijokllmnopqrstuvwxyz{|'}'~'''''''''''''''''''''''''''''''''''''''''''''''''''''(((()))))))))))******************************************************************************* * * * * ******************* *!*"*#*$*%*&*'*(*)***+*,*-*.*/*0*1*2*3*4*5*6*7*8*9*:*;*<*=*>*?*@*A*B*C*D*E*F*G*H*I*J*K*L*M*N*O*P*Q*R*S*T*U*V*W*X*Y*Z*[*\*]*^+_+`+a+b+c+d+e+f+g+h+i+j+k+k+l+m+n+o+p+q++r+s+s+t+u+v+w+x+y+z++{+|+}+~++++++++++++++++++*++++++++++++++++-secon_09A59khffD9JKiurjmFKwV#SecondTransfer.MainLoop.Disruptible(SecondTransfer.Sessions.HashableSockAddrSecondTransfer.Socks5.TypesSecondTransfer.Types SecondTransfer.IOCallbacks.TypesSecondTransfer.TLS.TypesSecondTransfer.Sessions.Config'SecondTransfer.IOCallbacks.SaveFragmentSecondTransfer.Sessions.TidalSecondTransfer.Exception%SecondTransfer.IOCallbacks.WrapSocket'SecondTransfer.IOCallbacks.SocketServer#SecondTransfer.IOCallbacks.CouplingSecondTransfer.Socks5.Session SecondTransfer.Sessions.InternalSecondTransfer.TLS.CoreServer&SecondTransfer.MainLoop.CoherentWorkerSecondTransfer.Utils.DevNull SecondTransfer.Utils.HTTPHeadersSecondTransfer.Http1SecondTransfer.Http1.TypesSecondTransfer.Http1.Proxy(SecondTransfer.MainLoop.ClientPetitionerSecondTransfer.MainLoopSecondTransfer.Http2SecondTransfer.Http2.CalmStateSecondTransfer.Http2.OutputTraySecondTransfer.MainLoop.Tokens$SecondTransfer.MainLoop.DebugMonitorSecondTransfer.MainLoop.LoggingSecondTransfer.MainLoop.Framer!SecondTransfer.ConstantsAndLimitsSecondTransfer.Socks5.Parsers!SecondTransfer.Socks5.Serializers SecondTransfer.MainLoop.Protocol"SecondTransfer.IOCallbacks.BotcherSecondTransfer.SessionsSecondTransfer.UtilsSecondTransfer.Http1.ParseSecondTransfer.Http1.Session"SecondTransfer.Http2.TransferTypesSecondTransfer.Http2.SessionSecondTransfer.Http2.Framer SecondTransfer.MainLoop.Internal!SecondTransfer.Http2.SimpleClient"SecondTransfer.Http2.MakeAttendantSecondTransferMonoDisruptible DisruptibledisruptHashableSockAddrhashableSockAddrFromNSSockAddrSocks5ConnectionCallbacks_logEvents_S5CCSocks5LogCallbackSocks5ConnectEventEstablished_S5EvHandlingHere_S5EvToExternal_S5Ev Dropped_S5EvS5ConnectionIdClientRequest_Packet _version_SP3_cmd_SP3 _reserved_SP3 _address_SP3 _port_SP3IndicatedAddressIPv4_IA DomainName_IAIPv6_IAServerSelectsMethod_Packet _version_SP2 _method_SP2ClientAuthMethods_Packet _version_SP1 _methods_SP1 ReplyFieldSucceeded_S5RFGeneralFailure_S5RFProtocolCommand Connect_S5PC Bind_S5PCUdpAssociate_S5PC AddressType IPv4_S5ATDomainName_S5AT IPv6_S5ATProtocolVersionlogEvents_S5CCiaToAddressTypeServerReply_Packet _version_SP4_replyField_SP4_reservedField_SP4 _address_SP4 _port_SP4 address_SP3cmd_SP3port_SP3 address_SP4port_SP4replyField_SP4HttpProtocolVersion Http11_HPV Http2_HPV IOCallbacks_pushAction_IOC_pullAction_IOC_bestEffortPullAction_IOC_closeAction_IOC CloseActionPullActionWrapping PullActionBestEffortPullAction PushActionnewPullActionWrappingpullFromWrapping'bestEffortPullFromWrappingConnectionData _addr_CnD TLSClientIO TLSServerIO SOCKS5PrefaceTLSEncryptedIO PlainTextIO IOChannels handshakebestEffortPullAction_IOCcloseAction_IOCpullAction_IOCpushAction_IOCnullConnectionData Attendantaddr_CnDConnectionCallbacks_logEvents_CoCaConnectionEventEstablished_CoEvALPNFailed_CoEv Ended_CoEv ConnectionId TLSContextnewTLSContextFromMemorynewTLSContextFromCertFileNamesunencryptTLSServerIOgetSelectedProtocolProtocolSelector FinishRequestlogEvents_CoCadefaultConnectionCallbacksSessionsCallbacks_reportErrorCallback_SC_dataDeliveryCallback_SC_newSessionCallback_SCNewSessionCallbackSessionGenericHandle Whole_SGH Partial_SGHDataFrameDeliveryCallbackCleanlyPrunableSessioncleanlyCloseSessionActivityMeteredSessionsessionLastActivity ErrorCallbackSessionComponent(SessionInputThread_HTTP2SessionComponent0SessionHeadersOutputThread_HTTP2SessionComponent-SessionDataOutputThread_HTTP2SessionComponent-SessionClientPollThread_HTTP2SessionComponentFramer_HTTP2SessionComponentSession_HTTP11SessionCoordinates sessionIdSessionsEnrichedHeaders_addUsedProtocoldataDeliveryCallback_SCnewSessionCallback_SCreportErrorCallback_SCSessionsConfig_sessionsCallbacks_sessionsEnrichedHeaders_dataFrameSize _pushEnabled_firstPushStream_networkChunkSize _trayMaxSizeaddUsedProtocoldefaultSessionsEnrichedHeaders dataFrameSizefirstPushStreamnetworkChunkSize pushEnabledsessionsCallbackssessionsEnrichedHeaders trayMaxSizedefaultSessionsConfigSaveReadFragmentnewSaveReadFragment TidalContext_maxConnectionPerPeer_TiC_highWaterMark_TiChighWaterMark_TiCmaxConnectionPerPeer_TiCdefaultTidalContextnewTidalSessiontidalConnectionManagerSOCKS5ProtocolExceptionStreamCancelledExceptionNoMoreDataExceptionGenericIOProblem IOProblemHTTP11SyntaxExceptionContentLengthMissingExceptionGatewayAbortedExceptionHTTP500PrecursorExceptionHTTP11ExceptionBadPrefaceExceptionFramerExceptionClientSessionAbortedExceptionConnectionCloseReasonNormalTermination_CCRSessionAlreadyClosed_CCRIOChannelClosed_CCRProtocolError_CCRHTTP2ProtocolExceptionHTTP2SessionException+convertHTTP500PrecursorExceptionToException)getHTTP500PrecursorExceptionFromExceptiongatewayAbortedException ioProblemnoMoreDataExceptionignoreExceptionreportExceptionskeyedReportExceptions forkIOExcblockedIndefinitelyOnMVarblockedIndefinitelyOnSTM ioExceptionSocketIOCallbacksSomeHasSocketPeer HasSocketPeergetSocketPeerAddress socket_SSsocketIOCallbacksTLSServerSocketIOCallbackscreateAndBindListeningSocket&createAndBindListeningSocketNSSockAddrtcpServetcpItclitlsServetlsItcliCouplingcouple breakCouplingiocallbacksToSinksendSourceToIOIOCSideBIOCSideApopIOCallbacksIntoExistanceSocks5ServerStateConnectOrForward Connect_COF Forward_COFDrop_COFinitSocks5ServerStatetlsSOCKS5ServeSessionsContext_sessionsConfig_nextSessionId nextSessionIdsessionsConfigsessionsConfig_SctxnextSessionId_SctxacquireNewSessionTagmakeSessionsContextmakeDefaultSessionsContextsessionExceptionHandler Socks5Hold NormalTCPHoldNamedAttendantstlsServeWithALPNtlsServeWithALPNNSSockAddr"tlsServeWithALPNNSSockAddr_PreparetlsServeWithALPNNSSockAddr_Do#tlsServeWithALPNUnderSOCKS5SockAddr+tlsServeWithALPNUnderSOCKS5SockAddr_Prepare&tlsServeWithALPNUnderSOCKS5SockAddr_DotlsSessionHandlerchooseProtocol coreListen Perception _streamId_Pr _sessionId_Pr_startedTime_Pr _protocol_Pr_anouncedProtocols_Pr_peerAddress_PrInputDataStreamAwareWorkerStackHeadersHeader HeaderValue HeaderNameRequest _headers_RQ _inputData_RQ_perception_RQanouncedProtocols_PrpeerAddress_Pr protocol_Pr sessionId_PrstartedTime_Pr streamId_Pr PushedStream_requestHeaders_Psh_responseHeaders_Psh_dataAndConclusion_PshDataAndConclusion PushedStreamsFootersFinalizationHeaders headers_RQ inputData_RQ perception_RQEffect_fragmentDeliveryCallback_Ef_priorityEffect_Ef _interrupt_EfPriorityEffect NoEffect_PrEf Uniform_PrEf PerYield_PrEfInterruptEffectInterruptConnectionAfter_IEfInterruptConnectionNow_IEfFragmentDeliveryCallbackdataAndConclusion_PshrequestHeaders_PshresponseHeaders_PshPrincipalStream _headers_PS_pushedStreams_PS_dataAndConclusion_PS _effect_PSfragmentDeliveryCallback_Ef interrupt_EfpriorityEffect_EfdefaultEffects TupledRequestTupledPrincipalStreamCoherentWorker AwareWorkerdataAndConclusion_PS effect_PS headers_PSpushedStreams_PS&tupledPrincipalStreamToPrincipalStreamrequestToTupledRequestcoherentToAwareWorkergetHeaderFromFlatList nullFooterdropIncomingDatadropWouldGoDataPrettyPrintHeadersConfig_indentSpace_PPHC HeaderEditorlowercaseHeadersheadersAreLowercase!headersAreLowercaseAtHeaderEditor fetchHeaderheaderIsPseudofromListtoListreplaceHeaderValue headerLensreplaceHostByAuthoritycombineAuthorityAndHostintroduceDateHeaderremoveConnectionHeaders fusionHeadersindentSpace_PPHCdefaultPrettyPrintHeadersConfigprettyPrintHeadershttp11Attendant HttpRequest _headers_Rq_body_Rq HttpResponse _headers_Rp_body_Rpbody_Rq headers_RqProxyToHttpServerproxyToConnectionHttp1CycleControllerreleaseResponseResourcesbody_Rp headers_RpioProxyToConnectionClientPetitionerrequest_noncehttp2Attendant CalmState _restOfMap_currentOffset _currentCalmCalmEnhacementMap newCalmStategetCurrentCalm advanceCalm TrayEntry_systemPriority_TyE_streamPriority_TyE_streamOrdinal_TyE _payload_TyE _streamId_TyE OutputTray _filling_OuT_maxLength_OuT _entries_OuTEntryListBuilder payload_TyE streamId_TyEstreamOrdinal_TyEstreamPriority_TyEsystemPriority_TyE entries_OuT filling_OuT maxLength_OuTtrayCompareKeytrayEntryCompare newOutputTrayaddEntrylowestCalmValue splitOverSizeStreamWorkerClass StreamWorker initService initSession initStreamStreamOutputActionSendHeaders_SOASendAssociatedHeaders_SOA SendData_SOASendAssociatedData_SOASendAssociatedFinish_SOA Finish_SOAGlobalStreamId LocalStreamIdStreamInputToken Headers_STkData_Stk Finish_StkUnpackedNameValueListactionIsForAssociatedStreampackHeaderTuplesunpackHeaderTuples getHeader$fBinaryUnpackedNameValueListnonce$fDisruptibleMonoDisruptibleLengthCallbackFramer readNextChunkreadNextChunkAndContinuereadUpToreadLengthFromUntamed maxUrlLength$fHashableHashableSockAddr reserved_SP3 version_SP3reservedField_SP4 version_SP4 anyWord16be anyWord32beword16beparseProtocolVersionparseAddressTypeparseProtocolCommandparseReplyFieldparseClientAuthMethods_PacketparseServerSelectsMethod_PacketparseIndicatedAddressparseClientRequest_PacketbyteSizepackanyWordNunpackwordNputProtocolVersion putReplyFieldputServerSelectsMethod_PacketputAddressTypeputIndicatedAddressputServerReply_Packet PlainText TLSServer$fTLSServerIOTLSServer$fTLSEncryptedIOTLSServer$fIOChannelsTLSServer$fPlainTextIOPlainText$fIOChannelsPlainText LogCallback,$fActivityMeteredSessionSessionGenericHandle$fEqSessionCoordinates _inner_SRF _fragment_SRF fragment_SRF inner_SRF pushActionbestEffortPullAction closeAction$fIOChannelsSaveReadFragmentTidalS pruneSameHostdropDeathConnectionspruneOldestConnections _context_TdS_connections_TdSConnectionListConnectionEntry MemoTableTidalMconnections_TdS context_TdSjustRegisterNewConnectiondropConnectionswhenAddingConnection insertNoise'convertHTTP2SessionExceptionToException%getHTTP2SessionExceptionFromException!convertFramerExceptionToExceptiongetFramerExceptionFromException!convertHTTP11ExceptionToExceptiongetHTTP11ExceptionFromException"$fExceptionSOCKS5ProtocolException#$fExceptionStreamCancelledException$fExceptionNoMoreDataException$fExceptionGenericIOProblem$fExceptionIOProblem$fShowIOProblem $fExceptionHTTP11SyntaxException($fExceptionContentLengthMissingException"$fExceptionGatewayAbortedException$$fExceptionHTTP500PrecursorException$fShowHTTP500PrecursorException$fExceptionHTTP11Exception$fShowHTTP11Exception$fExceptionBadPrefaceException$fExceptionFramerException$fShowFramerException($fExceptionClientSessionAbortedException!$fExceptionHTTP2ProtocolException $fExceptionHTTP2SessionException$fShowHTTP2SessionException _socket_SS _callbacks_SS callbacks_SS $fHasSocketPeerSocketIOCallbacks$fIOChannelsSocketIOCallbacks)$fHasSocketPeerTLSServerSocketIOCallbacks'$fTLSServerIOTLSServerSocketIOCallbacks*$fTLSEncryptedIOTLSServerSocketIOCallbacks _breakNow_Cou SideDatum_dt_SD_dt_M breakNow_Coupump newSideDatum IOCTransit _aToB_IOCT _bToA_IOCT _closed_IOCTdt_Mdt_SD aToB_IOCT bToA_IOCT closed_IOCT popActions$fIOChannelsIOCSideB$fIOChannelsIOCSideATLSServerSOCKS5CallbacksnegotiateSocksAndForwardnegotiateSocksForwardOrConnect_nextConnection_S5SnextConnection_S5StryRead pushDatumconnectOnBehalfOfClient toSocks5Addr'$fHasSocketPeerTLSServerSOCKS5Callbacks%$fTLSServerIOTLSServerSOCKS5Callbacks($fTLSEncryptedIOTLSServerSOCKS5Callbacks$$fIOChannelsTLSServerSOCKS5CallbacksSessionHandlerState_liveSessions_S _nextConnId_S_connCallbacks_SconnCallbacks_SliveSessions_S nextConnId_SWord24strToInt word24ToInt getWord24be putWord24be lowercaseTextunfoldChannelAndSource stripString domainFromUrl subByteString$fBinaryWord24 $fShowEffect splitByZerossanitizeHeaderValueinnerMap AutosortedHeaderPriority Pseudo_Hep Important_Hep Normal_HePloweraTitleIsLowercaseheaderIsImportantheaderPrioritytoFlatBscolon headerToManyrebaseheaderIsSingletonremoveDuplicateHeaders combineMaps$fMonoidHeaderEditorBodyStopConditionUseBodyLength_BSCConnectionClosedByPeer_BSC Chunked_BSCSemanticAbort_BSCHttp1ParserCompletionMustContinue_H1PCOnlyHeaders_H1PCHeadersAndBody_H1PCRequestIsMalformed_H1PCheaderListToHTTP1RequestTextRequestOrResponseLine Request_RoRL Response_RoRLHeaderParseClosureIncrementalHttp1Parser _fullText _stateParsernewIncrementalHttp1ParseraddByteslooksSuspiciouselaborateHeaders splitByColontransferEncodingIsChunkedverifyHeaderNameverifyHeaderValueverifyHeaderSyntaxparseFirstLine bsToLowerstripBs stripBsHName locateCRLFstwoCRLFsAreConsecutiveisWsCh8isWs http1Token http1Method unspacedUrispace requestLinedigit responseLine httpFirstLine chunkParser wrapChunk unwrapChunksheaderListToHTTP1ResponseTextserializeHTTPResponse validMethodmethodHasRequestBodymethodHasResponseBodycleanupAbsoluteUrihttpStatusTable$fShowIncrementalHttp1ParserSimpleSessionMetricsaddExtraHeaders,$fActivityMeteredSessionSimpleSessionMetricsfragmentMaxLengthSessionToFramerBlockSessionOutputCommandSessionOutputPacket Command_StFBPriorityTrain_StFBHeadersTrain_StFBOutputDataFeedCancelSession_SOCSpecificTerminate_SOC OutputFramesessionInputThread workerThreadSessionSettings_pushEnabled_SeS_frameSize_SeSHeaderOutputMessageNormalResponse_HMPushPromise_HM GoAway_HM InputFrameWorkerThreadEnvironment _streamId_WTE_headersOutput_WTE_streamBytesSink_WTE_streamsCancelled_WTE_sessionSettings_WTE_nextPushStream_WTE_resetStreamButton_WTE_childResetStreamButton_WTE frameSize_SeSpushEnabled_SeS ClientState_pendingRequests_ClS_nextStream_ClS_clientIsClosed_ClS_response2Waiter_ClS RequestResultMessagePostInputMechanismCoherentSession SessionMaker SessionRole Client_SR Server_SRSessionInputCommandFirstFrame_SICMiddleFrame_SICInternalAbort_SICInternalAbortStream_SICCancelSession_SIC WorkerMonadStream2HeaderBlockFragment HashTable SessionOutputSessionOutputChannelAbstractionSOCA SessionInputSessionchildResetStreamButton_WTEheadersOutput_WTEnextPushStream_WTEresetStreamButton_WTEsessionSettings_WTEstreamBytesSink_WTE streamId_WTEstreamsCancelled_WTEsendMiddleFrameToSessionsendFirstFrameToSessionsendCommandToSessionsendOutputToFramernewSessionOutputgetFrameFromSession SessionData_sessionsContext _sessionInput_sessionOutput_toEncodeHeaders_toDecodeHeaders_receivingHeaders_lastGoodStream_stream2HeaderBlockFragment_forWorkerThread _awareWorker _simpleClient_streamsCancelled_stream2PostInputMechanism_stream2WorkerThread_sessionIdAtSession_sessionSettings_nextPushStream _sessionRole _startTime _peerAddress_sessionIsEnding ClientMonadclientIsClosed_ClSnextStream_ClSpendingRequests_ClSresponse2Waiter_ClSmakeClientStatehandleRequest' handleRequest$fClientPetitionerClientState awareWorkerforWorkerThreadlastGoodStreamnextPushStream peerAddressreceivingHeaderssessionIdAtSession sessionInputsessionIsEnding sessionOutput sessionRolesessionSettingssessionsContext simpleClient startTimestream2HeaderBlockFragmentstream2PostInputMechanismstream2WorkerThreadstreamsCancelledtoDecodeHeaderstoEncodeHeadershttp2ServerSessionhttp2ClientSession http2Session streamIsIdleserverProcessIncomingHeadersclientProcessIncomingHeadersstreamInitiatedByClientsendOutPriorityTrainsendOutPriorityTrainManyvalidateIncomingHeadersServervalidateIncomingHeadersClientcloseConnectionBecauseIsInvalidquietlyCloseConnectioncloseConnectionForClientcancellAllStreamsrequestTerminationframeEndsStreamunlessReceivingHeaderscreateMechanismForStreamclosePostDataSourcestreamWorkerSendDatasendBytesToPimpostDataSourceFromMechanism isSettingsAck isLengthZero frameLength isStreamZeroisStreamCancelledsendPrimitive500ErrornormallyHandleStream pusherThreadsendDataOfStreamappendHeaderFragmentBlockgetHeaderBytesisAboutHeadersframeEndsHeadersstreamIdFromFrameheadersOutputThreadbytestringChunksessionPollThreadclientWorkerThreadclientSideTerminate#$fCleanlyPrunableSessionSessionData#$fActivityMeteredSessionSessionDataSessionPayloadgoAwayPriority wrapSessionoutputGatherer$startStreamOutputComandQueueIfNeededstartStreamOutputQueueflowControlOutputwithPrioritySend_withNormalPrioritySendwithHighPrioritySendpushGoAwayFramesendReorderingPrioritySendState_outputTray_PSS_dataReady_PSS_spaceReady_PSSStream2AvailSpaceFlowControlCommand AddBytes_FCMhttp2PrefixLengthFramerSessionData _stream2flow_defaultStreamWindow _maxRecvSize_outputIsForbidden _pushAction _closeAction_sessionIdAtFramer_lastInputStream_prioritySendState_sessionRole_FSD dataReady_PSSoutputTray_PSSspaceReady_PSSDeliveryNotifyCallbackSimpleSessionControlAwareWorker_SPClientState_SP FramerSessiondefaultStreamWindowlastInputStream maxRecvSizeoutputIsForbiddenprioritySendStatesessionIdAtFramersessionRole_FSD stream2flowhttp2FrameLength addCapacityfinishFlowControlForStream readNextFrame inputGathererupdateLastInputStream pushPrefixsendGoAwayFramesendSpecificTerminateGoAway sendBytesN releaseFramer goAwaySend serializeManypushControlFrame,$fActivityMeteredSessionSimpleSessionControlvoid