int secureblackbox_ftpserver_getactive(void* lpObj);

bool GetActive();

int secureblackbox_ftpserver_getallowanonymous(void* lpObj);
int secureblackbox_ftpserver_setallowanonymous(void* lpObj, int bAllowAnonymous);

bool GetAllowAnonymous();
int SetAllowAnonymous(bool bAllowAnonymous);

char* secureblackbox_ftpserver_getclientfileentryaccesstime(void* lpObj);
int secureblackbox_ftpserver_setclientfileentryaccesstime(void* lpObj, const char* lpszClientFileEntryAccessTime);

char* secureblackbox_ftpserver_getclientfileentrycreationtime(void* lpObj);
int secureblackbox_ftpserver_setclientfileentrycreationtime(void* lpObj, const char* lpszClientFileEntryCreationTime);

int secureblackbox_ftpserver_getclientfileentryentryformat(void* lpObj);
int secureblackbox_ftpserver_setclientfileentryentryformat(void* lpObj, int iClientFileEntryEntryFormat);

int secureblackbox_ftpserver_getclientfileentryfiletype(void* lpObj);
int secureblackbox_ftpserver_setclientfileentryfiletype(void* lpObj, int iClientFileEntryFileType);

int64 secureblackbox_ftpserver_getclientfileentryhandle(void* lpObj);
int secureblackbox_ftpserver_setclientfileentryhandle(void* lpObj, int64 lClientFileEntryHandle);

char* secureblackbox_ftpserver_getclientfileentrymodificationtime(void* lpObj);
int secureblackbox_ftpserver_setclientfileentrymodificationtime(void* lpObj, const char* lpszClientFileEntryModificationTime);

char* secureblackbox_ftpserver_getclientfileentryname(void* lpObj);
int secureblackbox_ftpserver_setclientfileentryname(void* lpObj, const char* lpszClientFileEntryName);

char* secureblackbox_ftpserver_getclientfileentrypath(void* lpObj);
int secureblackbox_ftpserver_setclientfileentrypath(void* lpObj, const char* lpszClientFileEntryPath);

char* secureblackbox_ftpserver_getclientfileentryprincipal(void* lpObj);
int secureblackbox_ftpserver_setclientfileentryprincipal(void* lpObj, const char* lpszClientFileEntryPrincipal);

int64 secureblackbox_ftpserver_getclientfileentrysize(void* lpObj);
int secureblackbox_ftpserver_setclientfileentrysize(void* lpObj, int64 lClientFileEntrySize);

int secureblackbox_ftpserver_getclientfileentryunixperms(void* lpObj);
int secureblackbox_ftpserver_setclientfileentryunixperms(void* lpObj, int iClientFileEntryUnixPerms);

char* secureblackbox_ftpserver_getclientfileentryunparsedname(void* lpObj);
int secureblackbox_ftpserver_setclientfileentryunparsedname(void* lpObj, const char* lpszClientFileEntryUnparsedName);

QString GetClientFileEntryAccessTime();
int SetClientFileEntryAccessTime(QString qsClientFileEntryAccessTime);

QString GetClientFileEntryCreationTime();
int SetClientFileEntryCreationTime(QString qsClientFileEntryCreationTime);

int GetClientFileEntryEntryFormat();
int SetClientFileEntryEntryFormat(int iClientFileEntryEntryFormat);

int GetClientFileEntryFileType();
int SetClientFileEntryFileType(int iClientFileEntryFileType);

qint64 GetClientFileEntryHandle();
int SetClientFileEntryHandle(qint64 lClientFileEntryHandle);

QString GetClientFileEntryModificationTime();
int SetClientFileEntryModificationTime(QString qsClientFileEntryModificationTime);

QString GetClientFileEntryName();
int SetClientFileEntryName(QString qsClientFileEntryName);

QString GetClientFileEntryPath();
int SetClientFileEntryPath(QString qsClientFileEntryPath);

QString GetClientFileEntryPrincipal();
int SetClientFileEntryPrincipal(QString qsClientFileEntryPrincipal);

qint64 GetClientFileEntrySize();
int SetClientFileEntrySize(qint64 lClientFileEntrySize);

int GetClientFileEntryUnixPerms();
int SetClientFileEntryUnixPerms(int iClientFileEntryUnixPerms);

QString GetClientFileEntryUnparsedName();
int SetClientFileEntryUnparsedName(QString qsClientFileEntryUnparsedName);

char* secureblackbox_ftpserver_getdatahost(void* lpObj);
int secureblackbox_ftpserver_setdatahost(void* lpObj, const char* lpszDataHost);

QString GetDataHost();
int SetDataHost(QString qsDataHost);

int secureblackbox_ftpserver_getdataportrangefrom(void* lpObj);
int secureblackbox_ftpserver_setdataportrangefrom(void* lpObj, int iDataPortRangeFrom);

int GetDataPortRangeFrom();
int SetDataPortRangeFrom(int iDataPortRangeFrom);

int secureblackbox_ftpserver_getdataportrangeto(void* lpObj);
int secureblackbox_ftpserver_setdataportrangeto(void* lpObj, int iDataPortRangeTo);

int GetDataPortRangeTo();
int SetDataPortRangeTo(int iDataPortRangeTo);

char* secureblackbox_ftpserver_getexternalcryptoasyncdocumentid(void* lpObj);
int secureblackbox_ftpserver_setexternalcryptoasyncdocumentid(void* lpObj, const char* lpszExternalCryptoAsyncDocumentID);

char* secureblackbox_ftpserver_getexternalcryptocustomparams(void* lpObj);
int secureblackbox_ftpserver_setexternalcryptocustomparams(void* lpObj, const char* lpszExternalCryptoCustomParams);

char* secureblackbox_ftpserver_getexternalcryptodata(void* lpObj);
int secureblackbox_ftpserver_setexternalcryptodata(void* lpObj, const char* lpszExternalCryptoData);

int secureblackbox_ftpserver_getexternalcryptoexternalhashcalculation(void* lpObj);
int secureblackbox_ftpserver_setexternalcryptoexternalhashcalculation(void* lpObj, int bExternalCryptoExternalHashCalculation);

char* secureblackbox_ftpserver_getexternalcryptohashalgorithm(void* lpObj);
int secureblackbox_ftpserver_setexternalcryptohashalgorithm(void* lpObj, const char* lpszExternalCryptoHashAlgorithm);

char* secureblackbox_ftpserver_getexternalcryptokeyid(void* lpObj);
int secureblackbox_ftpserver_setexternalcryptokeyid(void* lpObj, const char* lpszExternalCryptoKeyID);

char* secureblackbox_ftpserver_getexternalcryptokeysecret(void* lpObj);
int secureblackbox_ftpserver_setexternalcryptokeysecret(void* lpObj, const char* lpszExternalCryptoKeySecret);

int secureblackbox_ftpserver_getexternalcryptomethod(void* lpObj);
int secureblackbox_ftpserver_setexternalcryptomethod(void* lpObj, int iExternalCryptoMethod);

int secureblackbox_ftpserver_getexternalcryptomode(void* lpObj);
int secureblackbox_ftpserver_setexternalcryptomode(void* lpObj, int iExternalCryptoMode);

char* secureblackbox_ftpserver_getexternalcryptopublickeyalgorithm(void* lpObj);
int secureblackbox_ftpserver_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_ftpserver_getfipsmode(void* lpObj);
int secureblackbox_ftpserver_setfipsmode(void* lpObj, int bFIPSMode);

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

int secureblackbox_ftpserver_gethandshaketimeout(void* lpObj);
int secureblackbox_ftpserver_sethandshaketimeout(void* lpObj, int iHandshakeTimeout);

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

char* secureblackbox_ftpserver_gethost(void* lpObj);
int secureblackbox_ftpserver_sethost(void* lpObj, const char* lpszHost);

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

int secureblackbox_ftpserver_getimplicitssl(void* lpObj);
int secureblackbox_ftpserver_setimplicitssl(void* lpObj, int bImplicitSSL);

bool GetImplicitSSL();
int SetImplicitSSL(bool bImplicitSSL);

char* secureblackbox_ftpserver_getpassivemodehost(void* lpObj);
int secureblackbox_ftpserver_setpassivemodehost(void* lpObj, const char* lpszPassiveModeHost);

QString GetPassiveModeHost();
int SetPassiveModeHost(QString qsPassiveModeHost);

int secureblackbox_ftpserver_getpinnedclientaeadcipher(void* lpObj);

int secureblackbox_ftpserver_getpinnedclientchainvalidationdetails(void* lpObj);

int secureblackbox_ftpserver_getpinnedclientchainvalidationresult(void* lpObj);

char* secureblackbox_ftpserver_getpinnedclientciphersuite(void* lpObj);

int secureblackbox_ftpserver_getpinnedclientclientauthenticated(void* lpObj);

int secureblackbox_ftpserver_getpinnedclientclientauthrequested(void* lpObj);

int secureblackbox_ftpserver_getpinnedclientconnectionestablished(void* lpObj);

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

char* secureblackbox_ftpserver_getpinnedclientdigestalgorithm(void* lpObj);

char* secureblackbox_ftpserver_getpinnedclientencryptionalgorithm(void* lpObj);

int secureblackbox_ftpserver_getpinnedclientexportable(void* lpObj);

int64 secureblackbox_ftpserver_getpinnedclientid(void* lpObj);

char* secureblackbox_ftpserver_getpinnedclientkeyexchangealgorithm(void* lpObj);

int secureblackbox_ftpserver_getpinnedclientkeyexchangekeybits(void* lpObj);

char* secureblackbox_ftpserver_getpinnedclientnamedeccurve(void* lpObj);

int secureblackbox_ftpserver_getpinnedclientpfscipher(void* lpObj);

char* secureblackbox_ftpserver_getpinnedclientpresharedidentity(void* lpObj);

char* secureblackbox_ftpserver_getpinnedclientpresharedidentityhint(void* lpObj);

int secureblackbox_ftpserver_getpinnedclientpublickeybits(void* lpObj);

char* secureblackbox_ftpserver_getpinnedclientremoteaddress(void* lpObj);

int secureblackbox_ftpserver_getpinnedclientremoteport(void* lpObj);

int secureblackbox_ftpserver_getpinnedclientresumedsession(void* lpObj);

int secureblackbox_ftpserver_getpinnedclientsecureconnection(void* lpObj);

int secureblackbox_ftpserver_getpinnedclientserverauthenticated(void* lpObj);

char* secureblackbox_ftpserver_getpinnedclientsignaturealgorithm(void* lpObj);

int secureblackbox_ftpserver_getpinnedclientsymmetricblocksize(void* lpObj);

int secureblackbox_ftpserver_getpinnedclientsymmetrickeybits(void* lpObj);

int64 secureblackbox_ftpserver_getpinnedclienttotalbytesreceived(void* lpObj);

int64 secureblackbox_ftpserver_getpinnedclienttotalbytessent(void* lpObj);

char* secureblackbox_ftpserver_getpinnedclientvalidationlog(void* lpObj);

char* secureblackbox_ftpserver_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_ftpserver_getpinnedclientcertcount(void* lpObj);

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

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

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

int64 secureblackbox_ftpserver_getpinnedclientcerthandle(void* lpObj, int pinnedclientcertindex);

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

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

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

int secureblackbox_ftpserver_getpinnedclientcertkeybits(void* lpObj, int pinnedclientcertindex);

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

int secureblackbox_ftpserver_getpinnedclientcertkeyusage(void* lpObj, int pinnedclientcertindex);

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

int secureblackbox_ftpserver_getpinnedclientcertselfsigned(void* lpObj, int pinnedclientcertindex);

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

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

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

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

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

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

char* secureblackbox_ftpserver_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_ftpserver_getport(void* lpObj);
int secureblackbox_ftpserver_setport(void* lpObj, int iPort);

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

int secureblackbox_ftpserver_getreadonly(void* lpObj);
int secureblackbox_ftpserver_setreadonly(void* lpObj, int bReadOnly);

bool GetReadOnly();
int SetReadOnly(bool bReadOnly);

char* secureblackbox_ftpserver_getrootdirectory(void* lpObj);
int secureblackbox_ftpserver_setrootdirectory(void* lpObj, const char* lpszRootDirectory);

QString GetRootDirectory();
int SetRootDirectory(QString qsRootDirectory);

int secureblackbox_ftpserver_getsecurityoptions(void* lpObj);
int secureblackbox_ftpserver_setsecurityoptions(void* lpObj, int iSecurityOptions);

int GetSecurityOptions();
int SetSecurityOptions(int iSecurityOptions);

int secureblackbox_ftpserver_getsessiontimeout(void* lpObj);
int secureblackbox_ftpserver_setsessiontimeout(void* lpObj, int iSessionTimeout);

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

int secureblackbox_ftpserver_getsocketincomingspeedlimit(void* lpObj);
int secureblackbox_ftpserver_setsocketincomingspeedlimit(void* lpObj, int iSocketIncomingSpeedLimit);

char* secureblackbox_ftpserver_getsocketlocaladdress(void* lpObj);
int secureblackbox_ftpserver_setsocketlocaladdress(void* lpObj, const char* lpszSocketLocalAddress);

int secureblackbox_ftpserver_getsocketlocalport(void* lpObj);
int secureblackbox_ftpserver_setsocketlocalport(void* lpObj, int iSocketLocalPort);

int secureblackbox_ftpserver_getsocketoutgoingspeedlimit(void* lpObj);
int secureblackbox_ftpserver_setsocketoutgoingspeedlimit(void* lpObj, int iSocketOutgoingSpeedLimit);

int secureblackbox_ftpserver_getsockettimeout(void* lpObj);
int secureblackbox_ftpserver_setsockettimeout(void* lpObj, int iSocketTimeout);

int secureblackbox_ftpserver_getsocketuseipv6(void* lpObj);
int secureblackbox_ftpserver_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_ftpserver_gettlsservercertcount(void* lpObj);
int secureblackbox_ftpserver_settlsservercertcount(void* lpObj, int iTLSServerCertCount);

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

int64 secureblackbox_ftpserver_gettlsservercerthandle(void* lpObj, int tlsservercertindex);
int secureblackbox_ftpserver_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_ftpserver_gettlsautovalidatecertificates(void* lpObj);
int secureblackbox_ftpserver_settlsautovalidatecertificates(void* lpObj, int bTLSAutoValidateCertificates);

int secureblackbox_ftpserver_gettlsbaseconfiguration(void* lpObj);
int secureblackbox_ftpserver_settlsbaseconfiguration(void* lpObj, int iTLSBaseConfiguration);

char* secureblackbox_ftpserver_gettlsciphersuites(void* lpObj);
int secureblackbox_ftpserver_settlsciphersuites(void* lpObj, const char* lpszTLSCiphersuites);

int secureblackbox_ftpserver_gettlsclientauth(void* lpObj);
int secureblackbox_ftpserver_settlsclientauth(void* lpObj, int iTLSClientAuth);

char* secureblackbox_ftpserver_gettlseccurves(void* lpObj);
int secureblackbox_ftpserver_settlseccurves(void* lpObj, const char* lpszTLSECCurves);

char* secureblackbox_ftpserver_gettlsextensions(void* lpObj);
int secureblackbox_ftpserver_settlsextensions(void* lpObj, const char* lpszTLSExtensions);

int secureblackbox_ftpserver_gettlsforceresumeifdestinationchanges(void* lpObj);
int secureblackbox_ftpserver_settlsforceresumeifdestinationchanges(void* lpObj, int bTLSForceResumeIfDestinationChanges);

char* secureblackbox_ftpserver_gettlspresharedidentity(void* lpObj);
int secureblackbox_ftpserver_settlspresharedidentity(void* lpObj, const char* lpszTLSPreSharedIdentity);

char* secureblackbox_ftpserver_gettlspresharedkey(void* lpObj);
int secureblackbox_ftpserver_settlspresharedkey(void* lpObj, const char* lpszTLSPreSharedKey);

char* secureblackbox_ftpserver_gettlspresharedkeyciphersuite(void* lpObj);
int secureblackbox_ftpserver_settlspresharedkeyciphersuite(void* lpObj, const char* lpszTLSPreSharedKeyCiphersuite);

int secureblackbox_ftpserver_gettlsrenegotiationattackpreventionmode(void* lpObj);
int secureblackbox_ftpserver_settlsrenegotiationattackpreventionmode(void* lpObj, int iTLSRenegotiationAttackPreventionMode);

int secureblackbox_ftpserver_gettlsrevocationcheck(void* lpObj);
int secureblackbox_ftpserver_settlsrevocationcheck(void* lpObj, int iTLSRevocationCheck);

int secureblackbox_ftpserver_gettlsssloptions(void* lpObj);
int secureblackbox_ftpserver_settlsssloptions(void* lpObj, int iTLSSSLOptions);

int secureblackbox_ftpserver_gettlstlsmode(void* lpObj);
int secureblackbox_ftpserver_settlstlsmode(void* lpObj, int iTLSTLSMode);

int secureblackbox_ftpserver_gettlsuseextendedmastersecret(void* lpObj);
int secureblackbox_ftpserver_settlsuseextendedmastersecret(void* lpObj, int bTLSUseExtendedMasterSecret);

int secureblackbox_ftpserver_gettlsusesessionresumption(void* lpObj);
int secureblackbox_ftpserver_settlsusesessionresumption(void* lpObj, int bTLSUseSessionResumption);

int secureblackbox_ftpserver_gettlsversions(void* lpObj);
int secureblackbox_ftpserver_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_ftpserver_getusercount(void* lpObj);
int secureblackbox_ftpserver_setusercount(void* lpObj, int iUserCount);

int secureblackbox_ftpserver_getuserassociateddata(void* lpObj, int userindex, char** lpUserAssociatedData, int* lenUserAssociatedData);
int secureblackbox_ftpserver_setuserassociateddata(void* lpObj, int userindex, const char* lpUserAssociatedData, int lenUserAssociatedData);

char* secureblackbox_ftpserver_getuserbasepath(void* lpObj, int userindex);
int secureblackbox_ftpserver_setuserbasepath(void* lpObj, int userindex, const char* lpszUserBasePath);

char* secureblackbox_ftpserver_getuserdata(void* lpObj, int userindex);
int secureblackbox_ftpserver_setuserdata(void* lpObj, int userindex, const char* lpszUserData);

int64 secureblackbox_ftpserver_getuserhandle(void* lpObj, int userindex);
int secureblackbox_ftpserver_setuserhandle(void* lpObj, int userindex, int64 lUserHandle);

char* secureblackbox_ftpserver_getuserhashalgorithm(void* lpObj, int userindex);
int secureblackbox_ftpserver_setuserhashalgorithm(void* lpObj, int userindex, const char* lpszUserHashAlgorithm);

int secureblackbox_ftpserver_getuserincomingspeedlimit(void* lpObj, int userindex);
int secureblackbox_ftpserver_setuserincomingspeedlimit(void* lpObj, int userindex, int iUserIncomingSpeedLimit);

int secureblackbox_ftpserver_getuseroutgoingspeedlimit(void* lpObj, int userindex);
int secureblackbox_ftpserver_setuseroutgoingspeedlimit(void* lpObj, int userindex, int iUserOutgoingSpeedLimit);

char* secureblackbox_ftpserver_getuserpassword(void* lpObj, int userindex);
int secureblackbox_ftpserver_setuserpassword(void* lpObj, int userindex, const char* lpszUserPassword);

int secureblackbox_ftpserver_getusersharedsecret(void* lpObj, int userindex, char** lpUserSharedSecret, int* lenUserSharedSecret);
int secureblackbox_ftpserver_setusersharedsecret(void* lpObj, int userindex, const char* lpUserSharedSecret, int lenUserSharedSecret);

char* secureblackbox_ftpserver_getuserusername(void* lpObj, int userindex);
int secureblackbox_ftpserver_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);

int secureblackbox_ftpserver_getuseutf8(void* lpObj);
int secureblackbox_ftpserver_setuseutf8(void* lpObj, int bUseUTF8);

bool GetUseUTF8();
int SetUseUTF8(bool bUseUTF8);

int secureblackbox_ftpserver_cleanup(void* lpObj);

int Cleanup();

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

QString Config(const QString& qsConfigurationString);

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

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

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

int DropClient(qint64 lConnectionId, bool bForced);

char* secureblackbox_ftpserver_getclientbuffer(void* lpObj, int64 lConnectionID, int *lpSize);

QByteArray GetClientBuffer(qint64 lConnectionID);

char* secureblackbox_ftpserver_listclients(void* lpObj);

QString ListClients();

int secureblackbox_ftpserver_pinclient(void* lpObj, int64 lConnectionId);

int PinClient(qint64 lConnectionId);

int secureblackbox_ftpserver_reset(void* lpObj);

int Reset();

int secureblackbox_ftpserver_setclientbuffer(void* lpObj, int64 lConnectionID, const char* lpValue, int lenValue);

int SetClientBuffer(qint64 lConnectionID, QByteArray qbaValue);

int secureblackbox_ftpserver_setclientfileentry(void* lpObj, int64 lConnectionID);

int SetClientFileEntry(qint64 lConnectionID);

int secureblackbox_ftpserver_start(void* lpObj);

int Start();

int secureblackbox_ftpserver_stop(void* lpObj);

int Stop();

#define EID_FTPSERVER_ACCEPT 1

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

class FTPServerAcceptEventParams {
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(FTPServerAcceptEventParams *e);

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

#define EID_FTPSERVER_AFTERCHANGEDIRECTORY 2

virtual INT SECUREBLACKBOX_CALL FireAfterChangeDirectory(LONG64 &lConnectionID, LPSTR &lpszDirectory, INT &iOperationStatus);

class FTPServerAfterChangeDirectoryEventParams {
public:
  qint64 ConnectionID();

  const QString &Directory();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireAfterChangeDirectory(FTPServerAfterChangeDirectoryEventParams *e) {...}

#define EID_FTPSERVER_AFTERCREATEDIRECTORY 3

virtual INT SECUREBLACKBOX_CALL FireAfterCreateDirectory(LONG64 &lConnectionID, LPSTR &lpszDirectory, INT &iOperationStatus);

class FTPServerAfterCreateDirectoryEventParams {
public:
  qint64 ConnectionID();

  const QString &Directory();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireAfterCreateDirectory(FTPServerAfterCreateDirectoryEventParams *e) {...}

#define EID_FTPSERVER_AFTERREMOVEDIRECTORY 4

virtual INT SECUREBLACKBOX_CALL FireAfterRemoveDirectory(LONG64 &lConnectionID, LPSTR &lpszDirectory, INT &iOperationStatus);

class FTPServerAfterRemoveDirectoryEventParams {
public:
  qint64 ConnectionID();

  const QString &Directory();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireAfterRemoveDirectory(FTPServerAfterRemoveDirectoryEventParams *e) {...}

#define EID_FTPSERVER_AFTERREMOVEFILE 5

virtual INT SECUREBLACKBOX_CALL FireAfterRemoveFile(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iOperationStatus);

class FTPServerAfterRemoveFileEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireAfterRemoveFile(FTPServerAfterRemoveFileEventParams *e) {...}

#define EID_FTPSERVER_AFTERRENAMEFILE 6

virtual INT SECUREBLACKBOX_CALL FireAfterRenameFile(LONG64 &lConnectionID, LPSTR &lpszOldPath, LPSTR &lpszNewPath, INT &iOperationStatus);

class FTPServerAfterRenameFileEventParams {
public:
  qint64 ConnectionID();

  const QString &OldPath();

  const QString &NewPath();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireAfterRenameFile(FTPServerAfterRenameFileEventParams *e) {...}

#define EID_FTPSERVER_AFTERREQUESTATTRIBUTES 7

virtual INT SECUREBLACKBOX_CALL FireAfterRequestAttributes(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iOperationStatus);

class FTPServerAfterRequestAttributesEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireAfterRequestAttributes(FTPServerAfterRequestAttributesEventParams *e) {...}

#define EID_FTPSERVER_AUTHATTEMPT 8

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

class FTPServerAuthAttemptEventParams {
public:
  qint64 ConnectionID();

  const QString &Username();

  const QString &Password();

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

  const QString &BasePath();
  void SetBasePath(const QString &qsBasePath);

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

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

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

#define EID_FTPSERVER_BEFORECHANGEDIRECTORY 9

virtual INT SECUREBLACKBOX_CALL FireBeforeChangeDirectory(LONG64 &lConnectionID, LPSTR &lpszDirectory, INT &iAction);

class FTPServerBeforeChangeDirectoryEventParams {
public:
  qint64 ConnectionID();

  const QString &Directory();

  int Action();
  void SetAction(int iAction);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireBeforeChangeDirectory(FTPServerBeforeChangeDirectoryEventParams *e) {...}

#define EID_FTPSERVER_BEFORECREATEDIRECTORY 10

virtual INT SECUREBLACKBOX_CALL FireBeforeCreateDirectory(LONG64 &lConnectionID, LPSTR &lpszDirectory, INT &iAction);

class FTPServerBeforeCreateDirectoryEventParams {
public:
  qint64 ConnectionID();

  const QString &Directory();

  int Action();
  void SetAction(int iAction);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireBeforeCreateDirectory(FTPServerBeforeCreateDirectoryEventParams *e) {...}

#define EID_FTPSERVER_BEFOREDOWNLOADFILE 11

virtual INT SECUREBLACKBOX_CALL FireBeforeDownloadFile(LONG64 &lConnectionID, LPSTR &lpszPath, LONG64 &lRestartAt, INT &iAction);

class FTPServerBeforeDownloadFileEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

  qint64 RestartAt();

  int Action();
  void SetAction(int iAction);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireBeforeDownloadFile(FTPServerBeforeDownloadFileEventParams *e) {...}

#define EID_FTPSERVER_BEFOREFIND 12

virtual INT SECUREBLACKBOX_CALL FireBeforeFind(LONG64 &lConnectionID, LPSTR &lpszDirectory, INT &iAction);

class FTPServerBeforeFindEventParams {
public:
  qint64 ConnectionID();

  const QString &Directory();

  int Action();
  void SetAction(int iAction);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireBeforeFind(FTPServerBeforeFindEventParams *e) {...}

#define EID_FTPSERVER_BEFOREREMOVEDIRECTORY 13

virtual INT SECUREBLACKBOX_CALL FireBeforeRemoveDirectory(LONG64 &lConnectionID, LPSTR &lpszDirectory, INT &iAction);

class FTPServerBeforeRemoveDirectoryEventParams {
public:
  qint64 ConnectionID();

  const QString &Directory();

  int Action();
  void SetAction(int iAction);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireBeforeRemoveDirectory(FTPServerBeforeRemoveDirectoryEventParams *e) {...}

#define EID_FTPSERVER_BEFOREREMOVEFILE 14

virtual INT SECUREBLACKBOX_CALL FireBeforeRemoveFile(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iAction);

class FTPServerBeforeRemoveFileEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

  int Action();
  void SetAction(int iAction);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireBeforeRemoveFile(FTPServerBeforeRemoveFileEventParams *e) {...}

#define EID_FTPSERVER_BEFORERENAMEFILE 15

virtual INT SECUREBLACKBOX_CALL FireBeforeRenameFile(LONG64 &lConnectionID, LPSTR &lpszOldPath, LPSTR &lpszNewPath, INT &iAction);

class FTPServerBeforeRenameFileEventParams {
public:
  qint64 ConnectionID();

  const QString &OldPath();

  const QString &NewPath();

  int Action();
  void SetAction(int iAction);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireBeforeRenameFile(FTPServerBeforeRenameFileEventParams *e) {...}

#define EID_FTPSERVER_BEFOREREQUESTATTRIBUTES 16

virtual INT SECUREBLACKBOX_CALL FireBeforeRequestAttributes(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iAction);

class FTPServerBeforeRequestAttributesEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

  int Action();
  void SetAction(int iAction);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireBeforeRequestAttributes(FTPServerBeforeRequestAttributesEventParams *e) {...}

#define EID_FTPSERVER_BEFORESENDREPLY 17

virtual INT SECUREBLACKBOX_CALL FireBeforeSendReply(LONG64 &lConnectionID, INT &iCode, LPSTR &lpszReply, LPSTR &lpszCommand);

class FTPServerBeforeSendReplyEventParams {
public:
  qint64 ConnectionID();

  int Code();
  void SetCode(int iCode);

  const QString &Reply();
  void SetReply(const QString &qsReply);

  const QString &Command();

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireBeforeSendReply(FTPServerBeforeSendReplyEventParams *e) {...}

#define EID_FTPSERVER_BEFOREUPLOADFILE 18

virtual INT SECUREBLACKBOX_CALL FireBeforeUploadFile(LONG64 &lConnectionID, LPSTR &lpszPath, LONG64 &lRestartAt, BOOL &bAppend, INT &iAction);

class FTPServerBeforeUploadFileEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

  qint64 RestartAt();

  bool Append();

  int Action();
  void SetAction(int iAction);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireBeforeUploadFile(FTPServerBeforeUploadFileEventParams *e) {...}

#define EID_FTPSERVER_CHANGEDIRECTORY 19

virtual INT SECUREBLACKBOX_CALL FireChangeDirectory(LONG64 &lConnectionID, LPSTR &lpszDirectory, INT &iOperationStatus);

class FTPServerChangeDirectoryEventParams {
public:
  qint64 ConnectionID();

  const QString &Directory();
  void SetDirectory(const QString &qsDirectory);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireChangeDirectory(FTPServerChangeDirectoryEventParams *e) {...}

#define EID_FTPSERVER_COMMANDPROCESSED 20

virtual INT SECUREBLACKBOX_CALL FireCommandProcessed(LONG64 &lConnectionID, LPSTR &lpszCurrentDirectory, LPSTR &lpszCommand, INT &iReplyCode);

class FTPServerCommandProcessedEventParams {
public:
  qint64 ConnectionID();

  const QString &CurrentDirectory();

  const QString &Command();

  int ReplyCode();

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireCommandProcessed(FTPServerCommandProcessedEventParams *e) {...}

#define EID_FTPSERVER_COMMANDRECEIVED 21

virtual INT SECUREBLACKBOX_CALL FireCommandReceived(LONG64 &lConnectionID, LPSTR &lpszCommand, LPSTR &lpszParameters, BOOL &bIgnore);

class FTPServerCommandReceivedEventParams {
public:
  qint64 ConnectionID();

  const QString &Command();

  const QString &Parameters();

  bool Ignore();
  void SetIgnore(bool bIgnore);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireCommandReceived(FTPServerCommandReceivedEventParams *e) {...}

#define EID_FTPSERVER_CONNECT 22

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

class FTPServerConnectEventParams {
public:
  qint64 ConnectionID();

  const QString &RemoteAddress();

  int Port();

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

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

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

#define EID_FTPSERVER_CREATEDIRECTORY 23

virtual INT SECUREBLACKBOX_CALL FireCreateDirectory(LONG64 &lConnectionID, LPSTR &lpszDirectory, INT &iOperationStatus);

class FTPServerCreateDirectoryEventParams {
public:
  qint64 ConnectionID();

  const QString &Directory();
  void SetDirectory(const QString &qsDirectory);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireCreateDirectory(FTPServerCreateDirectoryEventParams *e) {...}

#define EID_FTPSERVER_DISCONNECT 24

virtual INT SECUREBLACKBOX_CALL FireDisconnect(LONG64 &lConnectionID);

class FTPServerDisconnectEventParams {
public:
  qint64 ConnectionID();

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

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

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

#define EID_FTPSERVER_DOWNLOADBEGIN 25

virtual INT SECUREBLACKBOX_CALL FireDownloadBegin(LONG64 &lConnectionID, LPSTR &lpszPath);

class FTPServerDownloadBeginEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireDownloadBegin(FTPServerDownloadBeginEventParams *e) {...}

#define EID_FTPSERVER_DOWNLOADEND 26

virtual INT SECUREBLACKBOX_CALL FireDownloadEnd(LONG64 &lConnectionID, LPSTR &lpszPath);

class FTPServerDownloadEndEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireDownloadEnd(FTPServerDownloadEndEventParams *e) {...}

#define EID_FTPSERVER_DOWNLOADFILE 27

virtual INT SECUREBLACKBOX_CALL FireDownloadFile(LONG64 &lConnectionID, LPSTR &lpszPath, LONG64 &lRestartAt, INT &iOperationStatus);

class FTPServerDownloadFileEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

  qint64 RestartAt();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireDownloadFile(FTPServerDownloadFileEventParams *e) {...}

#define EID_FTPSERVER_DOWNLOADPROGRESS 28

virtual INT SECUREBLACKBOX_CALL FireDownloadProgress(LONG64 &lConnectionID, LPSTR &lpszPath, LONG64 &lProgress, LONG64 &lTotal);

class FTPServerDownloadProgressEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

  qint64 Progress();

  qint64 Total();

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireDownloadProgress(FTPServerDownloadProgressEventParams *e) {...}

#define EID_FTPSERVER_ERROR 29

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

class FTPServerErrorEventParams {
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(FTPServerErrorEventParams *e);

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

#define EID_FTPSERVER_EXTERNALSIGN 30

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

class FTPServerExternalSignEventParams {
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(FTPServerExternalSignEventParams *e);

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

#define EID_FTPSERVER_FINDCLOSE 31

virtual INT SECUREBLACKBOX_CALL FireFindClose(LONG64 &lConnectionID, INT &iOperationStatus);

class FTPServerFindCloseEventParams {
public:
  qint64 ConnectionID();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireFindClose(FTPServerFindCloseEventParams *e) {...}

#define EID_FTPSERVER_FINDINIT 32

virtual INT SECUREBLACKBOX_CALL FireFindInit(LONG64 &lConnectionID, LPSTR &lpszDirectory, INT &iOperationStatus);

class FTPServerFindInitEventParams {
public:
  qint64 ConnectionID();

  const QString &Directory();
  void SetDirectory(const QString &qsDirectory);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireFindInit(FTPServerFindInitEventParams *e) {...}

#define EID_FTPSERVER_FINDNEXT 33

virtual INT SECUREBLACKBOX_CALL FireFindNext(LONG64 &lConnectionID, INT &iOperationStatus);

class FTPServerFindNextEventParams {
public:
  qint64 ConnectionID();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireFindNext(FTPServerFindNextEventParams *e) {...}

#define EID_FTPSERVER_NOTIFICATION 34

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

class FTPServerNotificationEventParams {
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(FTPServerNotificationEventParams *e);

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

#define EID_FTPSERVER_READFILE 35

virtual INT SECUREBLACKBOX_CALL FireReadFile(LONG64 &lConnectionID, INT &iSize, INT &iOperationStatus);

class FTPServerReadFileEventParams {
public:
  qint64 ConnectionID();

  int Size();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireReadFile(FTPServerReadFileEventParams *e) {...}

#define EID_FTPSERVER_REMOVEDIRECTORY 36

virtual INT SECUREBLACKBOX_CALL FireRemoveDirectory(LONG64 &lConnectionID, LPSTR &lpszDirectory, INT &iOperationStatus);

class FTPServerRemoveDirectoryEventParams {
public:
  qint64 ConnectionID();

  const QString &Directory();
  void SetDirectory(const QString &qsDirectory);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireRemoveDirectory(FTPServerRemoveDirectoryEventParams *e) {...}

#define EID_FTPSERVER_REMOVEFILE 37

virtual INT SECUREBLACKBOX_CALL FireRemoveFile(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iOperationStatus);

class FTPServerRemoveFileEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireRemoveFile(FTPServerRemoveFileEventParams *e) {...}

#define EID_FTPSERVER_RENAMEFILE 38

virtual INT SECUREBLACKBOX_CALL FireRenameFile(LONG64 &lConnectionID, LPSTR &lpszOldPath, LPSTR &lpszNewPath, INT &iOperationStatus);

class FTPServerRenameFileEventParams {
public:
  qint64 ConnectionID();

  const QString &OldPath();

  const QString &NewPath();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireRenameFile(FTPServerRenameFileEventParams *e) {...}

#define EID_FTPSERVER_REQUESTATTRIBUTES 39

virtual INT SECUREBLACKBOX_CALL FireRequestAttributes(LONG64 &lConnectionID, LPSTR &lpszPath, INT &iOperationStatus);

class FTPServerRequestAttributesEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireRequestAttributes(FTPServerRequestAttributesEventParams *e) {...}

#define EID_FTPSERVER_TLSCERTVALIDATE 40

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

class FTPServerTLSCertValidateEventParams {
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(FTPServerTLSCertValidateEventParams *e);

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

#define EID_FTPSERVER_TLSESTABLISHED 41

virtual INT SECUREBLACKBOX_CALL FireTLSEstablished(LONG64 &lConnectionID);

class FTPServerTLSEstablishedEventParams {
public:
  qint64 ConnectionID();

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

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

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

#define EID_FTPSERVER_TLSHANDSHAKE 42

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

class FTPServerTLSHandshakeEventParams {
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(FTPServerTLSHandshakeEventParams *e);

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

#define EID_FTPSERVER_TLSPSK 43

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

class FTPServerTLSPSKEventParams {
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(FTPServerTLSPSKEventParams *e);

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

#define EID_FTPSERVER_TLSSHUTDOWN 44

virtual INT SECUREBLACKBOX_CALL FireTLSShutdown(LONG64 &lConnectionID);

class FTPServerTLSShutdownEventParams {
public:
  qint64 ConnectionID();

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

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

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

#define EID_FTPSERVER_TRANSFERCOMPLETED 45

virtual INT SECUREBLACKBOX_CALL FireTransferCompleted(LONG64 &lConnectionID, INT &iOperationStatus);

class FTPServerTransferCompletedEventParams {
public:
  qint64 ConnectionID();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireTransferCompleted(FTPServerTransferCompletedEventParams *e) {...}

#define EID_FTPSERVER_UPLOADBEGIN 46

virtual INT SECUREBLACKBOX_CALL FireUploadBegin(LONG64 &lConnectionID, LPSTR &lpszPath);

class FTPServerUploadBeginEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireUploadBegin(FTPServerUploadBeginEventParams *e) {...}

#define EID_FTPSERVER_UPLOADEND 47

virtual INT SECUREBLACKBOX_CALL FireUploadEnd(LONG64 &lConnectionID, LPSTR &lpszPath);

class FTPServerUploadEndEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireUploadEnd(FTPServerUploadEndEventParams *e) {...}

#define EID_FTPSERVER_UPLOADFILE 48

virtual INT SECUREBLACKBOX_CALL FireUploadFile(LONG64 &lConnectionID, LPSTR &lpszPath, LONG64 &lRestartAt, BOOL &bAppend, INT &iOperationStatus);

class FTPServerUploadFileEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

  qint64 RestartAt();

  bool Append();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireUploadFile(FTPServerUploadFileEventParams *e) {...}

#define EID_FTPSERVER_UPLOADPROGRESS 49

virtual INT SECUREBLACKBOX_CALL FireUploadProgress(LONG64 &lConnectionID, LPSTR &lpszPath, LONG64 &lProgress, LONG64 &lTotal);

class FTPServerUploadProgressEventParams {
public:
  qint64 ConnectionID();

  const QString &Path();

  qint64 Progress();

  qint64 Total();

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireUploadProgress(FTPServerUploadProgressEventParams *e) {...}

#define EID_FTPSERVER_WRITEFILE 50

virtual INT SECUREBLACKBOX_CALL FireWriteFile(LONG64 &lConnectionID, INT &iOperationStatus);

class FTPServerWriteFileEventParams {
public:
  qint64 ConnectionID();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass FTPServer and override this emitter function.
virtual int FireWriteFile(FTPServerWriteFileEventParams *e) {...}