:x      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                           !"##$$$$$$$%%% % % % % %%&&&&''''''''''''' '!'"'#'$'%'&'''(()(*(+(,(-(.(/(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.l.m.n.o/p0q0r0s1t1u"v"w"<None!"b Parse out a  UdpHeader, and the size of the payload. Render a  UdpHeader.       Safe!"PThe next time that something in the heap will expire, if the heap is non-empty.)Remove all expired entries from the heap.^Given the current time, partition the heap into valid entries, and entries that have expired.Add an entry to the 4, and return the time of the next expiration event.RThe amount of time until the top of the heap expires, relative to the time given.  Convert a x into microseconds for use with  threadDelay.    2SafeyyyNone!A specialized version of runPut> that allows the initial and successive buffer sizes for the Builder to be defined. For example, if you're rendering an IP4 packet, you might give the first parameter as 20 (the size of the fixed header), and the second as 40 (the maximum additional length for options).!!!!Safe2OT&Lenses that don't change type.'DGeneral lenses that allow for the type of the inner field to change.zqThis is just a handy way of not exposing a Contrafunctor class, as we only really need it for the definition of *.{|}"#~$%&'(z)*+,-./0"#$%&'()*+,-./'&(%$)*#"+,-./{|}"#~$%&'(z)*+,-./0None!"9;IOTb U>An alias to TcpSeqNum, as these two are used in the same role.@The length of the fixed part of the TcpHeader, in 4-byte octets.eThe encoded size of a header.fwRender a TcpHeader. The checksum value is never rendered, as it is expected to be calculated and poked in afterwords.gParse a TcpHeader.Render out the Word82 that contains the Control field of the TcpHeader.lGet the rendered length of a list of TcpOptions, in 4-byte words, and the number of padding bytes required. This rounds up to the nearest 4-byte word.Parse in known tcp options.n6The length of the data segment, including Syn and Fin.o+The last sequence number used in a segment.p The ack number for this segment._23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrs?23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnop?JKLMNOPQRSTWX[eVUZY\]^_`abcdgfHIhij6789:;<=>?@ABCDEFGk2345lmnop@23456789:;<=>?@ABCDEFGHIJ KLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrsNone!"\The receive window. INVARIANTS: VAll segments in rwSegments are within the window defined by rwRcvNxt and rwRcvWnd-The segments in rwSegments should not overlapOut of order segments.Left-edge of the receive window Right-edge of the receive window"Maximum size of the receive window'The first byte occupied by this segment&The last byte occupied by this segment1The next segment number, directly after this one.+Drop data off of the front of this segment.Resolve overlap between two segments. It's assumed that the two segments do actually overlap. Overlap is resolved by trimming the front of the later packet.The value of RCV.WND.$The left edge of the receive window.8The right edge of the receive window, RCV.NXT + RCV.WND.;Only sets RCV.NXT when the segment queue is empty. Returns / when the value has been successfully changed.dCheck an incoming segment, and queue it in the receive window. When the segment received was valid M is returned, including segments in the receive window were unblocked by it.NOTE: when Just[] is returned, this should be a signal to issue a duplicate ACK, as we've receive something out of sequence (fast retransmit).QIncrease the right edge of the window by n, clamping at the maximum window size.:Add a validated segment to the receive window, and return Use this segment to advance the window, which may unblock zero or more out of order segments. The list returned is always non-empty, as it includes the segment that's given.Insert a new segment into the receive window. NOTE: we don't need to worry about trimming the segment to fit the window, as that's already been done by sequenceNumberValid.Split out contiguous segments, and out of order segments. NOTE: this assumes that the segment list given does not contain any overlapping segments, and is ordered.5NOTE: this should never be called with an empty list.This is the check described on page 68 of RFC793, which checks that data falls within the expected receive window. When the check is successful, the segment returned is one that has been trimmed to fit in the window (if necessary).?When this produces a segment, the segment has these properties: (The sequence number is within the window(The segment body falls within the window8The segment has been copied from the original bytestringThe reason for point 3 is that when frames are allocated by devices, they are likely allocated to the full MTU, and not resized. Copying here frees up some memory.RCV.NXTRCV.NXT + RCV.WND  Safe!",Create a new hash table with the given size.0Monadic mapping over the values of a hash table.Delete a collection of keys from the table. This is good for multiple deletes, as deletes from the same bucket can be grouped together.0Create, update, or delete an entry in the hash table, returning some additional value derived from the operation. NOTE: This operation is only useful when you need to perform any of these operations at the same time -- the specialized versions of the individual behaviors all perform slightly better.HGives back an (unsorted) list of all the keys present in the hash table. None!"bThe broadcast MAC address. None!"0234The name of this device+The mac address associated with this device0Static configuration information for this device&Outgoing message queue for this deviceStart packet flowStop packet flow$Cleanup resources associated with a Statistics about this device0Static configuration data for creating a device.#How large the send queue should be.The TX checksum offload config.The RX checksum offload config.8Add one to the count of dropped packets for this device.+Add one to the error count for this device.(Update information about bytes received.(Update information about bytes received.?:?"  None!" Send a message out via a device. None<= )Run only one iteration of the Hans monad./Loop forever, running the underlying operation.Set the escape continuation to the current position, within the operation given, so that control flow always restores back through this point.Invoke the escape continuation.VCall-cc. NOTE: the continuation will inherit the escape point of the calling context. Synonym for % that also updates device statistics.Lift an  operation into .3Run a Get action in the context of the Hans monad, SRun a Get action in the context of the Hans monad, returning any unconsumed input.  None2brInformation about how to reach a specific destination address (source and next-hop addresses, and device to use).&The source address to use when sendingThe next-hop in the routeThe device used for delivery            Safe$General network stack configuration.Best to pick a prime number.7Number of times to retry an arp request before failing?The amount of time to wait between arp request retransmission.MNumber of seconds to wait before expiring a partially reassembled IP4 packet.Maximum packets being reassembled at any time.)Number of buckets in the udp socket tableIn microsecondsSmall-ish prime numberBest to pick a prime number'Time to remain in TimeWait, in seconds.Initial MSS for tcp connections >Maximum number of connections waiting for an acknowledgement.!)Initial local window for tcp connections."Maximum segment lifetime#hFrequency (in Hz) of timestamp clock updates. Should be between 1Hz and 1000Hz, according to RFC-1323.$9The max number of threads allowed in the time wait heap.%CThe maximum number of entries allowed in the TCP or UDP NAT tables !"#$%&' !"#$%& !"#$%& !"#$%&'None!"\(qThis structure holds bookkeeping variables for the remote end's receive window, as well as the retransmit queue.MThe retransmit queue contains segments that fall between SND.UNA and SND.NXTThe effective windowCached right edge!The sequence number of the frame.INVARIANT: the sequence number must always be greater than or equal to the current sequence number, and less than the value of the right edge of the segment.9The sequence number of the first byte AFTER this segment.INVARIANT: the sequence number must always be less than or equal to the current right edge sequence number, and greater than or equal to the left edge.The SACK flag for this segment. This flag is turned TRUE when the segment has been wholly acknowledged through the SACK option on an incoming ACK.* Create a ).+>Update the timestamp clock, and return the new value of TSval.,"The current value of the TS clock.7Given an echo'd timestamp, generate an RTT measurement..)Remove everything from the remote window./True when the window is empty.0True when the window is full.1The value of SND.NXT.,NOTE: SND.UNA <= SND.NXT < SND.UNA + SND.WND2BOnly sets the value of SND.NXT when the retransmit queue is empty.3The value of SND.WND.49The value of SND.UNA -- the left-edge of the send window.5tReturns the new send window, as well as boolean indicating whether or not the retransmit timer needs to be started.6A retransmit timer has gone off: reset the sack bit on all segments in the queue; if the left-edge exists, mark it as having been retransmitted, and return it back to be sent.+XXX: does this need to update the TS clock?7Remove all segments of the send window that occur before this sequence number, and increase the size of the available window. When the segment doesn't acknowledge anything in the window, ? as the second parameter. Otherwise, return a boolean that is t when there are no outstanding segments, and a measurement of the RTT when the segment has not been retransmitted.8pProcess a sack option, and return the updated window, and the segments that are missing from the remote window.!All segments that have not been selectively acknowledged. This can be used when replying to a duplicate ack that contains a SACK option, after the option has been processed. NOTE: this still doesn't remove the packets from the queue, it just means that we know what parts to retransmit.BMark segments that have been acknowledged through the SACK option.:True when the segment falls wholly within the range given.,()*+,-SND.NXTSND.WND./0123456789()*+,-./012345678(-1243/0.)*+,5678()*+,-./0123456789None!"<+Incremental checksum computation interface.:;<=>?@ABCDEFGHI :;<=>?@AB A<=>?@B:;:;<=>?@ABCDEFGHINone!"05IbM2Arp packets, specialized to IP4 and Mac addresses.^1This includes the flags, and the fragment offset.gBetween 0 and 32source address | +--------+--------+--------+--------+ | destination address | +--------+--------+--------+--------+ | zero |protocol| length | +--------+--------+--------+--------+The fragment offset, in bytes.#Calculate the size of an IP4 packet#Calculate the size of an IP4 headerGFragment a single IP packet into one or more, given an MTU to fit into.TGiven a fragment size and a packet, fragment the packet into multiple smaller ones.4Compute the value of the version/header length byte.Version| IHL |Type of Service| Total Length | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Identification |Flags| Fragment Offset | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Time to Live | Protocol | Header Checksum | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Source Address | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Destination Address | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+JParse an Arp packet, given a way to parse hardware and protocol addresses.MRender an Arp packet, given a way to render hardware and protocol addresses.Parse an Arp operation.Render an Arp operation.SLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~QLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Shiopqrstnmlfguvwxyz{|}~eZ[\]^_`abcdTUVWXYMNOPQRSLkj<LMNOPQRSTUVWXYZ [\]^_`abcdefghijklmnopqrstuvwxyz{|}~None!"L\  ZZ6   None!" The Arp table consists of a map of IP4 to Mac, as well as a heap that orders the IP4 addresses according to when their corresponding entries should be expired.NOTE: There's currently no way to limit the memory use of the arp table, but that might not be a huge problem as the entries are added based on requests from higher layers.RINVARIANT: there should never be entries in the map that aren't also in the heap. Loops forever, delaying until the next arp table entry needs to be purged. If no entries exist, it waits for the maximum entry lifetime before checking again.!Lookup an entry in the Arp table.DInsert an entry into the Arp table, and unblock any waiting actions.iIf nobody has responded to queries for this address, notify any waiters that there is no mac associated.rNOTE: in the future, it might be nice to keep an entry in the table that indicates that this host is unreachable. Have the entry block on a !^Write the discovered Mac to a bounded channel, passing it through a filtering function first."(Returns either the address, or an empty  # that will eventually contain the , or  if the Arp request fails. *Register to wait on an entry in the table.  !"  !" " !   !" NoneI#$%&'()*+,-./012345 #$%&'()*+,&'()543210/.#$%*+,-#$%&'()*+,-./012345None fails on any non  option with an error message.89:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      89:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      IJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~FGHABCDE=>?@:;<    89 689:;<=>?@ABCDEFGHIOJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~M      NonebDB| MBZ | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ B: BROADCAST flag MBZ: MUST BE ZERO (reserved for future use) Figure 2: Format of the flags  field]HardwareType is an enumeration of the supported hardware types as assigned in the ARP RFC /http://www.iana.org/assignments/arp-parameters/11 is a Transaction ID, a random number chosen by the client, used by the client and server to associate messages and responses between a client and a server.33 is a low-level message container that is very close to the binary representation of DHCPv4 message. It is suitable for containing any DHCPv4 message. Values of this type should only be created using the publicly exported functions.5>Message op code / message type. 1 = BOOTREQUEST, 2 = BOOTREPLY6UClient sets to zero, optionally used by relay agents when booting via a relay agent.7Transaction ID, a random number chosen by the client, used by the client and server to associate messages and responses between a client and a server.8`Filled in by client, seconds elapsed since client began address acquisition or renewal process.9>Client requests messages be sent to hardware broadcast address:sClient IP address; only filled in if client is in BOUND, RENEW or REBINDING state and can respond to ARP requests.;your (client) address<XIP address of next server to use in bootstrap; returned in DHCPOFFER, DHCPACK by server=9Relay agent IP address, used in booting via a relay agent>Client hardware address?1Optional server host name, null terminated string@Boot file name, full terminated string; "generic" name of null in DHCPDISCOVER, fully qualified directory-path name in DHCPOFFERAOptional parameters field.BB/ is sent by the DHCPv4 server in response to a U. This offer is only valid for a short period of time as the client might receive many offers. The client must next request a lease from a specific server using the information in that server's offer.D2The maximum number of relays this message can use.ETransaction ID of this exchangeF5The IPv4 address that this server is willing to leaseG%The IPv4 address of the DHCPv4 serverH+The IPv4 address of the DHCPv4 relay serverI"The hardware address of the clientJ5The options that this server would include in a leaseKK9 is sent by the DHCPv4 server to acknowledge a sucessful [t message. Upon receiving this message the client has completed the exchange and has successfully obtained a lease.M2The maximum number of relays this message can use.N Transaction ID for this exchangeOLease: assigned client addressPDHCP server's IPv4 addressQDHCP relay server's addressRClient's hardware addressS#Lease: duration of lease in secondsT,Subset of information requested in previous [UUk is used by the client to discover what servers are available. This message is sent to the IPv4 broadcast.W.Transaction ID of this and subsequent messagesXSet = to instruct the server to send to broadcast hardware addressYHardware address of the clientZ?Used to specify the information that client needs in the offers[[2 is used by the client to accept an offered lease.]Transaction ID of offer^Set 9 to instruct server to send to broadcast hardware address`Hardware address of the clienta1Used to specify the information that client needsb.Used to specify the address which was acceptedcc* is a sum of the server response messages.ff) is a sum of the client request messages.ii define all of the information that would be needed to act as a DHCP server for one client. The server is defined to be able to issue a single "lease" whose parameters are defined below.k#The IPv4 address of the DHCP serverl*Lease: timezone offset in seconds from UTCm%Lease: client IPv4 address on networknLease: duration in secondsoLease: subnet mask on networkp#Lease: broadcast address on networkq!Lease: gateway routers on networkr$Lease: client's assigned domain namesLease: network DNS serverstt creates K% messages suitable for responding to [ messages given a static i configuration.uu creates a suitable B in response to a client's UB message using the configuration settings specified in the given i.vv# is the binary decoder for parsing 3 values.wv% is the binary encoder for rendering 3 values.xxT attempts to find a valid high-level message contained in a low-level message. The 3A is a large type and can encode invalid combinations of options.yy embeds U messages in the low-level 32 type, typically for the purpose of serialization.zz embeds K messages in the low-level 32 type, typically for the purpose of serialization.{{ embeds B messages in the low-level 32 type, typically for the purpose of serialization.|| embeds [ messages in the low-level 32 type, typically for the purpose of serialization.}} creates a new UO message with a set of options suitable for configuring a basic network stack.~~ creates a [$ message suitable for accepting an B from the DHCPv4 server.^123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstDHCPv4 server settingsClient's request messageuDHCPv4 server settingsClient's discover messagevw !x"yz{|}%New randomly generated transaction IDThe client's hardware address~%The offer as received from the serverN123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Nfgh[\]^_`abUVWXYZijklmnopqrscdeKLMNOPQRSTBCDEFGHIJ3456789:;<=>?@A12tu}~|z{yxvw123456789:;<=>?@ABCDEFGHIJK LMNOPQRSTUVWXYZ[\]^_`abcdefghi jklmnopqrstuvw !x"yz{|}~None!"#Keys are of the form (src,dest,prot,ident).Handle an incoming fragment. If the fragment is buffered, but doesn't complete the packet, the escape continuation is invoked.$DEvery second, purge the fragment table of entries that have expired.%BCreate a buffer, given an expiration time, initial fragment, and Z of that initial fragment. The initial header is included for the case where the initial fragment is also the first fragment in the sequence.&1For use with HT.alter. When the first element is , the second will be r, indicating that the entry in the table should be updated, and there's no result yet. When the first element is , the second will be a, indicating that the entry should be removed from the table, and that this is the final buffer.'^When the buffer is full and all fragments are accounted for, reassemble it into a new packet.($Insert the fragment into the buffer.)*+,-./012345678#$9:%&'(;)*+,-./012345678#$9:%&'(;None!"HBHNone!"Simple routing.<QInsertions must keep this list ordered by the network prefix length, descending.=Optional default route.[If the address given is the source address for a rule in the table, return the associated .*Give back routes that involve this device. ><=?@ABCDEFGH><=?@ABCDEFGHNone!" (Addresses currently assigned to devices.The ARP cache.IP4 packet fragmentsArp retry count  Finish sending these IP4 packets %Send this IP4 payload to this address)Any interface that will route the messageThe interface with this address$This device with this source address>Lookup the source address, as well as the next hop and device.DIs this an address that's assigned to a device in the network stack?"Give back the result of using the I function on the internal state.@Give back the list of routing rules associated with this device.                     3SafeJKLMNJKLMNJKLMN4Safe!"OThe buffer and current sizePData available signalQFTake up to n bytes from the buffer, blocking until some data is ready.RSTake up to n bytes from the buffer, returning immediately if no data is available.S5Remove up to n bytes of data from the internal state.TUVWXYOPZ[\]QR^_`SaXZ[\]QR TUVWXYOPZ[\]QR^_`Sa5Safe!"b(Available space in the buffer, in bytes.cChunks present in the buffer.d{The wait queue. Waiters queue up trying to take the MVar, and are unblocked when there are chunks available in the queue.e%Write a chunk to the buffer. Returns f$ if the chunk could not be written.g;Read a chunk from the buffer, blocking until one is ready. hPoll for a ready chunk.iSee if the buffer is empty.jThe return value is as follows:The first element is F when the chunk has been written to the queue The second element is - when there is more data present in the queueThis covers a funny case where the queue was empty, and the chunk that was given was too big for the whole buffer -- the buffer wasn't written, and the queue is still empty.klbcmnodpeghiqrjsmpeghi klbcmnodpeghiqrjsNone05None/5ATb$$Forget what kind of address this is.%-Try to remember what this opaque address was.&5Check to see if this address is the wildcard address.'The wildcard address(6Check to see if this address is the broadcast address.)The broadcast address. #$%&'()*+ #$'&%() #$%&'()#$%&'()*+6None!"25tLocal address to listen onu*The port on this network stack to forwardv!Destination machine to forward towDestination port to forward toxActive TCP flowsy/Ports that have been forwarded in the TCP layerzActive UDP flows{/Ports that have been forwarded in the UDP layer|;When flows are active, this is the id of the reaping thread}iNOTE: as TcpPort and UdpPort are both type aliases to Word16, Flow isn't parameterized on the port type.~(Gives back the other end of the session.#Insert an entry into the NAT table.eRemove entries from the NAT table, decrementing the size by the number of entries that were removed.+Lookup and touch an entry in the NAT table.DEvery two minutes, reap old entries from the TCP and UDP NAT tables.GRemove port forwarding for UDP based on source address and port number.GRemove port forwarding for UDP based on source address and port number.6Lookup information about an active forwarding session.6Lookup information about an active forwarding session.1Insert a TCP forwarding entry into the NAT state.1Insert a UDP forwarding entry into the NAT state.KReturns the forwarding rule to use, if this connection should be forwarded.GReturns the forwarding rule to use, if this session should be forwarded7tuvwxyz{|}~tuvw}~ tuvwxyz{|}~None!"9:;<='-8Retrieve the left and right edges of the receive window:(RCV.NXT, RCV.NXT + RCV.WND)2SND.NXT3RCV.NXT4RCV.WND;MParent to notify if this tcb was generated from a socket in the LISTEN state@SND.UPASND.WL1BSND.WL2CISSERCV.UPFIRSJ Local portK Remote portLCached routingM Remote hostNMaximum segment sizexReset retransmit info.y@Increment the retry count, and double the last retransmit timer.z Invalidate the retransmit timer.|BUpdate all slow-tick timers. Return the old timers, for use with 'atomicModifyIORef\''.};Reset idle timer in the presence of packets, for use with 'atomicModifyIORef\''.~SCalibrate the RTO timer, given a round-trip measurement, as specified by RFC-6298.:The Tcb type is the only one that supports changing state.Create a new listening socket."Create a child from a Syn request.SReserve a slot in the accept queue, returns True when the space has been reserved.(Release a slot back to the accept queue.<Add a Tcb to the accept queue for this listening connection.2Wait until a Tcb is available in the accept queue.2True when the timestamp option should be included.(Disable the use of the timestamp option.)Record that a delayed ack should be sent."Set the value of RCV.NXT. Returns 0 when the value has been set successfully, and f$ if the receive queue was not empty."Set the value of SND.NXT. Returns 0 when the value has been set successfully, and f! if the send queue was not empty.Cleanup the Tcb."Queue bytes in the receive buffer.DDetermine if there are bytes in the receive buffer that can be read.Remove data from the receive buffer, and move the right-side of the receive window. Reading 0 bytes indicates that the remote side has closed the connection.Non-blocking version of L. Reading 0 bytes indicates that the remote side has closed the connection.{,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~On Established On ClosedISSk,-./0123456789:=>?IFC<;@ABDEGHJKLMNOPQRSTUVWXYZ[\`gc]f^_abdehijklmnopqrstuvwxyz{|}~kvjklmnopqrstuwxyz{|~\]^_`abcdefghi./,-UVWXYZ[9:;<=>?@ABCDEFGHIJKLMNOPQ}RST0123456787,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\ ]^_`abcdefghij klmnopqrstuvwxyz{|}~None!"  SEQ=SEG.ACK CTL=RST  SEQ=0 ACK=SEG.SEQ+SEG.LEN CTL=RST,ACK  SEQ=ISS ACK=RCV.NXT CTL=SYN,ACKSEG.SEQSEG.ACK Local port Remote portNone!"5[b2Requests that can be made to the responder thread.|Decrements when a connection enters SynReceived or SynSent, and increments back up once it's closed, or enters Established.Returns Y when there is space in the Syn backlog, and False if the connection should be rejected.'Yield back an entry in the Syn backlog. Register a new listening socket.Remove a listening socket.$Lookup a socket in the Listen state.Register a socket in the TimeWait state. If the heap was empty, fork off a thread to reap its contents after the timeWaitTimeout.BNOTE: this doesn't remove the original socket from the Active set..Reset the timer associated with a TimeWaitTcb.DModify the TimeWait heap, and spawn a reaping thread when necessary.&Lookup a socket in the TimeWait state.'Delete an entry from the TimeWait heap.Register a new active socket.Lookup an active socket. Delete the 9#, and notify any waiting processes./Delete an active connection from the tcp state.#Pick a fresh port for a connection.5$None!"5bERegister a listener for messages to this address and port, returning 2 an action to unregister the listener on success.  None!" :The configuration for this instance of the network stack.Nat table/configThe input packet queueAll registered devicesState for IP4 processing?Internal IP4 responder for messages produced in teh fast path.State for UDP processing=Responder thread for UDP messages produced in the fast path.State for TCP processing=Responder thread for TCP messages produced in the fast path.The TCP timer threadw     tuvw}~  !None!"BA device that just posts outgoing packets back to the input queue.7None!"Not sure how this should work yet... Should it only ever show tap device names? Maybe this should return a singleton list of an ephemeral device?&Send a packet out over the tap device.%Receive a packet from the tap device.  #None!"MStop packets flowing, and cleanup any resources associated with this device.-Start processing packets through this device.>$None!"bRQueue a message on the responder queue instead of attempting to send it directly.tSend an IP4 packet to the given destination. If it's not possible to find a route to the destination, return False.!Prepare IP4 fragments to be sent.Send an IP4 packet to the given destination. This assumes that routing has already taken place, and that the source and destination addresses are correct.QRetrieve the outgoing address for this IP4 packet, and send along all fragments.Make an Arp request for the given IP address, until the maximum retries have been exhausted, or the entry made it into the table.EThe final step to render an IP header and its payload out as a lazy  ByteString^. Compute the checksum over the packet with its checksum zeroed, then reconstruct a new lazy  ByteStringA that contains chunks from the old header, and the new checksum.Emit a destination unreachable ICMP message. This will always be queued via the responder queue, as it is most likely coming from the fast path. The bytestring argument is assumed to be the original IP4 datagram, trimmed to IP4 header + 8 bytes of data.  8Nonebhlnqr%None!"bBInteraction with routing and message delivery for a network layer.TCalculate the pseudo-header for checksumming a packet at this layer of the network.1Lookup a route to reach this destination address. (Send a single datagram to a destination. JSend a datagram and lookup routing information at the same time. Returns f* if no route to the destination was known.     Desired output deviceDesired source address Destination                 &NoneAdd a TCP port-forwarding rule."Remove a TCP port-forwarding rule.Add a UDP port-forwarding rule."Remove a UDP port-forwarding rule.Local address (can be wildcard) Local portRemote address Remote portLocal address (can be wildcard) Local portLocal address (can be wildcard) Local portRemote address Remote portLocal address (can be wildcard) Local port9None!"BTry to produce a new TCP packet that should be forwarded. Returns 3 if the packet was destined for the local machine.BTry to produce a new TCP packet that should be forwarded. Returns 3 if the packet was destined for the local machine. Local addr Remote addr Local addr Remote addr:None0:DR?It's not possible to reach this host from this source address.>Something is already listening on this host/port combination.This connection already exists.>No information about the other end of the socket was present.All ports are in use.!The connection is already closed./Connect this socket to one on a remote machine.Returns True iff there is currently space in the buffer to accept a write. Note, this is probably a bad thing to count on in a concurrent system ...!Send a chunk of data on a socket.Returns True iff there is data in the buffer that can be read. Note, this is probably a bad thing to count on in a concurrent system ...bRead a chunk of data from a socket. Reading an empty result indicates that the socket has closed.lNon-blocking read from a socket. Reading an empty result means that the socket has closed, while reading a 4 result indicates that there was no data available./Create a listening socket, with a backlog of n."Close an open socket.%Bytes to bufferARaise an exception when no route can be found to the destination.JReturn source routing information, when a route exists to the destination." !"#$%&' !"#$%&' !"#$%&'(None!"b (Send a single ACK immediately.)Send a single FIN packet.*Send a data segment, potentially sending multiple packets if the send window allows, and the payload is larger than MSS. When the remote window is full, this returns 0.+IDetermine if there is any room in the remote window for us to send data.,bSend a segment and queue it in the remote window. The number of bytes that were sent is returned.\The presence of a tracked TSecr value controls whether or not we send the timestamp option.-9Responder thread for messages generated in the fast-path..1Queue an outgoing TCP segment from the fast-path. See note "No Retransmit Queue" (#Hans.Tcp.Output#no-retransmit-queue)./1Queue an outgoing TCP segment from the fast-path.0 Queue an ACK from the fast-path.15Send outgoing tcp segments, with a route calculation. See note "No Retransmit Queue" (#Hans.Tcp.Output#no-retransmit-queue).2%Lowest-level output function for TCP. See note "No Retransmit Queue" (#Hans.Tcp.Output#no-retransmit-queue).ORender out a tcp packet, calculating the checksum when the device requires it. ()*+,-./012 ()*+,-./012 12,()*+./0- ()*+,-./012;None!"0DR$Routing information for this socket.5"The source address of this socket.6The local port for this socket.7"The remote address of this socket.8The remote port of this socket.WAdd a new active connection to the TCP state. The connection will initially be in the ^' state, as a Syn will be sent when the 9 is created..Guard an action that will use the send window.1Guard an action that will use the receive buffer.345678345678345678)None!"b&A single case for an incoming segment.9Process incoming tcp segments.EProcess incoming segments that are destined for an active connection.GProcess incoming segments that are destined for a listening connection.IProcess incoming segments that are destined for a connection in TimeWait..Process incoming segments to a forwarded port.dUpdate the internal timestamp. This follows the algorithm described on pages 15 and 16 of RFC-1323.At this point, the list of segments is contiguous, and starts at the old value of RCV.NXT. RCV.NXT has been advanced to point at the end of the segment list.hProcessing for the FinWait2 state, when the retransmit queue is known to be empty. (Page 73 of RFC-793)"Invalidate, and remove the active 9, replacing it with a 0 that was derived from it.xApply an RTT measurement to the timers in a tcb, and return the relevant information about the state of the send queue. HHandle incoming packets destined for a tcb that's in the SYN-SENT state. {Respond to a segment directed at a socket in the Listen state. This implements the LISTEN case from pages 64-67 of RFC793. (Create a child TCB from a listening one. ?Determine which options should be sent in the SYN,ACK response. >Reject the SYN by sending an RST, drop the segment and return.nRespond to a segment that was directed at a closed port. This implements the CLOSED case on page 64 of RFC7939     999     *None!":}Process the slow and fast tcp timers. The fast timer runs four times a second, while the slow timer runs two times a second.;tThe body of the fast and slow tick handlers. The boolean indicates whether or not the slow tick should also be run.<Handle the retransmit timer. When the timer expires, if there is anything in the send window, retransmit the left-most segment.=fMake sure that the connection is still active. The Idle timer is checked when the 2MSL timer expires.:;<=:;<=:;<=:;<=+None!"b@,Send Udp over IP4 with a pre-computed route.=Given a way to make the pseudo header, render the UDP packet.>?@Destination addr Source portDestination portPayload>?@@>?>?@<None!"DR"Cached route, and port informationKnown source only.C7Receive, with information about who sent this datagram.ESend to a specific end host.ABCDE ABCDE ABCDE'None!"0:DR  !"#$%&'345678ABCDE !" #$%'&ABECD437856,None!"0bR.Parse the A and CNAME parts out of a response.FGHIJKLMNOPQRSTUVWXYZ[FGHIJKLMNOPQRSTUVWXYZPKLMNOQRSIJ[TUVFGHWXYZFGHIJKLMNOPQRSTUVWXYZ[-None!"b eInitial timeoutfNumber of retriesg}Whether or not routing information received from the DHCP server should be used as the default route for the network stack.hXWhether or not to fork a renew thread once configuration information has been received.BOOTP server port.BOOTP client port. Wait for a result on a socket!/Discover a dhcp server, and request an address."Only accept an offer.#gRespond to an offer with a request, and configure the network stack if an acknowledgement is received.$Perform a DHCP Renew.%Apply the information in the Ack to the NetworkStack, and Device. Returns information about the lease, as well as an IO action that can be used to renew it._`abcdefgh&'i j!"#($%)*+ _`abcdefghij cdefghi_`abj_`abcdefgh&'i j!"#($%)*+.None9;\k%Make a GHC Handle from a Hans handle.,k-.lmnkk,k-.lmn/None!"boRProcess a message destined for the UDP layer. When the message cannot be routed, f is returned.o/ooo/0None!"bpHandle incoming Arp packets.07Update an entry in the arp table, if it exists already.q0Process a packet that has arrived from a device.rThe processing stage after the packet has been decoded and validated. It's exposed here so that routing to an address that's managed by the network stack can skip the device layer.1(Validate the destination of this packet.2Process incoming ICMP packets.p0qr12pqrpqrp0qr121None!"bsHandle incoming packets.stststst"None!"Ju2Create a network stack with no devices registered.3TCreate and register the loopback device. Additionally, add its routing information.v_Initialize and register a device with the network stack. NOTE: this does not start the device.wAdd a route to the IP4 layer.u3vwG !"#$%&fghqr#$'&%() suvwG !"#$%&usv#$%&'() hqrfgwu3vw4=>?=>@=>A=>B=>BCCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoopqrstuvwxyz{|}~                                               ! " # $ % " & ' ( ) * + , - . / 0 1 2 3 3 4 5 6 7 8 9 : ; < = > ? @ A B B C D E F G H I J K L M N O P Q R S T U V W XYZ[\]^_`abcdefghiijklmnopqrstuvwxyz{{|}~      !"##$%&'()*+,-./0123456789:;<=>?@ABCDEFFGHIJKLMNOPQRSTUVWXYZZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQQRRSTUVWXYZ[\]^_``abcdefghhijklmnopqqrstuvvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDDEFGHIJKLLMNOPQRSTUVWXYZ[\]^_`abcddeffghijklmnopqrstuvwxyzz{|}~                           !7##$$$ $ $ $ $ %%%%%%%%%&&&&::::::: :!:":#:$:%:&:':(:):*:*:+:,:-(.(/(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,O,P,Q,R,S,T,U,V,W,X,Y,Z,[,\,],^,_,`,a-b-b-c-d-e-e-f-g-h-i-j-k.l.m.n.o/p0q0r0s1t1u"v"w"xyz{2|}~~ " Yl=B>       !"#$%&'()*+,--./012345678393:3;3<3=4>4?4@4A4B4l4l4C4D444E4F4G4H4I4J4)4K5L5M5?5NO5P5Q5R5S5T5T555U5E5V5W5X6Y6Z6[6\6]6^6_6`6a6b6c6d6e6f6g666h6i6j6k6l6m6n6n6o6p6q6r6r6s6t6u6u6v6w6x6x6b6y6z6{6|6}6~6666666666a77777777777$$$$$999:::::::::::::((;;;;;8;;;9;;;;;;;))))))))))))))))))++<<<E<<<<<<<<--------------.../000"!hans-3.0.2-GPIpvDF0acQKMmo8PFxkX0 Hans.TimeHans.Udp.PacketHans.Serialize Hans.LensHans.Tcp.PacketHans.Tcp.RecvWindowHans.HashTableHans.Ethernet.TypesHans.Device.Types Hans.Ethernet Hans.MonadHans.Network.Types Hans.ConfigHans.Tcp.SendWindow Hans.ChecksumHans.IP4.PacketHans.Dns.PacketHans.IP4.ArpTableHans.IP4.Dhcp.CodecHans.IP4.Dhcp.OptionsHans.IP4.Dhcp.PacketHans.IP4.FragmentsHans.IP4.Icmp4Hans.IP4.RoutingTableHans.IP4.StateHans.Addr.Types Hans.Addr Hans.Tcp.TcbHans.Tcp.MessageHans.Tcp.StateHans.Udp.State Hans.TypesHans.Device.LoopbackHans Hans.DeviceHans.IP4.Output Hans.NetworkHans.Nat Hans.SocketHans.Tcp.OutputHans.Tcp.InputHans.Tcp.TimersHans.Udp.OutputHans.DnsHans.IP4.Dhcp.ClientHans.Socket.HandleHans.Udp.InputHans.IP4.Input Hans.Input Hans.ThreadsHans.Buffer.SignalHans.Buffer.StreamHans.Buffer.DatagramHans.Nat.StateHans.Device.TapHans.IP4Hans.Nat.ForwardHans.Socket.TypesHans.Socket.TcpHans.Socket.Udp"heaps-0.3.3-7OlaDU2RmgdCkYZ3VSFd9u Data.HeaptoUnsortedListpayloadpriorityEntry UdpHeader udpSourcePort udpDestPort udpChecksumUdpPort getUdpPort putUdpPortemptyUdpHeader udpHeaderSize getUdpHeader putUdpHeader $fEqUdpHeader$fShowUdpHeader ExpireHeapExpires expiresBefore emptyHeap fromListHeap filterHeap partitionHeap nextEvent dropExpiredpartitionExpiredexpireAtnullHeapexpirationDelay toUSeconds runPutPacketASetter'ASetterGetterGettingLens'Lenslensviewtosetovermodifybitbyte$fFunctorModify$fFunctorConst SackBlocksbLeftsbRight TcpOptionOptEndOfOptions OptNoOptionOptMaxSegmentSizeOptWindowScalingOptSackPermittedOptSack OptTimestamp OptUnknown TcpOptionTagOptTagEndOfOptionsOptTagNoOptionOptTagMaxSegmentSizeOptTagWindowScalingOptTagSackPermitted OptTagSackOptTagTimestamp OptTagUnknown HasTcpOptions tcpOptions TcpHeader tcpSourcePort tcpDestPort tcpSeqNum tcpAckNum tcpFlags_ tcpWindow tcpChecksumtcpUrgentPointer tcpOptions_ TcpAckNum TcpSeqNumTcpPort putTcpPort fromTcpSeqNum withinWindowemptyTcpHeadertcpNstcpCwrtcpEcetcpUrgtcpAcktcpPshtcpRsttcpSyntcpFin tcpHeaderSize putTcpHeader getTcpHeader findTcpOption setTcpOption setTcpOptions tcpOptionTagtcpOptionsSize tcpOptionSize tcpSegLentcpSegLastSeqNumtcpSegNextAckNum$fHasTcpOptions[]$fHasTcpOptionsTcpHeader$fOrdTcpSeqNum$fNumTcpSeqNum $fEqTcpSeqNum$fShowTcpSeqNum$fEqTcpOptionTag$fShowTcpOptionTag$fShowSackBlock $fEqSackBlock$fShowTcpOption $fEqTcpOption $fEqTcpHeader$fShowTcpHeaderWindow emptyWindowrcvWndrcvNxtrcvRight setRcvNxt recvSegment moveRcvRightsequenceNumberValid $fShowSegment $fShowWindow HashTable newHashTablefilterHashTablemapHashTableM_ mapHashTablelookupdeletedeletesaltersizekeyshasKeyEthernetHeadereDesteSourceeType EtherTypeMac ETYPE_IPV6 ETYPE_ARP ETYPE_IPV4 BroadcastMacgetMacputMacshowMacreadMacgetEthernetHeaderputEthernetHeader$fSerializeMac$fEqMac$fOrdMac $fShowMac $fReadMac$fEqEthernetHeader$fShowEthernetHeader DeviceStats_statTX_statRX StatGroup _statBytes _statPackets _statErrors _statDroppedStatDeviceException FailedToOpenDevicedevNamedevMac devConfig devSendQueuedevStartdevStop devCleanupdevStatsHasDeviceConfig deviceConfig DeviceConfigdcSendQueueLen dcTxOffload dcRxOffloaddcMtuChecksumOffloadcoIP4coUdpcoTcpcoIcmp4 DeviceNamedefaultChecksumOffload txOffload rxOffloaddefaultDeviceConfig incrementStataddStat statBytes statPackets statErrors statDropped newStatGroup dumpStatGroupstatTXstatRXnewDeviceStats dumpStats updateDropped updateError updateBytes updatePackets$fExceptionDeviceException $fOrdDevice $fEqDevice$fHasDeviceConfigDevice$fHasDeviceConfigDeviceConfig$fShowChecksumOffload$fShowDeviceConfig$fShowDeviceException sendEthernet runHansOncerunHans setEscapeescapecallCC dropPacketiodecodedecode' $fBaseMHansIO $fMonadHans$fApplicativeHans $fFunctorHans RouteInforiSourceriNextriDevNetworkProtocolPROT_UDPPROT_TCP PROT_ICMP4getNetworkProtocolputNetworkProtocol$fHasDeviceConfigRouteInfo $fEqRouteInfo$fFunctorRouteInfo HasConfigconfigConfigcfgInputQueueSizecfgArpTableSizecfgArpTableLifetime cfgArpRetrycfgArpRetryDelaycfgIP4FragTimeoutcfgIP4InitialTTLcfgIP4MaxFragTableEntriescfgUdpSocketTableSizecfgDnsResolveTimeoutcfgTcpListenTableSizecfgTcpActiveTableSizecfgTcpTimeoutTimeWaitcfgTcpInitialMSScfgTcpMaxSynBacklogcfgTcpInitialWindow cfgTcpMSLcfgTcpTSClockFrequencycfgTcpTimeWaitSocketLimitcfgNatMaxEntries defaultConfig$fHasConfigConfigTSClockinitialTSClock updateTSClocktsVal flushWindow nullWindow fullWindowsndNxt setSndNxtsndWndsndUna queueSegmentretransmitTimeout ackSegment handleSack$fHasTcpOptionsSegmentPair8ChecksumextendChecksumPartialChecksumemptyPartialChecksumfinalizeChecksumcomputeChecksum stepChecksum$fChecksumByteString$fChecksumShortByteString$fChecksumByteString0 $fChecksum[]$fChecksumWord32$fChecksumWord16$fChecksumPair8$fEqPartialChecksum$fShowPartialChecksumArpOper ArpPacketarpOperarpSHAarpSPAarpTHAarpTPA IP4Optionip4OptionCopiedip4OptionClass ip4OptionNum ip4OptionData IP4Headerip4TypeOfServiceip4Ident ip4Fragment_ ip4TimeToLive ip4Protocol ip4Checksum ip4SourceAddr ip4DestAddr ip4OptionsIP4IdentIP4MaskIP4ArpReply ArpRequest WildcardIP4CurrentNetworkIP4 BroadcastIP4getIP4putIP4packIP4 unpackIP4showIP4readIP4hostmasknetmask maskRangemaskBitsmaskAddr clearHostBits setHostBitsbroadcastAddress readIP4Mask showIP4Maskip4PseudoHeaderemptyIP4Headerip4DCSPip4ECN ip4Fragmentip4DontFragmentip4MoreFragmentsip4FragmentOffsetnoMoreFragments moreFragments addOffsetsetIdent ip4PacketSize ip4HeaderSize splitPacketfragmentPacket ip4VersionIHL getIP4Packet putIP4HeaderrenderIP4Options getIP4Options ip4OptionSize getIP4Option ip4OptionType putIP4Option getArpPacketrenderArpPacket putArpPacket getArpOper putArpOper $fEqIP4Mask$fSerializeIP4$fEqIP4$fOrdIP4 $fShowIP4 $fReadIP4 $fHashableIP4 $fChecksumIP4 $fGenericIP4 $fShowIP4Mask $fReadIP4Mask $fEqIP4Option$fShowIP4Option $fEqIP4Header$fShowIP4Header $fEqArpPacket$fShowArpPacketRDataRDARDNSRDMDRDMFRDCNAMERDSOARDMBRDMGRDMRRDPTRRDHINFORDMINFORDMXRDNULL RDUnknownClassINCSCHHSQClass QAnyClassTypeANSMDMFCNAMESOAMBMGMRNULLPTRHINFOMINFOMXAAAAQTypeAFXRMAILBMAILAQTAnyRRrrNamerrClassrrTTLrrRDataQueryqNameqTypeqClassNameRespCode RespNoErrorRespFormatErrorRespServerFailure RespNameErrorRespNotImplemented RespRefused RespReservedOpCodeOpQueryOpIQueryOpStatus OpReserved DNSHeaderdnsIddnsQuery dnsOpCodednsAAdnsTCdnsRDdnsRAdnsRC DNSPacket dnsHeader dnsQuestions dnsAnswersdnsAuthorityRecordsdnsAdditionalRecords getDNSPacket putDNSPacket $fShowOpCode $fEqRespCode$fShowRespCode$fShowDNSHeader $fShowType $fShowQType $fShowClass $fEqClass $fShowQClass $fShowQuery $fShowRData$fShowRR$fShowDNSPacket$fShowRW $fShowLabel QueryResultKnownUnknown WaitStrategyArpTable newArpTable lookupEntryaddEntrymarkUnreachableblockingStrategywriteChanStrategy resolveAddr SubnetMaskunmask CodecAtomgetAtomputAtomatomSizeword32ToSubnetMasksubnetMaskToWord32 computeMask$fCodecAtomSubnetMask$fCodecAtomMac$fCodecAtomIP4Mask$fCodecAtomIP4$fCodecAtomBool$fCodecAtomWord32$fCodecAtomWord16$fCodecAtomWord8$fCodecAtom(,)$fShowSubnetMask$fEqSubnetMaskNVTAsciiStringOption getOption putOptionOverloadOption UsedFileFieldUsedSNameFieldUsedBothFieldsNetBiosNodeTypeBNodePNodeMNodeHNodeOptionTagOrError UnknownTagKnownTagDhcp4OptionTag OptTagPad OptTagEndOptTagSubnetMaskOptTagTimeOffset OptTagRoutersOptTagTimeServersOptTagIEN116NameServersOptTagNameServersOptTagLogServersOptTagCookieServersOptTagLPRServersOptTagImpressServersOptTagResourceLocationServersOptTagHostNameOptTagBootFileSizeOptTagMeritDumpFileOptTagDomainNameOptTagSwapServerOptTagRootPathOptTagExtensionsPathOptTagEnableIPForwarding!OptTagEnableNonLocalSourceRoutingOptTagPolicyFilters#OptTagMaximumDatagramReassemblySizeOptTagDefaultTTLOptTagPathMTUAgingTimeoutOptTagPathMTUPlateauTableOptTagInterfaceMTUOptTagAllSubnetsAreLocalOptTagBroadcastAddressOptTagPerformMaskDiscoveryOptTagShouldSupplyMasks"OptTagShouldPerformRouterDiscoveryOptTagRouterSolicitationAddressOptTagStaticRoutes OptTagShouldNegotiateArpTrailersOptTagArpCacheTimeout%OptTagUseRFC1042EthernetEncapsulationOptTagTcpDefaultTTLOptTagTcpKeepaliveIntervalOptTagTcpKeepaliveUseGarbageOptTagNisDomainNameOptTagNisServersOptTagNtpServersOptTagVendorSpecificOptTagNetBiosNameServers OptTagNetBiosDistributionServersOptTagNetBiosNodeTypeOptTagNetBiosScopeOptTagXWindowsFontServerOptTagXWindowsDisplayManagersOptTagNisPlusDomainOptTagNisPlusServersOptTagSmtpServersOptTagPopServersOptTagNntpServersOptTagWwwServersOptTagFingerServersOptTagIrcServersOptTagStreetTalkServers*OptTagStreetTalkDirectoryAssistanceServers OptTagFQDNOptTagRequestIPAddressOptTagIPAddressLeaseTimeOptTagOverloadOptTagTftpServerOptTagBootfileNameOptTagMessageTypeOptTagServerIdentifierOptTagParameterRequestListOptTagErrorMessageOptTagMaxDHCPMessageSizeOptTagRenewalTimeOptTagRebindingTimeOptTagVendorClassOptTagClientIdentifierOptTagNetWareDomainNameOptTagNetWareInfoOptTagAutoconfiguration ControlTag ControlPad ControlEndDhcp4MessageType Dhcp4Discover Dhcp4Offer Dhcp4Request Dhcp4DeclineDhcp4AckDhcp4Nak Dhcp4Release Dhcp4Inform Dhcp4Option OptSubnetMask OptTimeOffset OptRoutersOptTimeServersOptIEN116NameServersOptNameServers OptLogServersOptCookieServers OptLPRServersOptImpressServersOptResourceLocationServers OptHostNameOptBootFileSizeOptMeritDumpFile OptDomainName OptSwapServer OptRootPathOptExtensionsPathOptEnableIPForwardingOptEnableNonLocalSourceRoutingOptPolicyFilters OptMaximumDatagramReassemblySize OptDefaultTTLOptPathMTUAgingTimeoutOptPathMTUPlateauTableOptInterfaceMTUOptAllSubnetsAreLocalOptBroadcastAddressOptPerformMaskDiscoveryOptShouldSupplyMasksOptShouldPerformRouterDiscoveryOptRouterSolicitationAddressOptStaticRoutesOptShouldNegotiateArpTrailersOptArpCacheTimeout"OptUseRFC1042EthernetEncapsulationOptTcpDefaultTTLOptTcpKeepaliveIntervalOptTcpKeepaliveUseGarbageOptNisDomainName OptNisServers OptNtpServersOptVendorSpecificOptNetBiosNameServersOptNetBiosDistributionServersOptNetBiosNodeTypeOptNetBiosScopeOptXWindowsFontServerOptXWindowsDisplayManagersOptNisPlusDomainOptNisPlusServersOptSmtpServers OptPopServersOptNntpServers OptWwwServersOptFingerServers OptIrcServersOptStreetTalkServers'OptStreetTalkDirectoryAssistanceServersOptFQDNOptRequestIPAddressOptIPAddressLeaseTime OptOverload OptTftpServerOptBootfileNameOptMessageTypeOptServerIdentifierOptParameterRequestListOptErrorMessageOptMaxDHCPMessageSizeOptRenewalTimeOptRebindingTimeOptVendorClassOptClientIdentifierOptNetWareDomainNameOptNetWareInfoOptAutoconfiguration MagicCookiedhcp4MagicCookiegetDhcp4OptionputDhcp4OptionputControlOption getOptionTag putOptionTaggetDhcp4OptionsputDhcp4Options scrubControlseatPad replicateA repeatedlynullTerminatedlookupOverload lookupFile lookupSname lookupParamslookupMessageTypelookupRequestAddrlookupLeaseTimedefaultFixedGetOptiondefaultFixedPutOptionfixedLen getRecordgetLenputLen$fOptionNVTAsciiString$fCodecAtomOptionTagOrError$fOptionByteString$fOptionSubnetMask $fOptionIP4$fOptionWord32$fOptionWord16 $fOptionWord8 $fOptionBool $fOption(,) $fOption[]$fCodecAtomOverloadOption$fOptionOverloadOption$fCodecAtomNetBiosNodeType$fOptionNetBiosNodeType$fCodecAtomDhcp4MessageType$fOptionDhcp4MessageType$fCodecAtomMagicCookie$fEqDhcp4MessageType$fShowDhcp4MessageType$fEqControlTag$fShowControlTag$fShowDhcp4OptionTag$fEqDhcp4OptionTag$fShowOptionTagOrError$fEqOptionTagOrError$fShowNetBiosNodeType$fEqNetBiosNodeType$fShowOverloadOption$fEqOverloadOption$fEqNVTAsciiString$fShowNVTAsciiString$fShowDhcp4Option$fEqDhcp4OptionXid Dhcp4Messagedhcp4Op dhcp4Hopsdhcp4Xid dhcp4Secsdhcp4Broadcastdhcp4ClientAddr dhcp4YourAddrdhcp4ServerAddrdhcp4RelayAddrdhcp4ClientHardwareAddrdhcp4ServerHostnamedhcp4BootFilename dhcp4OptionsOffer offerHopsofferXid offerYourAddrofferServerAddrofferRelayAddrofferClientHardwareAddr offerOptionsAckackHopsackXid ackYourAddr ackServerAddr ackRelayAddrackClientHardwareAddr ackLeaseTime ackOptionsDiscover discoverXiddiscoverBroadcastdiscoverClientHardwareAddrdiscoverParametersRequest requestXidrequestBroadcastrequestServerAddrrequestClientHardwareAddressrequestParametersrequestAddress ReplyMessage AckMessage OfferMessageRequestMessageDiscoverMessageServerSettingsSettingsstaticServerAddrstaticTimeOffsetstaticClientAddrstaticLeaseTime staticSubnetstaticBroadcast staticRoutersstaticDomainName staticDNS requestToAckdiscoverToOffergetDhcp4MessageputDhcp4MessageparseDhcpMessagediscoverToMessage ackToMessageofferToMessagerequestToMessage mkDiscoverofferToRequest$fCodecAtomFlags$fCodecAtomHardwareType$fCodecAtomDhcp4Op$fCodecAtomXid$fShowServerSettings$fEqXid $fShowXid $fShowOffer $fShowAck$fShowReplyMessage$fShowDiscover $fShowRequest$fShowRequestMessage $fEqDhcp4Op $fShowDhcp4Op$fEqDhcp4Message$fShowDhcp4Message$fEqHardwareType$fShowHardwareType $fShowFlags $fEqFlags FragTable newFragTablecleanupFragTableprocessFragment$fShowFragmentSequenceNumber Identifier RouterAddressraAddrraPreferenceLevelPreferenceLevelTraceRouteCodeTraceRouteForwardedTraceRouteDiscarded RedirectCodeRedirectForNetworkRedirectForHost"RedirectForTypeOfServiceAndNetworkRedirectForTypeOfServiceAndHostTimeExceededCodeTimeToLiveExceededInTransitFragmentReassemblyTimeExceededDestinationUnreachableCodeNetUnreachableHostUnreachableProtocolUnreachablePortUnreachableFragmentationUnreachableSourceRouteFailedDestinationNetworkUnknownDestinationHostUnknownSourceHostIsolatedErrorAdministrativelyProhibitedHostAdministrativelyProhibitedNetworkUnreachableForTOSHostUnreachableForTOS'CommunicationAdministrativelyProhibitedHostPrecedenceViolationPrecedenceCutoffInEffectNoCode Icmp4Packet EchoReplyDestinationUnreachable SourceQuenchRedirectEchoRouterAdvertisementRouterSolicitation TimeExceededParameterProblem TimestampTimestampReply InformationInformationReply TraceRoute AddressMaskAddressMaskReplyLifetime getLifetime putLifetimenoCodegetIcmp4PacketrenderIcmp4PacketputIcmp4Packet getIdentifier putIdentifiergetSequenceNumberputSequenceNumber getUntilDone$fSerializeRouterAddress$fSerializeTraceRouteCode$fSerializeRedirectCode$fSerializeTimeExceededCode%$fSerializeDestinationUnreachableCode$fSerializeNoCode$fEqDestinationUnreachableCode $fShowDestinationUnreachableCode$fEqTimeExceededCode$fShowTimeExceededCode$fEqRedirectCode$fShowRedirectCode$fEqTraceRouteCode$fShowTraceRouteCode$fEqRouterAddress$fShowRouterAddress$fEqIcmp4Packet$fShowIcmp4Packet RoutingTableRoute routeNetwork routeType routeDevice RouteTypeDirectIndirectLoopback routeSource routeNextHopempty getRoutesaddRule deleteRule lookupRouteisLocal routesForDev HasIP4Stateip4StateIP4State ip4Routes ip4ArpTable ip4Fragments ip4ArpRetryip4ArpRetryDelayip4ResponderQueue ip4RandomSeedResponderRequestFinishSend SendSource SourceAny SourceIP4 SourceDev newIP4StateaddRoute lookupRoute4 isLocalAddr nextIdent$fHasIP4StateIP4StateAddrAddr4putAddrshowAddr sameFamily$fHashableAddr$fEqAddr $fOrdAddr $fShowAddr $fGenericAddr NetworkAddrtoAddrfromAddrisWildcardAddr wildcardAddrisBroadcastAddr broadcastAddr$fNetworkAddrIP4$fNetworkAddrAddr CanReceive getRecvWindowCanSend getSendWindow TimeWaitTcbtwSndNxttwRcvNxttwRcvWnd twLocalPort twRemotePort twRouteInfotwRemoteTcb tcbParent tcbConfigtcbStatetcbEstablished tcbClosedtcbSndUp tcbSndWl1 tcbSndWl2tcbIss tcbSendWindowtcbRcvUptcbIrstcbNeedsDelayedAck tcbRecvWindow tcbRecvBuffer tcbLocalPort tcbRemotePort tcbRouteInfo tcbRemotetcbMss tcbTimers tcbTSRecenttcbLastAckSent TcbConfigtcUseTimestamp ListenTcblSrclPortlAccept lAcceptSignallTSClockStateListenSynSent SynReceived EstablishedFinWait1FinWait2 CloseWaitClosingLastAckTimeWaitClosedGetStategetState TcpTimers ttDelayedAcktt2MSLttRetransmitValid ttRetransmit ttRetriesttRTOttSRTTttRTTVar ttMaxIdlettIdle SlowTicksemptyTcpTimersresetRetransmitretryRetransmitstopRetransmit reset2MSL updateTimersresetIdleTimer calibrateRTO whenStatesetState newListenTcb createChild reserveSlot releaseSlot acceptTcbusingTimestampsdisableTimestampnewTcbsignalDelayedAck finalizeTcb queueByteshaveBytesAvail receiveBytestryReceiveBytes mkTimeWaitTcb getSndNxt getSndWnd getSndUna getRcvNxt getRcvWnd getRcvRight$fCanReceiveTimeWaitTcb$fCanReceiveTcb$fCanReceiveIORef $fCanSendTcb$fCanSendIORef$fGetStateTimeWaitTcb $fGetStateTcb$fGetStateListenTcb $fEqState $fShowState$fEqTimeWaitTcbmkRstmkRstAckmkSynmkSynAckmkAck HasTcpStatetcpStateTcpResponderRequest SendSegment SendWithTcbTcpStateKeytcbKeytcpQueue tcpActive newTcpStatedecrSynBacklogincrSynBacklogregisterListeningdeleteListeninglookupListeningregisterTimeWait resetTimeWaitlookupTimeWaitdeleteTimeWaitregisterActive lookupActive closeActive deleteActive nextTcpPortnextIss$fHasTcpStateTcpState $fHashableKey$fHashableListenKey$fShowListenKey $fEqListenKey$fOrdListenKey$fGenericListenKey $fShowKey$fEqKey$fOrdKey $fGenericKey HasUdpStateudpStateUdpResponderRequest SendDatagramUdpStateudpRecvudpPorts udpQueue_ UdpBuffer newUdpStateudpQueue lookupRecv registerRecv nextUdpPort$fHasUdpStateUdpStateHasNetworkStack networkStack NetworkStacknsConfignsNatnsInput nsDevices nsIP4StatensIP4Responder nsUdpStatensUdpResponder nsTcpStatensTcpResponder nsTcpTimersnsNameServers4 InputPacket FromDeviceFromIP4addNameServer4getNameServers4$fHasNetworkStackNetworkStack$fHasNatStateNetworkStack$fHasTcpStateNetworkStack$fHasUdpStateNetworkStack$fHasIP4StateNetworkStack$fHasConfigNetworkStacknewLoopbackDevice listDevices closeDevice startDevice responderqueueIP4sendIP4 prepareIP4 primSendIP4 queueIcmp4portUnreachableNetwork pseudoHeader sendDatagram' sendDatagram routeDatagram findNextHop $fNetworkIP4 $fNetworkAddrforwardTcpPortremoveTcpPortForwardforwardUdpPortremoveUdpPortForwardRoutingExceptionListenExceptionConnectionException DataSocketsConnect sCanWritesWritesCanReadsReadsTryRead ListenSocketClientsListensAcceptSocketsClose SocketConfigscRecvBufferSizeSockPortdefaultSocketConfigsendAcksendFinsendDatacanSend sendWithTcbqueueTcp queueWithTcbqueueAckrouteTcpsendTcpTcpListenSocket TcpSocket tcpLocalAddr tcpLocalPort tcpRemoteAddr tcpRemotePort processTcp tcpTimers updateActive handleRTO handle2MSLqueueUdp primSendUdp UdpSocket newUdpSocketrecvfrom recvfrom'sendtoSourceFromHost FromAddr4 DnsException NoNameServers HostEntryhostName hostAliases hostAddressesHostNameparseHostEntry parseAddrparsePtr getHostByName sendRequest queryServers4 sourceHosttoLabels sourceQTypemkPacket$fExceptionDnsException$fShowHostEntry$fShowDnsException $fShowSource DhcpLease dhcpRenewdhcpAddr DhcpConfigdcInitialTimeout dcRetriesdcDefaultRoute dcAutoRenewdefaultDhcpConfig dhcpClientmakeHansHandle$fBufferedIOsock $fRawIOsock$fIODevicesock processUdp processArp processIP4 handleIP4processPacketsprocessEthernetnewNetworkStack addDevice addIP4Route time-1.6.0.1Data.Time.Clock.UTCNominalDiffTime forkNamed castConst'Modify runModifyConstrunConsttcpFixedHeaderSize putTcpControl getTcpOptions getTcpPort putTcpSeqNum getTcpSeqNum putTcpAckNum getTcpAckNumtcpFlagsgetTcpOptionTagputTcpOptionTag putTcpOption getTcpOptiongetMaxSegmentSizeputMaxSegmentSizegetSackPermittedputSackPermittedgetSackputSack getSackBlock putSackBlock sackLengthgetWindowScalingputWindowScaling getTimestamp putTimestamp getUnknown putUnknown wSegmentswRcvNxt wRcvRightwMaxsegStartsegEndsegNexttrimSegresolveOverlapghc-prim GHC.TypesTruebaseGHC.BaseJust addSegment advanceLeftinsertOutOfOrdersplitContiguousSegmentsegHdrsegBody mkSegmentBuckethtSize htBucketscons'nfListnfListId mapBuckets getBucket modifyBucketIOunHanswRetransmitQueue wSndAvail segRightEdgeleftEdge rightEdgesack measureRTTNothingsackRetransmitprocessSackBlocks segWithinwSndNxtwSndWndwTSClockSegmentstscVal tscLastUpdate segHeader segSentAtsegSACK segHeaderLpcAccumpcCarryLabelPtrGetRWrwOffsetrwLabelsunGet getOffset lookupPtr labelsToName addLabelsliftGetgetWord8 getWord16be getWord32be getInt32begetBytesisolatelabel putInt32be getDNSHeader parseOpCode parseRespCodegetQuerygetRRgetTypegetQType getQClassgetNamegetClassgetRData putDNSHeader renderOpCoderenderRespCodeputNameputQueryputTypeputQType putQClassputRRputClassputRData purgeArpTableGHC.MVarMVarregisterWaiter getWaiterWaitingPresentatMacs atLifetime atPurgeThreadFlags HardwareType broadcastFlagEthernetDhcp4Op BootRequest BootReplyhardwareTypeAddressLengthputPaddedByteStringselectKnownTagsgetOfferServerAddr purgeEntriesmkBuffer updateBufferbufFull addFragmentFragment fragStartfragEnd fragPayloadBuffer bufExpirebufSize bufHeader bufFragments ftEntries ftDuration ftPurgeThreadTablemkKey mkFragment mergeFragmentrtRules rtDefaultRuleruleMask rulePrefix ruleRoute ruleMaskLen ruleSource ruleDevicemkRuleroutesTo!random-1.1-54KmMHXjttlERYcr1mvsAe System.RandomrandomSignal newSignalsignal waitSignal tryWaitSignalbufState bufSignal takeBytes tryTakeBytessTakestBufstClosed newBuffer closeBufferbytesAvailableputBytes emptyStatesNullsPutbufAvail bufChunks writeChunkFalse readChunk tryReadChunk isEmptyBuffer queueChunk BufContents bufContentsemptyBufContentschunksAvailable dequeueChunk pfSourceAddr pfSourcePort pfDestAddr pfDestPort natTcpTable_ natTcpRules_ natUdpTable_ natUdpRules_ natReaper_Flow otherSideinsertNatTable expireEntrieslookupNatTablereapertcpForwardingActiveudpForwardingActive addTcpSession addUdpSessionshouldForwardTcpshouldForwardUdpNatTable natConfignatTableSessionsSessionsessLeft sessRight PortForward HasNatStatenatStateNatState flowLocal flowLocalPort flowRemoteflowRemotePort newNatState sessionFlows addSession removeOldest removeSession newNatTable fourMinutesaddTcpPortForwardaddUdpPortForward ruleApplies$fHasNatStateNatState$fHashableFlowqueueTcb SeqNumVar AcceptQueueaqFreeaqTcbsdefaultTcbConfigtcpSynBacklog_updateTimeWait Tcp4USTimertcpTimer tcpSecret tcpLastUpdate tcpListen_ tcpActive_ tcpTimeWait_tcpPorts tcpISSTimer tcpQueue_ TimeWaitHeap ListenKey listenKey tcpListen tcpTimeWait tcpSynBacklognewTcp4USTimer pickFreshPort tapSendLoop tapRecvLoopIOVecc_closec_readc_writevc_init_tap_device openDevice initTapDevicetapClose writeIOVec arpOutgoingarpRequestThreadrenderIP4Packet prepareHeader sendIP4Frames tryForwardTcp tryForwardUdp newSession NoRouteToHostAlreadyListeningAlreadyConnected NoConnectionNoPortAvailable DoesNotExistrouteroute'ConnectionRefusedConnectionClosing$fExceptionRoutingException$fExceptionListenException$fExceptionConnectionException addTimestamprenderTcpPackettcpRoute activeOpen guardSend guardRecvtlNStlTcbtcpNStcpTcb$fListenSocketTcpListenSocket$fSocketTcpListenSocket$fDataSocketTcpSocket$fSocketTcpSocket$fHasNetworkStackTcpSocket InputCase tryActive tryListening tryTimeWait tryForwardupdateTimestamphandleActiveSegsprocessFinWait2 enterTimeWaithandleRTTMeasurement handleSynSenthandleListeningcreateChildTcbprocessSynOptions rejectSyn handleClosed handleActivehandleTimeWaitrenderUdpPacketsendUdp KnownRoute KnownSourceudpNS udpBuffer udpSockStateudpClose SockState$fDataSocketUdpSocket$fSocketUdpSocket$fHasNetworkStackUdpSocketbootpsbootpc waitResponse dhcpDiscover awaitOffer dhcpRequestrenew handleAckmkXid renderMessageawaitAck lookupGateway lookupSubnetgetNameServersmemcpy copyToPtrcopyBSrouteMsg updateEntrycheckDestination processICMPregisterLoopback