Fixed CORE-6412: Firebird is freezing when trying to manage users via triggers

AlexPeshkoff · AlexPeshkoff · commit 0cfdd3de2ca0 · 2020-10-14T19:30:28.000+03:00
diff --git a/src/auth/SecureRemotePassword/manage/SrpManagement.cpp b/src/auth/SecureRemotePassword/manage/SrpManagement.cpp
diff --git a/src/common/classes/auto.h b/src/common/classes/auto.h
@@ -188,6 +188,16 @@ class AutoDispose : public AutoPtr<Where, SimpleDispose>
 };
 
 
+template <typename Where>
+class AutoRelease : public AutoPtr<Where, SimpleRelease>
+{
+public:
+	AutoRelease(Where* v = nullptr)
+		: AutoPtr<Where, SimpleRelease>(v)
+	{ }
+};
+
+
 template <typename T>
 class AutoSetRestore
 {
diff --git a/src/include/firebird/FirebirdInterface.idl b/src/include/firebird/FirebirdInterface.idl
@@ -797,6 +797,10 @@ interface LogonInfo : Versioned
 	const string networkProtocol();
 	const string remoteAddress();
 	const uchar* authBlock(uint* length);
+
+version:
+	Attachment attachment(Status status);
+	Transaction transaction(Status status);
 }
 
 interface Management : PluginBase
diff --git a/src/include/firebird/IdlFbInterfaces.h b/src/include/firebird/IdlFbInterfaces.h
@@ -3162,6 +3162,8 @@ namespace Firebird
 			const char* (CLOOP_CARG *networkProtocol)(ILogonInfo* self) throw();
 			const char* (CLOOP_CARG *remoteAddress)(ILogonInfo* self) throw();
 			const unsigned char* (CLOOP_CARG *authBlock)(ILogonInfo* self, unsigned* length) throw();
+			IAttachment* (CLOOP_CARG *attachment)(ILogonInfo* self, IStatus* status) throw();
+			ITransaction* (CLOOP_CARG *transaction)(ILogonInfo* self, IStatus* status) throw();
 		};
 
 	protected:
@@ -3175,7 +3177,7 @@ namespace Firebird
 		}
 
 	public:
-		static const unsigned VERSION = 2;
+		static const unsigned VERSION = 3;
 
 		const char* name()
 		{
@@ -3206,6 +3208,34 @@ namespace Firebird
 			const unsigned char* ret = static_cast<VTable*>(this->cloopVTable)->authBlock(this, length);
 			return ret;
 		}
+
+		template <typename StatusType> IAttachment* attachment(StatusType* status)
+		{
+			if (cloopVTable->version < 3)
+			{
+				StatusType::setVersionError(status, "ILogonInfo", cloopVTable->version, 3);
+				StatusType::checkException(status);
+				return 0;
+			}
+			StatusType::clearException(status);
+			IAttachment* ret = static_cast<VTable*>(this->cloopVTable)->attachment(this, status);
+			StatusType::checkException(status);
+			return ret;
+		}
+
+		template <typename StatusType> ITransaction* transaction(StatusType* status)
+		{
+			if (cloopVTable->version < 3)
+			{
+				StatusType::setVersionError(status, "ILogonInfo", cloopVTable->version, 3);
+				StatusType::checkException(status);
+				return 0;
+			}
+			StatusType::clearException(status);
+			ITransaction* ret = static_cast<VTable*>(this->cloopVTable)->transaction(this, status);
+			StatusType::checkException(status);
+			return ret;
+		}
 	};
 
 	class IManagement : public IPluginBase
@@ -12559,6 +12589,8 @@ namespace Firebird
 					this->networkProtocol = &Name::cloopnetworkProtocolDispatcher;
 					this->remoteAddress = &Name::cloopremoteAddressDispatcher;
 					this->authBlock = &Name::cloopauthBlockDispatcher;
+					this->attachment = &Name::cloopattachmentDispatcher;
+					this->transaction = &Name::clooptransactionDispatcher;
 				}
 			} vTable;
 
@@ -12629,6 +12661,36 @@ namespace Firebird
 				return static_cast<const unsigned char*>(0);
 			}
 		}
+
+		static IAttachment* CLOOP_CARG cloopattachmentDispatcher(ILogonInfo* self, IStatus* status) throw()
+		{
+			StatusType status2(status);
+
+			try
+			{
+				return static_cast<Name*>(self)->Name::attachment(&status2);
+			}
+			catch (...)
+			{
+				StatusType::catchException(&status2);
+				return static_cast<IAttachment*>(0);
+			}
+		}
+
+		static ITransaction* CLOOP_CARG clooptransactionDispatcher(ILogonInfo* self, IStatus* status) throw()
+		{
+			StatusType status2(status);
+
+			try
+			{
+				return static_cast<Name*>(self)->Name::transaction(&status2);
+			}
+			catch (...)
+			{
+				StatusType::catchException(&status2);
+				return static_cast<ITransaction*>(0);
+			}
+		}
 	};
 
 	template <typename Name, typename StatusType, typename Base = IVersionedImpl<Name, StatusType, Inherit<ILogonInfo> > >
@@ -12649,6 +12711,8 @@ namespace Firebird
 		virtual const char* networkProtocol() = 0;
 		virtual const char* remoteAddress() = 0;
 		virtual const unsigned char* authBlock(unsigned* length) = 0;
+		virtual IAttachment* attachment(StatusType* status) = 0;
+		virtual ITransaction* transaction(StatusType* status) = 0;
 	};
 
 	template <typename Name, typename StatusType, typename Base>
diff --git a/src/include/gen/Firebird.pas b/src/include/gen/Firebird.pas
@@ -447,6 +447,8 @@ 	ISC_TIMESTAMP_TZ_EX = record
 	ILogonInfo_networkProtocolPtr = function(this: ILogonInfo): PAnsiChar; cdecl;
 	ILogonInfo_remoteAddressPtr = function(this: ILogonInfo): PAnsiChar; cdecl;
 	ILogonInfo_authBlockPtr = function(this: ILogonInfo; length: CardinalPtr): BytePtr; cdecl;
+	ILogonInfo_attachmentPtr = function(this: ILogonInfo; status: IStatus): IAttachment; cdecl;
+	ILogonInfo_transactionPtr = function(this: ILogonInfo; status: IStatus): ITransaction; cdecl;
 	IManagement_startPtr = procedure(this: IManagement; status: IStatus; logonInfo: ILogonInfo); cdecl;
 	IManagement_executePtr = function(this: IManagement; status: IStatus; user: IUser; callback: IListUsers): Integer; cdecl;
 	IManagement_commitPtr = procedure(this: IManagement; status: IStatus); cdecl;
@@ -2127,16 +2129,20 @@ 	LogonInfoVTable = class(VersionedVTable)
 		networkProtocol: ILogonInfo_networkProtocolPtr;
 		remoteAddress: ILogonInfo_remoteAddressPtr;
 		authBlock: ILogonInfo_authBlockPtr;
+		attachment: ILogonInfo_attachmentPtr;
+		transaction: ILogonInfo_transactionPtr;
 	end;
 
 	ILogonInfo = class(IVersioned)
-		const VERSION = 2;
+		const VERSION = 3;
 
 		function name(): PAnsiChar;
 		function role(): PAnsiChar;
 		function networkProtocol(): PAnsiChar;
 		function remoteAddress(): PAnsiChar;
 		function authBlock(length: CardinalPtr): BytePtr;
+		function attachment(status: IStatus): IAttachment;
+		function transaction(status: IStatus): ITransaction;
 	end;
 
 	ILogonInfoImpl = class(ILogonInfo)
@@ -2147,6 +2153,8 @@ 	ILogonInfoImpl = class(ILogonInfo)
 		function networkProtocol(): PAnsiChar; virtual; abstract;
 		function remoteAddress(): PAnsiChar; virtual; abstract;
 		function authBlock(length: CardinalPtr): BytePtr; virtual; abstract;
+		function attachment(status: IStatus): IAttachment; virtual; abstract;
+		function transaction(status: IStatus): ITransaction; virtual; abstract;
 	end;
 
 	ManagementVTable = class(PluginBaseVTable)
@@ -6925,6 +6933,18 @@ function ILogonInfo.authBlock(length: CardinalPtr): BytePtr;
 	Result := LogonInfoVTable(vTable).authBlock(Self, length);
 end;
 
+function ILogonInfo.attachment(status: IStatus): IAttachment;
+begin
+	Result := LogonInfoVTable(vTable).attachment(Self, status);
+	FbException.checkException(status);
+end;
+
+function ILogonInfo.transaction(status: IStatus): ITransaction;
+begin
+	Result := LogonInfoVTable(vTable).transaction(Self, status);
+	FbException.checkException(status);
+end;
+
 procedure IManagement.start(status: IStatus; logonInfo: ILogonInfo);
 begin
 	ManagementVTable(vTable).start(Self, status, logonInfo);
@@ -11392,6 +11412,24 @@ function ILogonInfoImpl_authBlockDispatcher(this: ILogonInfo; length: CardinalPt
 	end
 end;
 
+function ILogonInfoImpl_attachmentDispatcher(this: ILogonInfo; status: IStatus): IAttachment; cdecl;
+begin
+	try
+		Result := ILogonInfoImpl(this).attachment(status);
+	except
+		on e: Exception do FbException.catchException(status, e);
+	end
+end;
+
+function ILogonInfoImpl_transactionDispatcher(this: ILogonInfo; status: IStatus): ITransaction; cdecl;
+begin
+	try
+		Result := ILogonInfoImpl(this).transaction(status);
+	except
+		on e: Exception do FbException.catchException(status, e);
+	end
+end;
+
 var
 	ILogonInfoImpl_vTable: LogonInfoVTable;
 
@@ -15088,12 +15126,14 @@ initialization
 	IListUsersImpl_vTable.list := @IListUsersImpl_listDispatcher;
 
 	ILogonInfoImpl_vTable := LogonInfoVTable.create;
-	ILogonInfoImpl_vTable.version := 2;
+	ILogonInfoImpl_vTable.version := 3;
 	ILogonInfoImpl_vTable.name := @ILogonInfoImpl_nameDispatcher;
 	ILogonInfoImpl_vTable.role := @ILogonInfoImpl_roleDispatcher;
 	ILogonInfoImpl_vTable.networkProtocol := @ILogonInfoImpl_networkProtocolDispatcher;
 	ILogonInfoImpl_vTable.remoteAddress := @ILogonInfoImpl_remoteAddressDispatcher;
 	ILogonInfoImpl_vTable.authBlock := @ILogonInfoImpl_authBlockDispatcher;
+	ILogonInfoImpl_vTable.attachment := @ILogonInfoImpl_attachmentDispatcher;
+	ILogonInfoImpl_vTable.transaction := @ILogonInfoImpl_transactionDispatcher;
 
 	IManagementImpl_vTable := ManagementVTable.create;
 	IManagementImpl_vTable.version := 4;
diff --git a/src/jrd/UserManagement.cpp b/src/jrd/UserManagement.cpp
@@ -40,8 +40,8 @@ namespace
 	class UserIdInfo : public AutoIface<ILogonInfoImpl<UserIdInfo, CheckStatusWrapper> >
 	{
 	public:
-		explicit UserIdInfo(const Attachment* pAtt)
-			: att(pAtt)
+		explicit UserIdInfo(Attachment* pAtt, jrd_tra* pTra)
+			: att(pAtt), tra(pTra)
 		{ }
 
 		// ILogonInfo implementation
@@ -74,8 +74,19 @@ namespace
 			return aBlock.getCount() ? aBlock.begin() : NULL;
 		}
 
+		JAttachment* attachment(CheckStatusWrapper*)
+		{
+			return att->getInterface();
+		}
+
+		JTransaction* transaction(CheckStatusWrapper*)
+		{
+			return tra->getInterface(false);
+		}
+
 	private:
-		const Attachment* att;
+		Attachment* att;
+		jrd_tra* tra;
 	};
 
 	class FillSnapshot : public AutoIface<IListUsersImpl<FillSnapshot, CheckStatusWrapper> >
@@ -146,13 +157,14 @@ bool UsersTableScan::retrieveRecord(thread_db* tdbb, jrd_rel* relation,
 }
 
 
-UserManagement::UserManagement(jrd_tra* tra)
-	: SnapshotData(*tra->tra_pool),
+UserManagement::UserManagement(jrd_tra* pTra)
+	: SnapshotData(*pTra->tra_pool),
 	  threadDbb(NULL),
-	  commands(*tra->tra_pool),
-	  managers(*tra->tra_pool),
-	  plugins(*tra->tra_pool),
-	  att(tra->tra_attachment)
+	  commands(*pTra->tra_pool),
+	  managers(*pTra->tra_pool),
+	  plugins(*pTra->tra_pool),
+	  att(pTra->tra_attachment),
+	  tra(pTra)
 {
 	if (!att || !att->att_user)
 	{
@@ -172,7 +184,7 @@ IManagement* UserManagement::registerManager(Auth::Get& getPlugin, const char* p
 	LocalStatus status;
 	CheckStatusWrapper statusWrapper(&status);
 
-	UserIdInfo idInfo(att);
+	UserIdInfo idInfo(att, tra);
 	manager->start(&statusWrapper, &idInfo);
 	if (status.getState() & IStatus::STATE_ERRORS)
 	{
@@ -298,6 +310,7 @@ USHORT UserManagement::put(Auth::DynamicUserData* userData)
 	{
 		status_exception::raise(Arg::Gds(isc_imp_exc) << Arg::Gds(isc_random) << "Too many user management DDL per transaction");
 	}
+
 	commands.push(userData);
 	return ret;
 }
diff --git a/src/jrd/UserManagement.h b/src/jrd/UserManagement.h
@@ -76,6 +76,7 @@ class UserManagement : public SnapshotData
 	Firebird::ObjectsArray<Manager> managers;
 	Firebird::NoCaseString plugins;
 	Attachment* att;
+	jrd_tra* tra;
 
 	Firebird::IManagement* getManager(const char* name);
 	void openAllManagers();
diff --git a/src/utilities/gsec/gsec.cpp b/src/utilities/gsec/gsec.cpp
@@ -190,6 +190,16 @@ namespace {
 			return authBytes;
 		}
 
+		Firebird::IAttachment* attachment(Firebird::CheckStatusWrapper* status)
+		{
+			return nullptr;
+		}
+
+		Firebird::ITransaction* transaction(Firebird::CheckStatusWrapper* status)
+		{
+			return nullptr;
+		}
+
 	private:
 		const char* dba;
 		const char* sqlRole;
