int secureblackbox_restserver_getactive(void* lpObj);

bool GetActive();

int secureblackbox_restserver_getallowcustomrequests(void* lpObj);
int secureblackbox_restserver_setallowcustomrequests(void* lpObj, int bAllowCustomRequests);

bool GetAllowCustomRequests();
int SetAllowCustomRequests(bool bAllowCustomRequests);

int secureblackbox_restserver_getallowkeepalive(void* lpObj);
int secureblackbox_restserver_setallowkeepalive(void* lpObj, int bAllowKeepAlive);

bool GetAllowKeepAlive();
int SetAllowKeepAlive(bool bAllowKeepAlive);

char* secureblackbox_restserver_getauthrealm(void* lpObj);
int secureblackbox_restserver_setauthrealm(void* lpObj, const char* lpszAuthRealm);

QString GetAuthRealm();
int SetAuthRealm(QString qsAuthRealm);

int secureblackbox_restserver_getauthtypes(void* lpObj);
int secureblackbox_restserver_setauthtypes(void* lpObj, int iAuthTypes);

int GetAuthTypes();
int SetAuthTypes(int iAuthTypes);

int secureblackbox_restserver_getboundport(void* lpObj);

int GetBoundPort();

int secureblackbox_restserver_getcompressionlevel(void* lpObj);
int secureblackbox_restserver_setcompressionlevel(void* lpObj, int iCompressionLevel);

int GetCompressionLevel();
int SetCompressionLevel(int iCompressionLevel);

char* secureblackbox_restserver_getdocumentroot(void* lpObj);
int secureblackbox_restserver_setdocumentroot(void* lpObj, const char* lpszDocumentRoot);

QString GetDocumentRoot();
int SetDocumentRoot(QString qsDocumentRoot);

char* secureblackbox_restserver_getexternalcryptoasyncdocumentid(void* lpObj);
int secureblackbox_restserver_setexternalcryptoasyncdocumentid(void* lpObj, const char* lpszExternalCryptoAsyncDocumentID);

char* secureblackbox_restserver_getexternalcryptocustomparams(void* lpObj);
int secureblackbox_restserver_setexternalcryptocustomparams(void* lpObj, const char* lpszExternalCryptoCustomParams);

char* secureblackbox_restserver_getexternalcryptodata(void* lpObj);
int secureblackbox_restserver_setexternalcryptodata(void* lpObj, const char* lpszExternalCryptoData);

int secureblackbox_restserver_getexternalcryptoexternalhashcalculation(void* lpObj);
int secureblackbox_restserver_setexternalcryptoexternalhashcalculation(void* lpObj, int bExternalCryptoExternalHashCalculation);

char* secureblackbox_restserver_getexternalcryptohashalgorithm(void* lpObj);
int secureblackbox_restserver_setexternalcryptohashalgorithm(void* lpObj, const char* lpszExternalCryptoHashAlgorithm);

char* secureblackbox_restserver_getexternalcryptokeyid(void* lpObj);
int secureblackbox_restserver_setexternalcryptokeyid(void* lpObj, const char* lpszExternalCryptoKeyID);

char* secureblackbox_restserver_getexternalcryptokeysecret(void* lpObj);
int secureblackbox_restserver_setexternalcryptokeysecret(void* lpObj, const char* lpszExternalCryptoKeySecret);

int secureblackbox_restserver_getexternalcryptomethod(void* lpObj);
int secureblackbox_restserver_setexternalcryptomethod(void* lpObj, int iExternalCryptoMethod);

int secureblackbox_restserver_getexternalcryptomode(void* lpObj);
int secureblackbox_restserver_setexternalcryptomode(void* lpObj, int iExternalCryptoMode);

char* secureblackbox_restserver_getexternalcryptopublickeyalgorithm(void* lpObj);
int secureblackbox_restserver_setexternalcryptopublickeyalgorithm(void* lpObj, const char* lpszExternalCryptoPublicKeyAlgorithm);

QString GetExternalCryptoAsyncDocumentID();
int SetExternalCryptoAsyncDocumentID(QString qsExternalCryptoAsyncDocumentID);

QString GetExternalCryptoCustomParams();
int SetExternalCryptoCustomParams(QString qsExternalCryptoCustomParams);

QString GetExternalCryptoData();
int SetExternalCryptoData(QString qsExternalCryptoData);

bool GetExternalCryptoExternalHashCalculation();
int SetExternalCryptoExternalHashCalculation(bool bExternalCryptoExternalHashCalculation);

QString GetExternalCryptoHashAlgorithm();
int SetExternalCryptoHashAlgorithm(QString qsExternalCryptoHashAlgorithm);

QString GetExternalCryptoKeyID();
int SetExternalCryptoKeyID(QString qsExternalCryptoKeyID);

QString GetExternalCryptoKeySecret();
int SetExternalCryptoKeySecret(QString qsExternalCryptoKeySecret);

int GetExternalCryptoMethod();
int SetExternalCryptoMethod(int iExternalCryptoMethod);

int GetExternalCryptoMode();
int SetExternalCryptoMode(int iExternalCryptoMode);

QString GetExternalCryptoPublicKeyAlgorithm();
int SetExternalCryptoPublicKeyAlgorithm(QString qsExternalCryptoPublicKeyAlgorithm);

int secureblackbox_restserver_getfipsmode(void* lpObj);
int secureblackbox_restserver_setfipsmode(void* lpObj, int bFIPSMode);

bool GetFIPSMode();
int SetFIPSMode(bool bFIPSMode);

int secureblackbox_restserver_gethandshaketimeout(void* lpObj);
int secureblackbox_restserver_sethandshaketimeout(void* lpObj, int iHandshakeTimeout);

int GetHandshakeTimeout();
int SetHandshakeTimeout(int iHandshakeTimeout);

char* secureblackbox_restserver_gethost(void* lpObj);
int secureblackbox_restserver_sethost(void* lpObj, const char* lpszHost);

QString GetHost();
int SetHost(QString qsHost);

int secureblackbox_restserver_getpinnedclientaeadcipher(void* lpObj);

int secureblackbox_restserver_getpinnedclientchainvalidationdetails(void* lpObj);

int secureblackbox_restserver_getpinnedclientchainvalidationresult(void* lpObj);

char* secureblackbox_restserver_getpinnedclientciphersuite(void* lpObj);

int secureblackbox_restserver_getpinnedclientclientauthenticated(void* lpObj);

int secureblackbox_restserver_getpinnedclientclientauthrequested(void* lpObj);

int secureblackbox_restserver_getpinnedclientconnectionestablished(void* lpObj);

int secureblackbox_restserver_getpinnedclientconnectionid(void* lpObj, char** lpPinnedClientConnectionID, int* lenPinnedClientConnectionID);

char* secureblackbox_restserver_getpinnedclientdigestalgorithm(void* lpObj);

char* secureblackbox_restserver_getpinnedclientencryptionalgorithm(void* lpObj);

int secureblackbox_restserver_getpinnedclientexportable(void* lpObj);

int64 secureblackbox_restserver_getpinnedclientid(void* lpObj);

char* secureblackbox_restserver_getpinnedclientkeyexchangealgorithm(void* lpObj);

int secureblackbox_restserver_getpinnedclientkeyexchangekeybits(void* lpObj);

char* secureblackbox_restserver_getpinnedclientnamedeccurve(void* lpObj);

int secureblackbox_restserver_getpinnedclientpfscipher(void* lpObj);

char* secureblackbox_restserver_getpinnedclientpresharedidentity(void* lpObj);

char* secureblackbox_restserver_getpinnedclientpresharedidentityhint(void* lpObj);

int secureblackbox_restserver_getpinnedclientpublickeybits(void* lpObj);

char* secureblackbox_restserver_getpinnedclientremoteaddress(void* lpObj);

int secureblackbox_restserver_getpinnedclientremoteport(void* lpObj);

int secureblackbox_restserver_getpinnedclientresumedsession(void* lpObj);

int secureblackbox_restserver_getpinnedclientsecureconnection(void* lpObj);

int secureblackbox_restserver_getpinnedclientserverauthenticated(void* lpObj);

char* secureblackbox_restserver_getpinnedclientsignaturealgorithm(void* lpObj);

int secureblackbox_restserver_getpinnedclientsymmetricblocksize(void* lpObj);

int secureblackbox_restserver_getpinnedclientsymmetrickeybits(void* lpObj);

int64 secureblackbox_restserver_getpinnedclienttotalbytesreceived(void* lpObj);

int64 secureblackbox_restserver_getpinnedclienttotalbytessent(void* lpObj);

char* secureblackbox_restserver_getpinnedclientvalidationlog(void* lpObj);

char* secureblackbox_restserver_getpinnedclientversion(void* lpObj);

bool GetPinnedClientAEADCipher();

int GetPinnedClientChainValidationDetails();

int GetPinnedClientChainValidationResult();

QString GetPinnedClientCiphersuite();

bool GetPinnedClientClientAuthenticated();

bool GetPinnedClientClientAuthRequested();

bool GetPinnedClientConnectionEstablished();

QByteArray GetPinnedClientConnectionID();

QString GetPinnedClientDigestAlgorithm();

QString GetPinnedClientEncryptionAlgorithm();

bool GetPinnedClientExportable();

qint64 GetPinnedClientID();

QString GetPinnedClientKeyExchangeAlgorithm();

int GetPinnedClientKeyExchangeKeyBits();

QString GetPinnedClientNamedECCurve();

bool GetPinnedClientPFSCipher();

QString GetPinnedClientPreSharedIdentity();

QString GetPinnedClientPreSharedIdentityHint();

int GetPinnedClientPublicKeyBits();

QString GetPinnedClientRemoteAddress();

int GetPinnedClientRemotePort();

bool GetPinnedClientResumedSession();

bool GetPinnedClientSecureConnection();

bool GetPinnedClientServerAuthenticated();

QString GetPinnedClientSignatureAlgorithm();

int GetPinnedClientSymmetricBlockSize();

int GetPinnedClientSymmetricKeyBits();

qint64 GetPinnedClientTotalBytesReceived();

qint64 GetPinnedClientTotalBytesSent();

QString GetPinnedClientValidationLog();

QString GetPinnedClientVersion();

int secureblackbox_restserver_getpinnedclientcertcount(void* lpObj);

int secureblackbox_restserver_getpinnedclientcertbytes(void* lpObj, int pinnedclientcertindex, char** lpPinnedClientCertBytes, int* lenPinnedClientCertBytes);

int secureblackbox_restserver_getpinnedclientcertcakeyid(void* lpObj, int pinnedclientcertindex, char** lpPinnedClientCertCAKeyID, int* lenPinnedClientCertCAKeyID);

char* secureblackbox_restserver_getpinnedclientcertfingerprint(void* lpObj, int pinnedclientcertindex);

int64 secureblackbox_restserver_getpinnedclientcerthandle(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_restserver_getpinnedclientcertissuer(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_restserver_getpinnedclientcertissuerrdn(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_restserver_getpinnedclientcertkeyalgorithm(void* lpObj, int pinnedclientcertindex);

int secureblackbox_restserver_getpinnedclientcertkeybits(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_restserver_getpinnedclientcertkeyfingerprint(void* lpObj, int pinnedclientcertindex);

int secureblackbox_restserver_getpinnedclientcertkeyusage(void* lpObj, int pinnedclientcertindex);

int secureblackbox_restserver_getpinnedclientcertpublickeybytes(void* lpObj, int pinnedclientcertindex, char** lpPinnedClientCertPublicKeyBytes, int* lenPinnedClientCertPublicKeyBytes);

int secureblackbox_restserver_getpinnedclientcertselfsigned(void* lpObj, int pinnedclientcertindex);

int secureblackbox_restserver_getpinnedclientcertserialnumber(void* lpObj, int pinnedclientcertindex, char** lpPinnedClientCertSerialNumber, int* lenPinnedClientCertSerialNumber);

char* secureblackbox_restserver_getpinnedclientcertsigalgorithm(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_restserver_getpinnedclientcertsubject(void* lpObj, int pinnedclientcertindex);

int secureblackbox_restserver_getpinnedclientcertsubjectkeyid(void* lpObj, int pinnedclientcertindex, char** lpPinnedClientCertSubjectKeyID, int* lenPinnedClientCertSubjectKeyID);

char* secureblackbox_restserver_getpinnedclientcertsubjectrdn(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_restserver_getpinnedclientcertvalidfrom(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_restserver_getpinnedclientcertvalidto(void* lpObj, int pinnedclientcertindex);

int GetPinnedClientCertCount();

QByteArray GetPinnedClientCertBytes(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertCAKeyID(int iPinnedClientCertIndex);

QString GetPinnedClientCertFingerprint(int iPinnedClientCertIndex);

qint64 GetPinnedClientCertHandle(int iPinnedClientCertIndex);

QString GetPinnedClientCertIssuer(int iPinnedClientCertIndex);

QString GetPinnedClientCertIssuerRDN(int iPinnedClientCertIndex);

QString GetPinnedClientCertKeyAlgorithm(int iPinnedClientCertIndex);

int GetPinnedClientCertKeyBits(int iPinnedClientCertIndex);

QString GetPinnedClientCertKeyFingerprint(int iPinnedClientCertIndex);

int GetPinnedClientCertKeyUsage(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertPublicKeyBytes(int iPinnedClientCertIndex);

bool GetPinnedClientCertSelfSigned(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertSerialNumber(int iPinnedClientCertIndex);

QString GetPinnedClientCertSigAlgorithm(int iPinnedClientCertIndex);

QString GetPinnedClientCertSubject(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertSubjectKeyID(int iPinnedClientCertIndex);

QString GetPinnedClientCertSubjectRDN(int iPinnedClientCertIndex);

QString GetPinnedClientCertValidFrom(int iPinnedClientCertIndex);

QString GetPinnedClientCertValidTo(int iPinnedClientCertIndex);

int secureblackbox_restserver_getport(void* lpObj);
int secureblackbox_restserver_setport(void* lpObj, int iPort);

int GetPort();
int SetPort(int iPort);

int secureblackbox_restserver_getportrangefrom(void* lpObj);
int secureblackbox_restserver_setportrangefrom(void* lpObj, int iPortRangeFrom);

int GetPortRangeFrom();
int SetPortRangeFrom(int iPortRangeFrom);

int secureblackbox_restserver_getportrangeto(void* lpObj);
int secureblackbox_restserver_setportrangeto(void* lpObj, int iPortRangeTo);

int GetPortRangeTo();
int SetPortRangeTo(int iPortRangeTo);

int secureblackbox_restserver_getsessiontimeout(void* lpObj);
int secureblackbox_restserver_setsessiontimeout(void* lpObj, int iSessionTimeout);

int GetSessionTimeout();
int SetSessionTimeout(int iSessionTimeout);

int secureblackbox_restserver_getsocketincomingspeedlimit(void* lpObj);
int secureblackbox_restserver_setsocketincomingspeedlimit(void* lpObj, int iSocketIncomingSpeedLimit);

char* secureblackbox_restserver_getsocketlocaladdress(void* lpObj);
int secureblackbox_restserver_setsocketlocaladdress(void* lpObj, const char* lpszSocketLocalAddress);

int secureblackbox_restserver_getsocketlocalport(void* lpObj);
int secureblackbox_restserver_setsocketlocalport(void* lpObj, int iSocketLocalPort);

int secureblackbox_restserver_getsocketoutgoingspeedlimit(void* lpObj);
int secureblackbox_restserver_setsocketoutgoingspeedlimit(void* lpObj, int iSocketOutgoingSpeedLimit);

int secureblackbox_restserver_getsockettimeout(void* lpObj);
int secureblackbox_restserver_setsockettimeout(void* lpObj, int iSocketTimeout);

int secureblackbox_restserver_getsocketuseipv6(void* lpObj);
int secureblackbox_restserver_setsocketuseipv6(void* lpObj, int bSocketUseIPv6);

int GetSocketIncomingSpeedLimit();
int SetSocketIncomingSpeedLimit(int iSocketIncomingSpeedLimit);

QString GetSocketLocalAddress();
int SetSocketLocalAddress(QString qsSocketLocalAddress);

int GetSocketLocalPort();
int SetSocketLocalPort(int iSocketLocalPort);

int GetSocketOutgoingSpeedLimit();
int SetSocketOutgoingSpeedLimit(int iSocketOutgoingSpeedLimit);

int GetSocketTimeout();
int SetSocketTimeout(int iSocketTimeout);

bool GetSocketUseIPv6();
int SetSocketUseIPv6(bool bSocketUseIPv6);

int secureblackbox_restserver_gettlsservercertcount(void* lpObj);
int secureblackbox_restserver_settlsservercertcount(void* lpObj, int iTLSServerCertCount);

int secureblackbox_restserver_gettlsservercertbytes(void* lpObj, int tlsservercertindex, char** lpTLSServerCertBytes, int* lenTLSServerCertBytes);

int64 secureblackbox_restserver_gettlsservercerthandle(void* lpObj, int tlsservercertindex);
int secureblackbox_restserver_settlsservercerthandle(void* lpObj, int tlsservercertindex, int64 lTLSServerCertHandle);

int GetTLSServerCertCount();
int SetTLSServerCertCount(int iTLSServerCertCount);

QByteArray GetTLSServerCertBytes(int iTLSServerCertIndex);

qint64 GetTLSServerCertHandle(int iTLSServerCertIndex);
int SetTLSServerCertHandle(int iTLSServerCertIndex, qint64 lTLSServerCertHandle);

int secureblackbox_restserver_gettlsautovalidatecertificates(void* lpObj);
int secureblackbox_restserver_settlsautovalidatecertificates(void* lpObj, int bTLSAutoValidateCertificates);

int secureblackbox_restserver_gettlsbaseconfiguration(void* lpObj);
int secureblackbox_restserver_settlsbaseconfiguration(void* lpObj, int iTLSBaseConfiguration);

char* secureblackbox_restserver_gettlsciphersuites(void* lpObj);
int secureblackbox_restserver_settlsciphersuites(void* lpObj, const char* lpszTLSCiphersuites);

int secureblackbox_restserver_gettlsclientauth(void* lpObj);
int secureblackbox_restserver_settlsclientauth(void* lpObj, int iTLSClientAuth);

char* secureblackbox_restserver_gettlseccurves(void* lpObj);
int secureblackbox_restserver_settlseccurves(void* lpObj, const char* lpszTLSECCurves);

char* secureblackbox_restserver_gettlsextensions(void* lpObj);
int secureblackbox_restserver_settlsextensions(void* lpObj, const char* lpszTLSExtensions);

int secureblackbox_restserver_gettlsforceresumeifdestinationchanges(void* lpObj);
int secureblackbox_restserver_settlsforceresumeifdestinationchanges(void* lpObj, int bTLSForceResumeIfDestinationChanges);

char* secureblackbox_restserver_gettlspresharedidentity(void* lpObj);
int secureblackbox_restserver_settlspresharedidentity(void* lpObj, const char* lpszTLSPreSharedIdentity);

char* secureblackbox_restserver_gettlspresharedkey(void* lpObj);
int secureblackbox_restserver_settlspresharedkey(void* lpObj, const char* lpszTLSPreSharedKey);

char* secureblackbox_restserver_gettlspresharedkeyciphersuite(void* lpObj);
int secureblackbox_restserver_settlspresharedkeyciphersuite(void* lpObj, const char* lpszTLSPreSharedKeyCiphersuite);

int secureblackbox_restserver_gettlsrenegotiationattackpreventionmode(void* lpObj);
int secureblackbox_restserver_settlsrenegotiationattackpreventionmode(void* lpObj, int iTLSRenegotiationAttackPreventionMode);

int secureblackbox_restserver_gettlsrevocationcheck(void* lpObj);
int secureblackbox_restserver_settlsrevocationcheck(void* lpObj, int iTLSRevocationCheck);

int secureblackbox_restserver_gettlsssloptions(void* lpObj);
int secureblackbox_restserver_settlsssloptions(void* lpObj, int iTLSSSLOptions);

int secureblackbox_restserver_gettlstlsmode(void* lpObj);
int secureblackbox_restserver_settlstlsmode(void* lpObj, int iTLSTLSMode);

int secureblackbox_restserver_gettlsuseextendedmastersecret(void* lpObj);
int secureblackbox_restserver_settlsuseextendedmastersecret(void* lpObj, int bTLSUseExtendedMasterSecret);

int secureblackbox_restserver_gettlsusesessionresumption(void* lpObj);
int secureblackbox_restserver_settlsusesessionresumption(void* lpObj, int bTLSUseSessionResumption);

int secureblackbox_restserver_gettlsversions(void* lpObj);
int secureblackbox_restserver_settlsversions(void* lpObj, int iTLSVersions);

bool GetTLSAutoValidateCertificates();
int SetTLSAutoValidateCertificates(bool bTLSAutoValidateCertificates);

int GetTLSBaseConfiguration();
int SetTLSBaseConfiguration(int iTLSBaseConfiguration);

QString GetTLSCiphersuites();
int SetTLSCiphersuites(QString qsTLSCiphersuites);

int GetTLSClientAuth();
int SetTLSClientAuth(int iTLSClientAuth);

QString GetTLSECCurves();
int SetTLSECCurves(QString qsTLSECCurves);

QString GetTLSExtensions();
int SetTLSExtensions(QString qsTLSExtensions);

bool GetTLSForceResumeIfDestinationChanges();
int SetTLSForceResumeIfDestinationChanges(bool bTLSForceResumeIfDestinationChanges);

QString GetTLSPreSharedIdentity();
int SetTLSPreSharedIdentity(QString qsTLSPreSharedIdentity);

QString GetTLSPreSharedKey();
int SetTLSPreSharedKey(QString qsTLSPreSharedKey);

QString GetTLSPreSharedKeyCiphersuite();
int SetTLSPreSharedKeyCiphersuite(QString qsTLSPreSharedKeyCiphersuite);

int GetTLSRenegotiationAttackPreventionMode();
int SetTLSRenegotiationAttackPreventionMode(int iTLSRenegotiationAttackPreventionMode);

int GetTLSRevocationCheck();
int SetTLSRevocationCheck(int iTLSRevocationCheck);

int GetTLSSSLOptions();
int SetTLSSSLOptions(int iTLSSSLOptions);

int GetTLSTLSMode();
int SetTLSTLSMode(int iTLSTLSMode);

bool GetTLSUseExtendedMasterSecret();
int SetTLSUseExtendedMasterSecret(bool bTLSUseExtendedMasterSecret);

bool GetTLSUseSessionResumption();
int SetTLSUseSessionResumption(bool bTLSUseSessionResumption);

int GetTLSVersions();
int SetTLSVersions(int iTLSVersions);

int secureblackbox_restserver_getusechunkedtransfer(void* lpObj);
int secureblackbox_restserver_setusechunkedtransfer(void* lpObj, int bUseChunkedTransfer);

bool GetUseChunkedTransfer();
int SetUseChunkedTransfer(bool bUseChunkedTransfer);

int secureblackbox_restserver_getusecompression(void* lpObj);
int secureblackbox_restserver_setusecompression(void* lpObj, int bUseCompression);

bool GetUseCompression();
int SetUseCompression(bool bUseCompression);

int secureblackbox_restserver_getusercount(void* lpObj);
int secureblackbox_restserver_setusercount(void* lpObj, int iUserCount);

int secureblackbox_restserver_getuserassociateddata(void* lpObj, int userindex, char** lpUserAssociatedData, int* lenUserAssociatedData);
int secureblackbox_restserver_setuserassociateddata(void* lpObj, int userindex, const char* lpUserAssociatedData, int lenUserAssociatedData);

char* secureblackbox_restserver_getuserbasepath(void* lpObj, int userindex);
int secureblackbox_restserver_setuserbasepath(void* lpObj, int userindex, const char* lpszUserBasePath);

char* secureblackbox_restserver_getuserdata(void* lpObj, int userindex);
int secureblackbox_restserver_setuserdata(void* lpObj, int userindex, const char* lpszUserData);

int64 secureblackbox_restserver_getuserhandle(void* lpObj, int userindex);
int secureblackbox_restserver_setuserhandle(void* lpObj, int userindex, int64 lUserHandle);

char* secureblackbox_restserver_getuserhashalgorithm(void* lpObj, int userindex);
int secureblackbox_restserver_setuserhashalgorithm(void* lpObj, int userindex, const char* lpszUserHashAlgorithm);

int secureblackbox_restserver_getuserincomingspeedlimit(void* lpObj, int userindex);
int secureblackbox_restserver_setuserincomingspeedlimit(void* lpObj, int userindex, int iUserIncomingSpeedLimit);

int secureblackbox_restserver_getuseroutgoingspeedlimit(void* lpObj, int userindex);
int secureblackbox_restserver_setuseroutgoingspeedlimit(void* lpObj, int userindex, int iUserOutgoingSpeedLimit);

char* secureblackbox_restserver_getuserpassword(void* lpObj, int userindex);
int secureblackbox_restserver_setuserpassword(void* lpObj, int userindex, const char* lpszUserPassword);

int secureblackbox_restserver_getusersharedsecret(void* lpObj, int userindex, char** lpUserSharedSecret, int* lenUserSharedSecret);
int secureblackbox_restserver_setusersharedsecret(void* lpObj, int userindex, const char* lpUserSharedSecret, int lenUserSharedSecret);

char* secureblackbox_restserver_getuserusername(void* lpObj, int userindex);
int secureblackbox_restserver_setuserusername(void* lpObj, int userindex, const char* lpszUserUsername);

int GetUserCount();
int SetUserCount(int iUserCount);

QByteArray GetUserAssociatedData(int iUserIndex);
int SetUserAssociatedData(int iUserIndex, QByteArray qbaUserAssociatedData);

QString GetUserBasePath(int iUserIndex);
int SetUserBasePath(int iUserIndex, QString qsUserBasePath);

QString GetUserData(int iUserIndex);
int SetUserData(int iUserIndex, QString qsUserData);

qint64 GetUserHandle(int iUserIndex);
int SetUserHandle(int iUserIndex, qint64 lUserHandle);

QString GetUserHashAlgorithm(int iUserIndex);
int SetUserHashAlgorithm(int iUserIndex, QString qsUserHashAlgorithm);

int GetUserIncomingSpeedLimit(int iUserIndex);
int SetUserIncomingSpeedLimit(int iUserIndex, int iUserIncomingSpeedLimit);

int GetUserOutgoingSpeedLimit(int iUserIndex);
int SetUserOutgoingSpeedLimit(int iUserIndex, int iUserOutgoingSpeedLimit);

QString GetUserPassword(int iUserIndex);
int SetUserPassword(int iUserIndex, QString qsUserPassword);

QByteArray GetUserSharedSecret(int iUserIndex);
int SetUserSharedSecret(int iUserIndex, QByteArray qbaUserSharedSecret);

QString GetUserUsername(int iUserIndex);
int SetUserUsername(int iUserIndex, QString qsUserUsername);

char* secureblackbox_restserver_getwebsitename(void* lpObj);
int secureblackbox_restserver_setwebsitename(void* lpObj, const char* lpszWebsiteName);

QString GetWebsiteName();
int SetWebsiteName(QString qsWebsiteName);

int secureblackbox_restserver_cleanup(void* lpObj);

int Cleanup();

char* secureblackbox_restserver_config(void* lpObj, const char* lpszConfigurationString);

QString Config(const QString& qsConfigurationString);

char* secureblackbox_restserver_doaction(void* lpObj, const char* lpszActionID, const char* lpszActionParams);

QString DoAction(const QString& qsActionID, const QString& qsActionParams);

int secureblackbox_restserver_dropclient(void* lpObj, int64 lConnectionId, int bForced);

int DropClient(qint64 lConnectionId, bool bForced);

char* secureblackbox_restserver_getrequestbytes(void* lpObj, int64 lConnectionId, const char* lpszRequestFilter, int *lpSize);

QByteArray GetRequestBytes(qint64 lConnectionId, const QString& qsRequestFilter);

char* secureblackbox_restserver_getrequestheader(void* lpObj, int64 lConnectionId, const char* lpszHeaderName);

QString GetRequestHeader(qint64 lConnectionId, const QString& qsHeaderName);

int secureblackbox_restserver_getrequeststream(void* lpObj, int64 lConnectionId, const char* lpszRequestFilter, SecureBlackboxStream* sOutputStream);

int GetRequestStream(qint64 lConnectionId, const QString& qsRequestFilter, SecureBlackboxStream* sOutputStream);

char* secureblackbox_restserver_getrequeststring(void* lpObj, int64 lConnectionId, const char* lpszRequestFilter);

QString GetRequestString(qint64 lConnectionId, const QString& qsRequestFilter);

char* secureblackbox_restserver_getrequestusername(void* lpObj, int64 lConnectionId);

QString GetRequestUsername(qint64 lConnectionId);

char* secureblackbox_restserver_getresponseheader(void* lpObj, int64 lConnectionId, const char* lpszHeaderName);

QString GetResponseHeader(qint64 lConnectionId, const QString& qsHeaderName);

char* secureblackbox_restserver_listclients(void* lpObj);

QString ListClients();

int secureblackbox_restserver_pinclient(void* lpObj, int64 lConnectionId);

int PinClient(qint64 lConnectionId);

char* secureblackbox_restserver_processgenericrequest(void* lpObj, int64 lConnectionId, const char* lpRequestBytes, int lenRequestBytes, int *lpSize);

QByteArray ProcessGenericRequest(qint64 lConnectionId, QByteArray qbaRequestBytes);

int secureblackbox_restserver_processgenericrequeststream(void* lpObj, int64 lConnectionId, const char* lpszRequestHeaders, SecureBlackboxStream* sRequestData, SecureBlackboxStream* sResponseData);

int ProcessGenericRequestStream(qint64 lConnectionId, const QString& qsRequestHeaders, SecureBlackboxStream* sRequestData, SecureBlackboxStream* sResponseData);

int secureblackbox_restserver_reset(void* lpObj);

int Reset();

int secureblackbox_restserver_setresponsebytes(void* lpObj, int64 lConnectionId, const char* lpBytes, int lenBytes, const char* lpszContentType, const char* lpszResponseFilter);

int SetResponseBytes(qint64 lConnectionId, QByteArray qbaBytes, const QString& qsContentType, const QString& qsResponseFilter);

int secureblackbox_restserver_setresponsefile(void* lpObj, int64 lConnectionId, const char* lpszFileName, const char* lpszContentType, const char* lpszResponseFilter);

int SetResponseFile(qint64 lConnectionId, const QString& qsFileName, const QString& qsContentType, const QString& qsResponseFilter);

int secureblackbox_restserver_setresponseheader(void* lpObj, int64 lConnectionId, const char* lpszHeaderName, const char* lpszValue);

int SetResponseHeader(qint64 lConnectionId, const QString& qsHeaderName, const QString& qsValue);

int secureblackbox_restserver_setresponsejson(void* lpObj, int64 lConnectionId, const char* lpszData, const char* lpszResponseFilter);

int SetResponseJSON(qint64 lConnectionId, const QString& qsData, const QString& qsResponseFilter);

int secureblackbox_restserver_setresponsestatus(void* lpObj, int64 lConnectionId, int iStatusCode);

int SetResponseStatus(qint64 lConnectionId, int iStatusCode);

int secureblackbox_restserver_setresponsestream(void* lpObj, int64 lConnectionId, SecureBlackboxStream* sDataStream, int bCloseStream, const char* lpszContentType, const char* lpszResponseFilter);

int SetResponseStream(qint64 lConnectionId, SecureBlackboxStream* sDataStream, bool bCloseStream, const QString& qsContentType, const QString& qsResponseFilter);

int secureblackbox_restserver_setresponsestring(void* lpObj, int64 lConnectionId, const char* lpszDataStr, const char* lpszContentType, const char* lpszResponseFilter);

int SetResponseString(qint64 lConnectionId, const QString& qsDataStr, const QString& qsContentType, const QString& qsResponseFilter);

int secureblackbox_restserver_setresponsexml(void* lpObj, int64 lConnectionId, const char* lpszData, const char* lpszResponseFilter);

int SetResponseXML(qint64 lConnectionId, const QString& qsData, const QString& qsResponseFilter);

int secureblackbox_restserver_start(void* lpObj);

int Start();

int secureblackbox_restserver_stop(void* lpObj);

int Stop();

#define EID_RESTSERVER_ACCEPT 1

virtual INT SECUREBLACKBOX_CALL FireAccept(LPSTR &lpszRemoteAddress, INT &iRemotePort, BOOL &bAccept);

class RESTServerAcceptEventParams {
public:
  const QString &RemoteAddress();

  int RemotePort();

  bool Accept();
  void SetAccept(bool bAccept);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Accept(RESTServerAcceptEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireAccept(RESTServerAcceptEventParams *e) {...}

#define EID_RESTSERVER_AUTHATTEMPT 2

virtual INT SECUREBLACKBOX_CALL FireAuthAttempt(LONG64 &lConnectionID, LPSTR &lpszHTTPMethod, LPSTR &lpszURI, LPSTR &lpszAuthMethod, LPSTR &lpszUsername, LPSTR &lpszPassword, BOOL &bAllow);

class RESTServerAuthAttemptEventParams {
public:
  qint64 ConnectionID();

  const QString &HTTPMethod();

  const QString &URI();

  const QString &AuthMethod();

  const QString &Username();

  const QString &Password();

  bool Allow();
  void SetAllow(bool bAllow);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void AuthAttempt(RESTServerAuthAttemptEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireAuthAttempt(RESTServerAuthAttemptEventParams *e) {...}

#define EID_RESTSERVER_CONNECT 3

virtual INT SECUREBLACKBOX_CALL FireConnect(LONG64 &lConnectionID, LPSTR &lpszRemoteAddress, INT &iRemotePort);

class RESTServerConnectEventParams {
public:
  qint64 ConnectionID();

  const QString &RemoteAddress();

  int RemotePort();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Connect(RESTServerConnectEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireConnect(RESTServerConnectEventParams *e) {...}

#define EID_RESTSERVER_CUSTOMREQUEST 4

virtual INT SECUREBLACKBOX_CALL FireCustomRequest(LONG64 &lConnectionID, LPSTR &lpszURI, LPSTR &lpszHTTPMethod, BOOL &bHandled);

class RESTServerCustomRequestEventParams {
public:
  qint64 ConnectionID();

  const QString &URI();

  const QString &HTTPMethod();

  bool Handled();
  void SetHandled(bool bHandled);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void CustomRequest(RESTServerCustomRequestEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireCustomRequest(RESTServerCustomRequestEventParams *e) {...}

#define EID_RESTSERVER_DATA 5

virtual INT SECUREBLACKBOX_CALL FireData(LONG64 &lConnectionID, LPSTR &lpBuffer, INT &lenBuffer);

class RESTServerDataEventParams {
public:
  qint64 ConnectionID();

  const QByteArray &Buffer();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Data(RESTServerDataEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireData(RESTServerDataEventParams *e) {...}

#define EID_RESTSERVER_DELETEREQUEST 6

virtual INT SECUREBLACKBOX_CALL FireDeleteRequest(LONG64 &lConnectionID, LPSTR &lpszURI, BOOL &bHandled);

class RESTServerDeleteRequestEventParams {
public:
  qint64 ConnectionID();

  const QString &URI();

  bool Handled();
  void SetHandled(bool bHandled);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void DeleteRequest(RESTServerDeleteRequestEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireDeleteRequest(RESTServerDeleteRequestEventParams *e) {...}

#define EID_RESTSERVER_DISCONNECT 7

virtual INT SECUREBLACKBOX_CALL FireDisconnect(LONG64 &lConnectionID);

class RESTServerDisconnectEventParams {
public:
  qint64 ConnectionID();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Disconnect(RESTServerDisconnectEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireDisconnect(RESTServerDisconnectEventParams *e) {...}

#define EID_RESTSERVER_ERROR 8

virtual INT SECUREBLACKBOX_CALL FireError(LONG64 &lConnectionId, INT &iErrorCode, BOOL &bFatal, BOOL &bRemote, LPSTR &lpszDescription);

class RESTServerErrorEventParams {
public:
  qint64 ConnectionId();

  int ErrorCode();

  bool Fatal();

  bool Remote();

  const QString &Description();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Error(RESTServerErrorEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireError(RESTServerErrorEventParams *e) {...}

#define EID_RESTSERVER_EXTERNALSIGN 9

virtual INT SECUREBLACKBOX_CALL FireExternalSign(LONG64 &lConnectionID, LPSTR &lpszOperationId, LPSTR &lpszHashAlgorithm, LPSTR &lpszPars, LPSTR &lpszData, LPSTR &lpszSignedData);

class RESTServerExternalSignEventParams {
public:
  qint64 ConnectionID();

  const QString &OperationId();

  const QString &HashAlgorithm();

  const QString &Pars();

  const QString &Data();

  const QString &SignedData();
  void SetSignedData(const QString &qsSignedData);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void ExternalSign(RESTServerExternalSignEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireExternalSign(RESTServerExternalSignEventParams *e) {...}

#define EID_RESTSERVER_FILEERROR 10

virtual INT SECUREBLACKBOX_CALL FireFileError(LONG64 &lConnectionID, LPSTR &lpszFileName, INT &iErrorCode);

class RESTServerFileErrorEventParams {
public:
  qint64 ConnectionID();

  const QString &FileName();

  int ErrorCode();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void FileError(RESTServerFileErrorEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireFileError(RESTServerFileErrorEventParams *e) {...}

#define EID_RESTSERVER_GETREQUEST 11

virtual INT SECUREBLACKBOX_CALL FireGetRequest(LONG64 &lConnectionID, LPSTR &lpszURI, BOOL &bHandled);

class RESTServerGetRequestEventParams {
public:
  qint64 ConnectionID();

  const QString &URI();

  bool Handled();
  void SetHandled(bool bHandled);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void GetRequest(RESTServerGetRequestEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireGetRequest(RESTServerGetRequestEventParams *e) {...}

#define EID_RESTSERVER_HEADERSPREPARED 12

virtual INT SECUREBLACKBOX_CALL FireHeadersPrepared(LONG64 &lConnectionID);

class RESTServerHeadersPreparedEventParams {
public:
  qint64 ConnectionID();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void HeadersPrepared(RESTServerHeadersPreparedEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireHeadersPrepared(RESTServerHeadersPreparedEventParams *e) {...}

#define EID_RESTSERVER_HEADREQUEST 13

virtual INT SECUREBLACKBOX_CALL FireHeadRequest(LONG64 &lConnectionID, LPSTR &lpszURI, BOOL &bHandled);

class RESTServerHeadRequestEventParams {
public:
  qint64 ConnectionID();

  const QString &URI();

  bool Handled();
  void SetHandled(bool bHandled);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void HeadRequest(RESTServerHeadRequestEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireHeadRequest(RESTServerHeadRequestEventParams *e) {...}

#define EID_RESTSERVER_NOTIFICATION 14

virtual INT SECUREBLACKBOX_CALL FireNotification(LPSTR &lpszEventID, LPSTR &lpszEventParam);

class RESTServerNotificationEventParams {
public:
  const QString &EventID();

  const QString &EventParam();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Notification(RESTServerNotificationEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireNotification(RESTServerNotificationEventParams *e) {...}

#define EID_RESTSERVER_OPTIONSREQUEST 15

virtual INT SECUREBLACKBOX_CALL FireOptionsRequest(LONG64 &lConnectionID, LPSTR &lpszURI, BOOL &bHandled);

class RESTServerOptionsRequestEventParams {
public:
  qint64 ConnectionID();

  const QString &URI();

  bool Handled();
  void SetHandled(bool bHandled);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void OptionsRequest(RESTServerOptionsRequestEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireOptionsRequest(RESTServerOptionsRequestEventParams *e) {...}

#define EID_RESTSERVER_PATCHREQUEST 16

virtual INT SECUREBLACKBOX_CALL FirePatchRequest(LONG64 &lConnectionID, LPSTR &lpszURI, BOOL &bHandled);

class RESTServerPatchRequestEventParams {
public:
  qint64 ConnectionID();

  const QString &URI();

  bool Handled();
  void SetHandled(bool bHandled);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void PatchRequest(RESTServerPatchRequestEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FirePatchRequest(RESTServerPatchRequestEventParams *e) {...}

#define EID_RESTSERVER_POSTREQUEST 17

virtual INT SECUREBLACKBOX_CALL FirePostRequest(LONG64 &lConnectionID, LPSTR &lpszURI, BOOL &bHandled);

class RESTServerPostRequestEventParams {
public:
  qint64 ConnectionID();

  const QString &URI();

  bool Handled();
  void SetHandled(bool bHandled);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void PostRequest(RESTServerPostRequestEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FirePostRequest(RESTServerPostRequestEventParams *e) {...}

#define EID_RESTSERVER_PUTREQUEST 18

virtual INT SECUREBLACKBOX_CALL FirePutRequest(LONG64 &lConnectionID, LPSTR &lpszURI, BOOL &bHandled);

class RESTServerPutRequestEventParams {
public:
  qint64 ConnectionID();

  const QString &URI();

  bool Handled();
  void SetHandled(bool bHandled);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void PutRequest(RESTServerPutRequestEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FirePutRequest(RESTServerPutRequestEventParams *e) {...}

#define EID_RESTSERVER_RESOURCEACCESS 19

virtual INT SECUREBLACKBOX_CALL FireResourceAccess(LONG64 &lConnectionID, LPSTR &lpszHTTPMethod, LPSTR &lpszURI, BOOL &bAllow, LPSTR &lpszRedirectURI);

class RESTServerResourceAccessEventParams {
public:
  qint64 ConnectionID();

  const QString &HTTPMethod();

  const QString &URI();

  bool Allow();
  void SetAllow(bool bAllow);

  const QString &RedirectURI();
  void SetRedirectURI(const QString &qsRedirectURI);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void ResourceAccess(RESTServerResourceAccessEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireResourceAccess(RESTServerResourceAccessEventParams *e) {...}

#define EID_RESTSERVER_TLSCERTVALIDATE 20

virtual INT SECUREBLACKBOX_CALL FireTLSCertValidate(LONG64 &lConnectionID, BOOL &bAccept);

class RESTServerTLSCertValidateEventParams {
public:
  qint64 ConnectionID();

  bool Accept();
  void SetAccept(bool bAccept);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void TLSCertValidate(RESTServerTLSCertValidateEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireTLSCertValidate(RESTServerTLSCertValidateEventParams *e) {...}

#define EID_RESTSERVER_TLSESTABLISHED 21

virtual INT SECUREBLACKBOX_CALL FireTLSEstablished(LONG64 &lConnectionID);

class RESTServerTLSEstablishedEventParams {
public:
  qint64 ConnectionID();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void TLSEstablished(RESTServerTLSEstablishedEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireTLSEstablished(RESTServerTLSEstablishedEventParams *e) {...}

#define EID_RESTSERVER_TLSHANDSHAKE 22

virtual INT SECUREBLACKBOX_CALL FireTLSHandshake(LONG64 &lConnectionID, LPSTR &lpszServerName, BOOL &bAbort);

class RESTServerTLSHandshakeEventParams {
public:
  qint64 ConnectionID();

  const QString &ServerName();

  bool Abort();
  void SetAbort(bool bAbort);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void TLSHandshake(RESTServerTLSHandshakeEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireTLSHandshake(RESTServerTLSHandshakeEventParams *e) {...}

#define EID_RESTSERVER_TLSPSK 23

virtual INT SECUREBLACKBOX_CALL FireTLSPSK(LONG64 &lConnectionID, LPSTR &lpszIdentity, LPSTR &lpszPSK, LPSTR &lpszCiphersuite);

class RESTServerTLSPSKEventParams {
public:
  qint64 ConnectionID();

  const QString &Identity();

  const QString &PSK();
  void SetPSK(const QString &qsPSK);

  const QString &Ciphersuite();
  void SetCiphersuite(const QString &qsCiphersuite);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void TLSPSK(RESTServerTLSPSKEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireTLSPSK(RESTServerTLSPSKEventParams *e) {...}

#define EID_RESTSERVER_TLSSHUTDOWN 24

virtual INT SECUREBLACKBOX_CALL FireTLSShutdown(LONG64 &lConnectionID);

class RESTServerTLSShutdownEventParams {
public:
  qint64 ConnectionID();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void TLSShutdown(RESTServerTLSShutdownEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireTLSShutdown(RESTServerTLSShutdownEventParams *e) {...}

#define EID_RESTSERVER_TRACEREQUEST 25

virtual INT SECUREBLACKBOX_CALL FireTraceRequest(LONG64 &lConnectionID, LPSTR &lpszURI, BOOL &bHandled);

class RESTServerTraceRequestEventParams {
public:
  qint64 ConnectionID();

  const QString &URI();

  bool Handled();
  void SetHandled(bool bHandled);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void TraceRequest(RESTServerTraceRequestEventParams *e);

// Or, subclass RESTServer and override this emitter function.
virtual int FireTraceRequest(RESTServerTraceRequestEventParams *e) {...}