## Tor's modules ## ### Generic modules ### `buffers.c` : Implements the `buf_t` buffered data type for connections, and several low-level data handling functions to handle network protocols on it. `channel.c` : Generic channel implementation. Channels handle sending and receiving cells among tor nodes. `channeltls.c` : Channel implementation for TLS-based OR connections. Uses `connection_or.c`. `circuitbuild.c` : Code for constructing circuits and choosing their paths. (*Note*: this module could plausibly be split into handling the client side, the server side, and the path generation aspects of circuit building.) `circuitlist.c` : Code for maintaining and navigating the global list of circuits. `circuitmux.c` : Generic circuitmux implementation. A circuitmux handles deciding, for a particular channel, which circuit should write next. `circuitmux_ewma.c` : A circuitmux implementation based on the EWMA (exponentially weighted moving average) algorithm. `circuituse.c` : Code to actually send and receive data on circuits. `command.c` : Handles incoming cells on channels. `config.c` : Parses options from torrc, and uses them to configure the rest of Tor. `confparse.c` : Generic torrc-style parser. Used to parse torrc and state files. `connection.c` : Generic and common connection tools, and implementation for the simpler connection types. `connection_edge.c` : Implementation for entry and exit connections. `connection_or.c` : Implementation for OR connections (the ones that send cells over TLS). `main.c` : Principal entry point, main loops, scheduled events, and network management for Tor. `ntmain.c` : Implements Tor as a Windows service. (Not very well.) `onion.c` : Generic code for generating and responding to CREATE and CREATED cells, and performing the appropriate onion handshakes. Also contains code to manage the server-side onion queue. `onion_fast.c` : Implements the old SHA1-based CREATE_FAST/CREATED_FAST circuit creation handshake. (Now deprecated.) `onion_ntor.c` : Implements the Curve25519-based NTOR circuit creation handshake. `onion_tap.c` : Implements the old RSA1024/DH1024-based TAP circuit creation handshake. (Now deprecated.) `relay.c` : Handles particular types of relay cells, and provides code to receive, encrypt, route, and interpret relay cells. `scheduler.c` : Decides which channel/circuit pair is ready to receive the next cell. `statefile.c` : Handles loading and storing Tor's state file. `tor_main.c` : Contains the actual `main()` function. (This is placed in a separate file so that the unit tests can have their own `main()`.) ### Node-status modules ### `directory.c` : Implements the HTTP-based directory protocol, including sending, receiving, and handling most request types. (*Note*: The client parts of this, and the generic-HTTP parts of this, could plausibly be split off.) `microdesc.c` : Implements the compact "microdescriptor" format for keeping track of what we know about a router. `networkstatus.c` : Code for fetching, storing, and interpreting consensus vote documents. `nodelist.c` : Higher-level view of our knowledge of which Tor servers exist. Each `node_t` corresponds to a router we know about. `routerlist.c` : Code for storing and retrieving router descriptors and extrainfo documents. `routerparse.c` : Generic and specific code for parsing all Tor directory information types. `routerset.c` : Parses and interprets a specification for a set of routers (by IP range, fingerprint, nickname (deprecated), or country). ### Client modules ### `addressmap.c` : Handles client-side associations between one address and another. These are used to implement client-side DNS caching (NOT RECOMMENDED), MapAddress directives, Automapping, and more. `circpathbias.c` : Path bias attack detection for circuits: tracks whether connections made through a particular guard have an unusually high failure rate. `circuitstats.c` : Code to track circuit performance statistics in order to adapt our behavior. Notably includes an algorithm to track circuit build times. `dnsserv.c` : Implements DNSPort for clients. (Note that in spite of the word "server" in this module's name, it is used for Tor clients. It implements a DNS server, not DNS for servers.) `entrynodes.c` : Chooses, monitors, and remembers guard nodes. Also contains some bridge-related code. `torcert.c` : Code to interpret and generate Ed25519-based certificates. ### Server modules ### `dns.c` : Server-side DNS code. Handles sending and receiving DNS requests on exit nodes, and implements the server-side DNS cache. `dirserv.c` : Implements part of directory caches that handles responding to client requests. `ext_orport.c` : Implements the extended ORPort protocol for communication between server-side pluggable transports and Tor servers. `hibernate.c` : Performs bandwidth accounting, and puts Tor relays into hibernation when their bandwidth is exhausted. `router.c` : Management code for running a Tor server. In charge of RSA key maintenance, descriptor generation and uploading. `routerkeys.c` : Key handling code for a Tor server. (Currently handles only the Ed25519 keys, but the RSA keys could be moved here too.) ### Onion service modules ### `rendcache.c` : Stores onion service descriptors. `rendclient.c` : Client-side implementation of the onion service protocol. `rendcommon.c` : Parts of the onion service protocol that are shared by clients, services, and/or Tor servers. `rendmid.c` : Tor-server-side implementation of the onion service protocol. (Handles acting as an introduction point or a rendezvous point.) `rendservice.c` : Service-side implementation of the onion service protocol. `replaycache.c` : Backend to check introduce2 requests for replay attempts. ### Authority modules ### `dircollate.c` : Helper for `dirvote.c`: Given a set of votes, each containing a list of Tor nodes, determines which entries across all the votes correspond to the same nodes, and yields them in a useful order. `dirvote.c` : Implements the directory voting algorithms that authorities use. `keypin.c` : Implements a persistent key-pinning mechanism to tie RSA1024 identities to ed25519 identities. ### Miscellaneous modules ### `control.c` : Implements the Tor controller protocol. `cpuworker.c` : Implements the inner work queue function. We use this to move the work of circuit creation (on server-side) to other CPUs. `fp_pair.c` : Types for handling 2-tuples of 20-byte fingerprints. `geoip.c` : Parses geoip files (which map IP addresses to country codes), and performs lookups on the internal geoip table. Also stores some geoip-related statistics. `policies.c` : Parses and implements Tor exit policies. `reasons.c` : Maps internal reason-codes to human-readable strings. `rephist.c` : Tracks Tor servers' performance over time. `status.c` : Writes periodic "heartbeat" status messages about the state of the Tor process. `transports.c` : Implements management for the pluggable transports subsystem.