tor-commits July 2021

tor-commits@lists.torproject.org

17 participants
1544 discussions

[Git][tpo/applications/fenix][tor-browser-90.0.0b6-11.0-1] squash! Add Tor integration and UI
by Matthew Finkel (＠sysrqb) 08 Jul '21

08 Jul '21

Matthew Finkel pushed to branch tor-browser-90.0.0b6-11.0-1 at The Tor Project / Applications / fenix Commits: 16dc16f5 by Matthew Finkel at 2021-07-08T20:16:18+00:00 squash! Add Tor integration and UI Bug 40179: Show Snowflake bridge option on Release - - - - - 1 changed file: - app/src/main/java/org/mozilla/fenix/settings/TorBridgeConfigFragment.kt Changes: ===================================== app/src/main/java/org/mozilla/fenix/settings/TorBridgeConfigFragment.kt ===================================== @@ -40,13 +40,6 @@ class TorBridgeConfigFragment : PreferenceFragmentCompat() { // `*` is Kotlin's "spread" operator, for expanding an Array as a vararg. addToRadioGroup(*builtinBridgeRadioGroups.toTypedArray()) - - // Snowflake is not available on Release at this time. - if (Config.channel.isRelease) { - radioSnowflake.apply { - isVisible = false - } - } } override fun onResume() { View it on GitLab: https://gitlab.torproject.org/tpo/applications/fenix/-/commit/16dc16f51280f… -- View it on GitLab: https://gitlab.torproject.org/tpo/applications/fenix/-/commit/16dc16f51280f… You're receiving this email because of your account on gitlab.torproject.org.

1 0

[snowflake/main] Fix race is broker test reported by `go test -race`
by arlo＠torproject.org 08 Jul '21

08 Jul '21

commit dfb68d7cfc4b69c5e1f5628f3db002c3595fa1f0 Author: Arlo Breault <arlolra(a)gmail.com> Date: Thu Jul 8 15:31:56 2021 -0400 Fix race is broker test reported by `go test -race` --- broker/snowflake-broker_test.go | 27 +++++++++++++++------------ 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/broker/snowflake-broker_test.go b/broker/snowflake-broker_test.go index 77e62cf..9e1c9f1 100644 --- a/broker/snowflake-broker_test.go +++ b/broker/snowflake-broker_test.go @@ -173,10 +173,10 @@ func TestBroker(t *testing.T) { So(err, ShouldBeNil) Convey("with a client offer if available.", func() { - go func(ctx *BrokerContext) { + go func(i *IPC) { proxyPolls(i, w, r) done <- true - }(ctx) + }(i) // Pass a fake client offer to this proxy p := <-ctx.proxyPolls So(p.id, ShouldEqual, "ymbcCMto7KHNGYlp") @@ -187,10 +187,10 @@ func TestBroker(t *testing.T) { }) Convey("return empty 200 OK when no client offer is available.", func() { - go func(ctx *BrokerContext) { + go func(i *IPC) { proxyPolls(i, w, r) done <- true - }(ctx) + }(i) p := <-ctx.proxyPolls So(p.id, ShouldEqual, "ymbcCMto7KHNGYlp") // nil means timeout @@ -202,6 +202,7 @@ func TestBroker(t *testing.T) { }) Convey("Responds to proxy answers...", func() { + done := make(chan bool) s := ctx.AddSnowflake("test", "", NATUnrestricted, 0) w := httptest.NewRecorder() data := bytes.NewReader([]byte(`{"Version":"1.0","Sid":"test","Answer":"test"}`)) @@ -209,10 +210,12 @@ func TestBroker(t *testing.T) { Convey("by passing to the client if valid.", func() { r, err := http.NewRequest("POST", "snowflake.broker/answer", data) So(err, ShouldBeNil) - go func(ctx *BrokerContext) { + go func(i *IPC) { proxyAnswers(i, w, r) - }(ctx) + done <- true + }(i) answer := <-s.answerChannel + <-done So(w.Code, ShouldEqual, http.StatusOK) So(answer, ShouldResemble, "test") }) @@ -265,10 +268,10 @@ func TestBroker(t *testing.T) { rp, err := http.NewRequest("POST", "snowflake.broker/proxy", datap) So(err, ShouldBeNil) - go func(ctx *BrokerContext) { + go func(i *IPC) { proxyPolls(i, wp, rp) proxy_done <- true - }(ctx) + }(i) // Client offer wc := httptest.NewRecorder() @@ -289,10 +292,10 @@ func TestBroker(t *testing.T) { datap = bytes.NewReader([]byte(`{"Version":"1.0","Sid":"ymbcCMto7KHNGYlp","Answer":"test"}`)) rp, err = http.NewRequest("POST", "snowflake.broker/answer", datap) So(err, ShouldBeNil) - go func(ctx *BrokerContext) { + go func(i *IPC) { proxyAnswers(i, wp, rp) proxy_done <- true - }(ctx) + }(i) <-proxy_done <-client_done @@ -682,10 +685,10 @@ func TestMetrics(t *testing.T) { r, err := http.NewRequest("POST", "snowflake.broker/proxy", data) r.RemoteAddr = "129.97.208.23:8888" //CA geoip So(err, ShouldBeNil) - go func(ctx *BrokerContext) { + go func(i *IPC) { proxyPolls(i, w, r) done <- true - }(ctx) + }(i) p := <-ctx.proxyPolls //manually unblock poll p.offerChannel <- nil <-done

1 0

[snowflake/main] Move http handlers to a separate file
by arlo＠torproject.org 08 Jul '21

08 Jul '21

commit 0ced1cc32497f3b47a614ef4a526af7925447252 Author: Arlo Breault <abreault(a)wikimedia.org> Date: Thu May 20 08:31:30 2021 -0400 Move http handlers to a separate file --- broker/broker.go | 196 ---------------------------------------------------- broker/http.go | 205 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 205 insertions(+), 196 deletions(-) diff --git a/broker/broker.go b/broker/broker.go index 58f3955..437a4d1 100644 --- a/broker/broker.go +++ b/broker/broker.go @@ -8,10 +8,8 @@ package main import ( "container/heap" "crypto/tls" - "errors" "flag" "io" - "io/ioutil" "log" "net/http" "os" @@ -21,17 +19,12 @@ import ( "syscall" "time" - "git.torproject.org/pluggable-transports/snowflake.git/common/messages" "git.torproject.org/pluggable-transports/snowflake.git/common/safelog" "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus/promhttp" "golang.org/x/crypto/acme/autocert" ) -const ( - readLimit = 100000 // Maximum number of bytes to be read from an HTTP request -) - type BrokerContext struct { snowflakes *SnowflakeHeap restrictedSnowflakes *SnowflakeHeap @@ -69,38 +62,6 @@ func NewBrokerContext(metricsLogger *log.Logger) *BrokerContext { } } -// Implements the http.Handler interface -type SnowflakeHandler struct { - *IPC - handle func(*IPC, http.ResponseWriter, *http.Request) -} - -// Implements the http.Handler interface -type MetricsHandler struct { - logFilename string - handle func(string, http.ResponseWriter, *http.Request) -} - -func (sh SnowflakeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { - w.Header().Set("Access-Control-Allow-Origin", "*") - w.Header().Set("Access-Control-Allow-Headers", "Origin, X-Session-ID") - // Return early if it's CORS preflight. - if "OPTIONS" == r.Method { - return - } - sh.handle(sh.IPC, w, r) -} - -func (mh MetricsHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { - w.Header().Set("Access-Control-Allow-Origin", "*") - w.Header().Set("Access-Control-Allow-Headers", "Origin, X-Session-ID") - // Return early if it's CORS preflight. - if "OPTIONS" == r.Method { - return - } - mh.handle(mh.logFilename, w, r) -} - // Proxies may poll for client offers concurrently. type ProxyPoll struct { id string @@ -178,169 +139,12 @@ func (ctx *BrokerContext) AddSnowflake(id string, proxyType string, natType stri return snowflake } -/* -For snowflake proxies to request a client from the Broker. -*/ -func proxyPolls(i *IPC, w http.ResponseWriter, r *http.Request) { - body, err := ioutil.ReadAll(http.MaxBytesReader(w, r.Body, readLimit)) - if err != nil { - log.Println("Invalid data.") - w.WriteHeader(http.StatusBadRequest) - return - } - - arg := messages.Arg{ - Body: body, - RemoteAddr: r.RemoteAddr, - NatType: "", - } - - var response []byte - err = i.ProxyPolls(arg, &response) - switch { - case err == nil: - case errors.Is(err, messages.ErrBadRequest): - w.WriteHeader(http.StatusBadRequest) - return - case errors.Is(err, messages.ErrInternal): - fallthrough - default: - log.Println(err) - w.WriteHeader(http.StatusInternalServerError) - return - } - - if _, err := w.Write(response); err != nil { - log.Printf("proxyPolls unable to write offer with error: %v", err) - } -} - // Client offer contains an SDP and the NAT type of the client type ClientOffer struct { natType string sdp []byte } -/* -Expects a WebRTC SDP offer in the Request to give to an assigned -snowflake proxy, which responds with the SDP answer to be sent in -the HTTP response back to the client. -*/ -func clientOffers(i *IPC, w http.ResponseWriter, r *http.Request) { - body, err := ioutil.ReadAll(http.MaxBytesReader(w, r.Body, readLimit)) - if err != nil { - log.Printf("Error reading client request: %s", err.Error()) - w.WriteHeader(http.StatusBadRequest) - return - } - - arg := messages.Arg{ - Body: body, - RemoteAddr: "", - NatType: r.Header.Get("Snowflake-NAT-Type"), - } - - var response []byte - err = i.ClientOffers(arg, &response) - switch { - case err == nil: - case errors.Is(err, messages.ErrUnavailable): - w.WriteHeader(http.StatusServiceUnavailable) - return - case errors.Is(err, messages.ErrTimeout): - w.WriteHeader(http.StatusGatewayTimeout) - return - default: - log.Println(err) - w.WriteHeader(http.StatusInternalServerError) - return - } - - if _, err := w.Write(response); err != nil { - log.Printf("clientOffers unable to write answer with error: %v", err) - } -} - -/* -Expects snowflake proxes which have previously successfully received -an offer from proxyHandler to respond with an answer in an HTTP POST, -which the broker will pass back to the original client. -*/ -func proxyAnswers(i *IPC, w http.ResponseWriter, r *http.Request) { - body, err := ioutil.ReadAll(http.MaxBytesReader(w, r.Body, readLimit)) - if err != nil { - log.Println("Invalid data.") - w.WriteHeader(http.StatusBadRequest) - return - } - - arg := messages.Arg{ - Body: body, - RemoteAddr: "", - NatType: "", - } - - var response []byte - err = i.ProxyAnswers(arg, &response) - switch { - case err == nil: - case errors.Is(err, messages.ErrBadRequest): - w.WriteHeader(http.StatusBadRequest) - return - case errors.Is(err, messages.ErrInternal): - fallthrough - default: - log.Println(err) - w.WriteHeader(http.StatusInternalServerError) - return - } - - if _, err := w.Write(response); err != nil { - log.Printf("proxyAnswers unable to write answer response with error: %v", err) - } -} - -func debugHandler(i *IPC, w http.ResponseWriter, r *http.Request) { - var response string - - err := i.Debug(new(interface{}), &response) - if err != nil { - log.Println(err) - w.WriteHeader(http.StatusInternalServerError) - return - } - - if _, err := w.Write([]byte(response)); err != nil { - log.Printf("writing proxy information returned error: %v ", err) - } -} - -func robotsTxtHandler(w http.ResponseWriter, r *http.Request) { - w.Header().Set("Content-Type", "text/plain; charset=utf-8") - if _, err := w.Write([]byte("User-agent: *\nDisallow: /\n")); err != nil { - log.Printf("robotsTxtHandler unable to write, with this error: %v", err) - } -} - -func metricsHandler(metricsFilename string, w http.ResponseWriter, r *http.Request) { - w.Header().Set("Content-Type", "text/plain; charset=utf-8") - - if metricsFilename == "" { - http.NotFound(w, r) - return - } - metricsFile, err := os.OpenFile(metricsFilename, os.O_RDONLY, 0644) - if err != nil { - log.Println("Error opening metrics file for reading") - http.NotFound(w, r) - return - } - - if _, err := io.Copy(w, metricsFile); err != nil { - log.Printf("copying metricsFile returned error: %v", err) - } -} - func main() { var acmeEmail string var acmeHostnamesCommas string diff --git a/broker/http.go b/broker/http.go new file mode 100644 index 0000000..6555d7a --- /dev/null +++ b/broker/http.go @@ -0,0 +1,205 @@ +package main + +import ( + "errors" + "io" + "io/ioutil" + "log" + "net/http" + "os" + + "git.torproject.org/pluggable-transports/snowflake.git/common/messages" +) + +const ( + readLimit = 100000 // Maximum number of bytes to be read from an HTTP request +) + +// Implements the http.Handler interface +type SnowflakeHandler struct { + *IPC + handle func(*IPC, http.ResponseWriter, *http.Request) +} + +func (sh SnowflakeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Access-Control-Allow-Origin", "*") + w.Header().Set("Access-Control-Allow-Headers", "Origin, X-Session-ID") + // Return early if it's CORS preflight. + if "OPTIONS" == r.Method { + return + } + sh.handle(sh.IPC, w, r) +} + +// Implements the http.Handler interface +type MetricsHandler struct { + logFilename string + handle func(string, http.ResponseWriter, *http.Request) +} + +func (mh MetricsHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Access-Control-Allow-Origin", "*") + w.Header().Set("Access-Control-Allow-Headers", "Origin, X-Session-ID") + // Return early if it's CORS preflight. + if "OPTIONS" == r.Method { + return + } + mh.handle(mh.logFilename, w, r) +} + +func robotsTxtHandler(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "text/plain; charset=utf-8") + if _, err := w.Write([]byte("User-agent: *\nDisallow: /\n")); err != nil { + log.Printf("robotsTxtHandler unable to write, with this error: %v", err) + } +} + +func metricsHandler(metricsFilename string, w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "text/plain; charset=utf-8") + + if metricsFilename == "" { + http.NotFound(w, r) + return + } + metricsFile, err := os.OpenFile(metricsFilename, os.O_RDONLY, 0644) + if err != nil { + log.Println("Error opening metrics file for reading") + http.NotFound(w, r) + return + } + + if _, err := io.Copy(w, metricsFile); err != nil { + log.Printf("copying metricsFile returned error: %v", err) + } +} + +func debugHandler(i *IPC, w http.ResponseWriter, r *http.Request) { + var response string + + err := i.Debug(new(interface{}), &response) + if err != nil { + log.Println(err) + w.WriteHeader(http.StatusInternalServerError) + return + } + + if _, err := w.Write([]byte(response)); err != nil { + log.Printf("writing proxy information returned error: %v ", err) + } +} + +/* +For snowflake proxies to request a client from the Broker. +*/ +func proxyPolls(i *IPC, w http.ResponseWriter, r *http.Request) { + body, err := ioutil.ReadAll(http.MaxBytesReader(w, r.Body, readLimit)) + if err != nil { + log.Println("Invalid data.") + w.WriteHeader(http.StatusBadRequest) + return + } + + arg := messages.Arg{ + Body: body, + RemoteAddr: r.RemoteAddr, + NatType: "", + } + + var response []byte + err = i.ProxyPolls(arg, &response) + switch { + case err == nil: + case errors.Is(err, messages.ErrBadRequest): + w.WriteHeader(http.StatusBadRequest) + return + case errors.Is(err, messages.ErrInternal): + fallthrough + default: + log.Println(err) + w.WriteHeader(http.StatusInternalServerError) + return + } + + if _, err := w.Write(response); err != nil { + log.Printf("proxyPolls unable to write offer with error: %v", err) + } +} + +/* +Expects a WebRTC SDP offer in the Request to give to an assigned +snowflake proxy, which responds with the SDP answer to be sent in +the HTTP response back to the client. +*/ +func clientOffers(i *IPC, w http.ResponseWriter, r *http.Request) { + body, err := ioutil.ReadAll(http.MaxBytesReader(w, r.Body, readLimit)) + if err != nil { + log.Printf("Error reading client request: %s", err.Error()) + w.WriteHeader(http.StatusBadRequest) + return + } + + arg := messages.Arg{ + Body: body, + RemoteAddr: "", + NatType: r.Header.Get("Snowflake-NAT-Type"), + } + + var response []byte + err = i.ClientOffers(arg, &response) + switch { + case err == nil: + case errors.Is(err, messages.ErrUnavailable): + w.WriteHeader(http.StatusServiceUnavailable) + return + case errors.Is(err, messages.ErrTimeout): + w.WriteHeader(http.StatusGatewayTimeout) + return + default: + log.Println(err) + w.WriteHeader(http.StatusInternalServerError) + return + } + + if _, err := w.Write(response); err != nil { + log.Printf("clientOffers unable to write answer with error: %v", err) + } +} + +/* +Expects snowflake proxes which have previously successfully received +an offer from proxyHandler to respond with an answer in an HTTP POST, +which the broker will pass back to the original client. +*/ +func proxyAnswers(i *IPC, w http.ResponseWriter, r *http.Request) { + body, err := ioutil.ReadAll(http.MaxBytesReader(w, r.Body, readLimit)) + if err != nil { + log.Println("Invalid data.") + w.WriteHeader(http.StatusBadRequest) + return + } + + arg := messages.Arg{ + Body: body, + RemoteAddr: "", + NatType: "", + } + + var response []byte + err = i.ProxyAnswers(arg, &response) + switch { + case err == nil: + case errors.Is(err, messages.ErrBadRequest): + w.WriteHeader(http.StatusBadRequest) + return + case errors.Is(err, messages.ErrInternal): + fallthrough + default: + log.Println(err) + w.WriteHeader(http.StatusInternalServerError) + return + } + + if _, err := w.Write(response); err != nil { + log.Printf("proxyAnswers unable to write answer response with error: %v", err) + } +}

1 0

[snowflake/main] Get rid of legacy version
by arlo＠torproject.org 08 Jul '21

08 Jul '21

commit 87ad06a5e2f1b0d72c64dd0ca17543f524ac1d63 Author: Arlo Breault <arlolra(a)gmail.com> Date: Thu Jun 3 17:04:58 2021 -0400 Get rid of legacy version Move the logic for the legacy version into the http handlers and use a shim when doing ipc. --- broker/http.go | 51 ++++++++++++++++++++++++++++++++++++++------------ broker/ipc.go | 44 ++++++++++++------------------------------- common/messages/ipc.go | 7 ++----- 3 files changed, 53 insertions(+), 49 deletions(-) diff --git a/broker/http.go b/broker/http.go index 6555d7a..2c45b2b 100644 --- a/broker/http.go +++ b/broker/http.go @@ -102,7 +102,6 @@ func proxyPolls(i *IPC, w http.ResponseWriter, r *http.Request) { arg := messages.Arg{ Body: body, RemoteAddr: r.RemoteAddr, - NatType: "", } var response []byte @@ -138,28 +137,57 @@ func clientOffers(i *IPC, w http.ResponseWriter, r *http.Request) { return } + // Handle the legacy version + isLegacy := false + if len(body) > 0 && body[0] == '{' { + isLegacy = true + req := messages.ClientPollRequest{ + Offer: string(body), + NAT: r.Header.Get("Snowflake-NAT-Type"), + } + body, err = req.EncodePollRequest() + if err != nil { + log.Printf("Error shimming the legacy request: %s", err.Error()) + w.WriteHeader(http.StatusInternalServerError) + return + } + } + arg := messages.Arg{ Body: body, RemoteAddr: "", - NatType: r.Header.Get("Snowflake-NAT-Type"), } var response []byte err = i.ClientOffers(arg, &response) - switch { - case err == nil: - case errors.Is(err, messages.ErrUnavailable): - w.WriteHeader(http.StatusServiceUnavailable) - return - case errors.Is(err, messages.ErrTimeout): - w.WriteHeader(http.StatusGatewayTimeout) - return - default: + if err != nil { + // Assert err == messages.ErrInternal log.Println(err) w.WriteHeader(http.StatusInternalServerError) return } + if isLegacy { + resp, err := messages.DecodeClientPollResponse(response) + if err != nil { + log.Println(err) + w.WriteHeader(http.StatusInternalServerError) + return + } + switch resp.Error { + case "": + response = []byte(resp.Answer) + case "no snowflake proxies currently available": + w.WriteHeader(http.StatusServiceUnavailable) + return + case "timed out waiting for answer!": + w.WriteHeader(http.StatusGatewayTimeout) + return + default: + panic("unknown error") + } + } + if _, err := w.Write(response); err != nil { log.Printf("clientOffers unable to write answer with error: %v", err) } @@ -181,7 +209,6 @@ func proxyAnswers(i *IPC, w http.ResponseWriter, r *http.Request) { arg := messages.Arg{ Body: body, RemoteAddr: "", - NatType: "", } var response []byte diff --git a/broker/ipc.go b/broker/ipc.go index 79ccf0f..a05f560 100644 --- a/broker/ipc.go +++ b/broker/ipc.go @@ -21,14 +21,10 @@ const ( NATUnrestricted = "unrestricted" ) -// We support two client message formats. The legacy format is for backwards -// combatability and relies heavily on HTTP headers and status codes to convey -// information. type clientVersion int const ( - v0 clientVersion = iota //legacy version - v1 + v1 clientVersion = iota ) type IPC struct { @@ -141,32 +137,22 @@ func (i *IPC) ClientOffers(arg messages.Arg, response *[]byte) error { startTime := time.Now() body := arg.Body - if len(body) > 0 && body[0] == '{' { - version = v0 + parts := bytes.SplitN(body, []byte("\n"), 2) + if len(parts) < 2 { + // no version number found + err := fmt.Errorf("unsupported message version") + return sendClientResponse(&messages.ClientPollResponse{Error: err.Error()}, response) + } + body = parts[1] + if string(parts[0]) == "1.0" { + version = v1 } else { - parts := bytes.SplitN(body, []byte("\n"), 2) - if len(parts) < 2 { - // no version number found - err := fmt.Errorf("unsupported message version") - return sendClientResponse(&messages.ClientPollResponse{Error: err.Error()}, response) - } - body = parts[1] - if string(parts[0]) == "1.0" { - version = v1 - - } else { - err := fmt.Errorf("unsupported message version") - return sendClientResponse(&messages.ClientPollResponse{Error: err.Error()}, response) - } + err := fmt.Errorf("unsupported message version") + return sendClientResponse(&messages.ClientPollResponse{Error: err.Error()}, response) } var offer *ClientOffer switch version { - case v0: - offer = &ClientOffer{ - natType: arg.NatType, - sdp: body, - } case v1: req, err := messages.DecodeClientPollRequest(body) if err != nil { @@ -203,8 +189,6 @@ func (i *IPC) ClientOffers(arg messages.Arg, response *[]byte) error { } i.ctx.metrics.lock.Unlock() switch version { - case v0: - return messages.ErrUnavailable case v1: resp := &messages.ClientPollResponse{Error: "no snowflake proxies currently available"} return sendClientResponse(resp, response) @@ -230,8 +214,6 @@ func (i *IPC) ClientOffers(arg messages.Arg, response *[]byte) error { i.ctx.metrics.promMetrics.ClientPollTotal.With(prometheus.Labels{"nat": offer.natType, "status": "matched"}).Inc() i.ctx.metrics.lock.Unlock() switch version { - case v0: - *response = []byte(answer) case v1: resp := &messages.ClientPollResponse{Answer: answer} err = sendClientResponse(resp, response) @@ -243,8 +225,6 @@ func (i *IPC) ClientOffers(arg messages.Arg, response *[]byte) error { case <-time.After(time.Second * ClientTimeout): log.Println("Client: Timed out.") switch version { - case v0: - err = messages.ErrTimeout case v1: resp := &messages.ClientPollResponse{ Error: "timed out waiting for answer!"} diff --git a/common/messages/ipc.go b/common/messages/ipc.go index 3f89200..ee29a57 100644 --- a/common/messages/ipc.go +++ b/common/messages/ipc.go @@ -7,12 +7,9 @@ import ( type Arg struct { Body []byte RemoteAddr string - NatType string } var ( - ErrBadRequest = errors.New("bad request") - ErrInternal = errors.New("internal error") - ErrUnavailable = errors.New("service unavailable") - ErrTimeout = errors.New("timeout") + ErrBadRequest = errors.New("bad request") + ErrInternal = errors.New("internal error") )

1 0

[snowflake/main] Intermediary refactor teasing apart http / ipc
by arlo＠torproject.org 08 Jul '21

08 Jul '21

commit 015958fbe66bd91a003c6fc92a11bd5d13b887c3 Author: Arlo Breault <arlolra(a)gmail.com> Date: Thu May 20 07:49:27 2021 -0400 Intermediary refactor teasing apart http / ipc Introduces an IPC struct and moves the logic out of the http handlers and into methods on that. --- broker/broker.go | 338 +++++++++------------------------------- broker/ipc.go | 293 ++++++++++++++++++++++++++++++++++ broker/snowflake-broker_test.go | 111 ++++++------- common/messages/ipc.go | 18 +++ 4 files changed, 445 insertions(+), 315 deletions(-) diff --git a/broker/broker.go b/broker/broker.go index fc4727d..58f3955 100644 --- a/broker/broker.go +++ b/broker/broker.go @@ -6,15 +6,13 @@ SessionDescriptions in order to negotiate a WebRTC connection. package main import ( - "bytes" "container/heap" "crypto/tls" + "errors" "flag" - "fmt" "io" "io/ioutil" "log" - "net" "net/http" "os" "os/signal" @@ -31,23 +29,7 @@ import ( ) const ( - ClientTimeout = 10 - ProxyTimeout = 10 - readLimit = 100000 //Maximum number of bytes to be read from an HTTP request - - NATUnknown = "unknown" - NATRestricted = "restricted" - NATUnrestricted = "unrestricted" -) - -// We support two client message formats. The legacy format is for backwards -// combatability and relies heavily on HTTP headers and status codes to convey -// information. -type clientVersion int - -const ( - v0 clientVersion = iota //legacy version - v1 + readLimit = 100000 // Maximum number of bytes to be read from an HTTP request ) type BrokerContext struct { @@ -89,8 +71,8 @@ func NewBrokerContext(metricsLogger *log.Logger) *BrokerContext { // Implements the http.Handler interface type SnowflakeHandler struct { - *BrokerContext - handle func(*BrokerContext, http.ResponseWriter, *http.Request) + *IPC + handle func(*IPC, http.ResponseWriter, *http.Request) } // Implements the http.Handler interface @@ -106,7 +88,7 @@ func (sh SnowflakeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { if "OPTIONS" == r.Method { return } - sh.handle(sh.BrokerContext, w, r) + sh.handle(sh.IPC, w, r) } func (mh MetricsHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { @@ -199,7 +181,7 @@ func (ctx *BrokerContext) AddSnowflake(id string, proxyType string, natType stri /* For snowflake proxies to request a client from the Broker. */ -func proxyPolls(ctx *BrokerContext, w http.ResponseWriter, r *http.Request) { +func proxyPolls(i *IPC, w http.ResponseWriter, r *http.Request) { body, err := ioutil.ReadAll(http.MaxBytesReader(w, r.Body, readLimit)) if err != nil { log.Println("Invalid data.") @@ -207,47 +189,28 @@ func proxyPolls(ctx *BrokerContext, w http.ResponseWriter, r *http.Request) { return } - sid, proxyType, natType, clients, err := messages.DecodePollRequest(body) - if err != nil { - w.WriteHeader(http.StatusBadRequest) - return - } - - // Log geoip stats - remoteIP, _, err := net.SplitHostPort(r.RemoteAddr) - if err != nil { - log.Println("Error processing proxy IP: ", err.Error()) - } else { - ctx.metrics.lock.Lock() - ctx.metrics.UpdateCountryStats(remoteIP, proxyType, natType) - ctx.metrics.lock.Unlock() + arg := messages.Arg{ + Body: body, + RemoteAddr: r.RemoteAddr, + NatType: "", } - // Wait for a client to avail an offer to the snowflake, or timeout if nil. - offer := ctx.RequestOffer(sid, proxyType, natType, clients) - var b []byte - if nil == offer { - ctx.metrics.lock.Lock() - ctx.metrics.proxyIdleCount++ - ctx.metrics.promMetrics.ProxyPollTotal.With(prometheus.Labels{"nat": natType, "status": "idle"}).Inc() - ctx.metrics.lock.Unlock() - - b, err = messages.EncodePollResponse("", false, "") - if err != nil { - w.WriteHeader(http.StatusInternalServerError) - return - } - - w.Write(b) + var response []byte + err = i.ProxyPolls(arg, &response) + switch { + case err == nil: + case errors.Is(err, messages.ErrBadRequest): + w.WriteHeader(http.StatusBadRequest) return - } - ctx.metrics.promMetrics.ProxyPollTotal.With(prometheus.Labels{"nat": natType, "status": "matched"}).Inc() - b, err = messages.EncodePollResponse(string(offer.sdp), true, offer.natType) - if err != nil { + case errors.Is(err, messages.ErrInternal): + fallthrough + default: + log.Println(err) w.WriteHeader(http.StatusInternalServerError) return } - if _, err := w.Write(b); err != nil { + + if _, err := w.Write(response); err != nil { log.Printf("proxyPolls unable to write offer with error: %v", err) } } @@ -258,162 +221,44 @@ type ClientOffer struct { sdp []byte } -// Sends an encoded response to the client and an -// HTTP server error if the response encoding fails -func sendClientResponse(resp *messages.ClientPollResponse, w http.ResponseWriter) { - data, err := resp.EncodePollResponse() - if err != nil { - log.Printf("error encoding answer") - w.WriteHeader(http.StatusInternalServerError) - } else { - if _, err := w.Write([]byte(data)); err != nil { - log.Printf("unable to write answer with error: %v", err) - } - } -} - /* Expects a WebRTC SDP offer in the Request to give to an assigned snowflake proxy, which responds with the SDP answer to be sent in the HTTP response back to the client. */ -func clientOffers(ctx *BrokerContext, w http.ResponseWriter, r *http.Request) { - var err error - var version clientVersion - - startTime := time.Now() +func clientOffers(i *IPC, w http.ResponseWriter, r *http.Request) { body, err := ioutil.ReadAll(http.MaxBytesReader(w, r.Body, readLimit)) if err != nil { log.Printf("Error reading client request: %s", err.Error()) - w.WriteHeader(http.StatusInternalServerError) + w.WriteHeader(http.StatusBadRequest) return } - if len(body) > 0 && body[0] == '{' { - version = v0 - } else { - parts := bytes.SplitN(body, []byte("\n"), 2) - if len(parts) < 2 { - // no version number found - err := fmt.Errorf("unsupported message version") - sendClientResponse(&messages.ClientPollResponse{Error: err.Error()}, w) - return - } - body = parts[1] - if string(parts[0]) == "1.0" { - version = v1 - } else { - err := fmt.Errorf("unsupported message version") - sendClientResponse(&messages.ClientPollResponse{Error: err.Error()}, w) - return - } + arg := messages.Arg{ + Body: body, + RemoteAddr: "", + NatType: r.Header.Get("Snowflake-NAT-Type"), } - var offer *ClientOffer - switch version { - case v0: - offer = &ClientOffer{ - natType: r.Header.Get("Snowflake-NAT-Type"), - sdp: body, - } - case v1: - req, err := messages.DecodeClientPollRequest(body) - if err != nil { - sendClientResponse(&messages.ClientPollResponse{Error: err.Error()}, w) - return - } - offer = &ClientOffer{ - natType: req.NAT, - sdp: []byte(req.Offer), - } + var response []byte + err = i.ClientOffers(arg, &response) + switch { + case err == nil: + case errors.Is(err, messages.ErrUnavailable): + w.WriteHeader(http.StatusServiceUnavailable) + return + case errors.Is(err, messages.ErrTimeout): + w.WriteHeader(http.StatusGatewayTimeout) + return default: - panic("unknown version") - } - - // Only hand out known restricted snowflakes to unrestricted clients - var snowflakeHeap *SnowflakeHeap - if offer.natType == NATUnrestricted { - snowflakeHeap = ctx.restrictedSnowflakes - } else { - snowflakeHeap = ctx.snowflakes - } - - // Immediately fail if there are no snowflakes available. - ctx.snowflakeLock.Lock() - numSnowflakes := snowflakeHeap.Len() - ctx.snowflakeLock.Unlock() - if numSnowflakes <= 0 { - ctx.metrics.lock.Lock() - ctx.metrics.clientDeniedCount++ - ctx.metrics.promMetrics.ClientPollTotal.With(prometheus.Labels{"nat": offer.natType, "status": "denied"}).Inc() - if offer.natType == NATUnrestricted { - ctx.metrics.clientUnrestrictedDeniedCount++ - } else { - ctx.metrics.clientRestrictedDeniedCount++ - } - ctx.metrics.lock.Unlock() - switch version { - case v0: - w.WriteHeader(http.StatusServiceUnavailable) - case v1: - resp := &messages.ClientPollResponse{Error: "no snowflake proxies currently available"} - sendClientResponse(resp, w) - default: - panic("unknown version") - } + log.Println(err) + w.WriteHeader(http.StatusInternalServerError) return } - // Otherwise, find the most available snowflake proxy, and pass the offer to it. - // Delete must be deferred in order to correctly process answer request later. - ctx.snowflakeLock.Lock() - snowflake := heap.Pop(snowflakeHeap).(*Snowflake) - ctx.snowflakeLock.Unlock() - snowflake.offerChannel <- offer - - // Wait for the answer to be returned on the channel or timeout. - select { - case answer := <-snowflake.answerChannel: - ctx.metrics.lock.Lock() - ctx.metrics.clientProxyMatchCount++ - ctx.metrics.promMetrics.ClientPollTotal.With(prometheus.Labels{"nat": offer.natType, "status": "matched"}).Inc() - ctx.metrics.lock.Unlock() - switch version { - case v0: - if _, err := w.Write([]byte(answer)); err != nil { - log.Printf("unable to write answer with error: %v", err) - } - case v1: - resp := &messages.ClientPollResponse{Answer: answer} - sendClientResponse(resp, w) - default: - panic("unknown version") - } - // Initial tracking of elapsed time. - ctx.metrics.clientRoundtripEstimate = time.Since(startTime) / - time.Millisecond - case <-time.After(time.Second * ClientTimeout): - log.Println("Client: Timed out.") - switch version { - case v0: - w.WriteHeader(http.StatusGatewayTimeout) - if _, err := w.Write( - []byte("timed out waiting for answer!")); err != nil { - log.Printf("unable to write timeout error, failed with error: %v", - err) - } - case v1: - resp := &messages.ClientPollResponse{ - Error: "timed out waiting for answer!"} - sendClientResponse(resp, w) - default: - panic("unknown version") - } - } - ctx.snowflakeLock.Lock() - ctx.metrics.promMetrics.AvailableProxies.With(prometheus.Labels{"nat": snowflake.natType, "type": snowflake.proxyType}).Dec() - delete(ctx.idToSnowflake, snowflake.id) - ctx.snowflakeLock.Unlock() + if _, err := w.Write(response); err != nil { + log.Printf("clientOffers unable to write answer with error: %v", err) + } } /* @@ -421,82 +266,51 @@ Expects snowflake proxes which have previously successfully received an offer from proxyHandler to respond with an answer in an HTTP POST, which the broker will pass back to the original client. */ -func proxyAnswers(ctx *BrokerContext, w http.ResponseWriter, r *http.Request) { - +func proxyAnswers(i *IPC, w http.ResponseWriter, r *http.Request) { body, err := ioutil.ReadAll(http.MaxBytesReader(w, r.Body, readLimit)) - if nil != err || nil == body || len(body) <= 0 { + if err != nil { log.Println("Invalid data.") w.WriteHeader(http.StatusBadRequest) return } - answer, id, err := messages.DecodeAnswerRequest(body) - if err != nil || answer == "" { - w.WriteHeader(http.StatusBadRequest) - return + arg := messages.Arg{ + Body: body, + RemoteAddr: "", + NatType: "", } - var success = true - ctx.snowflakeLock.Lock() - snowflake, ok := ctx.idToSnowflake[id] - ctx.snowflakeLock.Unlock() - if !ok || nil == snowflake { - // The snowflake took too long to respond with an answer, so its client - // disappeared / the snowflake is no longer recognized by the Broker. - success = false - } - b, err := messages.EncodeAnswerResponse(success) - if err != nil { - log.Printf("Error encoding answer: %s", err.Error()) + var response []byte + err = i.ProxyAnswers(arg, &response) + switch { + case err == nil: + case errors.Is(err, messages.ErrBadRequest): + w.WriteHeader(http.StatusBadRequest) + return + case errors.Is(err, messages.ErrInternal): + fallthrough + default: + log.Println(err) w.WriteHeader(http.StatusInternalServerError) return } - w.Write(b) - if success { - snowflake.answerChannel <- answer + if _, err := w.Write(response); err != nil { + log.Printf("proxyAnswers unable to write answer response with error: %v", err) } - } -func debugHandler(ctx *BrokerContext, w http.ResponseWriter, r *http.Request) { - - var webexts, browsers, standalones, unknowns int - var natRestricted, natUnrestricted, natUnknown int - ctx.snowflakeLock.Lock() - s := fmt.Sprintf("current snowflakes available: %d\n", len(ctx.idToSnowflake)) - for _, snowflake := range ctx.idToSnowflake { - if snowflake.proxyType == "badge" { - browsers++ - } else if snowflake.proxyType == "webext" { - webexts++ - } else if snowflake.proxyType == "standalone" { - standalones++ - } else { - unknowns++ - } - - switch snowflake.natType { - case NATRestricted: - natRestricted++ - case NATUnrestricted: - natUnrestricted++ - default: - natUnknown++ - } +func debugHandler(i *IPC, w http.ResponseWriter, r *http.Request) { + var response string + err := i.Debug(new(interface{}), &response) + if err != nil { + log.Println(err) + w.WriteHeader(http.StatusInternalServerError) + return } - ctx.snowflakeLock.Unlock() - s += fmt.Sprintf("\tstandalone proxies: %d", standalones) - s += fmt.Sprintf("\n\tbrowser proxies: %d", browsers) - s += fmt.Sprintf("\n\twebext proxies: %d", webexts) - s += fmt.Sprintf("\n\tunknown proxies: %d", unknowns) - - s += fmt.Sprintf("\nNAT Types available:") - s += fmt.Sprintf("\n\trestricted: %d", natRestricted) - s += fmt.Sprintf("\n\tunrestricted: %d", natUnrestricted) - s += fmt.Sprintf("\n\tunknown: %d", natUnknown) - if _, err := w.Write([]byte(s)); err != nil { + + if _, err := w.Write([]byte(response)); err != nil { log.Printf("writing proxy information returned error: %v ", err) } } @@ -589,12 +403,14 @@ func main() { go ctx.Broker() + i := &IPC{ctx} + http.HandleFunc("/robots.txt", robotsTxtHandler) - http.Handle("/proxy", SnowflakeHandler{ctx, proxyPolls}) - http.Handle("/client", SnowflakeHandler{ctx, clientOffers}) - http.Handle("/answer", SnowflakeHandler{ctx, proxyAnswers}) - http.Handle("/debug", SnowflakeHandler{ctx, debugHandler}) + http.Handle("/proxy", SnowflakeHandler{i, proxyPolls}) + http.Handle("/client", SnowflakeHandler{i, clientOffers}) + http.Handle("/answer", SnowflakeHandler{i, proxyAnswers}) + http.Handle("/debug", SnowflakeHandler{i, debugHandler}) http.Handle("/metrics", MetricsHandler{metricsFilename, metricsHandler}) http.Handle("/prometheus", promhttp.HandlerFor(ctx.metrics.promMetrics.registry, promhttp.HandlerOpts{})) diff --git a/broker/ipc.go b/broker/ipc.go new file mode 100644 index 0000000..79ccf0f --- /dev/null +++ b/broker/ipc.go @@ -0,0 +1,293 @@ +package main + +import ( + "bytes" + "container/heap" + "fmt" + "log" + "net" + "time" + + "git.torproject.org/pluggable-transports/snowflake.git/common/messages" + "github.com/prometheus/client_golang/prometheus" +) + +const ( + ClientTimeout = 10 + ProxyTimeout = 10 + + NATUnknown = "unknown" + NATRestricted = "restricted" + NATUnrestricted = "unrestricted" +) + +// We support two client message formats. The legacy format is for backwards +// combatability and relies heavily on HTTP headers and status codes to convey +// information. +type clientVersion int + +const ( + v0 clientVersion = iota //legacy version + v1 +) + +type IPC struct { + ctx *BrokerContext +} + +func (i *IPC) Debug(_ interface{}, response *string) error { + var webexts, browsers, standalones, unknowns int + var natRestricted, natUnrestricted, natUnknown int + + i.ctx.snowflakeLock.Lock() + s := fmt.Sprintf("current snowflakes available: %d\n", len(i.ctx.idToSnowflake)) + for _, snowflake := range i.ctx.idToSnowflake { + if snowflake.proxyType == "badge" { + browsers++ + } else if snowflake.proxyType == "webext" { + webexts++ + } else if snowflake.proxyType == "standalone" { + standalones++ + } else { + unknowns++ + } + + switch snowflake.natType { + case NATRestricted: + natRestricted++ + case NATUnrestricted: + natUnrestricted++ + default: + natUnknown++ + } + + } + i.ctx.snowflakeLock.Unlock() + + s += fmt.Sprintf("\tstandalone proxies: %d", standalones) + s += fmt.Sprintf("\n\tbrowser proxies: %d", browsers) + s += fmt.Sprintf("\n\twebext proxies: %d", webexts) + s += fmt.Sprintf("\n\tunknown proxies: %d", unknowns) + + s += fmt.Sprintf("\nNAT Types available:") + s += fmt.Sprintf("\n\trestricted: %d", natRestricted) + s += fmt.Sprintf("\n\tunrestricted: %d", natUnrestricted) + s += fmt.Sprintf("\n\tunknown: %d", natUnknown) + + *response = s + return nil +} + +func (i *IPC) ProxyPolls(arg messages.Arg, response *[]byte) error { + sid, proxyType, natType, clients, err := messages.DecodePollRequest(arg.Body) + if err != nil { + return messages.ErrBadRequest + } + + // Log geoip stats + remoteIP, _, err := net.SplitHostPort(arg.RemoteAddr) + if err != nil { + log.Println("Error processing proxy IP: ", err.Error()) + } else { + i.ctx.metrics.lock.Lock() + i.ctx.metrics.UpdateCountryStats(remoteIP, proxyType, natType) + i.ctx.metrics.lock.Unlock() + } + + var b []byte + + // Wait for a client to avail an offer to the snowflake, or timeout if nil. + offer := i.ctx.RequestOffer(sid, proxyType, natType, clients) + + if offer == nil { + i.ctx.metrics.lock.Lock() + i.ctx.metrics.proxyIdleCount++ + i.ctx.metrics.promMetrics.ProxyPollTotal.With(prometheus.Labels{"nat": natType, "status": "idle"}).Inc() + i.ctx.metrics.lock.Unlock() + + b, err = messages.EncodePollResponse("", false, "") + if err != nil { + return messages.ErrInternal + } + + *response = b + return nil + } + + i.ctx.metrics.promMetrics.ProxyPollTotal.With(prometheus.Labels{"nat": natType, "status": "matched"}).Inc() + b, err = messages.EncodePollResponse(string(offer.sdp), true, offer.natType) + if err != nil { + return messages.ErrInternal + } + *response = b + + return nil +} + +func sendClientResponse(resp *messages.ClientPollResponse, response *[]byte) error { + data, err := resp.EncodePollResponse() + if err != nil { + log.Printf("error encoding answer") + return messages.ErrInternal + } else { + *response = []byte(data) + return nil + } +} + +func (i *IPC) ClientOffers(arg messages.Arg, response *[]byte) error { + var version clientVersion + + startTime := time.Now() + body := arg.Body + + if len(body) > 0 && body[0] == '{' { + version = v0 + } else { + parts := bytes.SplitN(body, []byte("\n"), 2) + if len(parts) < 2 { + // no version number found + err := fmt.Errorf("unsupported message version") + return sendClientResponse(&messages.ClientPollResponse{Error: err.Error()}, response) + } + body = parts[1] + if string(parts[0]) == "1.0" { + version = v1 + + } else { + err := fmt.Errorf("unsupported message version") + return sendClientResponse(&messages.ClientPollResponse{Error: err.Error()}, response) + } + } + + var offer *ClientOffer + switch version { + case v0: + offer = &ClientOffer{ + natType: arg.NatType, + sdp: body, + } + case v1: + req, err := messages.DecodeClientPollRequest(body) + if err != nil { + return sendClientResponse(&messages.ClientPollResponse{Error: err.Error()}, response) + } + offer = &ClientOffer{ + natType: req.NAT, + sdp: []byte(req.Offer), + } + default: + panic("unknown version") + } + + // Only hand out known restricted snowflakes to unrestricted clients + var snowflakeHeap *SnowflakeHeap + if offer.natType == NATUnrestricted { + snowflakeHeap = i.ctx.restrictedSnowflakes + } else { + snowflakeHeap = i.ctx.snowflakes + } + + // Immediately fail if there are no snowflakes available. + i.ctx.snowflakeLock.Lock() + numSnowflakes := snowflakeHeap.Len() + i.ctx.snowflakeLock.Unlock() + if numSnowflakes <= 0 { + i.ctx.metrics.lock.Lock() + i.ctx.metrics.clientDeniedCount++ + i.ctx.metrics.promMetrics.ClientPollTotal.With(prometheus.Labels{"nat": offer.natType, "status": "denied"}).Inc() + if offer.natType == NATUnrestricted { + i.ctx.metrics.clientUnrestrictedDeniedCount++ + } else { + i.ctx.metrics.clientRestrictedDeniedCount++ + } + i.ctx.metrics.lock.Unlock() + switch version { + case v0: + return messages.ErrUnavailable + case v1: + resp := &messages.ClientPollResponse{Error: "no snowflake proxies currently available"} + return sendClientResponse(resp, response) + default: + panic("unknown version") + } + } + + // Otherwise, find the most available snowflake proxy, and pass the offer to it. + // Delete must be deferred in order to correctly process answer request later. + i.ctx.snowflakeLock.Lock() + snowflake := heap.Pop(snowflakeHeap).(*Snowflake) + i.ctx.snowflakeLock.Unlock() + snowflake.offerChannel <- offer + + var err error + + // Wait for the answer to be returned on the channel or timeout. + select { + case answer := <-snowflake.answerChannel: + i.ctx.metrics.lock.Lock() + i.ctx.metrics.clientProxyMatchCount++ + i.ctx.metrics.promMetrics.ClientPollTotal.With(prometheus.Labels{"nat": offer.natType, "status": "matched"}).Inc() + i.ctx.metrics.lock.Unlock() + switch version { + case v0: + *response = []byte(answer) + case v1: + resp := &messages.ClientPollResponse{Answer: answer} + err = sendClientResponse(resp, response) + default: + panic("unknown version") + } + // Initial tracking of elapsed time. + i.ctx.metrics.clientRoundtripEstimate = time.Since(startTime) / time.Millisecond + case <-time.After(time.Second * ClientTimeout): + log.Println("Client: Timed out.") + switch version { + case v0: + err = messages.ErrTimeout + case v1: + resp := &messages.ClientPollResponse{ + Error: "timed out waiting for answer!"} + err = sendClientResponse(resp, response) + default: + panic("unknown version") + } + } + + i.ctx.snowflakeLock.Lock() + i.ctx.metrics.promMetrics.AvailableProxies.With(prometheus.Labels{"nat": snowflake.natType, "type": snowflake.proxyType}).Dec() + delete(i.ctx.idToSnowflake, snowflake.id) + i.ctx.snowflakeLock.Unlock() + + return err +} + +func (i *IPC) ProxyAnswers(arg messages.Arg, response *[]byte) error { + answer, id, err := messages.DecodeAnswerRequest(arg.Body) + if err != nil || answer == "" { + return messages.ErrBadRequest + } + + var success = true + i.ctx.snowflakeLock.Lock() + snowflake, ok := i.ctx.idToSnowflake[id] + i.ctx.snowflakeLock.Unlock() + if !ok || snowflake == nil { + // The snowflake took too long to respond with an answer, so its client + // disappeared / the snowflake is no longer recognized by the Broker. + success = false + } + + b, err := messages.EncodeAnswerResponse(success) + if err != nil { + log.Printf("Error encoding answer: %s", err.Error()) + return messages.ErrInternal + } + *response = b + + if success { + snowflake.answerChannel <- answer + } + + return nil +} diff --git a/broker/snowflake-broker_test.go b/broker/snowflake-broker_test.go index 825bc6f..77e62cf 100644 --- a/broker/snowflake-broker_test.go +++ b/broker/snowflake-broker_test.go @@ -28,6 +28,7 @@ func TestBroker(t *testing.T) { Convey("Context", t, func() { ctx := NewBrokerContext(NullLogger()) + i := &IPC{ctx} Convey("Adds Snowflake", func() { So(ctx.snowflakes.Len(), ShouldEqual, 0) @@ -76,7 +77,7 @@ func TestBroker(t *testing.T) { So(err, ShouldBeNil) Convey("with error when no snowflakes are available.", func() { - clientOffers(ctx, w, r) + clientOffers(i, w, r) So(w.Code, ShouldEqual, http.StatusOK) So(w.Body.String(), ShouldEqual, `{"error":"no snowflake proxies currently available"}`) }) @@ -86,7 +87,7 @@ func TestBroker(t *testing.T) { // Prepare a fake proxy to respond with. snowflake := ctx.AddSnowflake("fake", "", NATUnrestricted, 0) go func() { - clientOffers(ctx, w, r) + clientOffers(i, w, r) done <- true }() offer := <-snowflake.offerChannel @@ -104,7 +105,7 @@ func TestBroker(t *testing.T) { done := make(chan bool) snowflake := ctx.AddSnowflake("fake", "", NATUnrestricted, 0) go func() { - clientOffers(ctx, w, r) + clientOffers(i, w, r) // Takes a few seconds here... done <- true }() @@ -124,7 +125,7 @@ func TestBroker(t *testing.T) { r.Header.Set("Snowflake-NAT-TYPE", "restricted") Convey("with 503 when no snowflakes are available.", func() { - clientOffers(ctx, w, r) + clientOffers(i, w, r) So(w.Code, ShouldEqual, http.StatusServiceUnavailable) So(w.Body.String(), ShouldEqual, "") }) @@ -134,7 +135,7 @@ func TestBroker(t *testing.T) { // Prepare a fake proxy to respond with. snowflake := ctx.AddSnowflake("fake", "", NATUnrestricted, 0) go func() { - clientOffers(ctx, w, r) + clientOffers(i, w, r) done <- true }() offer := <-snowflake.offerChannel @@ -152,7 +153,7 @@ func TestBroker(t *testing.T) { done := make(chan bool) snowflake := ctx.AddSnowflake("fake", "", NATUnrestricted, 0) go func() { - clientOffers(ctx, w, r) + clientOffers(i, w, r) // Takes a few seconds here... done <- true }() @@ -173,7 +174,7 @@ func TestBroker(t *testing.T) { Convey("with a client offer if available.", func() { go func(ctx *BrokerContext) { - proxyPolls(ctx, w, r) + proxyPolls(i, w, r) done <- true }(ctx) // Pass a fake client offer to this proxy @@ -187,7 +188,7 @@ func TestBroker(t *testing.T) { Convey("return empty 200 OK when no client offer is available.", func() { go func(ctx *BrokerContext) { - proxyPolls(ctx, w, r) + proxyPolls(i, w, r) done <- true }(ctx) p := <-ctx.proxyPolls @@ -209,7 +210,7 @@ func TestBroker(t *testing.T) { r, err := http.NewRequest("POST", "snowflake.broker/answer", data) So(err, ShouldBeNil) go func(ctx *BrokerContext) { - proxyAnswers(ctx, w, r) + proxyAnswers(i, w, r) }(ctx) answer := <-s.answerChannel So(w.Code, ShouldEqual, http.StatusOK) @@ -220,7 +221,7 @@ func TestBroker(t *testing.T) { data = bytes.NewReader([]byte(`{"Version":"1.0","Sid":"invalid","Answer":"test"}`)) r, err := http.NewRequest("POST", "snowflake.broker/answer", data) So(err, ShouldBeNil) - proxyAnswers(ctx, w, r) + proxyAnswers(i, w, r) So(w.Code, ShouldEqual, http.StatusOK) b, err := ioutil.ReadAll(w.Body) So(err, ShouldBeNil) @@ -232,7 +233,7 @@ func TestBroker(t *testing.T) { data := bytes.NewReader(nil) r, err := http.NewRequest("POST", "snowflake.broker/answer", data) So(err, ShouldBeNil) - proxyAnswers(ctx, w, r) + proxyAnswers(i, w, r) So(w.Code, ShouldEqual, http.StatusBadRequest) }) @@ -240,7 +241,7 @@ func TestBroker(t *testing.T) { data := bytes.NewReader(make([]byte, 100001)) r, err := http.NewRequest("POST", "snowflake.broker/answer", data) So(err, ShouldBeNil) - proxyAnswers(ctx, w, r) + proxyAnswers(i, w, r) So(w.Code, ShouldEqual, http.StatusBadRequest) }) @@ -250,6 +251,7 @@ func TestBroker(t *testing.T) { Convey("End-To-End", t, func() { ctx := NewBrokerContext(NullLogger()) + i := &IPC{ctx} Convey("Check for client/proxy data race", func() { proxy_done := make(chan bool) @@ -264,7 +266,7 @@ func TestBroker(t *testing.T) { So(err, ShouldBeNil) go func(ctx *BrokerContext) { - proxyPolls(ctx, wp, rp) + proxyPolls(i, wp, rp) proxy_done <- true }(ctx) @@ -275,7 +277,7 @@ func TestBroker(t *testing.T) { So(err, ShouldBeNil) go func() { - clientOffers(ctx, wc, rc) + clientOffers(i, wc, rc) client_done <- true }() @@ -288,7 +290,7 @@ func TestBroker(t *testing.T) { rp, err = http.NewRequest("POST", "snowflake.broker/answer", datap) So(err, ShouldBeNil) go func(ctx *BrokerContext) { - proxyAnswers(ctx, wp, rp) + proxyAnswers(i, wp, rp) proxy_done <- true }(ctx) @@ -307,7 +309,7 @@ func TestBroker(t *testing.T) { rP, err := http.NewRequest("POST", "snowflake.broker/proxy", dataP) So(err, ShouldBeNil) go func() { - proxyPolls(ctx, wP, rP) + proxyPolls(i, wP, rP) polled <- true }() @@ -328,7 +330,7 @@ func TestBroker(t *testing.T) { rC, err := http.NewRequest("POST", "snowflake.broker/client", dataC) So(err, ShouldBeNil) go func() { - clientOffers(ctx, wC, rC) + clientOffers(i, wC, rC) done <- true }() @@ -341,7 +343,7 @@ func TestBroker(t *testing.T) { dataA := bytes.NewReader([]byte(`{"Version":"1.0","Sid":"ymbcCMto7KHNGYlp","Answer":"test"}`)) rA, err := http.NewRequest("POST", "snowflake.broker/answer", dataA) So(err, ShouldBeNil) - proxyAnswers(ctx, wA, rA) + proxyAnswers(i, wA, rA) So(wA.Code, ShouldEqual, http.StatusOK) <-done @@ -503,6 +505,7 @@ func TestMetrics(t *testing.T) { done := make(chan bool) buf := new(bytes.Buffer) ctx := NewBrokerContext(log.New(buf, "", 0)) + i := &IPC{ctx} err := ctx.metrics.LoadGeoipDatabases("test_geoip", "test_geoip6") So(err, ShouldEqual, nil) @@ -514,10 +517,10 @@ func TestMetrics(t *testing.T) { r, err := http.NewRequest("POST", "snowflake.broker/proxy", data) r.RemoteAddr = "129.97.208.23:8888" //CA geoip So(err, ShouldBeNil) - go func(ctx *BrokerContext) { - proxyPolls(ctx, w, r) + go func(i *IPC) { + proxyPolls(i, w, r) done <- true - }(ctx) + }(i) p := <-ctx.proxyPolls //manually unblock poll p.offerChannel <- nil <-done @@ -527,10 +530,10 @@ func TestMetrics(t *testing.T) { r, err = http.NewRequest("POST", "snowflake.broker/proxy", data) r.RemoteAddr = "129.97.208.23:8888" //CA geoip So(err, ShouldBeNil) - go func(ctx *BrokerContext) { - proxyPolls(ctx, w, r) + go func(i *IPC) { + proxyPolls(i, w, r) done <- true - }(ctx) + }(i) p = <-ctx.proxyPolls //manually unblock poll p.offerChannel <- nil <-done @@ -540,10 +543,10 @@ func TestMetrics(t *testing.T) { r, err = http.NewRequest("POST", "snowflake.broker/proxy", data) r.RemoteAddr = "129.97.208.23:8888" //CA geoip So(err, ShouldBeNil) - go func(ctx *BrokerContext) { - proxyPolls(ctx, w, r) + go func(i *IPC) { + proxyPolls(i, w, r) done <- true - }(ctx) + }(i) p = <-ctx.proxyPolls //manually unblock poll p.offerChannel <- nil <-done @@ -553,10 +556,10 @@ func TestMetrics(t *testing.T) { r, err = http.NewRequest("POST", "snowflake.broker/proxy", data) r.RemoteAddr = "129.97.208.23:8888" //CA geoip So(err, ShouldBeNil) - go func(ctx *BrokerContext) { - proxyPolls(ctx, w, r) + go func(i *IPC) { + proxyPolls(i, w, r) done <- true - }(ctx) + }(i) p = <-ctx.proxyPolls //manually unblock poll p.offerChannel <- nil <-done @@ -573,7 +576,7 @@ func TestMetrics(t *testing.T) { r, err := http.NewRequest("POST", "snowflake.broker/client", data) So(err, ShouldBeNil) - clientOffers(ctx, w, r) + clientOffers(i, w, r) ctx.metrics.printMetrics() So(buf.String(), ShouldContainSubstring, "client-denied-count 8\nclient-restricted-denied-count 8\nclient-unrestricted-denied-count 0\nclient-snowflake-match-count 0") @@ -595,7 +598,7 @@ func TestMetrics(t *testing.T) { // Prepare a fake proxy to respond with. snowflake := ctx.AddSnowflake("fake", "", NATUnrestricted, 0) go func() { - clientOffers(ctx, w, r) + clientOffers(i, w, r) done <- true }() offer := <-snowflake.offerChannel @@ -614,49 +617,49 @@ func TestMetrics(t *testing.T) { r, err := http.NewRequest("POST", "snowflake.broker/client", data) So(err, ShouldBeNil) - clientOffers(ctx, w, r) + clientOffers(i, w, r) w = httptest.NewRecorder() data = bytes.NewReader( []byte("1.0\n{\"offer\": \"fake\", \"nat\": \"restricted\"}")) r, err = http.NewRequest("POST", "snowflake.broker/client", data) So(err, ShouldBeNil) - clientOffers(ctx, w, r) + clientOffers(i, w, r) w = httptest.NewRecorder() data = bytes.NewReader( []byte("1.0\n{\"offer\": \"fake\", \"nat\": \"restricted\"}")) r, err = http.NewRequest("POST", "snowflake.broker/client", data) So(err, ShouldBeNil) - clientOffers(ctx, w, r) + clientOffers(i, w, r) w = httptest.NewRecorder() data = bytes.NewReader( []byte("1.0\n{\"offer\": \"fake\", \"nat\": \"restricted\"}")) r, err = http.NewRequest("POST", "snowflake.broker/client", data) So(err, ShouldBeNil) - clientOffers(ctx, w, r) + clientOffers(i, w, r) w = httptest.NewRecorder() data = bytes.NewReader( []byte("1.0\n{\"offer\": \"fake\", \"nat\": \"restricted\"}")) r, err = http.NewRequest("POST", "snowflake.broker/client", data) So(err, ShouldBeNil) - clientOffers(ctx, w, r) + clientOffers(i, w, r) w = httptest.NewRecorder() data = bytes.NewReader( []byte("1.0\n{\"offer\": \"fake\", \"nat\": \"restricted\"}")) r, err = http.NewRequest("POST", "snowflake.broker/client", data) So(err, ShouldBeNil) - clientOffers(ctx, w, r) + clientOffers(i, w, r) w = httptest.NewRecorder() data = bytes.NewReader( []byte("1.0\n{\"offer\": \"fake\", \"nat\": \"restricted\"}")) r, err = http.NewRequest("POST", "snowflake.broker/client", data) So(err, ShouldBeNil) - clientOffers(ctx, w, r) + clientOffers(i, w, r) w = httptest.NewRecorder() data = bytes.NewReader( []byte("1.0\n{\"offer\": \"fake\", \"nat\": \"restricted\"}")) r, err = http.NewRequest("POST", "snowflake.broker/client", data) So(err, ShouldBeNil) - clientOffers(ctx, w, r) + clientOffers(i, w, r) ctx.metrics.printMetrics() So(buf.String(), ShouldContainSubstring, "client-denied-count 8\nclient-restricted-denied-count 8\nclient-unrestricted-denied-count 0\n") @@ -666,7 +669,7 @@ func TestMetrics(t *testing.T) { []byte("1.0\n{\"offer\": \"fake\", \"nat\": \"restricted\"}")) r, err = http.NewRequest("POST", "snowflake.broker/client", data) So(err, ShouldBeNil) - clientOffers(ctx, w, r) + clientOffers(i, w, r) buf.Reset() ctx.metrics.printMetrics() So(buf.String(), ShouldContainSubstring, "client-denied-count 16\nclient-restricted-denied-count 16\nclient-unrestricted-denied-count 0\n") @@ -680,7 +683,7 @@ func TestMetrics(t *testing.T) { r.RemoteAddr = "129.97.208.23:8888" //CA geoip So(err, ShouldBeNil) go func(ctx *BrokerContext) { - proxyPolls(ctx, w, r) + proxyPolls(i, w, r) done <- true }(ctx) p := <-ctx.proxyPolls //manually unblock poll @@ -693,10 +696,10 @@ func TestMetrics(t *testing.T) { log.Printf("unable to get NewRequest with error: %v", err) } r.RemoteAddr = "129.97.208.23:8888" //CA geoip - go func(ctx *BrokerContext) { - proxyPolls(ctx, w, r) + go func(i *IPC) { + proxyPolls(i, w, r) done <- true - }(ctx) + }(i) p = <-ctx.proxyPolls //manually unblock poll p.offerChannel <- nil <-done @@ -711,10 +714,10 @@ func TestMetrics(t *testing.T) { r, err := http.NewRequest("POST", "snowflake.broker/proxy", data) r.RemoteAddr = "129.97.208.23:8888" //CA geoip So(err, ShouldBeNil) - go func(ctx *BrokerContext) { - proxyPolls(ctx, w, r) + go func(i *IPC) { + proxyPolls(i, w, r) done <- true - }(ctx) + }(i) p := <-ctx.proxyPolls //manually unblock poll p.offerChannel <- nil <-done @@ -728,10 +731,10 @@ func TestMetrics(t *testing.T) { log.Printf("unable to get NewRequest with error: %v", err) } r.RemoteAddr = "129.97.208.24:8888" //CA geoip - go func(ctx *BrokerContext) { - proxyPolls(ctx, w, r) + go func(i *IPC) { + proxyPolls(i, w, r) done <- true - }(ctx) + }(i) p = <-ctx.proxyPolls //manually unblock poll p.offerChannel <- nil <-done @@ -747,7 +750,7 @@ func TestMetrics(t *testing.T) { r, err := http.NewRequest("POST", "snowflake.broker/client", data) So(err, ShouldBeNil) - clientOffers(ctx, w, r) + clientOffers(i, w, r) ctx.metrics.printMetrics() So(buf.String(), ShouldContainSubstring, "client-denied-count 8\nclient-restricted-denied-count 8\nclient-unrestricted-denied-count 0\nclient-snowflake-match-count 0") @@ -760,7 +763,7 @@ func TestMetrics(t *testing.T) { r, err = http.NewRequest("POST", "snowflake.broker/client", data) So(err, ShouldBeNil) - clientOffers(ctx, w, r) + clientOffers(i, w, r) ctx.metrics.printMetrics() So(buf.String(), ShouldContainSubstring, "client-denied-count 8\nclient-restricted-denied-count 0\nclient-unrestricted-denied-count 8\nclient-snowflake-match-count 0") @@ -773,7 +776,7 @@ func TestMetrics(t *testing.T) { r, err = http.NewRequest("POST", "snowflake.broker/client", data) So(err, ShouldBeNil) - clientOffers(ctx, w, r) + clientOffers(i, w, r) ctx.metrics.printMetrics() So(buf.String(), ShouldContainSubstring, "client-denied-count 8\nclient-restricted-denied-count 8\nclient-unrestricted-denied-count 0\nclient-snowflake-match-count 0") diff --git a/common/messages/ipc.go b/common/messages/ipc.go new file mode 100644 index 0000000..3f89200 --- /dev/null +++ b/common/messages/ipc.go @@ -0,0 +1,18 @@ +package messages + +import ( + "errors" +) + +type Arg struct { + Body []byte + RemoteAddr string + NatType string +} + +var ( + ErrBadRequest = errors.New("bad request") + ErrInternal = errors.New("internal error") + ErrUnavailable = errors.New("service unavailable") + ErrTimeout = errors.New("timeout") +)

1 0

[snowflake/main] Use variables for string matching
by arlo＠torproject.org 08 Jul '21

08 Jul '21

commit c3c84fdb48ec27fe8fa5527693d18176df40637f Author: Arlo Breault <arlolra(a)gmail.com> Date: Thu Jul 8 12:47:23 2021 -0400 Use variables for string matching The legacy code does case matching on these exact strings so it's better to ensure they're constant. --- broker/http.go | 4 ++-- broker/ipc.go | 5 ++--- common/messages/ipc.go | 3 +++ 3 files changed, 7 insertions(+), 5 deletions(-) diff --git a/broker/http.go b/broker/http.go index 2c45b2b..e30e442 100644 --- a/broker/http.go +++ b/broker/http.go @@ -177,10 +177,10 @@ func clientOffers(i *IPC, w http.ResponseWriter, r *http.Request) { switch resp.Error { case "": response = []byte(resp.Answer) - case "no snowflake proxies currently available": + case messages.StrNoProxies: w.WriteHeader(http.StatusServiceUnavailable) return - case "timed out waiting for answer!": + case messages.StrTimedOut: w.WriteHeader(http.StatusGatewayTimeout) return default: diff --git a/broker/ipc.go b/broker/ipc.go index a05f560..7ab27af 100644 --- a/broker/ipc.go +++ b/broker/ipc.go @@ -190,7 +190,7 @@ func (i *IPC) ClientOffers(arg messages.Arg, response *[]byte) error { i.ctx.metrics.lock.Unlock() switch version { case v1: - resp := &messages.ClientPollResponse{Error: "no snowflake proxies currently available"} + resp := &messages.ClientPollResponse{Error: messages.StrNoProxies} return sendClientResponse(resp, response) default: panic("unknown version") @@ -226,8 +226,7 @@ func (i *IPC) ClientOffers(arg messages.Arg, response *[]byte) error { log.Println("Client: Timed out.") switch version { case v1: - resp := &messages.ClientPollResponse{ - Error: "timed out waiting for answer!"} + resp := &messages.ClientPollResponse{Error: messages.StrTimedOut} err = sendClientResponse(resp, response) default: panic("unknown version") diff --git a/common/messages/ipc.go b/common/messages/ipc.go index ee29a57..13e096f 100644 --- a/common/messages/ipc.go +++ b/common/messages/ipc.go @@ -12,4 +12,7 @@ type Arg struct { var ( ErrBadRequest = errors.New("bad request") ErrInternal = errors.New("internal error") + + StrTimedOut = "timed out waiting for answer!" + StrNoProxies = "no snowflake proxies currently available" )

1 0

[snowflake/main] Remove and restore some comments, after review
by arlo＠torproject.org 08 Jul '21

08 Jul '21

commit 2c2f93c022c64ad45f5d471b692eb6317b50d209 Author: Arlo Breault <arlolra(a)gmail.com> Date: Thu Jul 8 15:35:04 2021 -0400 Remove and restore some comments, after review --- broker/http.go | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/broker/http.go b/broker/http.go index e30e442..9ae2560 100644 --- a/broker/http.go +++ b/broker/http.go @@ -138,6 +138,10 @@ func clientOffers(i *IPC, w http.ResponseWriter, r *http.Request) { } // Handle the legacy version + // + // We support two client message formats. The legacy format is for backwards + // combatability and relies heavily on HTTP headers and status codes to convey + // information. isLegacy := false if len(body) > 0 && body[0] == '{' { isLegacy = true @@ -161,7 +165,6 @@ func clientOffers(i *IPC, w http.ResponseWriter, r *http.Request) { var response []byte err = i.ClientOffers(arg, &response) if err != nil { - // Assert err == messages.ErrInternal log.Println(err) w.WriteHeader(http.StatusInternalServerError) return

1 0

[Git][tpo/applications/fenix][tor-browser-90.0.0b6-11.0-1] squash! Modify UI/UX
by Matthew Finkel (＠sysrqb) 08 Jul '21

08 Jul '21

Matthew Finkel pushed to branch tor-browser-90.0.0b6-11.0-1 at The Tor Project / Applications / fenix Commits: f4b8b92d by Matthew Finkel at 2021-07-08T17:43:36+00:00 squash! Modify UI/UX Bug 40172: Find the Quit button - - - - - 2 changed files: - app/src/main/java/org/mozilla/fenix/components/toolbar/DefaultToolbarMenu.kt - app/src/main/java/org/mozilla/fenix/home/HomeMenu.kt Changes: ===================================== app/src/main/java/org/mozilla/fenix/components/toolbar/DefaultToolbarMenu.kt ===================================== @@ -73,7 +73,6 @@ open class DefaultToolbarMenu( private var isCurrentUrlBookmarked = false private var isBookmarkedJob: Job? = null - private val shouldDeleteDataOnQuit = context.settings().shouldDeleteBrowsingDataOnQuit private val shouldUseBottomToolbar = context.settings().shouldUseBottomToolbar private val accountManager = FenixAccountManager(context) @@ -578,7 +577,7 @@ open class DefaultToolbarMenu( //saveToCollectionItem, BrowserMenuDivider(), settingsItem, - if (shouldDeleteDataOnQuit) deleteDataOnQuit else null, + deleteDataOnQuit, if (shouldUseBottomToolbar) BrowserMenuDivider() else null, if (shouldUseBottomToolbar) menuToolbar else null ) ===================================== app/src/main/java/org/mozilla/fenix/home/HomeMenu.kt ===================================== @@ -229,7 +229,7 @@ class HomeMenu( @Suppress("ComplexMethod") private fun newCoreMenuItems(): List<BrowserMenuItem> { // val experiments = context.components.analytics.experiments - val settings = context.components.settings + // val settings = context.components.settings val bookmarksItem = BrowserMenuImageText( context.getString(R.string.library_bookmarks), @@ -316,7 +316,7 @@ class HomeMenu( whatsNewItem, helpItem, settingsItem, - if (settings.shouldDeleteBrowsingDataOnQuit) quitItem else null + quitItem ).also { items -> items.getHighlight()?.let { onHighlightPresent(it) } } View it on GitLab: https://gitlab.torproject.org/tpo/applications/fenix/-/commit/f4b8b92d6c219… -- View it on GitLab: https://gitlab.torproject.org/tpo/applications/fenix/-/commit/f4b8b92d6c219… You're receiving this email because of your account on gitlab.torproject.org.

1 0

[tor/main] Update torrc to encourage use of BridgeDistribution
by nickm＠torproject.org 08 Jul '21

08 Jul '21

commit 16e517245b764fa3a68e5ba398064ba28ddd4ac0 Author: Cecylia Bocovich <cohosh(a)torproject.org> Date: Tue Jul 6 13:09:24 2021 -0400 Update torrc to encourage use of BridgeDistribution Bridge operators should generally publish their descriptors except for rare cases, and instead use the BridgeDistribution none setting to prevent their bridge from being distributed by BridgeDB. --- src/config/torrc.minimal.in-staging | 2 +- src/config/torrc.sample.in | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/config/torrc.minimal.in-staging b/src/config/torrc.minimal.in-staging index 7f43cd324e..667ab294b4 100644 --- a/src/config/torrc.minimal.in-staging +++ b/src/config/torrc.minimal.in-staging @@ -224,4 +224,4 @@ ## mechanisms like https://bridges.torproject.org/. If you want to run ## a private bridge, for example because you'll give out your bridge ## address manually to your friends, uncomment this line: -#PublishServerDescriptor 0 +#BridgeDistribution none diff --git a/src/config/torrc.sample.in b/src/config/torrc.sample.in index 5d593871dd..edc30d043c 100644 --- a/src/config/torrc.sample.in +++ b/src/config/torrc.sample.in @@ -239,7 +239,7 @@ ## mechanisms like https://bridges.torproject.org/. If you want to run ## a private bridge, for example because you'll give out your bridge ## address manually to your friends, uncomment this line: -#PublishServerDescriptor 0 +#BridgeDistribution none ## Configuration options can be imported from files or folders using the %include ## option with the value being a path. This path can have wildcards. Wildcards are

1 0

[tor/main] Merge remote-tracking branch 'tor-gitlab/mr/410'
by nickm＠torproject.org 08 Jul '21

08 Jul '21

commit 9b2d179d9537b2f3e3275d22f014cf7385349553 Merge: b9f6eb68d9 16e517245b Author: Nick Mathewson <nickm(a)torproject.org> Date: Thu Jul 8 14:17:54 2021 -0400 Merge remote-tracking branch 'tor-gitlab/mr/410' src/config/torrc.minimal.in-staging | 2 +- src/config/torrc.sample.in | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)

1 0

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

tor-commits July 2021