GitLab

at 2026-08-19T19:37:53+02:00

fixup! TB 44806: Implement the tor integration in Rust.

TB 44930: Implement the commands on the Rust control port

Add a way to add a handler for when connections are closed.

     } else {

       throw new Error("Unknown server protocol");

     }

-    const receiver = {

-      onAsyncMessage: message => this.onAsyncMessage(message),

-    };

-    this.#controlPort.start(receiver);

+    this.#controlPort.start(this);

   }

   sendCommand(command) {

   onAsyncMessage(_message) {

     Assert.ok(false, "This test does not use async notifications.");

   }

+

+  onClosed() {}

 }
 class ControlPortClientAsyncNotification extends ControlPortClient {

   notificationPromise;

   #resolve;

+  closedPromise;

+  #closedResolve;

   constructor(server) {

     super(server);

-    const { promise, resolve } = Promise.withResolvers();

-    this.notificationPromise = promise;

-    this.#resolve = resolve;

+    this.notificationPromise = new Promise(

+      resolve => (this.#resolve = resolve)

+    );

+    this.closedPromise = new Promise(

+      resolve => (this.#closedResolve = resolve)

+    );

   }

   onAsyncMessage(message) {

     Assert.equal(message, "650-Test\r\n650 notification");

     this.#resolve();

   }

+

+  onClosed() {

+    this.#closedResolve();

+  }

 }

 add_task(async function test_asyncNotification() {

     await cp.notificationPromise;

     cp.close();

     server.close();

+    await cp.closedPromise;

   });

 });

 [scriptable, uuid(4b250614-968a-412f-9191-9ffd9d4bd001)]

 interface torITorControlPortReceiver : nsISupports {

   void onAsyncMessage(in ACString message);

+  void onClosed();

 };

 [scriptable, uuid(1389d157-4695-43a2-a7d8-538aaa350766)]

 use bytes::Bytes;

 use std::{

-    cell::Cell,

+    cell::{Cell, RefCell},

     rc::{Rc, Weak},

 };

     socket: Rc<dyn ControlSocket>,

     writer: Rc<CommandWriter>,

     message_pump: Rc<MessagePump>,

+    close_handler: RefCell<Option<Box<dyn FnOnce()>>>,

     closed: Cell<bool>,

 }

                 Self::make_data_cb(weak_self.clone()),

                 Self::make_async_failure_cb(weak_self.clone()),

             ),

+            close_handler: RefCell::new(None),

             closed: Cell::new(false),

         });

         cp.message_pump.start().inspect_err(|_| {

         }

         self.reply_dispatcher.fail_all(ReplyError::ConnectionClosed);

         self.reply_dispatcher.set_async_handler(None);

-        self.socket.close()

+        let res = self.socket.close();

+        let handler = self.close_handler.borrow_mut().take();

+        if let Some(h) = handler {

+            h();

+        }

+        res

+    }

+

+    fn set_close_handler(&self, cb: Box<dyn FnOnce()>) {

+        if self.closed.get() {

+            // This should never happen in reality, but let's just call the

+            // callback if it does to make sure the callback is always called.

+            cb();

+            return;

+        }

+        *self.close_handler.borrow_mut() = Some(cb);

     }

 }

     pub fn close(&self) -> Result<(), ControlSocketError> {

         self.0.close()

     }

+

+    #[inline]

+    pub fn set_close_handler(&self, cb: Box<dyn FnOnce()>) {

+        self.0.set_close_handler(cb);

+    }

 }
     xpcom_method!(start => Start(receiver: *const torITorControlPortReceiver));

     pub fn start(&self, receiver: &torITorControlPortReceiver) -> Result<(), nsresult> {

         let receiver = RefPtr::new(receiver);

+        let receiver2 = receiver.clone();

         self.control_port

             .set_async_handler(Some(Box::new(move |reply| {

                 let mut buf = Vec::new();

                 // pass nsCStrings created in Rust to C++.

                 unsafe { receiver.OnAsyncMessage(&*as_str) };

             })));

+        self.control_port.set_close_handler(Box::new(move || {

+            // Safety: call to an XPCOM method of our interface that we crafted

+            // to make sure it was exposed on Rust bindings.

+            unsafe { receiver2.OnClosed() };

+        }));

         Ok(())

     }

         onAsyncMessage(message) {

           self.#handleNotification(message);

         },

+        onClosed() {

+          self.onClosed();

+        },

       };

       this.#socket.start(receiver);

       return;

...	...	@@ -190,10 +190,7 @@ class ControlPortClient {
190	190	} else {
191	191	throw new Error("Unknown server protocol");
192	192	}
193		- const receiver = {
194		- onAsyncMessage: message => this.onAsyncMessage(message),
195		- };
196		- this.#controlPort.start(receiver);
	193	+ this.#controlPort.start(this);
197	194	}
198	195
199	196	sendCommand(command) {
...	...	@@ -216,4 +213,6 @@ class ControlPortClient {
216	213	onAsyncMessage(_message) {
217	214	Assert.ok(false, "This test does not use async notifications.");
218	215	}
	216	+
	217	+ onClosed() {}
219	218	}

Pier Angelo Vendrame pushed to branch tor-browser-153.1.0esr-16.0-1 at The Tor Project / Applications / Tor Browser

Commits:

6 changed files:

Changes: