rework RequestSipEvent

FLEXISIP-387

• RequestSipEvent is not shared but move from a module to another
• transactions are owned by RequestSipEvent (fix premature destruction transaction because nobody keeps it)
• ResponseSipEvent is not shared but move from a module to another and then returns to caller for logging

include/flexisip/auth/flexisip-auth-status.hh

 /*
     Flexisip, a flexible SIP proxy server with media capabilities.
-    Copyright (C) 2010-2022 Belledonne Communications SARL, All rights reserved.
+    Copyright (C) 2010-2024 Belledonne Communications SARL, All rights reserved.
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU Affero General Public License as
@@ -33,21 +33,27 @@ namespace flexisip {
  */
 class FlexisipAuthStatus : public AuthStatus {
 public:
-	FlexisipAuthStatus(const std::shared_ptr<RequestSipEvent>& ev) : AuthStatus(), mEvent(ev) {
+	FlexisipAuthStatus(const std::shared_ptr<MsgSip>& msgSip) : AuthStatus(), mMsgSip(msgSip) {
 	}
 
 	/**
 	 * Request that has been used while construction.
 	 */
-	const std::shared_ptr<RequestSipEvent> &event() const {return mEvent;}
+	const std::shared_ptr<MsgSip>& getMsgSip() const {
+		return mMsgSip;
+	}
 
 	/**
 	 * This property is to be set by the user of FlexisipAuthModule
 	 * before calling verify(). If true, the module will not return 403
 	 * status code on authentication denied but will submit a new challenge.
 	 */
-	bool no403() const {return mNo403;}
-	void no403(bool no403) {mNo403 = no403;}
+	bool no403() const {
+		return mNo403;
+	}
+	void no403(bool no403) {
+		mNo403 = no403;
+	}
 
 	/**
 	 * This property is set by FlexisipAuthModule and can
@@ -55,8 +61,12 @@ public:
 	 * A 'true' value means that the module has already tried to fetch
 	 * the password from database and has succeeded.
 	 */
-	bool passwordFound() const {return mPasswordFound;}
-	void passwordFound(bool val) {mPasswordFound = val;}
+	bool passwordFound() const {
+		return mPasswordFound;
+	}
+	void passwordFound(bool val) {
+		mPasswordFound = val;
+	}
 
 	/**
 	 * List of digest algorithms to use for authentication. If there
@@ -67,13 +77,15 @@ public:
 	 * This property must be set before calling verify() and must
 	 * contain one element at least.
 	 */
-	std::list<std::string> &usedAlgo() {return mAlgoUsed;}
+	std::list<std::string>& usedAlgo() {
+		return mAlgoUsed;
+	}
 
 private:
-	std::shared_ptr<RequestSipEvent> mEvent;
+	std::shared_ptr<MsgSip> mMsgSip;
 	std::list<std::string> mAlgoUsed;
 	bool mNo403 = false;
 	bool mPasswordFound = false;
 };
 
-}
+} // namespace flexisip

include/flexisip/dos/module-dos.hh

@@ -53,8 +53,10 @@ private:
 
 	void onLoad(const GenericStruct* mc) override;
 	void onUnload() override;
-	void onRequest(std::shared_ptr<RequestSipEvent>& ev) override;
-	void onResponse(std::shared_ptr<ResponseSipEvent>&) override{};
+	std::unique_ptr<RequestSipEvent> onRequest(std::unique_ptr<RequestSipEvent>&& ev) override;
+	std::unique_ptr<ResponseSipEvent> onResponse(std::unique_ptr<ResponseSipEvent>&& ev) override {
+		return std::move(ev);
+	}
 	void onIdle() override;
 
 	bool isValidNextConfig(const ConfigValue& value) override;

include/flexisip/fork-context/fork-context.hh

 /*
     Flexisip, a flexible SIP proxy server with media capabilities.
-    Copyright (C) 2010-2023 Belledonne Communications SARL, All rights reserved.
+    Copyright (C) 2010-2024 Belledonne Communications SARL, All rights reserved.
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU Affero General Public License as
@@ -62,16 +62,16 @@ public:
 	static void setFork(const std::shared_ptr<IncomingTransaction>& tr, const std::shared_ptr<ForkContext>& fork);
 
 	// Called by the router module to notify a cancellation.
-	static void processCancel(const std::shared_ptr<RequestSipEvent>& ev);
+	static void processCancel(const RequestSipEvent& ev);
 	// called by the router module to notify the arrival of a response.
-	static bool processResponse(const std::shared_ptr<ResponseSipEvent>& ev);
+	static bool processResponse(ResponseSipEvent& ev);
 
 	bool isEqual(const std::shared_ptr<ForkContext>& other) const {
 		return getPtrForEquality() == other->getPtrForEquality();
 	}
 
 	// Called by the Router module to create a new branch.
-	virtual std::shared_ptr<BranchInfo> addBranch(const std::shared_ptr<RequestSipEvent>& ev,
+	virtual std::shared_ptr<BranchInfo> addBranch(std::unique_ptr<RequestSipEvent>&& ev,
 	                                              const std::shared_ptr<ExtendedContact>& contact) = 0;
 	virtual bool allCurrentBranchesAnswered(FinalStatusMode finalStatusMode) const = 0;
 	// Request if the fork has other branches with lower priorities to try
@@ -99,10 +99,10 @@ public:
 	virtual void
 	onNewRegister(const SipUri& dest, const std::string& uid, const std::shared_ptr<ExtendedContact>& newContact) = 0;
 	// Notifies the cancellation of the fork process.
-	virtual void onCancel(const std::shared_ptr<RequestSipEvent>& ev) = 0;
+	virtual void onCancel(const sofiasip::MsgSip& ms) = 0;
 	// Notifies the arrival of a new response on a given branch
-	virtual void onResponse(const std::shared_ptr<BranchInfo>& br, const std::shared_ptr<ResponseSipEvent>& event) = 0;
-	virtual const std::shared_ptr<RequestSipEvent>& getEvent() = 0;
+	virtual void onResponse(const std::shared_ptr<BranchInfo>& br, ResponseSipEvent& event) = 0;
+	virtual RequestSipEvent& getEvent() = 0;
 	virtual const std::shared_ptr<ForkContextConfig>& getConfig() const = 0;
 	virtual bool isFinished() const = 0;
 	/**

include/flexisip/sofia-wrapper/auth-status.hh

 /*
     Flexisip, a flexible SIP proxy server with media capabilities.
-    Copyright (C) 2010-2022 Belledonne Communications SARL, All rights reserved.
+    Copyright (C) 2010-2024 Belledonne Communications SARL, All rights reserved.
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU Affero General Public License as
@@ -22,6 +22,7 @@
 #include <string>
 
 #include <sofia-sip/auth_module.h>
+#include <utils/stl-backports.hh>
 
 namespace flexisip {
 
@@ -36,9 +37,10 @@ namespace flexisip {
  * @see See http://sofia-sip.sourceforge.net/refdocs/iptsec/structauth__status__t.html
  * for more documentation.
  */
+class RequestSipEvent;
 class AuthStatus {
 public:
-	using ResponseCb = std::function<void(AuthStatus& as)>;
+	using ResponseCb = flexisip::stl_backports::move_only_function<std::unique_ptr<RequestSipEvent>(AuthStatus& as)>;
 
 	AuthStatus() {
 		su_home_init(&mHome);
@@ -89,8 +91,8 @@ public:
 	const ResponseCb& callback() const {
 		return mResponseCb;
 	}
-	void callback(const ResponseCb& cb) {
-		mResponseCb = cb;
+	void callback(ResponseCb&& cb) {
+		mResponseCb = std::move(cb);
 	}
 
 	const char* display() const {

include/flexisip/event.hh

@@ -164,10 +164,10 @@ public:
 	RequestSipEvent(std::shared_ptr<IncomingAgent> incomingAgent,
 	                const std::shared_ptr<MsgSip>& msgSip,
 	                tport_t* tport = NULL);
-	RequestSipEvent(const std::shared_ptr<RequestSipEvent>& sipEvent);
+	RequestSipEvent(const RequestSipEvent& sipEvent);
 
 	// Sip event extends enable_shared_from_this and constructor should be private.
-	static std::shared_ptr<RequestSipEvent> makeRestored(std::shared_ptr<IncomingAgent> incomingAgent,
+	static std::unique_ptr<RequestSipEvent> makeRestored(std::shared_ptr<IncomingAgent> incomingAgent,
 	                                                     const std::shared_ptr<MsgSip>& msgSip,
 	                                                     const std::weak_ptr<Module>& currModule);
 
@@ -242,6 +242,8 @@ private:
 	void linkTransactions();
 
 	AuthResult mAuthResult{};
+	// keep ownership of transactions
+	std::shared_ptr<IncomingTransaction> mIncomingTransactionOwner;
 	std::shared_ptr<OutgoingTransaction> mOutgoingTransactionOwner;
 };
 
@@ -250,15 +252,15 @@ public:
 	ResponseSipEvent(std::shared_ptr<OutgoingAgent> outgoingAgent,
 	                 const std::shared_ptr<MsgSip>& msgSip,
 	                 tport_t* tport = NULL);
-	ResponseSipEvent(const std::shared_ptr<ResponseSipEvent>& sipEvent);
+	ResponseSipEvent(const ResponseSipEvent& sipEvent);
 
-	virtual void send(const std::shared_ptr<MsgSip>& msg,
-	                  url_string_t const* u = NULL,
-	                  tag_type_t tag = 0,
-	                  tag_value_t value = 0,
-	                  ...);
+	void send(const std::shared_ptr<MsgSip>& msg,
+	          url_string_t const* u = NULL,
+	          tag_type_t tag = 0,
+	          tag_value_t value = 0,
+	          ...) override;
 
-	virtual void setOutgoingAgent(const std::shared_ptr<OutgoingAgent>& agent);
+	void setOutgoingAgent(const std::shared_ptr<OutgoingAgent>& agent) override;
 
 	~ResponseSipEvent();