├── .appveyor.yml
├── .clang-format
├── .github
    ├── pull_request_template.md
    ├── pull_request_template.md.license
    └── workflows
    │   ├── push-docs.yml
    │   └── tests.yml
├── .gitignore
├── AUTHORS
├── CHANGELOG.md
├── CMakeLists.txt
├── CONTRIBUTING.md
├── LICENSES
    ├── CC-BY-SA-4.0.txt
    ├── CC0-1.0.txt
    ├── LGPL-2.1-or-later.txt
    ├── LicenseRef-MIT-variant.txt
    └── MIT.txt
├── QXmppConfig.cmake.in
├── README.md
├── SECURITY.md
├── cmake
    ├── QXmppLegacyConfig.cmake.in
    ├── QXmppLegacyConfigVersion.cmake
    └── modules
    │   ├── FindGLIB2.cmake
    │   ├── FindGObject.cmake
    │   ├── FindGStreamer.cmake
    │   └── MacroFindGStreamerLibrary.cmake
├── doc
    ├── CMakeLists.txt
    ├── Doxyfile.in
    ├── doap-rendering
    │   ├── README.md
    │   ├── doap.css
    │   ├── doap.xsl
    │   ├── update-xeplist.sh
    │   ├── xeplist.xml
    │   └── xeplist.xml.license
    ├── doap.xml
    ├── index.doc
    ├── using.doc
    └── xep.doc
├── examples
    ├── CMakeLists.txt
    ├── example_0_connected
    │   ├── README
    │   └── example_0_connected.cpp
    ├── example_1_echoClient
    │   ├── README
    │   ├── example_1_echoClient.cpp
    │   └── example_1_echoClient.h
    ├── example_2_rosterHandling
    │   ├── README
    │   ├── example_2_rosterHandling.cpp
    │   └── example_2_rosterHandling.h
    ├── example_3_transferHandling
    │   ├── example_3_transferHandling.cpp
    │   ├── example_3_transferHandling.h
    │   └── example_3_transferHandling.qrc
    ├── example_5_rpcInterface
    │   ├── CMakeLists.txt
    │   ├── main.cpp
    │   ├── remoteinterface.cpp
    │   ├── remoteinterface.h
    │   ├── xmlrpctest.txt
    │   └── xmlrpctest.txt.license
    ├── example_6_rpcClient
    │   ├── CMakeLists.txt
    │   ├── main.cpp
    │   ├── rpcClient.cpp
    │   └── rpcClient.h
    ├── example_7_archiveHandling
    │   ├── example_7_archiveHandling.cpp
    │   └── example_7_archiveHandling.h
    ├── example_8_server
    │   └── example_8_server.cpp
    └── example_9_vCard
    │   ├── CMakeLists.txt
    │   ├── README
    │   ├── example_9_vCard.cpp
    │   └── example_9_vCard.h
├── logo.svg
├── logo.svg.license
├── qxmpp.pc.in
├── qxmpp_legacy.pc.in
├── src
    ├── CMakeLists.txt
    ├── base
    │   ├── Algorithms.h
    │   ├── QXmppArchiveIq.cpp
    │   ├── QXmppArchiveIq.h
    │   ├── QXmppBindIq.cpp
    │   ├── QXmppBindIq.h
    │   ├── QXmppBitsOfBinaryContentId.cpp
    │   ├── QXmppBitsOfBinaryContentId.h
    │   ├── QXmppBitsOfBinaryData.cpp
    │   ├── QXmppBitsOfBinaryData.h
    │   ├── QXmppBitsOfBinaryDataList.h
    │   ├── QXmppBitsOfBinaryIq.cpp
    │   ├── QXmppBitsOfBinaryIq.h
    │   ├── QXmppBookmarkSet.cpp
    │   ├── QXmppBookmarkSet.h
    │   ├── QXmppByteStreamIq.cpp
    │   ├── QXmppByteStreamIq.h
    │   ├── QXmppColorGeneration.cpp
    │   ├── QXmppColorGeneration.h
    │   ├── QXmppConstants_p.h
    │   ├── QXmppDataForm.cpp
    │   ├── QXmppDataForm.h
    │   ├── QXmppDataFormBase.cpp
    │   ├── QXmppDataFormBase.h
    │   ├── QXmppDiscoveryIq.cpp
    │   ├── QXmppDiscoveryIq.h
    │   ├── QXmppE2eeMetadata.h
    │   ├── QXmppElement.cpp
    │   ├── QXmppElement.h
    │   ├── QXmppEncryptedFileSource.cpp
    │   ├── QXmppEncryptedFileSource.h
    │   ├── QXmppEntityTimeIq.cpp
    │   ├── QXmppEntityTimeIq.h
    │   ├── QXmppError.cpp
    │   ├── QXmppError.h
    │   ├── QXmppExtension.h
    │   ├── QXmppExternalService.h
    │   ├── QXmppExternalServiceDiscoveryIq.cpp
    │   ├── QXmppExternalServiceDiscoveryIq.h
    │   ├── QXmppFallback.h
    │   ├── QXmppFileMetadata.cpp
    │   ├── QXmppFileMetadata.h
    │   ├── QXmppFileShare.cpp
    │   ├── QXmppFileShare.h
    │   ├── QXmppFutureUtils_p.h
    │   ├── QXmppGeolocItem.cpp
    │   ├── QXmppGeolocItem.h
    │   ├── QXmppGlobal.cpp
    │   ├── QXmppGlobal.h
    │   ├── QXmppGlobal_p.h
    │   ├── QXmppHash.cpp
    │   ├── QXmppHash.h
    │   ├── QXmppHashing.cpp
    │   ├── QXmppHashing_p.h
    │   ├── QXmppHttpFileSource.cpp
    │   ├── QXmppHttpFileSource.h
    │   ├── QXmppHttpUploadIq.cpp
    │   ├── QXmppHttpUploadIq.h
    │   ├── QXmppIbbIq.cpp
    │   ├── QXmppIbbIq.h
    │   ├── QXmppIq.cpp
    │   ├── QXmppIq.h
    │   ├── QXmppJingleData.cpp
    │   ├── QXmppJingleData.h
    │   ├── QXmppJingleIq.h
    │   ├── QXmppLogger.cpp
    │   ├── QXmppLogger.h
    │   ├── QXmppMamIq.cpp
    │   ├── QXmppMamIq.h
    │   ├── QXmppMessage.cpp
    │   ├── QXmppMessage.h
    │   ├── QXmppMessageReaction.cpp
    │   ├── QXmppMessageReaction.h
    │   ├── QXmppMixConfigItem.h
    │   ├── QXmppMixInfoItem.h
    │   ├── QXmppMixInvitation.cpp
    │   ├── QXmppMixInvitation.h
    │   ├── QXmppMixIq.cpp
    │   ├── QXmppMixIq.h
    │   ├── QXmppMixIq_p.h
    │   ├── QXmppMixItems.cpp
    │   ├── QXmppMixParticipantItem.h
    │   ├── QXmppMucIq.cpp
    │   ├── QXmppMucIq.h
    │   ├── QXmppNonSASLAuth.cpp
    │   ├── QXmppNonSASLAuth.h
    │   ├── QXmppNonza.cpp
    │   ├── QXmppNonza.h
    │   ├── QXmppOmemoDataBase.cpp
    │   ├── QXmppOmemoElement_p.h
    │   ├── QXmppOmemoEnvelope_p.h
    │   ├── QXmppOutOfBandUrl.cpp
    │   ├── QXmppOutOfBandUrl.h
    │   ├── QXmppPacket.cpp
    │   ├── QXmppPacket_p.h
    │   ├── QXmppPingIq.cpp
    │   ├── QXmppPingIq.h
    │   ├── QXmppPresence.cpp
    │   ├── QXmppPresence.h
    │   ├── QXmppPromise.h
    │   ├── QXmppPubSubAffiliation.cpp
    │   ├── QXmppPubSubAffiliation.h
    │   ├── QXmppPubSubBaseItem.cpp
    │   ├── QXmppPubSubBaseItem.h
    │   ├── QXmppPubSubEvent.cpp
    │   ├── QXmppPubSubEvent.h
    │   ├── QXmppPubSubIq.cpp
    │   ├── QXmppPubSubIq_p.h
    │   ├── QXmppPubSubMetadata.cpp
    │   ├── QXmppPubSubMetadata.h
    │   ├── QXmppPubSubNodeConfig.cpp
    │   ├── QXmppPubSubNodeConfig.h
    │   ├── QXmppPubSubPublishOptions.h
    │   ├── QXmppPubSubSubAuthorization.cpp
    │   ├── QXmppPubSubSubAuthorization.h
    │   ├── QXmppPubSubSubscribeOptions.cpp
    │   ├── QXmppPubSubSubscribeOptions.h
    │   ├── QXmppPubSubSubscription.cpp
    │   ├── QXmppPubSubSubscription.h
    │   ├── QXmppPushEnableIq.cpp
    │   ├── QXmppPushEnableIq.h
    │   ├── QXmppRegisterIq.cpp
    │   ├── QXmppRegisterIq.h
    │   ├── QXmppResultSet.cpp
    │   ├── QXmppResultSet.h
    │   ├── QXmppRosterIq.cpp
    │   ├── QXmppRosterIq.h
    │   ├── QXmppRpcIq.cpp
    │   ├── QXmppRpcIq.h
    │   ├── QXmppSasl.cpp
    │   ├── QXmppSasl2UserAgent.h
    │   ├── QXmppSasl_p.h
    │   ├── QXmppSendResult.h
    │   ├── QXmppSocks.cpp
    │   ├── QXmppSocks.h
    │   ├── QXmppStanza.cpp
    │   ├── QXmppStanza.h
    │   ├── QXmppStanza_p.h
    │   ├── QXmppStreamError.h
    │   ├── QXmppStreamError_p.h
    │   ├── QXmppStreamFeatures.cpp
    │   ├── QXmppStreamFeatures.h
    │   ├── QXmppStreamInitiationIq.cpp
    │   ├── QXmppStreamInitiationIq_p.h
    │   ├── QXmppStreamManagement.cpp
    │   ├── QXmppStreamManagement_p.h
    │   ├── QXmppStun.cpp
    │   ├── QXmppStun.h
    │   ├── QXmppStun_p.h
    │   ├── QXmppTask.cpp
    │   ├── QXmppTask.h
    │   ├── QXmppThumbnail.cpp
    │   ├── QXmppThumbnail.h
    │   ├── QXmppTrustMessageElement.h
    │   ├── QXmppTrustMessageKeyOwner.h
    │   ├── QXmppTrustMessages.cpp
    │   ├── QXmppTrustMessages.h
    │   ├── QXmppUri.cpp
    │   ├── QXmppUri.h
    │   ├── QXmppUserTuneItem.cpp
    │   ├── QXmppUserTuneItem.h
    │   ├── QXmppUtils.cpp
    │   ├── QXmppUtils.h
    │   ├── QXmppUtils_p.h
    │   ├── QXmppVCardIq.cpp
    │   ├── QXmppVCardIq.h
    │   ├── QXmppVersionIq.cpp
    │   ├── QXmppVersionIq.h
    │   ├── Stream.cpp
    │   ├── Stream.h
    │   ├── StringLiterals.h
    │   ├── XmppSocket.h
    │   ├── compat
    │   │   ├── QXmppPubSubIq.h
    │   │   ├── QXmppPubSubItem.h
    │   │   ├── QXmppSessionIq.h
    │   │   ├── QXmppStartTlsPacket.h
    │   │   └── removed_api.cpp
    │   └── hsluv
    │   │   ├── hsluv.c
    │   │   └── hsluv.h
    ├── client
    │   ├── QXmppAccountMigrationManager.cpp
    │   ├── QXmppAccountMigrationManager.h
    │   ├── QXmppArchiveManager.cpp
    │   ├── QXmppArchiveManager.h
    │   ├── QXmppAtmManager.cpp
    │   ├── QXmppAtmManager.h
    │   ├── QXmppAtmTrustMemoryStorage.cpp
    │   ├── QXmppAtmTrustMemoryStorage.h
    │   ├── QXmppAtmTrustStorage.cpp
    │   ├── QXmppAtmTrustStorage.h
    │   ├── QXmppAttentionManager.cpp
    │   ├── QXmppAttentionManager.h
    │   ├── QXmppAuthenticationError.h
    │   ├── QXmppBindError.h
    │   ├── QXmppBlockingManager.cpp
    │   ├── QXmppBlockingManager.h
    │   ├── QXmppBookmarkManager.cpp
    │   ├── QXmppBookmarkManager.h
    │   ├── QXmppCall.cpp
    │   ├── QXmppCall.h
    │   ├── QXmppCallInviteManager.cpp
    │   ├── QXmppCallInviteManager.h
    │   ├── QXmppCallManager.cpp
    │   ├── QXmppCallManager.h
    │   ├── QXmppCallManager_p.h
    │   ├── QXmppCallStream.cpp
    │   ├── QXmppCallStream.h
    │   ├── QXmppCallStream_p.h
    │   ├── QXmppCall_p.h
    │   ├── QXmppCarbonManager.cpp
    │   ├── QXmppCarbonManager.h
    │   ├── QXmppCarbonManagerV2.cpp
    │   ├── QXmppCarbonManagerV2.h
    │   ├── QXmppClient.cpp
    │   ├── QXmppClient.h
    │   ├── QXmppClientExtension.cpp
    │   ├── QXmppClientExtension.h
    │   ├── QXmppClient_p.h
    │   ├── QXmppConfiguration.cpp
    │   ├── QXmppConfiguration.h
    │   ├── QXmppCredentials.h
    │   ├── QXmppDiscoveryManager.cpp
    │   ├── QXmppDiscoveryManager.h
    │   ├── QXmppE2eeExtension.cpp
    │   ├── QXmppE2eeExtension.h
    │   ├── QXmppEncryptedFileSharingProvider.cpp
    │   ├── QXmppEncryptedFileSharingProvider.h
    │   ├── QXmppEntityTimeManager.cpp
    │   ├── QXmppEntityTimeManager.h
    │   ├── QXmppExternalServiceDiscoveryManager.cpp
    │   ├── QXmppExternalServiceDiscoveryManager.h
    │   ├── QXmppFileEncryption.cpp
    │   ├── QXmppFileEncryption.h
    │   ├── QXmppFileSharingManager.cpp
    │   ├── QXmppFileSharingManager.h
    │   ├── QXmppFileSharingProvider.h
    │   ├── QXmppHttpFileSharingProvider.cpp
    │   ├── QXmppHttpFileSharingProvider.h
    │   ├── QXmppHttpUploadManager.cpp
    │   ├── QXmppHttpUploadManager.h
    │   ├── QXmppInvokable.cpp
    │   ├── QXmppInvokable.h
    │   ├── QXmppIqHandling.cpp
    │   ├── QXmppIqHandling.h
    │   ├── QXmppJingleMessageInitiationManager.cpp
    │   ├── QXmppJingleMessageInitiationManager.h
    │   ├── QXmppMamManager.cpp
    │   ├── QXmppMamManager.h
    │   ├── QXmppMessageHandler.cpp
    │   ├── QXmppMessageHandler.h
    │   ├── QXmppMessageReceiptManager.cpp
    │   ├── QXmppMessageReceiptManager.h
    │   ├── QXmppMixManager.cpp
    │   ├── QXmppMixManager.h
    │   ├── QXmppMovedItem_p.h
    │   ├── QXmppMovedManager.cpp
    │   ├── QXmppMovedManager.h
    │   ├── QXmppMucManager.cpp
    │   ├── QXmppMucManager.h
    │   ├── QXmppOutgoingClient.cpp
    │   ├── QXmppOutgoingClient.h
    │   ├── QXmppOutgoingClient_p.h
    │   ├── QXmppPep_p.h
    │   ├── QXmppPubSubEventHandler.h
    │   ├── QXmppPubSubManager.cpp
    │   ├── QXmppPubSubManager.h
    │   ├── QXmppRegistrationManager.cpp
    │   ├── QXmppRegistrationManager.h
    │   ├── QXmppRemoteMethod.cpp
    │   ├── QXmppRemoteMethod.h
    │   ├── QXmppRosterManager.cpp
    │   ├── QXmppRosterManager.h
    │   ├── QXmppRpcManager.cpp
    │   ├── QXmppRpcManager.h
    │   ├── QXmppSaslManager.cpp
    │   ├── QXmppSaslManager_p.h
    │   ├── QXmppSceEnvelope_p.h
    │   ├── QXmppSendStanzaParams.cpp
    │   ├── QXmppSendStanzaParams.h
    │   ├── QXmppTransferManager.cpp
    │   ├── QXmppTransferManager.h
    │   ├── QXmppTransferManager_p.h
    │   ├── QXmppTrustLevel.h
    │   ├── QXmppTrustManager.cpp
    │   ├── QXmppTrustManager.h
    │   ├── QXmppTrustMemoryStorage.cpp
    │   ├── QXmppTrustMemoryStorage.h
    │   ├── QXmppTrustSecurityPolicy.h
    │   ├── QXmppTrustStorage.cpp
    │   ├── QXmppTrustStorage.h
    │   ├── QXmppUploadRequestManager.cpp
    │   ├── QXmppUploadRequestManager.h
    │   ├── QXmppUserLocationManager.cpp
    │   ├── QXmppUserLocationManager.h
    │   ├── QXmppUserTuneManager.cpp
    │   ├── QXmppUserTuneManager.h
    │   ├── QXmppVCardManager.cpp
    │   ├── QXmppVCardManager.h
    │   ├── QXmppVersionManager.cpp
    │   ├── QXmppVersionManager.h
    │   ├── QcaInitializer.cpp
    │   ├── QcaInitializer_p.h
    │   └── compat
    │   │   └── removed_api.cpp
    ├── omemo
    │   ├── CMakeLists.txt
    │   ├── OmemoCryptoProvider.cpp
    │   ├── OmemoCryptoProvider.h
    │   ├── OmemoLibWrappers.h
    │   ├── QXmppOmemoConfig.cmake.in
    │   ├── QXmppOmemoData.cpp
    │   ├── QXmppOmemoDeviceBundle_p.h
    │   ├── QXmppOmemoDeviceElement_p.h
    │   ├── QXmppOmemoDeviceList_p.h
    │   ├── QXmppOmemoIq_p.h
    │   ├── QXmppOmemoItems_p.h
    │   ├── QXmppOmemoManager.cpp
    │   ├── QXmppOmemoManager.h
    │   ├── QXmppOmemoManager_p.cpp
    │   ├── QXmppOmemoManager_p.h
    │   ├── QXmppOmemoMemoryStorage.cpp
    │   ├── QXmppOmemoMemoryStorage.h
    │   ├── QXmppOmemoStorage.cpp
    │   ├── QXmppOmemoStorage.h
    │   └── README.md
    └── server
    │   ├── QXmppDialback.cpp
    │   ├── QXmppDialback.h
    │   ├── QXmppIncomingClient.cpp
    │   ├── QXmppIncomingClient.h
    │   ├── QXmppIncomingServer.cpp
    │   ├── QXmppIncomingServer.h
    │   ├── QXmppOutgoingServer.cpp
    │   ├── QXmppOutgoingServer.h
    │   ├── QXmppPasswordChecker.cpp
    │   ├── QXmppPasswordChecker.h
    │   ├── QXmppServer.cpp
    │   ├── QXmppServer.h
    │   ├── QXmppServerExtension.cpp
    │   ├── QXmppServerExtension.h
    │   ├── QXmppServerPlugin.cpp
    │   └── QXmppServerPlugin.h
├── tests
    ├── CMakeLists.txt
    ├── IntegrationTesting.h
    ├── TestClient.h
    ├── pubsubutil.h
    ├── qxmppaccountmigrationmanager
    │   └── tst_qxmppaccountmigrationmanager.cpp
    ├── qxmpparchiveiq
    │   └── tst_qxmpparchiveiq.cpp
    ├── qxmppatmmanager
    │   └── tst_qxmppatmmanager.cpp
    ├── qxmppattentionmanager
    │   └── tst_qxmppattentionmanager.cpp
    ├── qxmppbindiq
    │   └── tst_qxmppbindiq.cpp
    ├── qxmppbitsofbinarycontentid
    │   └── tst_qxmppbitsofbinarycontentid.cpp
    ├── qxmppbitsofbinaryiq
    │   └── tst_qxmppbitsofbinaryiq.cpp
    ├── qxmppblockingmanager
    │   └── tst_qxmppblockingmanager.cpp
    ├── qxmppcallinvitemanager
    │   └── tst_qxmppcallinvitemanager.cpp
    ├── qxmppcallmanager
    │   └── tst_qxmppcallmanager.cpp
    ├── qxmppcarbonmanager
    │   └── tst_qxmppcarbonmanager.cpp
    ├── qxmppclient
    │   └── tst_qxmppclient.cpp
    ├── qxmppdataform
    │   └── tst_qxmppdataform.cpp
    ├── qxmppdiscoveryiq
    │   └── tst_qxmppdiscoveryiq.cpp
    ├── qxmppdiscoverymanager
    │   └── tst_qxmppdiscoverymanager.cpp
    ├── qxmppentitytimeiq
    │   └── tst_qxmppentitytimeiq.cpp
    ├── qxmppentitytimemanager
    │   └── tst_qxmppentitytimemanager.cpp
    ├── qxmppexternalservicediscoveryiq
    │   └── tst_qxmppexternalservicediscoveryiq.cpp
    ├── qxmppexternalservicediscoverymanager
    │   └── tst_qxmppexternalservicediscoverymanager.cpp
    ├── qxmppfileencryption
    │   └── tst_qxmppfileencryption.cpp
    ├── qxmpphttpuploadiq
    │   └── tst_qxmpphttpuploadiq.cpp
    ├── qxmpphttpuploadmanager
    │   ├── CMakeLists.txt
    │   ├── test.svg
    │   ├── test.svg.license
    │   ├── tst_qxmpphttpuploadmanager.cpp
    │   └── tst_qxmpphttpuploadmanager.qrc
    ├── qxmppiceconnection
    │   └── tst_qxmppiceconnection.cpp
    ├── qxmppiq
    │   └── tst_qxmppiq.cpp
    ├── qxmppjingledata
    │   └── tst_qxmppjingledata.cpp
    ├── qxmppjinglemessageinitiationmanager
    │   └── tst_qxmppjinglemessageinitiationmanager.cpp
    ├── qxmppmammanager
    │   └── tst_qxmppmammanager.cpp
    ├── qxmppmessage
    │   └── tst_qxmppmessage.cpp
    ├── qxmppmessagereaction
    │   └── tst_qxmppmessagereaction.cpp
    ├── qxmppmessagereceiptmanager
    │   └── tst_qxmppmessagereceiptmanager.cpp
    ├── qxmppmixinvitation
    │   └── tst_qxmppmixinvitation.cpp
    ├── qxmppmixiq
    │   └── tst_qxmppmixiq.cpp
    ├── qxmppmixitems
    │   └── tst_qxmppmixitems.cpp
    ├── qxmppmixmanager
    │   └── tst_qxmppmixmanager.cpp
    ├── qxmppmovedmanager
    │   └── tst_qxmppmovedmanager.cpp
    ├── qxmppnonsaslauthiq
    │   └── tst_qxmppnonsaslauthiq.cpp
    ├── qxmppomemodata
    │   └── tst_qxmppomemodata.cpp
    ├── qxmppomemomanager
    │   └── tst_qxmppomemomanager.cpp
    ├── qxmppomemomemorystorage
    │   └── tst_qxmppomemomemorystorage.cpp
    ├── qxmpppresence
    │   └── tst_qxmpppresence.cpp
    ├── qxmpppubsub
    │   └── tst_qxmpppubsub.cpp
    ├── qxmpppubsubevent
    │   └── tst_qxmpppubsubevent.cpp
    ├── qxmpppubsubforms
    │   └── tst_qxmpppubsubforms.cpp
    ├── qxmpppubsubiq
    │   └── tst_qxmpppubsubiq.cpp
    ├── qxmpppubsubmanager
    │   └── tst_qxmpppubsubmanager.cpp
    ├── qxmpppushenableiq
    │   └── tst_qxmpppushenableiq.cpp
    ├── qxmppregisteriq
    │   └── tst_qxmppregisteriq.cpp
    ├── qxmppregistrationmanager
    │   └── tst_qxmppregistrationmanager.cpp
    ├── qxmppresultset
    │   └── tst_qxmppresultset.cpp
    ├── qxmpprosteriq
    │   └── tst_qxmpprosteriq.cpp
    ├── qxmpprostermanager
    │   └── tst_qxmpprostermanager.cpp
    ├── qxmpprpciq
    │   └── tst_qxmpprpciq.cpp
    ├── qxmppsasl
    │   └── tst_qxmppsasl.cpp
    ├── qxmppsceenvelope
    │   └── tst_qxmppsceenvelope.cpp
    ├── qxmppserver
    │   └── tst_qxmppserver.cpp
    ├── qxmppsocks
    │   └── tst_qxmppsocks.cpp
    ├── qxmppstanza
    │   └── tst_qxmppstanza.cpp
    ├── qxmppstream
    │   ├── cd
    │   └── tst_qxmppstream.cpp
    ├── qxmppstreamfeatures
    │   └── tst_qxmppstreamfeatures.cpp
    ├── qxmppstreaminitiationiq
    │   └── tst_qxmppstreaminitiationiq.cpp
    ├── qxmppstunmessage
    │   └── tst_qxmppstunmessage.cpp
    ├── qxmpptransfermanager
    │   ├── CMakeLists.txt
    │   ├── test.svg
    │   ├── test.svg.license
    │   ├── tst_qxmpptransfermanager.cpp
    │   └── tst_qxmpptransfermanager.qrc
    ├── qxmpptrustmemorystorage
    │   └── tst_qxmpptrustmemorystorage.cpp
    ├── qxmpptrustmessages
    │   └── tst_qxmpptrustmessages.cpp
    ├── qxmppuri
    │   └── tst_qxmppuri.cpp
    ├── qxmppuserlocationmanager
    │   └── tst_qxmppuserlocationmanager.cpp
    ├── qxmppusertunemanager
    │   └── tst_qxmppusertunemanager.cpp
    ├── qxmpputils
    │   ├── CMakeLists.txt
    │   ├── test.bmp
    │   ├── test.bmp.license
    │   ├── test.gif
    │   ├── test.gif.license
    │   ├── test.jpg
    │   ├── test.jpg.license
    │   ├── test.mng
    │   ├── test.mng.license
    │   ├── test.png
    │   ├── test.png.license
    │   ├── test.svg
    │   ├── test.svg.license
    │   ├── test.xpm
    │   ├── test.xpm.license
    │   ├── tst_qxmpputils.cpp
    │   └── tst_qxmpputils.qrc
    ├── qxmppvcardiq
    │   └── tst_qxmppvcardiq.cpp
    ├── qxmppvcardmanager
    │   └── tst_qxmppvcardmanager.cpp
    ├── qxmppversioniq
    │   └── tst_qxmppversioniq.cpp
    ├── qxmppversionmanager
    │   └── tst_qxmppversionmanager.cpp
    ├── travis
    │   ├── build-and-test
    │   ├── build-documentation
    │   ├── install-build-depends-debian
    │   ├── install-build-depends-macos
    │   └── push-documentation
    └── util.h
└── utils
    ├── pre-commit.sh
    ├── render-graphics.sh
    └── setup-hooks.sh


/.appveyor.yml:
--------------------------------------------------------------------------------
 1 | # SPDX-FileCopyrightText: 2018 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | #
 3 | # SPDX-License-Identifier: CC0-1.0
 4 | 
 5 | platform: x64
 6 | 
 7 | environment:
 8 |   matrix:
 9 |     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
10 |       GENERATOR: Visual Studio 15 2017 Win64
11 |       QTDIR: C:\Qt\5.11\msvc2017_64
12 | 
13 | build:
14 |   parallel: true
15 | 
16 | build_script:
17 |   - mkdir build
18 |   - cd build
19 |   - cmake -G "%GENERATOR%" .. "-DCMAKE_PREFIX_PATH=%QTDIR%"
20 |   - cmake --build .
21 | 


--------------------------------------------------------------------------------
/.clang-format:
--------------------------------------------------------------------------------
 1 | # SPDX-FileCopyrightText: 2019 Georg Rudoy <0xd34df00d@gmail.com>
 2 | #
 3 | # SPDX-License-Identifier: CC0-1.0
 4 | 
 5 | AlignAfterOpenBracket: Align
 6 | AlignTrailingComments: true
 7 | BasedOnStyle: WebKit
 8 | BraceWrapping:
 9 |   AfterClass: true
10 |   AfterFunction: true
11 |   AfterStruct: false
12 |   SplitEmptyRecord: false
13 | BreakAfterAttributes: Always
14 | BreakBeforeBinaryOperators: None
15 | BreakBeforeBraces: Custom
16 | BreakBeforeTernaryOperators: true
17 | BreakConstructorInitializers: BeforeColon
18 | BreakStringLiterals: true
19 | DisableFormat: false
20 | FixNamespaceComments: true
21 | IncludeBlocks: Regroup
22 | IncludeCategories:
23 |   - Regex: "^.QXmpp.*"
24 |     Priority: 1
25 |   - Regex: "^\".*\"$"
26 |     Priority: 2
27 |   - Regex: "^<Q(?!Xmpp).*"
28 |     Priority: 3
29 |   - Regex: "^<[^Q].*"
30 |     Priority: 4
31 | InsertBraces: true
32 | Language: Cpp
33 | NamespaceIndentation: None
34 | PointerAlignment: Right
35 | ReflowComments: true
36 | SortIncludes: true
37 | SpaceAfterTemplateKeyword: false
38 | SpacesBeforeTrailingComments: 2
39 | SpacesInLineCommentPrefix:
40 |   Minimum: 1
41 | 


--------------------------------------------------------------------------------
/.github/pull_request_template.md:
--------------------------------------------------------------------------------
 1 | PR check list:
 2 | - [ ] Document your code
 3 | - [ ] Add `\since QXmpp 1.X`, `QXMPP_EXPORT`
 4 | - [ ] Update `doc/doap.xml`
 5 | - [ ] Add unit tests
 6 | - [ ] Format the code: Run `clang-format -i src/<edited-file(s)> tests/<edited-file(s)>`
 7 | 
 8 | <!--
 9 | Points should be checked when they're done. They should also be checked when no
10 | changes were required.
11 | -->
12 | 


--------------------------------------------------------------------------------
/.github/pull_request_template.md.license:
--------------------------------------------------------------------------------
1 | SPDX-FileCopyrightText: 2021 Linus Jahn <lnj@kaidan.im>
2 | 
3 | SPDX-License-Identifier: CC0-1.0
4 | 


--------------------------------------------------------------------------------
/.github/workflows/push-docs.yml:
--------------------------------------------------------------------------------
 1 | # SPDX-FileCopyrightText: 2020 Linus Jahn <lnj@kaidan.im>
 2 | #
 3 | # SPDX-License-Identifier: CC0-1.0
 4 | 
 5 | ---
 6 | name: push-docs
 7 | 
 8 | on:
 9 |   push:
10 |     branches:
11 |       - master
12 | 
13 | jobs:
14 |   push-doc:
15 |     runs-on: ubuntu-latest
16 |     env:
17 |       PUSH_KEY_REPO_DOC_QXMPP_ORG: ${{ secrets.PUSH_KEY_REPO_DOC_QXMPP_ORG }}
18 |       CONFIG: full
19 |     steps:
20 |       - uses: actions/checkout@v3
21 |       - name: Install Qt
22 |         uses: jurplel/install-qt-action@v4
23 |       - name: Install extra packages
24 |         run: tests/travis/install-build-depends-debian
25 |       - name: Update XEP metadata
26 |         run: doc/doap-rendering/update-xeplist.sh
27 |       - name: Build documentation
28 |         run: tests/travis/push-documentation
29 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # SPDX-FileCopyrightText: 2010 Boris Pek <tehnick-8@yandex.ru>
 2 | #
 3 | # SPDX-License-Identifier: CC0-1.0
 4 | 
 5 | CMakeLists.txt.*
 6 | .DS_Store
 7 | /build*
 8 | .kdev4/
 9 | *.kdev4
10 | support-chat-avatar.png
11 | 


--------------------------------------------------------------------------------
/AUTHORS:
--------------------------------------------------------------------------------
 1 | SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | SPDX-License-Identifier: CC0-1.0
 3 | 
 4 | QXMPP AUTHORS
 5 | -------------
 6 | 
 7 | Manjeet Dahiya <manjeetdahiya@gmail.com>
 8 |  * Initial author of QXmpp.
 9 | 
10 | Jeremy Lainé <jeremy.laine@m4x.org>
11 |  * Co-author of QXmpp.
12 | 
13 | Linus Jahn <lnj@kaidan.im>
14 |  * Current lead developer of QXmpp.
15 | 
16 | Ian Reinhart Geiser <geiseri@kde.org>
17 |  * Initial author of Jabber-RPC support.
18 | 
19 | Georg Rudoy <0xd34df00d@gmail.com>
20 |  * Author of receipts manager, extended stanza addressing.
21 | 
22 | Niels Ole Salscheider <niels_ole@salscheider-online.de>
23 |  * Build system, cleanups.
24 | 
25 | Oliver Goffart <ogoffart@woboq.com>
26 |  * Author of QXmppResultSet.
27 | 


--------------------------------------------------------------------------------
/LICENSES/LicenseRef-MIT-variant.txt:
--------------------------------------------------------------------------------
 1 | Redistribution and use in source and binary forms, with or without
 2 | modification, are permitted provided that the following conditions
 3 | are met:
 4 | 
 5 | 1. Redistributions of source code must retain the copyright
 6 |    notice, this list of conditions and the following disclaimer.
 7 | 2. Redistributions in binary form must reproduce the copyright
 8 |    notice, this list of conditions and the following disclaimer in the
 9 |    documentation and/or other materials provided with the distribution.
10 | 3. The name of the author may not be used to endorse or promote products
11 |    derived from this software without specific prior written permission.
12 | 
13 | THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
14 | IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
15 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
16 | IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
17 | INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
18 | NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
19 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
20 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
22 | THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23 | 


--------------------------------------------------------------------------------
/LICENSES/MIT.txt:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) <year> <copyright holders>
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and 
 6 | associated documentation files (the "Software"), to deal in the Software without restriction, including 
 7 | without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 8 | copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the 
 9 | following conditions:
10 | 
11 | The above copyright notice and this permission notice shall be included in all copies or substantial 
12 | portions of the Software.
13 | 
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 
15 | LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO 
16 | EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
17 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 
18 | USE OR OTHER DEALINGS IN THE SOFTWARE.
19 | 


--------------------------------------------------------------------------------
/QXmppConfig.cmake.in:
--------------------------------------------------------------------------------
 1 | # SPDX-FileCopyrightText: 2017 Niels Ole Salscheider <niels_ole@salscheider-online.de>
 2 | #
 3 | # SPDX-License-Identifier: CC0-1.0
 4 | 
 5 | @PACKAGE_INIT@
 6 | 
 7 | set(_QXmpp_FIND_PARTS_REQUIRED)
 8 | if(QXmppQt@QT_VERSION_MAJOR@_FIND_REQUIRED)
 9 |     set(_QXmpp_FIND_PARTS_REQUIRED REQUIRED)
10 | endif()
11 | set(_QXmpp_FIND_PARTS_QUIET)
12 | if(QXmppQt@QT_VERSION_MAJOR@_FIND_QUIETLY)
13 |     set(_QXmpp_FIND_PARTS_QUIET QUIET)
14 | endif()
15 | 
16 | include(CMakeFindDependencyMacro)
17 | find_dependency(Qt@QT_VERSION_MAJOR@Core)
18 | find_dependency(Qt@QT_VERSION_MAJOR@Network)
19 | find_dependency(Qt@QT_VERSION_MAJOR@Xml)
20 | 
21 | include("${CMAKE_CURRENT_LIST_DIR}/QXmpp.cmake")
22 | 
23 | foreach(module ${QXmppQt@QT_VERSION_MAJOR@_FIND_COMPONENTS})
24 |     find_package(QXmpp${module}Qt@QT_VERSION_MAJOR@
25 |         ${QXmppQt@QT_VERSION_MAJOR@_FIND_VERSION}
26 |         ${_QXmpp_FIND_PARTS_REQUIRED}
27 |         ${_QXmpp_FIND_PARTS_QUIET}
28 |     )
29 |     set(QXmppQt@QT_VERSION_MAJOR@_${module}_FOUND ${QXmpp${module}Qt@QT_VERSION_MAJOR@_FOUND})
30 | endforeach()
31 | 
32 | check_required_components(QXmpp)
33 | 


--------------------------------------------------------------------------------
/SECURITY.md:
--------------------------------------------------------------------------------
 1 | <!--
 2 | SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 3 | 
 4 | SPDX-License-Identifier: CC0-1.0
 5 | -->
 6 | 
 7 | # Security Policy
 8 | 
 9 | ## Supported Versions
10 | 
11 | The latest 1.x stable release is supported. Fixes for relevant bugs and
12 | security issues are backported.
13 | 
14 | ## Reporting a Vulnerability
15 | 
16 | If you have found a security related issue, it is best to email us instead of
17 | opening a public issue.
18 | If your message is very sensitive, you may want to use PGP, but in most cases
19 | it's not needed.
20 | 
21 | | Name       | Email address      | PGP key                                             |
22 | | ---------- | ------------------ | --------------------------------------------------- |
23 | | Linus Jahn | lnj [AT] kaidan.im | [03C2D10DC97E5B0BEBB8F3B44663231A91A1E27B][pgp-lnj] |
24 | 
25 | 
26 | [pgp-lnj]: https://keys.openpgp.org/vks/v1/by-fingerprint/03C2D10DC97E5B0BEBB8F3B44663231A91A1E27B
27 | 


--------------------------------------------------------------------------------
/cmake/QXmppLegacyConfig.cmake.in:
--------------------------------------------------------------------------------
 1 | # SPDX-FileCopyrightText: 2023 Linus Jahn <lnj@kaidan.im>
 2 | #
 3 | # SPDX-License-Identifier: CC0-1.0
 4 | 
 5 | @PACKAGE_INIT@
 6 | 
 7 | set(_QXmpp_FIND_PARTS_REQUIRED)
 8 | if(QXmpp_FIND_REQUIRED)
 9 |     set(_QXmpp_FIND_PARTS_REQUIRED REQUIRED)
10 | endif()
11 | set(_QXmpp_FIND_PARTS_QUIET)
12 | if(QXmpp_FIND_QUIETLY)
13 |     set(_QXmpp_FIND_PARTS_QUIET QUIET)
14 | endif()
15 | 
16 | # Pass through arguments to QXmppQt5
17 | include(CMakeFindDependencyMacro)
18 | find_package(QXmppQt5
19 |     ${QXmpp_FIND_VERSION}
20 |     ${_QXmpp_FIND_PARTS_REQUIRED}
21 |     ${_QXmpp_FIND_PARTS_QUIET}
22 |     COMPONENTS ${QXmpp_FIND_COMPONENTS}
23 | )
24 | 
25 | set(QXmpp_FOUND ${QXmppQt5_FOUND})
26 | 


--------------------------------------------------------------------------------
/cmake/QXmppLegacyConfigVersion.cmake:
--------------------------------------------------------------------------------
1 | # SPDX-FileCopyrightText: 2023 Linus Jahn <lnj@kaidan.im>
2 | #
3 | # SPDX-License-Identifier: CC0-1.0
4 | 
5 | set(PACKAGE_VERSION "")
6 | # Allow all requested versions here, the actual check is going to be done in QXmppQt5.
7 | set(PACKAGE_VERSION_COMPATIBLE TRUE)
8 | 
9 | 


--------------------------------------------------------------------------------
/doc/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | # SPDX-FileCopyrightText: 2017 Niels Ole Salscheider <niels_ole@salscheider-online.de>
 2 | #
 3 | # SPDX-License-Identifier: CC0-1.0
 4 | 
 5 | find_package(Doxygen REQUIRED)
 6 | 
 7 | if(NOT DOXYGEN_FOUND)
 8 |     message(FATAL_ERROR "Doxygen is needed to build the documentation.")
 9 | endif()
10 | 
11 | configure_file(
12 |     ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in
13 |     ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
14 |     @ONLY
15 | )
16 | 
17 | add_custom_target(
18 |     doc ALL
19 |     COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
20 |     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
21 |     COMMENT "Generate API documentation with Doxygen"
22 |     VERBATIM
23 | )
24 | 
25 | install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html DESTINATION ${CMAKE_INSTALL_DOCDIR})
26 | 
27 | 


--------------------------------------------------------------------------------
/doc/Doxyfile.in:
--------------------------------------------------------------------------------
 1 | # SPDX-FileCopyrightText: 2017 Niels Ole Salscheider <niels_ole@salscheider-online.de>
 2 | #
 3 | # SPDX-License-Identifier: CC0-1.0
 4 | 
 5 | PROJECT_NAME           = "QXmpp"
 6 | PROJECT_NUMBER         = "Version: @PROJECT_VERSION@"
 7 | INPUT                  = @PROJECT_SOURCE_DIR@/doc/index.doc \
 8 |                          @PROJECT_SOURCE_DIR@/doc/using.doc \
 9 |                          @PROJECT_SOURCE_DIR@/doc/xep.doc \
10 |                          @PROJECT_SOURCE_DIR@/src
11 | HTML_EXTRA_FILES       = @PROJECT_SOURCE_DIR@/doc/doap.xml \
12 |                          @PROJECT_SOURCE_DIR@/doc/doap-rendering/doap.xsl \
13 |                          @PROJECT_SOURCE_DIR@/doc/doap-rendering/xeplist.xml \
14 |                          @PROJECT_SOURCE_DIR@/doc/doap-rendering/doap.css
15 | ALIASES                = "xep{1}=<a href=\"https://xmpp.org/extensions/xep-\1.html\">XEP-\1</a>" \
16 |                          "xep{2}=<a href=\"https://xmpp.org/extensions/xep-\1.html\">XEP-\1: \2</a>"
17 | ALPHABETICAL_INDEX     = NO
18 | EXCLUDE_PATTERNS       = */moc_* */mod_* */QXmppCodec.cpp */QXmppSasl.cpp
19 | FULL_PATH_NAMES        = NO
20 | HIDE_UNDOC_CLASSES     = YES
21 | GENERATE_LATEX         = NO
22 | QUIET                  = YES
23 | RECURSIVE              = YES
24 | ENABLE_PREPROCESSING   = YES
25 | MACRO_EXPANSION        = YES
26 | EXPAND_ONLY_PREDEF     = YES
27 | PREDEFINED             = "QXMPP_DEPRECATED_SINCE(major, minor)=1" "QT_DEPRECATED_X(msg)=" "QXMPP_DOC"
28 | 


--------------------------------------------------------------------------------
/doc/doap-rendering/README.md:
--------------------------------------------------------------------------------
 1 | <!--
 2 | SPDX-FileCopyrightText: 2022 Melvin Keskin <melvo@olomono.de>
 3 | 
 4 | SPDX-License-Identifier: CC0-1.0
 5 | -->
 6 | 
 7 | # DOAP rendering
 8 | 
 9 | Run `doc/doap-rendering/update-xeplist.sh` to get the latest XEP metadata before building the documentation.
10 | 
11 | You maybe need to open a local web server to display the list of supported XEPs in case your web browser prohibits the request to `doc/doap-rendering/doap.xsl`.
12 | Here is an example with Python's built-in web server and Firefox:
13 | ```
14 | python3 -m http.server
15 | firefox http://0.0.0.0:8000/xep.html
16 | ```
17 | 


--------------------------------------------------------------------------------
/doc/doap-rendering/update-xeplist.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # SPDX-FileCopyrightText: 2022 Melvin Keskin <melvo@olomono.de>
 4 | #
 5 | # SPDX-License-Identifier: CC0-1.0
 6 | 
 7 | #
 8 | # This script updates the list that contains XEP metadata used by "doap.xsl".
 9 | #
10 | # It should be run before generating the Doxygen documentation.
11 | #
12 | 
13 | SCRIPT_DIR=$(dirname "$(readlink -f "${0}")")
14 | 
15 | # The list is generated by "https://github.com/xsf/xeps/blob/master/tools/extract-metadata.py".
16 | curl -L https://xmpp.org/extensions/xeplist.xml > "${SCRIPT_DIR}/xeplist.xml"
17 | 


--------------------------------------------------------------------------------
/doc/doap-rendering/xeplist.xml.license:
--------------------------------------------------------------------------------
1 | SPDX-FileCopyrightText: 2004 XMPP Standards Foundation
2 | 
3 | SPDX-License-Identifier: CC0-1.0
4 | 


--------------------------------------------------------------------------------
/doc/index.doc:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2014 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: CC0-1.0
 4 | 
 5 | /*! \mainpage
 6 | 
 7 | QXmpp is a cross-platform C++ XMPP client library based on the Qt
 8 | framework. It tries to use Qt's programming conventions in order to ease
 9 | the learning curve for new programmers.
10 | 
11 | QXmpp based clients are built using QXmppClient instances which handle the
12 | establishment of the XMPP connection and provide a number of high-level
13 | "managers" to perform specific tasks. You can write your own managers to
14 | extend QXmpp by subclassing QXmppClientExtension.
15 | 
16 | <B>Main Class:</B>
17 | - QXmppClient
18 | 
19 | <B>Managers to perform specific tasks:</B>
20 | - QXmppRosterManager
21 | - QXmppVCardManager
22 | - QXmppTransferManager
23 | - QXmppMamManager
24 | - QXmppMucManager
25 | - QXmppCallManager
26 | - QXmppArchiveManager
27 | - QXmppVersionManager
28 | - QXmppDiscoveryManager
29 | - QXmppEntityTimeManager
30 | - QXmppUploadRequestManager
31 | - QXmppRegistrationManager
32 | - QXmppAttentionManager
33 | - QXmppPubSubManager
34 | - QXmppOmemoManager
35 | - QXmppBlockingManager
36 | 
37 | <B>XMPP stanzas:</B> If you are interested in a more low-level API, you can refer to these
38 | classes.
39 | - QXmppIq
40 | - QXmppMessage
41 | - QXmppPresence
42 | 
43 | <B>Project Details:</B>
44 | 
45 | - Project Page: https://github.com/qxmpp-project/qxmpp
46 | - Report Issues: https://github.com/qxmpp-project/qxmpp/issues
47 | - New Releases: https://github.com/qxmpp-project/qxmpp/releases
48 | 
49 | */
50 | 


--------------------------------------------------------------------------------
/doc/xep.doc:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2014 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: CC0-1.0
 4 | 
 5 | /*! \page xep XMPP Extension Protocols
 6 | 
 7 | This document lists the XMPP Extension Protocols (XEPs) supported by QXmpp.
 8 | 
 9 | \htmlonly
10 | <script>
11 |     <!-- Dynamic resizing of the frame is needed because its size inside of the page is unknown before rendering it. -->
12 |     function resizeIframe(obj) {
13 |         obj.style.height = obj.contentWindow.document.documentElement.scrollHeight + 20 + 'px';
14 |     }
15 | </script>
16 | <iframe src="doap.xml" class="xeps" style="position: absolute; height: 85%; width: 99%; border: none" frameborder="0" onload="resizeIframe(this)"/>
17 | \endhtmlonly
18 | 
19 | */
20 | 


--------------------------------------------------------------------------------
/examples/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | # SPDX-FileCopyrightText: 2017 Niels Ole Salscheider <niels_ole@salscheider-online.de>
 2 | #
 3 | # SPDX-License-Identifier: CC0-1.0
 4 | 
 5 | macro(add_simple_example EXAMPLE_NAME)
 6 |     add_executable(${EXAMPLE_NAME} example_${EXAMPLE_NAME}/example_${EXAMPLE_NAME}.cpp)
 7 |     target_link_libraries(${EXAMPLE_NAME} ${QXMPP_TARGET})
 8 | endmacro()
 9 | 
10 | include_directories(${PROJECT_SOURCE_DIR}/src/base)
11 | include_directories(${PROJECT_SOURCE_DIR}/src/client)
12 | include_directories(${PROJECT_SOURCE_DIR}/src/server)
13 | include_directories(${PROJECT_BINARY_DIR}/src)
14 | 
15 | add_simple_example(0_connected)
16 | add_simple_example(1_echoClient)
17 | add_simple_example(2_rosterHandling)
18 | add_simple_example(3_transferHandling)
19 | add_simple_example(7_archiveHandling)
20 | add_simple_example(8_server)
21 | 
22 | add_subdirectory(example_5_rpcInterface)
23 | add_subdirectory(example_6_rpcClient)
24 | add_subdirectory(example_9_vCard)
25 | 
26 | 


--------------------------------------------------------------------------------
/examples/example_0_connected/README:
--------------------------------------------------------------------------------
 1 | <!--
 2 | SPDX-FileCopyrightText: 2009 Manjeet Dahiya <manjeetdahiya@gmail.com>
 3 | 
 4 | SPDX-License-Identifier: CC0-1.0
 5 | -->
 6 | 
 7 | This example just connects to the xmpp server. And start receiving presences (updates) from the server.
 8 | 
 9 | After running this example, you can see this user online, if it's added in your roster (friends list).
10 | 
11 | Logging type has been set to stdout. You can see the progress on the command line.
12 | 


--------------------------------------------------------------------------------
/examples/example_0_connected/example_0_connected.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2012 Manjeet Dahiya <manjeetdahiya@gmail.com>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #include "QXmppClient.h"
 6 | #include "QXmppLogger.h"
 7 | 
 8 | #include <QCoreApplication>
 9 | 
10 | int main(int argc, char *argv[])
11 | {
12 |     QCoreApplication app(argc, argv);
13 | 
14 |     QXmppClient client;
15 |     client.logger()->setLoggingType(QXmppLogger::StdoutLogging);
16 | 
17 |     // For jabber
18 |     // client.connectToServer("username@jabber.org", "passwd");
19 | 
20 |     // For google talk
21 |     // client.connectToServer("username@gmail.com", "passwd");
22 | 
23 |     client.connectToServer("qxmpp.test1@qxmpp.org", "qxmpp123");
24 | 
25 |     return app.exec();
26 | }
27 | 


--------------------------------------------------------------------------------
/examples/example_1_echoClient/README:
--------------------------------------------------------------------------------
 1 | <!--
 2 | SPDX-FileCopyrightText: 2009 Manjeet Dahiya <manjeetdahiya@gmail.com>
 3 | 
 4 | SPDX-License-Identifier: CC0-1.0
 5 | -->
 6 | 
 7 | This is a very simple bot which echoes the message sent to it.
 8 | 
 9 | Run this example, send it a message from a friend of this bot. You will receive the message back.
10 | 
11 | This example shows how to receive and send messages.
12 | 


--------------------------------------------------------------------------------
/examples/example_1_echoClient/example_1_echoClient.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2012 Manjeet Dahiya <manjeetdahiya@gmail.com>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #include "example_1_echoClient.h"
 6 | 
 7 | #include "QXmppLogger.h"
 8 | #include "QXmppMessage.h"
 9 | 
10 | #include <QCoreApplication>
11 | 
12 | echoClient::echoClient(QObject *parent)
13 |     : QXmppClient(parent)
14 | {
15 |     connect(this, &QXmppClient::messageReceived, this, &echoClient::messageReceived);
16 | }
17 | 
18 | echoClient::~echoClient()
19 | {
20 | }
21 | 
22 | void echoClient::messageReceived(const QXmppMessage &message)
23 | {
24 |     QString from = message.from();
25 |     QString msg = message.body();
26 | 
27 |     sendPacket(QXmppMessage("", from, "Your message: " + msg));
28 | }
29 | 
30 | int main(int argc, char *argv[])
31 | {
32 |     QCoreApplication app(argc, argv);
33 | 
34 |     echoClient client;
35 |     client.logger()->setLoggingType(QXmppLogger::StdoutLogging);
36 |     client.connectToServer("qxmpp.test1@qxmpp.org", "qxmpp123");
37 | 
38 |     return app.exec();
39 | }
40 | 


--------------------------------------------------------------------------------
/examples/example_1_echoClient/example_1_echoClient.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2012 Manjeet Dahiya <manjeetdahiya@gmail.com>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef ECHOCLIENT_H
 6 | #define ECHOCLIENT_H
 7 | 
 8 | #include "QXmppClient.h"
 9 | 
10 | class echoClient : public QXmppClient
11 | {
12 |     Q_OBJECT
13 | 
14 | public:
15 |     echoClient(QObject *parent = nullptr);
16 |     ~echoClient() override;
17 | 
18 |     void messageReceived(const QXmppMessage &);
19 | };
20 | 
21 | #endif  // ECHOCLIENT_H
22 | 


--------------------------------------------------------------------------------
/examples/example_2_rosterHandling/README:
--------------------------------------------------------------------------------
1 | <!--
2 | SPDX-FileCopyrightText: 2009 Manjeet Dahiya <manjeetdahiya@gmail.com>
3 | 
4 | SPDX-License-Identifier: CC0-1.0
5 | -->
6 | 
7 | This example demonstrates how to get the roster and presence updates.
8 | 


--------------------------------------------------------------------------------
/examples/example_2_rosterHandling/example_2_rosterHandling.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2012 Manjeet Dahiya <manjeetdahiya@gmail.com>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef XMPPCLIENT_H
 6 | #define XMPPCLIENT_H
 7 | 
 8 | #include "QXmppClient.h"
 9 | 
10 | class QXmppRosterManager;
11 | 
12 | class xmppClient : public QXmppClient
13 | {
14 |     Q_OBJECT
15 | 
16 | public:
17 |     xmppClient(QObject *parent = nullptr);
18 |     ~xmppClient() override;
19 | 
20 |     void clientConnected();
21 |     void rosterReceived();
22 |     void presenceChanged(const QString &bareJid, const QString &resource);
23 | 
24 | private:
25 |     QXmppRosterManager *m_rosterManager;
26 | };
27 | 
28 | #endif  // XMPPCLIENT_H
29 | 


--------------------------------------------------------------------------------
/examples/example_3_transferHandling/example_3_transferHandling.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2012 Ian Reinhart Geiser <geiseri@kde.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef IBBCLIENT_H
 6 | #define IBBCLIENT_H
 7 | 
 8 | #include "QXmppClient.h"
 9 | #include "QXmppTransferManager.h"
10 | 
11 | class xmppClient : public QXmppClient
12 | {
13 |     Q_OBJECT
14 | 
15 | public:
16 |     xmppClient(QObject *parent = nullptr);
17 |     void setRecipient(const QString &recipient);
18 | 
19 | private:
20 |     Q_SLOT void slotError(QXmppTransferJob::Error error);
21 |     Q_SLOT void slotFileReceived(QXmppTransferJob *job);
22 |     Q_SLOT void slotFinished();
23 |     Q_SLOT void slotPresenceReceived(const QXmppPresence &presence);
24 |     Q_SLOT void slotProgress(qint64 done, qint64 total);
25 | 
26 |     QString m_recipient;
27 |     QXmppTransferManager *transferManager;
28 | };
29 | 
30 | #endif  // IBBCLIENT_H
31 | 


--------------------------------------------------------------------------------
/examples/example_3_transferHandling/example_3_transferHandling.qrc:
--------------------------------------------------------------------------------
 1 | <!--
 2 | SPDX-FileCopyrightText: 2012 Jeremy Lainé <jeremy.laine@m4x.org>
 3 | 
 4 | SPDX-License-Identifier: CC0-1.0
 5 | -->
 6 | 
 7 | <!DOCTYPE RCC><RCC version="1.0">
 8 | <qresource>
 9 |     <file>example_3_transferHandling.cpp</file>
10 | </qresource>
11 | </RCC>
12 | 


--------------------------------------------------------------------------------
/examples/example_5_rpcInterface/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | # SPDX-FileCopyrightText: 2017 Niels Ole Salscheider <niels_ole@salscheider-online.de>
2 | #
3 | # SPDX-License-Identifier: CC0-1.0
4 | 
5 | add_executable(5_rpcInterface main.cpp remoteinterface.cpp)
6 | target_link_libraries(5_rpcInterface ${QXMPP_TARGET})
7 | 


--------------------------------------------------------------------------------
/examples/example_5_rpcInterface/main.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2009 Ian Geiser <ian.geiser@gmail.com>
 2 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 3 | // SPDX-FileCopyrightText: 2011 Manjeet Dahiya <manjeetdahiya@gmail.com>
 4 | //
 5 | // SPDX-License-Identifier: LGPL-2.1-or-later
 6 | 
 7 | #include "QXmppClient.h"
 8 | #include "QXmppLogger.h"
 9 | #include "QXmppRpcManager.h"
10 | 
11 | #include "remoteinterface.h"
12 | 
13 | #include <QCoreApplication>
14 | 
15 | int main(int argc, char *argv[])
16 | {
17 |     QCoreApplication a(argc, argv);
18 | 
19 |     QXmppLogger::getLogger()->setLoggingType(QXmppLogger::StdoutLogging);
20 | 
21 |     QXmppClient client;
22 | 
23 |     // add RPC extension and register interface
24 |     auto *manager = new QXmppRpcManager;
25 |     client.addExtension(manager);
26 |     manager->addInvokableInterface(new RemoteInterface(&client));
27 | 
28 |     client.connectToServer("qxmpp.test1@qxmpp.org", "qxmpp123");
29 |     return a.exec();
30 | }
31 | 


--------------------------------------------------------------------------------
/examples/example_5_rpcInterface/remoteinterface.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2009 Ian Geiser <ian.geiser@gmail.com>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #include "remoteinterface.h"
 6 | 
 7 | RemoteInterface::RemoteInterface(QObject *parent) : QXmppInvokable(parent)
 8 | {
 9 | }
10 | 
11 | bool RemoteInterface::isAuthorized(const QString &jid) const
12 | {
13 |     Q_UNUSED(jid);
14 |     return true;
15 | }
16 | 
17 | QString RemoteInterface::echoString(const QString &message)
18 | {
19 |     return "Echo: " + message;
20 | }
21 | 


--------------------------------------------------------------------------------
/examples/example_5_rpcInterface/remoteinterface.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2009 Ian Geiser <ian.geiser@gmail.com>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef REMOTEINTERFACE_H
 6 | #define REMOTEINTERFACE_H
 7 | 
 8 | #include "QXmppRpcManager.h"
 9 | 
10 | class RemoteInterface : public QXmppInvokable
11 | {
12 |     Q_OBJECT
13 | public:
14 |     RemoteInterface(QObject *parent = nullptr);
15 | 
16 |     bool isAuthorized(const QString &jid) const override;
17 | 
18 |     // RPC Interface
19 | public:
20 |     Q_SLOT QString echoString(const QString &message);
21 | };
22 | 
23 | #endif  // REMOTEINTERFACE_H
24 | 


--------------------------------------------------------------------------------
/examples/example_5_rpcInterface/xmlrpctest.txt:
--------------------------------------------------------------------------------
 1 | <stream:stream 
 2 |   to='geiseri.com' 
 3 |   xmlns='jabber:client' 
 4 |   xmlns:stream='http://etherx.jabber.org/streams'>
 5 | 
 6 | <iq id='A3' type='set'>
 7 |   <query xmlns='jabber:iq:auth'>
 8 |     <username>client</username>
 9 |     <resource>telnet</resource>
10 |     <password>Passw0rd</password>
11 |   </query>
12 | </iq>
13 | 
14 | <presence/>
15 | 
16 | <iq type='set' 
17 |     from='client@geiseri.com/telnet' 
18 |     to='server@geiseri.com/QXmpp' 
19 |     id='rpc1'>
20 |   <query xmlns='jabber:iq:rpc'>
21 |     <methodCall>
22 |       <methodName>RemoteInterface.echoString</methodName>
23 |       <params>
24 |         <param>
25 |           <value><string>Test string</string></value>
26 |         </param>
27 |       </params>
28 |     </methodCall>
29 |   </query>
30 | </iq>
31 | 
32 | <iq type='set' 
33 |     from='client@geiseri.com/telnet' 
34 |     to='server@geiseri.com/QXmpp' 
35 |     id='rpc1'>
36 |   <query xmlns='jabber:iq:rpc'>
37 |     <methodCall>
38 |       <methodName>RemoteInterface.badMethod</methodName>
39 |       <params>
40 |         <param>
41 |           <value><string>Test string</string></value>
42 |         </param>
43 |       </params>
44 |     </methodCall>
45 |   </query>
46 | </iq>
47 | 
48 | <iq type='set' 
49 |     from='client@geiseri.com/telnet' 
50 |     to='server@geiseri.com/QXmpp' 
51 |     id='rpc1'>
52 |   <query xmlns='jabber:iq:rpc'>
53 |     <methodCall>
54 |       <methodName>BadInterface.echoString</methodName>
55 |       <params>
56 |         <param>
57 |           <value><string>Test string</string></value>
58 |         </param>
59 |       </params>
60 |     </methodCall>
61 |   </query>
62 | </iq>
63 | 
64 | 


--------------------------------------------------------------------------------
/examples/example_5_rpcInterface/xmlrpctest.txt.license:
--------------------------------------------------------------------------------
1 | SPDX-FileCopyrightText: 2009 Ian Geiser <ian.geiser@gmail.com>
2 | 
3 | SPDX-License-Identifier: CC0-1.0


--------------------------------------------------------------------------------
/examples/example_6_rpcClient/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | # SPDX-FileCopyrightText: 2017 Niels Ole Salscheider <niels_ole@salscheider-online.de>
2 | #
3 | # SPDX-License-Identifier: CC0-1.0
4 | 
5 | add_executable(6_rpcClient main.cpp rpcClient.cpp)
6 | target_link_libraries(6_rpcClient ${QXMPP_TARGET})
7 | 


--------------------------------------------------------------------------------
/examples/example_6_rpcClient/main.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2010 Ian Reinhart Geiser <geiseri@kde.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #include "QXmppLogger.h"
 6 | 
 7 | #include "rpcClient.h"
 8 | 
 9 | #include <QtCore/QCoreApplication>
10 | 
11 | int main(int argc, char *argv[])
12 | {
13 |     QCoreApplication a(argc, argv);
14 | 
15 |     QXmppLogger::getLogger()->setLoggingType(QXmppLogger::StdoutLogging);
16 | 
17 |     rpcClient client;
18 |     client.connectToServer("qxmpp.test2@qxmpp.org", "qxmpp456");
19 |     return a.exec();
20 | }
21 | 


--------------------------------------------------------------------------------
/examples/example_6_rpcClient/rpcClient.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2010 Ian Reinhart Geiser <geiseri@kde.org>
 2 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 3 | //
 4 | // SPDX-License-Identifier: LGPL-2.1-or-later
 5 | 
 6 | #include "rpcClient.h"
 7 | 
 8 | #include "QXmppRpcManager.h"
 9 | #include "QXmppUtils.h"
10 | 
11 | #include <QDebug>
12 | #include <QTimer>
13 | 
14 | rpcClient::rpcClient(QObject *parent)
15 |     : QXmppClient(parent)
16 | {
17 |     // add RPC manager
18 |     m_rpcManager = new QXmppRpcManager;
19 |     addExtension(m_rpcManager);
20 | 
21 |     // observe incoming presences
22 |     connect(this, &QXmppClient::presenceReceived,
23 |             this, &rpcClient::slotPresenceReceived);
24 | }
25 | 
26 | rpcClient::~rpcClient()
27 | {
28 | }
29 | 
30 | void rpcClient::slotInvokeRemoteMethod()
31 | {
32 |     QXmppRemoteMethodResult methodResult = m_rpcManager->callRemoteMethod(
33 |         m_remoteJid, "RemoteInterface.echoString", "This is a test");
34 |     if (methodResult.hasError) {
35 |         qDebug() << "Error:" << methodResult.code << methodResult.errorMessage;
36 |     } else {
37 |         qDebug() << "Result:" << methodResult.result;
38 |     }
39 | }
40 | 
41 | /// A presence was received.
42 | 
43 | void rpcClient::slotPresenceReceived(const QXmppPresence &presence)
44 | {
45 |     QStringView recipient = u"qxmpp.test1@qxmpp.org";
46 | 
47 |     // if we are the recipient, or if the presence is not from the recipient,
48 |     // do nothing
49 |     if (QXmppUtils::jidToBareJid(configuration().jid()) == recipient ||
50 |         QXmppUtils::jidToBareJid(presence.from()) != recipient ||
51 |         presence.type() != QXmppPresence::Available) {
52 |         return;
53 |     }
54 | 
55 |     // invoke the remote method in 1 second
56 |     m_remoteJid = presence.from();
57 |     QTimer::singleShot(1000, this, &rpcClient::slotInvokeRemoteMethod);
58 | }
59 | 


--------------------------------------------------------------------------------
/examples/example_6_rpcClient/rpcClient.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2010 Ian Reinhart Geiser <geiseri@kde.org>
 2 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 3 | //
 4 | // SPDX-License-Identifier: LGPL-2.1-or-later
 5 | 
 6 | #ifndef RPCCLIENT_H
 7 | #define RPCCLIENT_H
 8 | 
 9 | #include "QXmppClient.h"
10 | 
11 | class QXmppRpcManager;
12 | 
13 | class rpcClient : public QXmppClient
14 | {
15 |     Q_OBJECT
16 | 
17 | public:
18 |     rpcClient(QObject *parent = nullptr);
19 |     ~rpcClient() override;
20 | 
21 | private:
22 |     Q_SLOT void slotInvokeRemoteMethod();
23 |     Q_SLOT void slotPresenceReceived(const QXmppPresence &presence);
24 | 
25 |     QString m_remoteJid;
26 |     QXmppRpcManager *m_rpcManager;
27 | };
28 | 
29 | #endif  // RPCCLIENT_H
30 | 


--------------------------------------------------------------------------------
/examples/example_7_archiveHandling/example_7_archiveHandling.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2012 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef XMPPCLIENT_H
 6 | #define XMPPCLIENT_H
 7 | 
 8 | #include "QXmppArchiveIq.h"
 9 | #include "QXmppClient.h"
10 | 
11 | #include <QDateTime>
12 | 
13 | class QXmppArchiveManager;
14 | class QXmppResultSetReply;
15 | 
16 | class xmppClient : public QXmppClient
17 | {
18 |     Q_OBJECT
19 | 
20 | public:
21 |     enum PageDirection {
22 |         PageForwards = 0,
23 |         PageBackwards
24 |     };
25 | 
26 |     xmppClient(QObject *parent = nullptr);
27 |     ~xmppClient() override;
28 | 
29 |     void setPageDirection(PageDirection direction);
30 |     void setPageSize(int size);
31 | 
32 |     void clientConnected();
33 |     void archiveListReceived(const QList<QXmppArchiveChat> &chats, const QXmppResultSetReply &rsmReply);
34 |     void archiveChatReceived(const QXmppArchiveChat &chat, const QXmppResultSetReply &rsmReply);
35 | 
36 | private:
37 |     QXmppArchiveManager *archiveManager;
38 |     int m_collectionCount;
39 |     QDateTime m_startDate;
40 |     QDateTime m_endDate;
41 |     PageDirection m_pageDirection;
42 |     int m_pageSize;
43 | };
44 | 
45 | #endif  // XMPPCLIENT_H
46 | 


--------------------------------------------------------------------------------
/examples/example_8_server/example_8_server.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2019 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #include "QXmppLogger.h"
 6 | #include "QXmppPasswordChecker.h"
 7 | #include "QXmppServer.h"
 8 | 
 9 | #include <QtCore/QCoreApplication>
10 | 
11 | #define USERNAME "qxmpp.test1"
12 | #define PASSWORD "qxmpp123"
13 | 
14 | class passwordChecker : public QXmppPasswordChecker
15 | {
16 |     /// Retrieves the password for the given username.
17 |     QXmppPasswordReply::Error getPassword(const QXmppPasswordRequest &request, QString &password) override
18 |     {
19 |         if (request.username() == USERNAME) {
20 |             password = PASSWORD;
21 |             return QXmppPasswordReply::NoError;
22 |         } else {
23 |             return QXmppPasswordReply::AuthorizationError;
24 |         }
25 |     };
26 | 
27 |     /// Returns true as we implemented getPassword().
28 |     bool hasGetPassword() const override
29 |     {
30 |         return true;
31 |     };
32 | };
33 | 
34 | int main(int argc, char *argv[])
35 | {
36 |     QCoreApplication a(argc, argv);
37 | 
38 |     // we want one argument : the domain to serve
39 |     if (argc != 2) {
40 |         fprintf(stderr, "Usage: xmppServer <domain>\n");
41 |         return EXIT_FAILURE;
42 |     }
43 |     const QString domain = QString::fromLocal8Bit(argv[1]);
44 | 
45 |     QXmppLogger logger;
46 |     logger.setLoggingType(QXmppLogger::StdoutLogging);
47 | 
48 |     passwordChecker checker;
49 | 
50 |     QXmppServer server;
51 |     server.setDomain(domain);
52 |     server.setLogger(&logger);
53 |     server.setPasswordChecker(&checker);
54 |     server.listenForClients();
55 |     server.listenForServers();
56 |     return a.exec();
57 | }
58 | 


--------------------------------------------------------------------------------
/examples/example_9_vCard/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | # SPDX-FileCopyrightText: 2017 Niels Ole Salscheider <niels_ole@salscheider-online.de>
2 | #
3 | # SPDX-License-Identifier: CC0-1.0
4 | 
5 | find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Gui)
6 | 
7 | add_executable(9_vCard example_9_vCard.cpp)
8 | target_link_libraries(9_vCard Qt${QT_VERSION_MAJOR}::Gui ${QXMPP_TARGET})
9 | 


--------------------------------------------------------------------------------
/examples/example_9_vCard/README:
--------------------------------------------------------------------------------
1 | <!--
2 | SPDX-FileCopyrightText: 2009 Manjeet Dahiya <manjeetdahiya@gmail.com>
3 | 
4 | SPDX-License-Identifier: CC0-1.0
5 | -->
6 | 
7 | This example demonstrates how to get the vCards and handle Avatars of the roster entities.


--------------------------------------------------------------------------------
/examples/example_9_vCard/example_9_vCard.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2012 Manjeet Dahiya <manjeetdahiya@gmail.com>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef XMPPCLIENT_H
 6 | #define XMPPCLIENT_H
 7 | 
 8 | #include "QXmppClient.h"
 9 | 
10 | class QXmppRosterManager;
11 | class QXmppVCardIq;
12 | class QXmppVCardManager;
13 | 
14 | class xmppClient : public QXmppClient
15 | {
16 |     Q_OBJECT
17 | 
18 | public:
19 |     xmppClient(QObject *parent = nullptr);
20 |     ~xmppClient() override;
21 | 
22 |     void clientConnected();
23 |     void rosterReceived();
24 |     void vCardReceived(const QXmppVCardIq &);
25 | 
26 | private:
27 |     QXmppRosterManager *m_rosterManager;
28 |     QXmppVCardManager *m_vCardManager;
29 | };
30 | 
31 | #endif  // XMPPCLIENT_H
32 | 


--------------------------------------------------------------------------------
/logo.svg.license:
--------------------------------------------------------------------------------
1 | SPDX-FileCopyrightText: 2023 Raghavendra Kamath <raghu@raghukamath.com>
2 | 
3 | SPDX-License-Identifier: CC-BY-SA-4.0
4 | 
5 | 


--------------------------------------------------------------------------------
/qxmpp.pc.in:
--------------------------------------------------------------------------------
 1 | # SPDX-FileCopyrightText: 2017 Niels Ole Salscheider <niels_ole@salscheider-online.de>
 2 | #
 3 | # SPDX-License-Identifier: CC0-1.0
 4 | 
 5 | prefix=@CMAKE_INSTALL_PREFIX@
 6 | exec_prefix=${prefix}
 7 | libdir=@CMAKE_INSTALL_FULL_LIBDIR@
 8 | includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@/@QXMPP_TARGET@
 9 | 
10 | 
11 | Name: @QXMPP_TARGET@
12 | Description: QXmpp Library
13 | Version: @PROJECT_VERSION@
14 | Libs: -l@QXMPP_TARGET@
15 | Libs.private: -lQt@QT_VERSION_MAJOR@Network -lQt@QT_VERSION_MAJOR@Xml -lQt@QT_VERSION_MAJOR@Core
16 | Cflags: -I${includedir}
17 | 
18 | 


--------------------------------------------------------------------------------
/qxmpp_legacy.pc.in:
--------------------------------------------------------------------------------
 1 | # SPDX-FileCopyrightText: 2017 Niels Ole Salscheider <niels_ole@salscheider-online.de>
 2 | #
 3 | # SPDX-License-Identifier: CC0-1.0
 4 | 
 5 | prefix=@CMAKE_INSTALL_PREFIX@
 6 | exec_prefix=${prefix}
 7 | libdir=@CMAKE_INSTALL_FULL_LIBDIR@
 8 | includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@/QXmppQt5
 9 | 
10 | 
11 | Name: Qxmpp
12 | Description: QXmpp Library
13 | Version: @PROJECT_VERSION@
14 | Requires: QXmppQt5
15 | Libs: -lQXmppQt5
16 | Cflags: -I${includedir}
17 | 
18 | 


--------------------------------------------------------------------------------
/src/base/QXmppBindIq.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2011 Manjeet Dahiya <manjeetdahiya@gmail.com>
 2 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 3 | //
 4 | // SPDX-License-Identifier: LGPL-2.1-or-later
 5 | 
 6 | #ifndef QXMPPBINDIQ_H
 7 | #define QXMPPBINDIQ_H
 8 | 
 9 | #include "QXmppIq.h"
10 | 
11 | /// \brief The QXmppBindIq class represents an IQ used for resource
12 | /// binding as defined by RFC 3921.
13 | ///
14 | /// \ingroup Stanzas
15 | 
16 | class QXMPP_EXPORT QXmppBindIq : public QXmppIq
17 | {
18 | public:
19 |     static QXmppBindIq bindAddressIq(const QString &resource);
20 | 
21 |     QString jid() const;
22 |     void setJid(const QString &);
23 | 
24 |     QString resource() const;
25 |     void setResource(const QString &);
26 | 
27 |     /// \cond
28 |     static bool isBindIq(const QDomElement &element);
29 |     /// \endcond
30 | 
31 | protected:
32 |     /// \cond
33 |     void parseElementFromChild(const QDomElement &element) override;
34 |     void toXmlElementFromChild(QXmlStreamWriter *writer) const override;
35 |     /// \endcond
36 | 
37 | private:
38 |     QString m_jid;
39 |     QString m_resource;
40 | };
41 | 
42 | #endif  // QXMPPBIND_H
43 | 


--------------------------------------------------------------------------------
/src/base/QXmppBitsOfBinaryContentId.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2019 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPBITSOFBINARYCONTENTID_H
 6 | #define QXMPPBITSOFBINARYCONTENTID_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <QCryptographicHash>
11 | #include <QSharedDataPointer>
12 | 
13 | class QXmppBitsOfBinaryContentIdPrivate;
14 | 
15 | class QXMPP_EXPORT QXmppBitsOfBinaryContentId
16 | {
17 | public:
18 |     static QXmppBitsOfBinaryContentId fromCidUrl(const QString &input);
19 |     static QXmppBitsOfBinaryContentId fromContentId(const QString &input);
20 | 
21 |     QXmppBitsOfBinaryContentId();
22 |     QXmppBitsOfBinaryContentId(const QXmppBitsOfBinaryContentId &cid);
23 |     QXmppBitsOfBinaryContentId(QXmppBitsOfBinaryContentId &&);
24 |     ~QXmppBitsOfBinaryContentId();
25 | 
26 |     QXmppBitsOfBinaryContentId &operator=(const QXmppBitsOfBinaryContentId &other);
27 |     QXmppBitsOfBinaryContentId &operator=(QXmppBitsOfBinaryContentId &&);
28 | 
29 |     QString toContentId() const;
30 |     QString toCidUrl() const;
31 | 
32 |     QByteArray hash() const;
33 |     void setHash(const QByteArray &hash);
34 | 
35 |     QCryptographicHash::Algorithm algorithm() const;
36 |     void setAlgorithm(QCryptographicHash::Algorithm algo);
37 | 
38 |     bool isValid() const;
39 | 
40 |     static bool isBitsOfBinaryContentId(const QString &uri, bool checkIsCidUrl = false);
41 | 
42 |     bool operator==(const QXmppBitsOfBinaryContentId &other) const;
43 | 
44 | private:
45 |     QSharedDataPointer<QXmppBitsOfBinaryContentIdPrivate> d;
46 | };
47 | 
48 | #endif  // QXMPPBITSOFBINARYCONTENTID_H
49 | 


--------------------------------------------------------------------------------
/src/base/QXmppBitsOfBinaryData.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2019 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPBITSOFBINARYDATA_H
 6 | #define QXMPPBITSOFBINARYDATA_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <QSharedDataPointer>
11 | 
12 | class QDomElement;
13 | class QMimeType;
14 | class QXmlStreamWriter;
15 | class QXmppBitsOfBinaryDataPrivate;
16 | class QXmppBitsOfBinaryContentId;
17 | 
18 | class QXMPP_EXPORT QXmppBitsOfBinaryData
19 | {
20 | public:
21 |     static QXmppBitsOfBinaryData fromByteArray(QByteArray data);
22 | 
23 |     QXmppBitsOfBinaryData();
24 |     QXmppBitsOfBinaryData(const QXmppBitsOfBinaryData &);
25 |     QXmppBitsOfBinaryData(QXmppBitsOfBinaryData &&);
26 |     ~QXmppBitsOfBinaryData();
27 | 
28 |     QXmppBitsOfBinaryData &operator=(const QXmppBitsOfBinaryData &);
29 |     QXmppBitsOfBinaryData &operator=(QXmppBitsOfBinaryData &&);
30 | 
31 |     QXmppBitsOfBinaryContentId cid() const;
32 |     void setCid(const QXmppBitsOfBinaryContentId &cid);
33 | 
34 |     int maxAge() const;
35 |     void setMaxAge(int maxAge);
36 | 
37 |     QMimeType contentType() const;
38 |     void setContentType(const QMimeType &contentType);
39 | 
40 |     QByteArray data() const;
41 |     void setData(const QByteArray &data);
42 | 
43 |     bool static isBitsOfBinaryData(const QDomElement &element);
44 | 
45 |     /// \cond
46 |     void parseElementFromChild(const QDomElement &dataElement);
47 |     void toXmlElementFromChild(QXmlStreamWriter *writer) const;
48 |     /// \endcond
49 | 
50 |     bool operator==(const QXmppBitsOfBinaryData &other) const;
51 | 
52 | private:
53 |     QSharedDataPointer<QXmppBitsOfBinaryDataPrivate> d;
54 | };
55 | 
56 | #endif  // QXMPPBITSOFBINARYDATA_H
57 | 


--------------------------------------------------------------------------------
/src/base/QXmppBitsOfBinaryDataList.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2019 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPBITSOFBINARYDATACONTAINER_H
 6 | #define QXMPPBITSOFBINARYDATACONTAINER_H
 7 | 
 8 | #include "QXmppBitsOfBinaryData.h"
 9 | 
10 | #include <QVector>
11 | 
12 | class QDomElement;
13 | class QXmlStreamWriter;
14 | 
15 | class QXMPP_EXPORT QXmppBitsOfBinaryDataList : public QVector<QXmppBitsOfBinaryData>
16 | {
17 | public:
18 |     QXmppBitsOfBinaryDataList();
19 |     ~QXmppBitsOfBinaryDataList();
20 | 
21 |     /// \cond
22 |     QXmppBitsOfBinaryDataList(const QVector<QXmppBitsOfBinaryData> &data) : QVector<QXmppBitsOfBinaryData>(data) { }
23 |     QXmppBitsOfBinaryDataList(QVector<QXmppBitsOfBinaryData> &&data) : QVector<QXmppBitsOfBinaryData>(std::move(data)) { }
24 | 
25 |     void parse(const QDomElement &element);
26 |     void toXml(QXmlStreamWriter *writer) const;
27 |     /// \endcond
28 | };
29 | 
30 | #endif  // QXMPPBITSOFBINARYDATACONTAINER_H
31 | 


--------------------------------------------------------------------------------
/src/base/QXmppBitsOfBinaryIq.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2019 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #include "QXmppBitsOfBinaryIq.h"
 6 | 
 7 | #include "QXmppConstants_p.h"
 8 | #include "QXmppUtils_p.h"
 9 | 
10 | #include "StringLiterals.h"
11 | 
12 | #include <QDomElement>
13 | #include <QSharedData>
14 | 
15 | using namespace QXmpp::Private;
16 | 
17 | ///
18 | /// \class QXmppBitsOfBinaryIq
19 | ///
20 | /// QXmppBitsOfBinaryIq represents a \xep{0231, Bits of Binary} IQ to request
21 | /// and transmit Bits of Binary data elements.
22 | ///
23 | /// \since QXmpp 1.2
24 | ///
25 | 
26 | QXmppBitsOfBinaryIq::QXmppBitsOfBinaryIq() = default;
27 | 
28 | QXmppBitsOfBinaryIq::~QXmppBitsOfBinaryIq() = default;
29 | 
30 | ///
31 | /// Returns true, if \c element is a \xep{0231, Bits of Binary} IQ
32 | ///
33 | /// \note This may also return true, if the IQ is not a Bits of Binary IQ in
34 | /// first place, but only contains a Bits of Binary data element.
35 | ///
36 | bool QXmppBitsOfBinaryIq::isBitsOfBinaryIq(const QDomElement &element)
37 | {
38 |     return isIqType(element, u"data", ns_bob);
39 | }
40 | 
41 | /// \cond
42 | void QXmppBitsOfBinaryIq::parseElementFromChild(const QDomElement &element)
43 | {
44 |     auto child = firstChildElement(element, u"data", ns_bob);
45 |     if (!child.isNull()) {
46 |         QXmppBitsOfBinaryData::parseElementFromChild(child);
47 |     }
48 | }
49 | 
50 | void QXmppBitsOfBinaryIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
51 | {
52 |     QXmppBitsOfBinaryData::toXmlElementFromChild(writer);
53 | }
54 | /// \endcond
55 | 


--------------------------------------------------------------------------------
/src/base/QXmppBitsOfBinaryIq.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2019 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPBITSOFBINARYIQ_H
 6 | #define QXMPPBITSOFBINARYIQ_H
 7 | 
 8 | #include "QXmppBitsOfBinaryData.h"
 9 | #include "QXmppIq.h"
10 | 
11 | class QXMPP_EXPORT QXmppBitsOfBinaryIq : public QXmppIq, public QXmppBitsOfBinaryData
12 | {
13 | public:
14 |     QXmppBitsOfBinaryIq();
15 |     ~QXmppBitsOfBinaryIq() override;
16 | 
17 |     static bool isBitsOfBinaryIq(const QDomElement &element);
18 | 
19 | protected:
20 |     /// \cond
21 |     void parseElementFromChild(const QDomElement &element) override;
22 |     void toXmlElementFromChild(QXmlStreamWriter *writer) const override;
23 |     /// \endcond
24 | };
25 | 
26 | #endif  // QXMPPBITSOFBINARYIQ_H
27 | 


--------------------------------------------------------------------------------
/src/base/QXmppByteStreamIq.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPBYTESTREAMIQ_H
 6 | #define QXMPPBYTESTREAMIQ_H
 7 | 
 8 | #include "QXmppIq.h"
 9 | 
10 | #include <QHostAddress>
11 | 
12 | class QXMPP_EXPORT QXmppByteStreamIq : public QXmppIq
13 | {
14 | public:
15 |     enum Mode {
16 |         None = 0,
17 |         Tcp,
18 |         Udp
19 |     };
20 | 
21 |     class QXMPP_EXPORT StreamHost
22 |     {
23 |     public:
24 |         QString jid() const;
25 |         void setJid(const QString &jid);
26 | 
27 |         QString host() const;
28 |         void setHost(const QString &host);
29 | 
30 |         quint16 port() const;
31 |         void setPort(quint16 port);
32 | 
33 |         QString zeroconf() const;
34 |         void setZeroconf(const QString &zeroconf);
35 | 
36 |     private:
37 |         QString m_host;
38 |         QString m_jid;
39 |         quint16 m_port;
40 |         QString m_zeroconf;
41 |     };
42 | 
43 |     QXmppByteStreamIq::Mode mode() const;
44 |     void setMode(QXmppByteStreamIq::Mode mode);
45 | 
46 |     QString sid() const;
47 |     void setSid(const QString &sid);
48 | 
49 |     QString activate() const;
50 |     void setActivate(const QString &activate);
51 | 
52 |     QList<QXmppByteStreamIq::StreamHost> streamHosts() const;
53 |     void setStreamHosts(const QList<QXmppByteStreamIq::StreamHost> &streamHosts);
54 | 
55 |     QString streamHostUsed() const;
56 |     void setStreamHostUsed(const QString &jid);
57 | 
58 |     static bool isByteStreamIq(const QDomElement &element);
59 | 
60 | protected:
61 |     /// \cond
62 |     void parseElementFromChild(const QDomElement &element) override;
63 |     void toXmlElementFromChild(QXmlStreamWriter *writer) const override;
64 |     /// \endcond
65 | 
66 | private:
67 |     Mode m_mode = None;
68 |     QString m_sid;
69 | 
70 |     QString m_activate;
71 |     QList<StreamHost> m_streamHosts;
72 |     QString m_streamHostUsed;
73 | };
74 | 
75 | #endif
76 | 


--------------------------------------------------------------------------------
/src/base/QXmppColorGeneration.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2019 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #include "QXmppColorGeneration.h"
 6 | 
 7 | #include "hsluv/hsluv.h"
 8 | 
 9 | #include <QCryptographicHash>
10 | 
11 | using namespace QXmpp::Private;
12 | 
13 | ///
14 | /// \class QXmppColorGeneration
15 | ///
16 | /// \brief Generates colors from strings as defined in \xep{0392, Consistent Color Generation}.
17 | ///
18 | /// This way the colors are unique between different clients.
19 | ///
20 | /// \since QXmpp 1.10
21 | ///
22 | 
23 | ///
24 | /// Generates an RGB color triple for a string.
25 | ///
26 | QXmppColorGeneration::Rgb QXmppColorGeneration::generateRgb(QStringView str)
27 | {
28 |     double hue = generateColorAngle(str);
29 |     double saturation = 100.0;
30 |     double lightness = 50.0;
31 | 
32 |     // convert to rgb values (values are between 0.0 and 1.0)
33 |     double red, green, blue = 0.0;
34 |     hsluv2rgb(hue, saturation, lightness, &red, &green, &blue);
35 | 
36 |     return Rgb { quint8(red * 255.0), quint8(green * 255.0), quint8(blue * 255.0) };
37 | }
38 | 
39 | ///
40 | /// \fn QXmppColorGeneration::generateColor
41 | ///
42 | /// Generates a QColor for a string.
43 | ///
44 | /// \note This is a header-only function and it is only available when building the application
45 | /// using QXmpp with the Qt GUI module.
46 | ///
47 | 
48 | double QXmpp::Private::generateColorAngle(QStringView str)
49 | {
50 |     QByteArray input = str.toUtf8();
51 | 
52 |     // hash input through SHA-1
53 |     auto hashValue = QCryptographicHash::hash(str.toUtf8(), QCryptographicHash::Sha1);
54 | 
55 |     // the first two bytes are used to calculate the angle/hue
56 |     auto hashData = reinterpret_cast<quint8 *>(hashValue.data());
57 |     int angle = hashData[0] + hashData[1] * 256;
58 | 
59 |     return double(angle) / 65536.0 * 360.0;
60 | }
61 | 


--------------------------------------------------------------------------------
/src/base/QXmppColorGeneration.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2019 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPCOLORGENERATION_H
 6 | #define QXMPPCOLORGENERATION_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #ifdef QT_GUI_LIB
11 | #include <QColor>
12 | #endif
13 | 
14 | class QXmppColorGeneration
15 | {
16 | public:
17 |     struct QXMPP_EXPORT Rgb {
18 |         quint8 red;
19 |         quint8 green;
20 |         quint8 blue;
21 |     };
22 | 
23 |     QXMPP_EXPORT static Rgb generateRgb(QStringView str);
24 | 
25 | #if defined(QT_GUI_LIB) || defined(QXMPP_DOC)
26 |     static inline QColor generateColor(QStringView str)
27 |     {
28 |         auto rgb = generateRgb(str);
29 |         return QColor(rgb.red, rgb.green, rgb.blue);
30 |     }
31 | #endif
32 | };
33 | 
34 | namespace QXmpp::Private {
35 | double generateColorAngle(QStringView str);
36 | }
37 | 
38 | #endif  // QXMPPCOLORGENERATION_H
39 | 


--------------------------------------------------------------------------------
/src/base/QXmppE2eeMetadata.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPE2EEMETADATA_H
 6 | #define QXMPPE2EEMETADATA_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <QSharedDataPointer>
11 | 
12 | class QDateTime;
13 | class QXmppE2eeMetadataPrivate;
14 | 
15 | class QXMPP_EXPORT QXmppE2eeMetadata
16 | {
17 | public:
18 |     QXmppE2eeMetadata();
19 |     /// \cond
20 |     QXmppE2eeMetadata(QSharedDataPointer<QXmppE2eeMetadataPrivate> d);
21 |     /// \endcond
22 |     QXmppE2eeMetadata(const QXmppE2eeMetadata &other);
23 |     QXmppE2eeMetadata(QXmppE2eeMetadata &&);
24 |     ~QXmppE2eeMetadata();
25 | 
26 |     QXmppE2eeMetadata &operator=(const QXmppE2eeMetadata &other);
27 |     QXmppE2eeMetadata &operator=(QXmppE2eeMetadata &&);
28 | 
29 |     QXmpp::EncryptionMethod encryption() const;
30 |     void setEncryption(QXmpp::EncryptionMethod encryption);
31 | 
32 |     QByteArray senderKey() const;
33 |     void setSenderKey(const QByteArray &keyId);
34 | 
35 |     // XEP-0420: Stanza Content Encryption
36 |     QDateTime sceTimestamp() const;
37 |     void setSceTimestamp(const QDateTime &timestamp);
38 | 
39 | private:
40 |     friend class QXmppStanza;
41 | 
42 |     QSharedDataPointer<QXmppE2eeMetadataPrivate> d;
43 | };
44 | 
45 | #endif  // QXMPPE2EEMETADATA_H
46 | 


--------------------------------------------------------------------------------
/src/base/QXmppElement.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPELEMENT_H
 6 | #define QXMPPELEMENT_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <QMap>
11 | #include <QStringList>
12 | #include <QXmlStreamWriter>
13 | 
14 | class QDomElement;
15 | class QXmppElement;
16 | class QXmppElementPrivate;
17 | 
18 | using QXmppElementList = QList<QXmppElement>;
19 | 
20 | class QXMPP_EXPORT QXmppElement
21 | {
22 | public:
23 |     QXmppElement();
24 |     QXmppElement(const QXmppElement &other);
25 |     QXmppElement(const QDomElement &element);
26 |     ~QXmppElement();
27 | 
28 |     QDomElement sourceDomElement() const;
29 | 
30 |     QStringList attributeNames() const;
31 | 
32 |     QString attribute(const QString &name) const;
33 |     void setAttribute(const QString &name, const QString &value);
34 | 
35 |     void appendChild(const QXmppElement &child);
36 |     QXmppElement firstChildElement(const QString &name = QString()) const;
37 |     QXmppElement nextSiblingElement(const QString &name = QString()) const;
38 |     void removeChild(const QXmppElement &child);
39 | 
40 |     QString tagName() const;
41 |     void setTagName(const QString &type);
42 | 
43 |     QString value() const;
44 |     void setValue(const QString &text);
45 | 
46 |     bool isNull() const;
47 |     void toXml(QXmlStreamWriter *writer) const;
48 | 
49 |     QXmppElement &operator=(const QXmppElement &other);
50 | 
51 | private:
52 |     QXmppElement(QXmppElementPrivate *other);
53 |     // ### QXmpp2: Use an std::shared_ptr if possible?
54 |     QXmppElementPrivate *d;
55 | };
56 | 
57 | #endif
58 | 


--------------------------------------------------------------------------------
/src/base/QXmppEncryptedFileSource.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | // SPDX-FileCopyrightText: 2022 Jonah Brüchert <jbb@kaidan.im>
 3 | //
 4 | // SPDX-License-Identifier: LGPL-2.1-or-later
 5 | 
 6 | #ifndef QXMPPENCRYPTEDFILESOURCE_H
 7 | #define QXMPPENCRYPTEDFILESOURCE_H
 8 | 
 9 | #include "QXmppGlobal.h"
10 | #include "QXmppHash.h"
11 | #include "QXmppHttpFileSource.h"
12 | 
13 | #include <QSharedDataPointer>
14 | #include <QUrl>
15 | #include <QVector>
16 | 
17 | class QXmppEncryptedFileSourcePrivate;
18 | 
19 | // exported for tests
20 | class QXMPP_EXPORT QXmppEncryptedFileSource
21 | {
22 | public:
23 |     QXmppEncryptedFileSource();
24 |     QXMPP_PRIVATE_DECLARE_RULE_OF_SIX(QXmppEncryptedFileSource)
25 | 
26 |     QXmpp::Cipher cipher() const;
27 |     void setCipher(QXmpp::Cipher newCipher);
28 | 
29 |     const QByteArray &key() const;
30 |     void setKey(const QByteArray &newKey);
31 | 
32 |     const QByteArray &iv() const;
33 |     void setIv(const QByteArray &newIv);
34 | 
35 |     const QVector<QXmppHash> &hashes() const;
36 |     void setHashes(const QVector<QXmppHash> &newHashes);
37 | 
38 |     const QVector<QXmppHttpFileSource> &httpSources() const;
39 |     void setHttpSources(const QVector<QXmppHttpFileSource> &newHttpSources);
40 | 
41 |     /// \cond
42 |     bool parse(const QDomElement &el);
43 |     void toXml(QXmlStreamWriter *writer) const;
44 |     /// \endcond
45 | 
46 | private:
47 |     QSharedDataPointer<QXmppEncryptedFileSourcePrivate> d;
48 | };
49 | 
50 | #endif  // QXMPPENCRYPTEDFILESOURCE_H
51 | 


--------------------------------------------------------------------------------
/src/base/QXmppEntityTimeIq.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2010 Manjeet Dahiya <manjeetdahiya@gmail.com>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPENTITYTIMEIQ_H
 6 | #define QXMPPENTITYTIMEIQ_H
 7 | 
 8 | #include "QXmppIq.h"
 9 | 
10 | #include <QDateTime>
11 | 
12 | ///
13 | /// \brief QXmppEntityTimeIq represents an entity time request/response as
14 | /// defined in \xep{0202}: Entity Time.
15 | ///
16 | /// \ingroup Stanzas
17 | ///
18 | class QXMPP_EXPORT QXmppEntityTimeIq : public QXmppIq
19 | {
20 | public:
21 |     int tzo() const;
22 |     void setTzo(int tzo);
23 | 
24 |     QDateTime utc() const;
25 |     void setUtc(const QDateTime &utc);
26 | 
27 |     static bool isEntityTimeIq(const QDomElement &element);
28 |     /// \cond
29 |     static bool checkIqType(const QString &tagName, const QString &xmlns);
30 | 
31 | protected:
32 |     void parseElementFromChild(const QDomElement &element) override;
33 |     void toXmlElementFromChild(QXmlStreamWriter *writer) const override;
34 |     /// \endcond
35 | 
36 | private:
37 |     int m_tzo;
38 |     QDateTime m_utc;
39 | };
40 | 
41 | #endif  // QXMPPENTITYTIMEIQ_H
42 | 


--------------------------------------------------------------------------------
/src/base/QXmppError.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPERROR_H
 6 | #define QXMPPERROR_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <any>
11 | #include <optional>
12 | 
13 | class QFileDevice;
14 | class QIODevice;
15 | class QNetworkReply;
16 | 
17 | struct QXMPP_EXPORT QXmppError {
18 |     QString description;
19 |     std::any error;
20 | 
21 |     static QXmppError fromIoDevice(const QIODevice &device);
22 |     static QXmppError fromNetworkReply(const QNetworkReply &reply);
23 |     static QXmppError fromFileDevice(const QFileDevice &file);
24 | 
25 |     bool isFileError() const;
26 |     bool isNetworkError() const;
27 |     bool isStanzaError() const;
28 | 
29 |     template<typename T>
30 |     bool holdsType() const
31 |     {
32 |         return error.type().hash_code() == typeid(T).hash_code();
33 |     }
34 |     template<typename T>
35 |     std::optional<T> value() const
36 |     {
37 |         // any_cast always checks this, to avoid an additional check we use exceptions
38 |         try {
39 |             return std::any_cast<T>(error);
40 |         } catch (std::bad_any_cast) {
41 |             return {};
42 |         }
43 |     }
44 |     template<typename T>
45 |     std::optional<T> takeValue()
46 |     {
47 |         // we can't use unchecked any_cast with moving because we can't access the error after a
48 |         // failed any_cast
49 |         if (error.type().hash_code() == typeid(T).hash_code()) {
50 |             auto value = std::any_cast<T>(std::move(error));
51 |             error = std::any();
52 |             return value;
53 |         }
54 |         return {};
55 |     }
56 | };
57 | 
58 | #endif  // QXMPPERROR_H
59 | 


--------------------------------------------------------------------------------
/src/base/QXmppExtension.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPEXTENSION_H
 6 | #define QXMPPEXTENSION_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | class QXMPP_EXPORT QXmppExtension
11 | {
12 | };
13 | 
14 | #endif  // QXMPPEXTENSION_H
15 | 


--------------------------------------------------------------------------------
/src/base/QXmppExternalServiceDiscoveryIq.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2023 Tibor Csötönyi <work@taibsu.de>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPEXTERNALSERVICEDISCOVERYIQ_H
 6 | #define QXMPPEXTERNALSERVICEDISCOVERYIQ_H
 7 | 
 8 | #include "QXmppExternalService.h"
 9 | #include "QXmppIq.h"
10 | 
11 | class QXmppExternalServiceDiscoveryIqPrivate;
12 | 
13 | class QXMPP_EXPORT QXmppExternalServiceDiscoveryIq : public QXmppIq
14 | {
15 | public:
16 |     QXmppExternalServiceDiscoveryIq();
17 | 
18 |     QXMPP_PRIVATE_DECLARE_RULE_OF_SIX(QXmppExternalServiceDiscoveryIq)
19 | 
20 |     QVector<QXmppExternalService> externalServices();
21 |     void setExternalServices(const QVector<QXmppExternalService> &);
22 |     void addExternalService(const QXmppExternalService &);
23 | 
24 |     static bool isExternalServiceDiscoveryIq(const QDomElement &);
25 |     static bool checkIqType(const QString &tagName, const QString &xmlNamespace);
26 | 
27 | protected:
28 |     /// \cond
29 |     void parseElementFromChild(const QDomElement &) override;
30 |     void toXmlElementFromChild(QXmlStreamWriter *) const override;
31 |     /// \endcond
32 | 
33 | private:
34 |     QSharedDataPointer<QXmppExternalServiceDiscoveryIqPrivate> d;
35 | };
36 | 
37 | #endif  // QXMPPEXTERNALSERVICEDISCOVERYIQ_H
38 | 


--------------------------------------------------------------------------------
/src/base/QXmppFallback.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2024 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPFALLBACK_H
 6 | #define QXMPPFALLBACK_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <optional>
11 | 
12 | #include <QSharedDataPointer>
13 | 
14 | class QDomElement;
15 | class QXmlStreamWriter;
16 | 
17 | struct QXmppFallbackPrivate;
18 | 
19 | class QXMPP_EXPORT QXmppFallback
20 | {
21 | public:
22 |     enum Element {
23 |         Body,
24 |         Subject,
25 |     };
26 | 
27 |     struct Range {
28 |         /// Start index of the range
29 |         uint32_t start;
30 |         /// End index of the range
31 |         uint32_t end;
32 |     };
33 | 
34 |     struct Reference {
35 |         /// Element of the message stanza this refers to
36 |         Element element;
37 |         /// Optional character range in the text
38 |         std::optional<Range> range;
39 |     };
40 | 
41 |     QXmppFallback(const QString &forNamespace, const QVector<Reference> &references);
42 |     QXMPP_PRIVATE_DECLARE_RULE_OF_SIX(QXmppFallback)
43 | 
44 |     const QString &forNamespace() const;
45 |     void setForNamespace(const QString &);
46 | 
47 |     const QVector<Reference> &references() const;
48 |     void setReferences(const QVector<Reference> &);
49 | 
50 |     static std::optional<QXmppFallback> fromDom(const QDomElement &);
51 |     void toXml(QXmlStreamWriter *) const;
52 | 
53 | private:
54 |     QSharedDataPointer<QXmppFallbackPrivate> d;
55 | };
56 | 
57 | #endif  // QXMPPFALLBACK_H
58 | 


--------------------------------------------------------------------------------
/src/base/QXmppGeolocItem.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Cochise César <cochisecesar@zoho.com>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPGEOLOCITEM_H
 6 | #define QXMPPGEOLOCITEM_H
 7 | 
 8 | #include "QXmppPubSubBaseItem.h"
 9 | 
10 | #include <optional>
11 | 
12 | #include <QSharedDataPointer>
13 | 
14 | class QXmppGeolocItemPrivate;
15 | 
16 | class QXMPP_EXPORT QXmppGeolocItem : public QXmppPubSubBaseItem
17 | {
18 | public:
19 |     QXmppGeolocItem();
20 |     QXmppGeolocItem(const QXmppGeolocItem &other);
21 |     QXmppGeolocItem(QXmppGeolocItem &&);
22 |     ~QXmppGeolocItem() override;
23 | 
24 |     QXmppGeolocItem &operator=(const QXmppGeolocItem &other);
25 |     QXmppGeolocItem &operator=(QXmppGeolocItem &&);
26 | 
27 |     std::optional<double> accuracy() const;
28 |     void setAccuracy(std::optional<double> accuracy);
29 | 
30 |     QString country() const;
31 |     void setCountry(QString country);
32 | 
33 |     std::optional<double> latitude() const;
34 |     void setLatitude(std::optional<double> lat);
35 | 
36 |     QString locality() const;
37 |     void setLocality(QString locality);
38 | 
39 |     std::optional<double> longitude() const;
40 |     void setLongitude(std::optional<double> lon);
41 | 
42 |     static bool isItem(const QDomElement &itemElement);
43 | 
44 | protected:
45 |     /// \cond
46 |     void parsePayload(const QDomElement &payloadElement) override;
47 |     void serializePayload(QXmlStreamWriter *writer) const override;
48 |     /// \endcond
49 | 
50 | private:
51 |     QSharedDataPointer<QXmppGeolocItemPrivate> d;
52 | };
53 | 
54 | Q_DECLARE_METATYPE(QXmppGeolocItem)
55 | 
56 | #endif  // QXMPPGEOLOCITEM_H
57 | 


--------------------------------------------------------------------------------
/src/base/QXmppGlobal.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #include "QXmppConstants_p.h"
 6 | #include "QXmppGlobal_p.h"
 7 | #include "QXmppUtils_p.h"
 8 | 
 9 | #include "StringLiterals.h"
10 | 
11 | #include <array>
12 | 
13 | using namespace QXmpp::Private;
14 | 
15 | /// \cond
16 | constexpr auto ENCRYPTION_NAMESPACES = to_array<QStringView>({
17 |     {},
18 |     {},
19 |     ns_otr,
20 |     ns_legacy_openpgp,
21 |     ns_ox,
22 |     ns_omemo,
23 |     ns_omemo_1,
24 |     ns_omemo_2,
25 | });
26 | 
27 | constexpr auto ENCRYPTION_NAMES = to_array<QStringView>({
28 |     {},
29 |     {},
30 |     u"OTR",
31 |     u"Legacy OpenPGP",
32 |     u"OpenPGP for XMPP (OX)",
33 |     u"OMEMO",
34 |     u"OMEMO 1",
35 |     u"OMEMO 2",
36 | });
37 | 
38 | std::optional<QXmpp::EncryptionMethod> QXmpp::Private::encryptionFromString(QStringView str)
39 | {
40 |     auto itr = std::find(ENCRYPTION_NAMESPACES.begin(), ENCRYPTION_NAMESPACES.end(), str);
41 |     if (itr != ENCRYPTION_NAMESPACES.end()) {
42 |         return QXmpp::EncryptionMethod(std::distance(ENCRYPTION_NAMESPACES.begin(), itr));
43 |     }
44 |     return {};
45 | }
46 | 
47 | QStringView QXmpp::Private::encryptionToString(EncryptionMethod encryption)
48 | {
49 |     return ENCRYPTION_NAMESPACES[std::size_t(encryption)];
50 | }
51 | 
52 | QStringView QXmpp::Private::encryptionToName(EncryptionMethod encryption)
53 | {
54 |     return ENCRYPTION_NAMES[std::size_t(encryption)];
55 | }
56 | /// \endcond
57 | 


--------------------------------------------------------------------------------
/src/base/QXmppGlobal_p.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPGLOBAL_P_H
 6 | #define QXMPPGLOBAL_P_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <optional>
11 | 
12 | namespace QXmpp::Private {
13 | 
14 | // Encryption enum
15 | std::optional<EncryptionMethod> encryptionFromString(QStringView str);
16 | QStringView encryptionToString(EncryptionMethod);
17 | QStringView encryptionToName(EncryptionMethod);
18 | 
19 | }  // namespace QXmpp::Private
20 | 
21 | #endif  // QXMPPGLOBAL_P_H
22 | 


--------------------------------------------------------------------------------
/src/base/QXmppHash.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPHASH_H
 6 | #define QXMPPHASH_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <QByteArray>
11 | 
12 | class QDomElement;
13 | class QXmlStreamWriter;
14 | 
15 | namespace QXmpp {
16 | 
17 | enum class HashAlgorithm : uint32_t {
18 |     Unknown,
19 |     Md2,
20 |     Md5,
21 |     Shake128,
22 |     Shake256,
23 |     Sha1,
24 |     Sha224,
25 |     Sha256,
26 |     Sha384,
27 |     Sha512,
28 |     Sha3_256,
29 |     Sha3_512,
30 |     Blake2b_256,
31 |     Blake2b_512,
32 | };
33 | 
34 | }
35 | 
36 | class QXMPP_EXPORT QXmppHash
37 | {
38 | public:
39 |     QXmppHash();
40 | 
41 |     /// \cond
42 |     bool parse(const QDomElement &el);
43 |     void toXml(QXmlStreamWriter *writer) const;
44 |     /// \endcond
45 | 
46 |     QXmpp::HashAlgorithm algorithm() const;
47 |     void setAlgorithm(QXmpp::HashAlgorithm algorithm);
48 | 
49 |     QByteArray hash() const;
50 |     void setHash(const QByteArray &data);
51 | 
52 | private:
53 |     QXmpp::HashAlgorithm m_algorithm = QXmpp::HashAlgorithm::Unknown;
54 |     QByteArray m_hash;
55 | };
56 | 
57 | class QXMPP_EXPORT QXmppHashUsed
58 | {
59 | public:
60 |     QXmppHashUsed();
61 |     QXmppHashUsed(QXmpp::HashAlgorithm algorithm);
62 | 
63 |     /// \cond
64 |     bool parse(const QDomElement &el);
65 |     void toXml(QXmlStreamWriter *writer) const;
66 |     /// \endcond
67 | 
68 |     QXmpp::HashAlgorithm algorithm() const;
69 |     void setAlgorithm(QXmpp::HashAlgorithm algorithm);
70 | 
71 | private:
72 |     QXmpp::HashAlgorithm m_algorithm = QXmpp::HashAlgorithm::Unknown;
73 | };
74 | 
75 | #endif  // QXMPPHASH_H
76 | 


--------------------------------------------------------------------------------
/src/base/QXmppHashing_p.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPHASHING_H
 6 | #define QXMPPHASHING_H
 7 | 
 8 | #include "QXmppError.h"
 9 | #include "QXmppGlobal.h"
10 | #include "QXmppHash.h"
11 | 
12 | #include <memory>
13 | #include <variant>
14 | #include <vector>
15 | 
16 | #include <QCryptographicHash>
17 | 
18 | template<typename T>
19 | class QFuture;
20 | class QXmppHash;
21 | 
22 | namespace QXmpp::Private {
23 | 
24 | struct HashingResult {
25 |     using Result = std::variant<std::vector<QXmppHash>, Cancelled, QXmppError>;
26 | 
27 |     HashingResult(Result result, std::unique_ptr<QIODevice> data)
28 |         : result(std::move(result)), data(std::move(data))
29 |     {
30 |     }
31 | 
32 |     Result result;
33 |     std::unique_ptr<QIODevice> data;
34 | };
35 | 
36 | struct HashVerificationResult {
37 |     struct NoStrongHashes { };
38 |     struct NotMatching { };
39 |     struct Verified { };
40 |     using Result = std::variant<NoStrongHashes, NotMatching, Verified, Cancelled, QXmppError>;
41 | 
42 |     HashVerificationResult(Result result, std::unique_ptr<QIODevice> data)
43 |         : result(std::move(result)), data(std::move(data))
44 |     {
45 |     }
46 | 
47 |     Result result;
48 |     std::unique_ptr<QIODevice> data;
49 | };
50 | 
51 | using HashingResultPtr = std::shared_ptr<HashingResult>;
52 | using HashVerificationResultPtr = std::shared_ptr<HashVerificationResult>;
53 | 
54 | bool isHashingAlgorithmSecure(HashAlgorithm algorithm);
55 | uint16_t hashPriority(HashAlgorithm algorithm);
56 | 
57 | // QXMPP_EXPORT for unit tests
58 | QXMPP_EXPORT QFuture<HashingResultPtr> calculateHashes(std::unique_ptr<QIODevice> data, std::vector<HashAlgorithm> hashes);
59 | QFuture<HashVerificationResultPtr> verifyHashes(std::unique_ptr<QIODevice> data, std::vector<QXmppHash> hashes);
60 | 
61 | }  // namespace QXmpp::Private
62 | 
63 | #endif  // QXMPPHASHING_H
64 | 


--------------------------------------------------------------------------------
/src/base/QXmppHttpFileSource.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #include "QXmppHttpFileSource.h"
 6 | 
 7 | #include "QXmppConstants_p.h"
 8 | #include "QXmppUtils_p.h"
 9 | 
10 | #include "StringLiterals.h"
11 | 
12 | #include <QDomElement>
13 | #include <QXmlStreamWriter>
14 | 
15 | using namespace QXmpp::Private;
16 | 
17 | ///
18 | /// \class QXmppHttpFileSource
19 | ///
20 | /// Represents an HTTP File source for file sharing.
21 | ///
22 | /// \since QXmpp 1.5
23 | ///
24 | 
25 | /// Default constructor.
26 | QXmppHttpFileSource::QXmppHttpFileSource() = default;
27 | 
28 | /// Default constructor.
29 | QXmppHttpFileSource::QXmppHttpFileSource(QUrl url)
30 |     : m_url(std::move(url))
31 | {
32 | }
33 | 
34 | QXMPP_PRIVATE_DEFINE_RULE_OF_SIX(QXmppHttpFileSource)
35 | 
36 | ///
37 | /// Returns the HTTP url.
38 | ///
39 | const QUrl &QXmppHttpFileSource::url() const
40 | {
41 |     return m_url;
42 | }
43 | 
44 | ///
45 | /// Sets the HTTP url.
46 | ///
47 | void QXmppHttpFileSource::setUrl(QUrl url)
48 | {
49 |     m_url = std::move(url);
50 | }
51 | 
52 | /// \cond
53 | bool QXmppHttpFileSource::parse(const QDomElement &el)
54 | {
55 |     if (el.tagName() == u"url-data" && el.namespaceURI() == ns_url_data) {
56 |         m_url = QUrl(el.attribute(u"target"_s));
57 |         return true;
58 |     }
59 |     return false;
60 | }
61 | 
62 | void QXmppHttpFileSource::toXml(QXmlStreamWriter *writer) const
63 | {
64 |     writer->writeStartElement(QSL65("url-data"));
65 |     writer->writeDefaultNamespace(toString65(ns_url_data));
66 |     writer->writeAttribute(QSL65("target"), m_url.toString());
67 |     writer->writeEndElement();
68 | }
69 | /// \endcond
70 | 


--------------------------------------------------------------------------------
/src/base/QXmppHttpFileSource.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPHTTPFILESOURCE_H
 6 | #define QXMPPHTTPFILESOURCE_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <QUrl>
11 | 
12 | class QDomElement;
13 | class QXmlStreamWriter;
14 | 
15 | class QXMPP_EXPORT QXmppHttpFileSource
16 | {
17 | public:
18 |     QXmppHttpFileSource();
19 |     QXmppHttpFileSource(QUrl url);
20 |     QXMPP_PRIVATE_DECLARE_RULE_OF_SIX(QXmppHttpFileSource)
21 | 
22 |     const QUrl &url() const;
23 |     void setUrl(QUrl url);
24 | 
25 |     /// \cond
26 |     bool parse(const QDomElement &el);
27 |     void toXml(QXmlStreamWriter *writer) const;
28 |     /// \endcond
29 | 
30 | private:
31 |     static_assert(sizeof(QUrl) == sizeof(void *));
32 |     QUrl m_url;
33 | };
34 | 
35 | #endif  // QXMPPHTTPFILESOURCE_H
36 | 


--------------------------------------------------------------------------------
/src/base/QXmppIq.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2009 Manjeet Dahiya <manjeetdahiya@gmail.com>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPIQ_H
 6 | #define QXMPPIQ_H
 7 | 
 8 | #include "QXmppStanza.h"
 9 | 
10 | // forward declarations of QXmlStream* classes will not work on Mac, we need to
11 | // include the whole header.
12 | // See http://lists.trolltech.com/qt-interest/2008-07/thread00798-0.html
13 | // for an explanation.
14 | #include <QXmlStreamWriter>
15 | 
16 | class QXmppIqPrivate;
17 | 
18 | /// \brief The QXmppIq class is the base class for all IQs.
19 | ///
20 | /// \ingroup Stanzas
21 | 
22 | class QXMPP_EXPORT QXmppIq : public QXmppStanza
23 | {
24 | public:
25 |     /// This enum describes the type of IQ.
26 |     enum Type {
27 |         Error = 0,  ///< Error response.
28 |         Get,        ///< Get request.
29 |         Set,        ///< Set request.
30 |         Result      ///< Result.
31 |     };
32 | 
33 |     QXmppIq(QXmppIq::Type type = QXmppIq::Get);
34 |     QXmppIq(const QXmppIq &other);
35 |     QXmppIq(QXmppIq &&);
36 |     ~QXmppIq() override;
37 | 
38 |     QXmppIq &operator=(const QXmppIq &other);
39 |     QXmppIq &operator=(QXmppIq &&);
40 | 
41 |     QXmppIq::Type type() const;
42 |     void setType(QXmppIq::Type);
43 | 
44 |     bool isXmppStanza() const override;
45 | 
46 |     /// \cond
47 |     void parse(const QDomElement &element) override;
48 |     void toXml(QXmlStreamWriter *writer) const override;
49 | 
50 |     virtual void parseElementFromChild(const QDomElement &element);
51 |     virtual void toXmlElementFromChild(QXmlStreamWriter *writer) const;
52 |     /// \endcond
53 | 
54 | private:
55 |     QSharedDataPointer<QXmppIqPrivate> d;
56 | };
57 | 
58 | Q_DECLARE_METATYPE(QXmppIq::Type)
59 | 
60 | #endif  // QXMPPIQ_H
61 | 


--------------------------------------------------------------------------------
/src/base/QXmppJingleIq.h:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
2 | //
3 | // SPDX-License-Identifier: LGPL-2.1-or-later
4 | 
5 | #include "QXmppJingleData.h"
6 | 


--------------------------------------------------------------------------------
/src/base/QXmppMessageReaction.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Melvin Keskin <melvo@olomono.de>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPMESSAGEREACTION_H
 6 | #define QXMPPMESSAGEREACTION_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <QSharedDataPointer>
11 | 
12 | class QDomElement;
13 | class QXmlStreamWriter;
14 | class QXmppMessageReactionPrivate;
15 | 
16 | class QXMPP_EXPORT QXmppMessageReaction
17 | {
18 | public:
19 |     QXmppMessageReaction();
20 | 
21 |     QXMPP_PRIVATE_DECLARE_RULE_OF_SIX(QXmppMessageReaction)
22 | 
23 |     QString messageId() const;
24 |     void setMessageId(const QString &messageId);
25 | 
26 |     QVector<QString> emojis() const;
27 |     void setEmojis(const QVector<QString> &emojis);
28 | 
29 |     /// \cond
30 |     void parse(const QDomElement &element);
31 |     void toXml(QXmlStreamWriter *writer) const;
32 |     /// \endcond
33 | 
34 |     static bool isMessageReaction(const QDomElement &element);
35 | 
36 | private:
37 |     QSharedDataPointer<QXmppMessageReactionPrivate> d;
38 | };
39 | 
40 | #endif  // QXMPPMESSAGEREACTION_H
41 | 


--------------------------------------------------------------------------------
/src/base/QXmppMixInfoItem.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2019 Linus Jahn <lnj@kaidan.im>
 2 | // SPDX-FileCopyrightText: 2023 Melvin Keskin <melvo@olomono.de>
 3 | //
 4 | // SPDX-License-Identifier: LGPL-2.1-or-later
 5 | 
 6 | #ifndef QXMPPMIXINFOITEM_H
 7 | #define QXMPPMIXINFOITEM_H
 8 | 
 9 | #include "QXmppDataForm.h"
10 | #include "QXmppPubSubBaseItem.h"
11 | 
12 | class QXmppMixInfoItemPrivate;
13 | 
14 | class QXMPP_EXPORT QXmppMixInfoItem : public QXmppPubSubBaseItem
15 | {
16 | public:
17 |     QXmppMixInfoItem();
18 |     QXmppMixInfoItem(const QXmppMixInfoItem &);
19 |     QXmppMixInfoItem(QXmppMixInfoItem &&);
20 |     ~QXmppMixInfoItem();
21 | 
22 |     QXmppMixInfoItem &operator=(const QXmppMixInfoItem &);
23 |     QXmppMixInfoItem &operator=(QXmppMixInfoItem &&);
24 | 
25 |     QXmppDataForm::Type formType() const;
26 |     void setFormType(QXmppDataForm::Type formType);
27 | 
28 |     const QString &name() const;
29 |     void setName(QString);
30 | 
31 |     const QString &description() const;
32 |     void setDescription(QString);
33 | 
34 |     const QStringList &contactJids() const;
35 |     void setContactJids(QStringList);
36 | 
37 |     static bool isItem(const QDomElement &itemElement);
38 | 
39 | protected:
40 |     /// \cond
41 |     void parsePayload(const QDomElement &payloadElement) override;
42 |     void serializePayload(QXmlStreamWriter *writer) const override;
43 |     /// \endcond
44 | 
45 | private:
46 |     QSharedDataPointer<QXmppMixInfoItemPrivate> d;
47 | };
48 | 
49 | Q_DECLARE_METATYPE(QXmppMixInfoItem)
50 | 
51 | #endif  // QXMPPMIXINFOITEM_H
52 | 


--------------------------------------------------------------------------------
/src/base/QXmppMixInvitation.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2021 Melvin Keskin <melvo@olomono.de>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPMIXINVITATION_H
 6 | #define QXMPPMIXINVITATION_H
 7 | 
 8 | #include "QXmppElement.h"
 9 | 
10 | #include <QSharedDataPointer>
11 | 
12 | class QXmppMixInvitationPrivate;
13 | 
14 | class QXMPP_EXPORT QXmppMixInvitation
15 | {
16 | public:
17 |     QXmppMixInvitation();
18 |     QXmppMixInvitation(const QXmppMixInvitation &other);
19 |     QXmppMixInvitation(QXmppMixInvitation &&);
20 |     ~QXmppMixInvitation();
21 | 
22 |     QXmppMixInvitation &operator=(const QXmppMixInvitation &other);
23 |     QXmppMixInvitation &operator=(QXmppMixInvitation &&);
24 | 
25 |     QString inviterJid() const;
26 |     void setInviterJid(const QString &inviterJid);
27 | 
28 |     QString inviteeJid() const;
29 |     void setInviteeJid(const QString &inviteeJid);
30 | 
31 |     QString channelJid() const;
32 |     void setChannelJid(const QString &channelJid);
33 | 
34 |     QString token() const;
35 |     void setToken(const QString &token);
36 | 
37 |     /// \cond
38 |     void parse(const QDomElement &element);
39 |     void toXml(QXmlStreamWriter *writer) const;
40 |     /// \endcond
41 | 
42 |     static bool isMixInvitation(const QDomElement &element);
43 | 
44 | private:
45 |     QSharedDataPointer<QXmppMixInvitationPrivate> d;
46 | };
47 | 
48 | #endif  // QXMPPMIXINVITATION_H
49 | 


--------------------------------------------------------------------------------
/src/base/QXmppMixParticipantItem.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2019 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPMIXPARTICIPANTITEM_H
 6 | #define QXMPPMIXPARTICIPANTITEM_H
 7 | 
 8 | #include "QXmppPubSubBaseItem.h"
 9 | 
10 | class QXmppMixParticipantItemPrivate;
11 | 
12 | class QXMPP_EXPORT QXmppMixParticipantItem : public QXmppPubSubBaseItem
13 | {
14 | public:
15 |     QXmppMixParticipantItem();
16 |     QXmppMixParticipantItem(const QXmppMixParticipantItem &);
17 |     QXmppMixParticipantItem(QXmppMixParticipantItem &&);
18 |     ~QXmppMixParticipantItem();
19 | 
20 |     QXmppMixParticipantItem &operator=(const QXmppMixParticipantItem &);
21 |     QXmppMixParticipantItem &operator=(QXmppMixParticipantItem &&);
22 | 
23 |     const QString &nick() const;
24 |     void setNick(QString);
25 | 
26 |     const QString &jid() const;
27 |     void setJid(QString);
28 | 
29 |     static bool isItem(const QDomElement &);
30 | 
31 | protected:
32 |     /// \cond
33 |     void parsePayload(const QDomElement &payloadElement) override;
34 |     void serializePayload(QXmlStreamWriter *writer) const override;
35 |     /// \endcond
36 | 
37 | private:
38 |     QSharedDataPointer<QXmppMixParticipantItemPrivate> d;
39 | };
40 | 
41 | Q_DECLARE_METATYPE(QXmppMixParticipantItem)
42 | 
43 | #endif  // QXMPPMIXPARTICIPANTITEM_H
44 | 


--------------------------------------------------------------------------------
/src/base/QXmppNonSASLAuth.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2009 Manjeet Dahiya <manjeetdahiya@gmail.com>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXmppNonSASLAuth_H
 6 | #define QXmppNonSASLAuth_H
 7 | 
 8 | #include "QXmppIq.h"
 9 | 
10 | class QXMPP_EXPORT QXmppNonSASLAuthIq : public QXmppIq
11 | {
12 | public:
13 |     QXmppNonSASLAuthIq();
14 | 
15 |     QString username() const;
16 |     void setUsername(const QString &username);
17 | 
18 |     QByteArray digest() const;
19 |     void setDigest(const QString &streamId, const QString &password);
20 | 
21 |     QString password() const;
22 |     void setPassword(const QString &password);
23 | 
24 |     QString resource() const;
25 |     void setResource(const QString &resource);
26 | 
27 |     /// \cond
28 |     static bool isNonSASLAuthIq(const QDomElement &element);
29 | 
30 | protected:
31 |     void parseElementFromChild(const QDomElement &element) override;
32 |     void toXmlElementFromChild(QXmlStreamWriter *writer) const override;
33 |     /// \endcond
34 | 
35 | private:
36 |     QString m_username;
37 |     QByteArray m_digest;
38 |     QString m_password;
39 |     QString m_resource;
40 | };
41 | 
42 | #endif  // QXmppNonSASLAuth_H
43 | 


--------------------------------------------------------------------------------
/src/base/QXmppNonza.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2021 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #include "QXmppNonza.h"
 6 | 
 7 | ///
 8 | /// \class QXmppNonza
 9 | ///
10 | /// Abstract class for content that can be parsed from DOM and serialized to
11 | /// XML.
12 | ///
13 | /// If you want to implement a XMPP stanza (IQ, message or presence) then you
14 | /// should use QXmppStanza. Directly inheriting from this class is useful for
15 | /// other elements like stream management elements in the XML stream.
16 | ///
17 | /// \since QXmpp 1.5
18 | ///
19 | 
20 | ///
21 | /// \fn QXmppNonza::isXmppStanza
22 | ///
23 | /// Indicates if the QXmppStanza is a stanza in the XMPP sense (i. e. a message,
24 | /// iq or presence)
25 | ///
26 | /// \since QXmpp 1.0 (moved from QXmppStanza in 1.5)
27 | ///
28 | 
29 | ///
30 | /// \fn QXmppNonza::parse
31 | ///
32 | /// Parses the object from a DOM element.
33 | ///
34 | 
35 | ///
36 | /// \fn QXmppNonza::toXml
37 | ///
38 | /// Serializes the object to XML using a QXmlStreamWriter.
39 | ///
40 | 


--------------------------------------------------------------------------------
/src/base/QXmppNonza.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2021 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPNONZA_H
 6 | #define QXMPPNONZA_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | class QXmlStreamWriter;
11 | class QDomElement;
12 | 
13 | class QXmppNonza
14 | {
15 | public:
16 |     QXmppNonza() = default;
17 |     virtual ~QXmppNonza() = default;
18 | 
19 |     virtual inline bool isXmppStanza() const { return false; }
20 |     virtual void parse(const QDomElement &) = 0;
21 |     virtual void toXml(QXmlStreamWriter *writer) const = 0;
22 | };
23 | 
24 | #endif  // QXMPPNONZA_H
25 | 


--------------------------------------------------------------------------------
/src/base/QXmppOmemoElement_p.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2021 Germán Márquez Mejía <mancho@olomono.de>
 2 | // SPDX-FileCopyrightText: 2021 Melvin Keskin <melvo@olomono.de>
 3 | //
 4 | // SPDX-License-Identifier: LGPL-2.1-or-later
 5 | 
 6 | #ifndef QXMPPOMEMOELEMENT_H
 7 | #define QXMPPOMEMOELEMENT_H
 8 | 
 9 | #include "QXmppGlobal.h"
10 | #include "QXmppOmemoEnvelope_p.h"
11 | 
12 | #include <optional>
13 | 
14 | #include <QMultiMap>
15 | 
16 | class QDomElement;
17 | class QXmlStreamWriter;
18 | 
19 | class QXMPP_EXPORT QXmppOmemoElement
20 | {
21 | public:
22 |     uint32_t senderDeviceId() const;
23 |     void setSenderDeviceId(uint32_t id);
24 | 
25 |     QByteArray payload() const;
26 |     void setPayload(const QByteArray &payload);
27 | 
28 |     std::optional<QXmppOmemoEnvelope> searchEnvelope(const QString &recipientJid, uint32_t recipientDeviceId) const;
29 |     void addEnvelope(const QString &recipientJid, const QXmppOmemoEnvelope &envelope);
30 | 
31 |     /// \cond
32 |     void parse(const QDomElement &element);
33 |     void toXml(QXmlStreamWriter *writer) const;
34 |     /// \endcond
35 | 
36 |     static bool isOmemoElement(const QDomElement &element);
37 | 
38 | private:
39 |     uint32_t m_senderDeviceId = 0;
40 |     QByteArray m_payload;
41 |     QMultiMap<QString, QXmppOmemoEnvelope> m_envelopes;
42 | };
43 | 
44 | Q_DECLARE_TYPEINFO(QXmppOmemoElement, Q_MOVABLE_TYPE);
45 | 
46 | #endif  // QXMPPOMEMOELEMENT_H
47 | 


--------------------------------------------------------------------------------
/src/base/QXmppOmemoEnvelope_p.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2021 Germán Márquez Mejía <mancho@olomono.de>
 2 | // SPDX-FileCopyrightText: 2021 Melvin Keskin <melvo@olomono.de>
 3 | //
 4 | // SPDX-License-Identifier: LGPL-2.1-or-later
 5 | 
 6 | #ifndef QXMPPOMEMOENVELOPE_H
 7 | #define QXMPPOMEMOENVELOPE_H
 8 | 
 9 | #include "QXmppGlobal.h"
10 | 
11 | class QDomElement;
12 | class QXmlStreamWriter;
13 | 
14 | class QXMPP_EXPORT QXmppOmemoEnvelope
15 | {
16 | public:
17 |     uint32_t recipientDeviceId() const;
18 |     void setRecipientDeviceId(uint32_t id);
19 | 
20 |     bool isUsedForKeyExchange() const;
21 |     void setIsUsedForKeyExchange(bool isUsed);
22 | 
23 |     QByteArray data() const;
24 |     void setData(const QByteArray &data);
25 | 
26 |     /// \cond
27 |     void parse(const QDomElement &element);
28 |     void toXml(QXmlStreamWriter *writer) const;
29 |     /// \endcond
30 | 
31 |     static bool isOmemoEnvelope(const QDomElement &element);
32 | 
33 | private:
34 |     uint32_t m_recipientDeviceId = 0;
35 |     bool m_isUsedForKeyExchange = false;
36 |     QByteArray m_data;
37 | };
38 | 
39 | Q_DECLARE_TYPEINFO(QXmppOmemoEnvelope, Q_MOVABLE_TYPE);
40 | 
41 | #endif  // QXMPPOMEMOENVELOPE_H
42 | 


--------------------------------------------------------------------------------
/src/base/QXmppOutOfBandUrl.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Jonah Brüchert <jbb@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPOUTOFBANDURL_H
 6 | #define QXMPPOUTOFBANDURL_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <optional>
11 | 
12 | #include <QSharedDataPointer>
13 | 
14 | class QXmppOutOfBandUrlPrivate;
15 | class QDomElement;
16 | class QXmlStreamWriter;
17 | 
18 | class QXMPP_EXPORT QXmppOutOfBandUrl
19 | {
20 | public:
21 |     QXmppOutOfBandUrl();
22 | 
23 |     QXMPP_PRIVATE_DECLARE_RULE_OF_SIX(QXmppOutOfBandUrl)
24 | 
25 |     const QString &url() const;
26 |     void setUrl(const QString &url);
27 | 
28 |     const std::optional<QString> &description() const;
29 |     void setDescription(const std::optional<QString> &description);
30 | 
31 |     /// \cond
32 |     bool parse(const QDomElement &el);
33 |     void toXml(QXmlStreamWriter *writer) const;
34 |     /// \endcond
35 | 
36 | private:
37 |     QSharedDataPointer<QXmppOutOfBandUrlPrivate> d;
38 | };
39 | 
40 | #endif  // QXMPPOUTOFBANDURL_H
41 | 


--------------------------------------------------------------------------------
/src/base/QXmppPacket.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2020 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #include "QXmppNonza.h"
 6 | #include "QXmppPacket_p.h"
 7 | #include "QXmppUtils_p.h"
 8 | 
 9 | #include <QXmlStreamWriter>
10 | 
11 | using namespace QXmpp::Private;
12 | 
13 | /// \cond
14 | QXmppPacket::QXmppPacket(const QXmppNonza &nonza, QXmppPromise<QXmpp::SendResult> interface)
15 |     : QXmppPacket(serializeXml(nonza), nonza.isXmppStanza(), std::move(interface))
16 | {
17 | }
18 | 
19 | QXmppPacket::QXmppPacket(const QByteArray &data, bool isXmppStanza, QXmppPromise<QXmpp::SendResult> interface)
20 |     : m_promise(std::move(interface)),
21 |       m_data(data),
22 |       m_isXmppStanza(isXmppStanza)
23 | {
24 | }
25 | 
26 | QByteArray QXmppPacket::data() const
27 | {
28 |     return m_data;
29 | }
30 | 
31 | bool QXmppPacket::isXmppStanza() const
32 | {
33 |     return m_isXmppStanza;
34 | }
35 | 
36 | QXmppTask<QXmpp::SendResult> QXmppPacket::task()
37 | {
38 |     return m_promise.task();
39 | }
40 | 
41 | void QXmppPacket::reportFinished(QXmpp::SendResult &&result)
42 | {
43 |     m_promise.finish(std::move(result));
44 | }
45 | /// \endcond
46 | 


--------------------------------------------------------------------------------
/src/base/QXmppPacket_p.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2020 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPPACKET_H
 6 | #define QXMPPPACKET_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | #include "QXmppPromise.h"
10 | #include "QXmppSendResult.h"
11 | 
12 | #include <memory>
13 | 
14 | #include <QFutureInterface>
15 | 
16 | class QXmppNonza;
17 | 
18 | class QXmppPacket
19 | {
20 | public:
21 |     QXmppPacket(const QXmppNonza &nonza, QXmppPromise<QXmpp::SendResult> = {});
22 |     QXmppPacket(const QByteArray &data, bool isXmppStanza, QXmppPromise<QXmpp::SendResult> = {});
23 | 
24 |     QByteArray data() const;
25 |     bool isXmppStanza() const;
26 | 
27 |     QXmppTask<QXmpp::SendResult> task();
28 | 
29 |     void reportFinished(QXmpp::SendResult &&);
30 | 
31 | private:
32 |     QXmppPromise<QXmpp::SendResult> m_promise;
33 |     QByteArray m_data;
34 |     bool m_isXmppStanza;
35 | };
36 | 
37 | #endif  // QXMPPPACKET_H
38 | 


--------------------------------------------------------------------------------
/src/base/QXmppPingIq.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #include "QXmppPingIq.h"
 6 | 
 7 | #include "QXmppConstants_p.h"
 8 | #include "QXmppUtils.h"
 9 | #include "QXmppUtils_p.h"
10 | 
11 | #include "StringLiterals.h"
12 | 
13 | #include <QDomElement>
14 | 
15 | using namespace QXmpp::Private;
16 | 
17 | ///
18 | /// \class QXmppPingIq
19 | ///
20 | /// QXmppPingIq represents a Ping IQ as defined by \xep{0199, XMPP Ping}.
21 | ///
22 | /// \ingroup Stanzas
23 | ///
24 | 
25 | QXmppPingIq::QXmppPingIq()
26 |     : QXmppIq(QXmppIq::Get)
27 | {
28 | }
29 | 
30 | ///
31 | /// Returns true, if the element is a ping IQ.
32 | ///
33 | bool QXmppPingIq::isPingIq(const QDomElement &element)
34 | {
35 |     return isIqType(element, u"ping", ns_ping) && element.attribute(u"type"_s) == u"get";
36 | }
37 | 
38 | /// \cond
39 | void QXmppPingIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
40 | {
41 |     writer->writeStartElement(QSL65("ping"));
42 |     writer->writeDefaultNamespace(toString65(ns_ping));
43 |     writer->writeEndElement();
44 | }
45 | /// \endcond
46 | 


--------------------------------------------------------------------------------
/src/base/QXmppPingIq.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPPINGIQ_H
 6 | #define QXMPPPINGIQ_H
 7 | 
 8 | #include "QXmppIq.h"
 9 | 
10 | class QXMPP_EXPORT QXmppPingIq : public QXmppIq
11 | {
12 | public:
13 |     QXmppPingIq();
14 |     static bool isPingIq(const QDomElement &element);
15 | 
16 |     /// \cond
17 |     void toXmlElementFromChild(QXmlStreamWriter *writer) const override;
18 |     /// \endcond
19 | };
20 | 
21 | #endif
22 | 


--------------------------------------------------------------------------------
/src/base/QXmppPubSubPublishOptions.h:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 Linus Jahn <lnj@kaidan.im>
2 | //
3 | // SPDX-License-Identifier: LGPL-2.1-or-later
4 | 
5 | #include "QXmppPubSubNodeConfig.h"
6 | 


--------------------------------------------------------------------------------
/src/base/QXmppPubSubSubAuthorization.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2020 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPPUBSUBSUBAUTHORIZATION_H
 6 | #define QXMPPPUBSUBSUBAUTHORIZATION_H
 7 | 
 8 | #include "QXmppDataFormBase.h"
 9 | 
10 | class QXmppPubSubSubAuthorizationPrivate;
11 | 
12 | class QXMPP_EXPORT QXmppPubSubSubAuthorization : public QXmppExtensibleDataFormBase
13 | {
14 | public:
15 |     static std::optional<QXmppPubSubSubAuthorization> fromDataForm(const QXmppDataForm &);
16 | 
17 |     QXmppPubSubSubAuthorization();
18 |     QXmppPubSubSubAuthorization(const QXmppPubSubSubAuthorization &);
19 |     QXmppPubSubSubAuthorization(QXmppPubSubSubAuthorization &&);
20 |     ~QXmppPubSubSubAuthorization();
21 | 
22 |     QXmppPubSubSubAuthorization &operator=(const QXmppPubSubSubAuthorization &);
23 |     QXmppPubSubSubAuthorization &operator=(QXmppPubSubSubAuthorization &&);
24 | 
25 |     std::optional<bool> allowSubscription() const;
26 |     void setAllowSubscription(std::optional<bool> allowSubscription);
27 | 
28 |     QString node() const;
29 |     void setNode(const QString &node);
30 | 
31 |     QString subscriberJid() const;
32 |     void setSubscriberJid(const QString &subscriberJid);
33 | 
34 |     QString subid() const;
35 |     void setSubid(const QString &subid);
36 | 
37 | protected:
38 |     QString formType() const override;
39 |     bool parseField(const QXmppDataForm::Field &) override;
40 |     void serializeForm(QXmppDataForm &) const override;
41 | 
42 | private:
43 |     QSharedDataPointer<QXmppPubSubSubAuthorizationPrivate> d;
44 | };
45 | 
46 | #endif  // QXMPPPUBSUBSUBAUTHORIZATION_H
47 | 


--------------------------------------------------------------------------------
/src/base/QXmppPushEnableIq.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2020 Robert Märkisch <zatrox@kaidan.im>
 2 | // SPDX-FileCopyrightText: 2020 Linus Jahn <lnj@kaidan.im>
 3 | // SPDX-FileCopyrightText: 2020 Jonah Brüchert <jbb@kaidan.im>
 4 | //
 5 | // SPDX-License-Identifier: LGPL-2.1-or-later
 6 | 
 7 | #ifndef QXMPPPUSHENABLEIQ_H
 8 | #define QXMPPPUSHENABLEIQ_H
 9 | 
10 | #include <QXmppIq.h>
11 | 
12 | class QXmppPushEnableIqPrivate;
13 | class QXmppDataForm;
14 | 
15 | ///
16 | /// \brief This class represents an IQ to enable or disablepush notifications
17 | /// on the user server.
18 | ///
19 | /// \ingroup Stanzas
20 | ///
21 | /// \since QXmpp 1.3
22 | ///
23 | class QXMPP_EXPORT QXmppPushEnableIq : public QXmppIq
24 | {
25 | public:
26 |     QXmppPushEnableIq();
27 |     QXmppPushEnableIq(const QXmppPushEnableIq &);
28 |     QXmppPushEnableIq(QXmppPushEnableIq &&);
29 |     ~QXmppPushEnableIq() override;
30 |     QXmppPushEnableIq &operator=(const QXmppPushEnableIq &);
31 |     QXmppPushEnableIq &operator=(QXmppPushEnableIq &&);
32 | 
33 |     ///
34 |     /// \brief The Mode enum describes whether the IQ should enable or disable
35 |     /// push notifications
36 |     ///
37 |     enum Mode : bool {
38 |         Enable = true,
39 |         Disable = false
40 |     };
41 | 
42 |     QString jid() const;
43 |     void setJid(const QString &jid);
44 | 
45 |     QString node() const;
46 |     void setNode(const QString &node);
47 | 
48 |     void setMode(Mode mode);
49 |     Mode mode();
50 | 
51 |     QXmppDataForm dataForm() const;
52 |     void setDataForm(const QXmppDataForm &form);
53 | 
54 |     static bool isPushEnableIq(const QDomElement &element);
55 | 
56 | protected:
57 |     /// \cond
58 |     void parseElementFromChild(const QDomElement &element) override;
59 |     void toXmlElementFromChild(QXmlStreamWriter *writer) const override;
60 |     /// \endcond
61 | 
62 | private:
63 |     QSharedDataPointer<QXmppPushEnableIqPrivate> d;
64 | };
65 | 
66 | #endif  // QXMPPPUSHENABLEIQ_H
67 | 


--------------------------------------------------------------------------------
/src/base/QXmppResultSet.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2012 Oliver Goffart <ogoffart@woboq.com>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPRESULTSET_H
 6 | #define QXMPPRESULTSET_H
 7 | 
 8 | #include "QXmppStanza.h"
 9 | 
10 | #include <QDateTime>
11 | 
12 | /// \brief The QXmppResultSetQuery class represents a set element in a query
13 | /// as defined by \xep{0059}: Result Set Management.
14 | 
15 | class QXMPP_EXPORT QXmppResultSetQuery
16 | {
17 | public:
18 |     QXmppResultSetQuery();
19 | 
20 |     int max() const;
21 |     void setMax(int max);
22 | 
23 |     int index() const;
24 |     void setIndex(int index);
25 | 
26 |     QString before() const;
27 |     void setBefore(const QString &before);
28 | 
29 |     QString after() const;
30 |     void setAfter(const QString &after);
31 | 
32 |     bool isNull() const;
33 | 
34 |     /// \cond
35 |     void parse(const QDomElement &element);
36 |     void toXml(QXmlStreamWriter *writer) const;
37 |     /// \endcond
38 | 
39 | private:
40 |     int m_index;
41 |     int m_max;
42 |     QString m_after;
43 |     QString m_before;
44 | };
45 | 
46 | /// \brief The QXmppResultSetReply class represents a set element in a reply
47 | /// as defined by \xep{0059}: Result Set Management.
48 | 
49 | class QXMPP_EXPORT QXmppResultSetReply
50 | {
51 | public:
52 |     QXmppResultSetReply();
53 | 
54 |     QString first() const;
55 |     void setFirst(const QString &first);
56 | 
57 |     QString last() const;
58 |     void setLast(const QString &last);
59 | 
60 |     int count() const;
61 |     void setCount(int count);
62 | 
63 |     int index() const;
64 |     void setIndex(int index);
65 | 
66 |     bool isNull() const;
67 | 
68 |     /// \cond
69 |     void parse(const QDomElement &element);
70 |     void toXml(QXmlStreamWriter *writer) const;
71 |     /// \endcond
72 | 
73 | private:
74 |     int m_count;
75 |     int m_index;
76 |     QString m_first;
77 |     QString m_last;
78 | };
79 | 
80 | #endif  // QXMPPRESULTSET_H
81 | 


--------------------------------------------------------------------------------
/src/base/QXmppSasl2UserAgent.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2024 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPSASL2USERAGENT_H
 6 | #define QXMPPSASL2USERAGENT_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <QSharedDataPointer>
11 | #include <QUuid>
12 | 
13 | struct QXmppSasl2UserAgentPrivate;
14 | 
15 | class QXMPP_EXPORT QXmppSasl2UserAgent
16 | {
17 | public:
18 |     QXmppSasl2UserAgent();
19 |     QXmppSasl2UserAgent(QUuid deviceId, const QString &softwareName, const QString &deviceName);
20 | 
21 |     QXMPP_PRIVATE_DECLARE_RULE_OF_SIX(QXmppSasl2UserAgent)
22 | 
23 |     QUuid deviceId() const;
24 |     void setDeviceId(QUuid);
25 | 
26 |     const QString &softwareName() const;
27 |     void setSoftwareName(const QString &);
28 | 
29 |     const QString &deviceName() const;
30 |     void setDeviceName(const QString &);
31 | 
32 | private:
33 |     QSharedDataPointer<QXmppSasl2UserAgentPrivate> d;
34 | };
35 | 
36 | #endif  // QXMPPSASL2USERAGENT_H
37 | 


--------------------------------------------------------------------------------
/src/base/QXmppSendResult.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2021 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPSENDRESULT_H
 6 | #define QXMPPSENDRESULT_H
 7 | 
 8 | #include "QXmppError.h"
 9 | 
10 | #include <variant>
11 | 
12 | namespace QXmpp {
13 | 
14 | ///
15 | /// Describes the type of a packet sending error.
16 | ///
17 | /// \since QXmpp 1.5
18 | ///
19 | enum class SendError : uint8_t {
20 |     /// The packet was written to the socket with no success (only happens when Stream Management is disabled).
21 |     SocketWriteError,
22 |     /// The packet couldn't be sent because the connection hasn't been (re)established.
23 |     Disconnected,
24 |     /// The packet couldn't be sent because prior encryption failed.
25 |     EncryptionError,
26 | };
27 | 
28 | ///
29 | /// A struct indicating success when sending packets
30 | ///
31 | /// \since QXmpp 1.5
32 | ///
33 | struct SendSuccess {
34 |     /// Indicates whether the packet has been acknowledged by the other peer.
35 |     bool acknowledged = false;
36 | };
37 | 
38 | ///
39 | /// A variant containing either a SendSuccess object or a QXmppError.
40 | ///
41 | /// The QXmppError will likely contain a SendError.
42 | ///
43 | using SendResult = std::variant<SendSuccess, QXmppError>;
44 | 
45 | }  // namespace QXmpp
46 | 
47 | #endif  // QXMPPSENDRESULT_H
48 | 


--------------------------------------------------------------------------------
/src/base/QXmppSocks.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPSOCKS_H
 6 | #define QXMPPSOCKS_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <QHostAddress>
11 | #include <QTcpSocket>
12 | 
13 | class QTcpServer;
14 | 
15 | class QXMPP_EXPORT QXmppSocksClient : public QTcpSocket
16 | {
17 |     Q_OBJECT
18 | 
19 | public:
20 |     QXmppSocksClient(const QString &proxyHost, quint16 proxyPort, QObject *parent = nullptr);
21 |     void connectToHost(const QString &hostName, quint16 hostPort);
22 | 
23 | Q_SIGNALS:
24 |     void ready();
25 | 
26 | private Q_SLOTS:
27 |     void slotConnected();
28 |     void slotReadyRead();
29 | 
30 | private:
31 |     QString m_proxyHost;
32 |     quint16 m_proxyPort;
33 |     QString m_hostName;
34 |     quint16 m_hostPort;
35 |     int m_step;
36 | };
37 | 
38 | class QXMPP_EXPORT QXmppSocksServer : public QObject
39 | {
40 |     Q_OBJECT
41 | 
42 | public:
43 |     QXmppSocksServer(QObject *parent = nullptr);
44 |     void close();
45 |     bool listen(quint16 port = 0);
46 | 
47 |     quint16 serverPort() const;
48 | 
49 | Q_SIGNALS:
50 |     void newConnection(QTcpSocket *socket, QString hostName, quint16 port);
51 | 
52 | private Q_SLOTS:
53 |     void slotNewConnection();
54 |     void slotReadyRead();
55 | 
56 | private:
57 |     QTcpServer *m_server;
58 |     QTcpServer *m_server_v6;
59 |     QMap<QTcpSocket *, int> m_states;
60 | };
61 | 
62 | #endif
63 | 


--------------------------------------------------------------------------------
/src/base/QXmppStanza_p.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2017 Niels Ole Salscheider <niels_ole@salscheider-online.de>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPSTANZA_P_H
 6 | #define QXMPPSTANZA_P_H
 7 | 
 8 | #include "QXmppStanza.h"
 9 | 
10 | #include <optional>
11 | 
12 | //  W A R N I N G
13 | //  -------------
14 | //
15 | // This file is not part of the QXmpp API. It exists for the convenience
16 | // of the QXmppStanza class.
17 | //
18 | // This header file may change from version to version without notice,
19 | // or even be removed.
20 | //
21 | // We mean it.
22 | //
23 | 
24 | namespace QXmpp::Private {
25 | 
26 | // defined in QXmppStanza.cpp
27 | auto conditionToString(QXmppStanza::Error::Condition condition) -> QString;
28 | auto conditionFromString(const QString &string) -> std::optional<QXmppStanza::Error::Condition>;
29 | auto typeToString(QXmppStanza::Error::Type type) -> QString;
30 | auto typeFromString(const QString &string) -> std::optional<QXmppStanza::Error::Type>;
31 | 
32 | }  // namespace QXmpp::Private
33 | 
34 | #endif
35 | 


--------------------------------------------------------------------------------
/src/base/QXmppStreamError.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2024 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPSTREAMERROR_H
 6 | #define QXMPPSTREAMERROR_H
 7 | 
 8 | namespace QXmpp {
 9 | 
10 | ///
11 | /// All XMPP top-level stream errors
12 | ///
13 | /// \since QXmpp 1.7
14 | ///
15 | enum class StreamError {
16 |     BadFormat,
17 |     BadNamespacePrefix,
18 |     Conflict,
19 |     ConnectionTimeout,
20 |     HostGone,
21 |     HostUnknown,
22 |     ImproperAddressing,
23 |     InternalServerError,
24 |     InvalidFrom,
25 |     InvalidId,
26 |     InvalidNamespace,
27 |     InvalidXml,
28 |     NotAuthorized,
29 |     NotWellFormed,
30 |     PolicyViolation,
31 |     RemoteConnectionFailed,
32 |     Reset,
33 |     ResourceConstraint,
34 |     RestrictedXml,
35 |     SystemShutdown,
36 |     UndefinedCondition,
37 |     UnsupportedEncoding,
38 |     UnsupportedFeature,
39 |     UnsupportedStanzaType,
40 |     UnsupportedVersion,
41 | };
42 | 
43 | }  // namespace QXmpp
44 | 
45 | #endif  // QXMPPSTREAMERROR_H
46 | 


--------------------------------------------------------------------------------
/src/base/QXmppStreamError_p.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2024 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPSTREAMERROR_P_H
 6 | #define QXMPPSTREAMERROR_P_H
 7 | 
 8 | #include "QXmppError.h"
 9 | #include "QXmppStreamError.h"
10 | 
11 | #include <variant>
12 | 
13 | class QDomElement;
14 | class QXmlStreamWriter;
15 | 
16 | namespace QXmpp::Private {
17 | 
18 | // implemented in Stream.cpp
19 | struct StreamErrorElement {
20 |     struct SeeOtherHost {
21 |         QString host;
22 |         quint16 port;
23 | 
24 |         bool operator==(const SeeOtherHost &o) const { return host == o.host && port == o.port; }
25 |     };
26 | 
27 |     using Condition = std::variant<StreamError, SeeOtherHost>;
28 | 
29 |     static QString streamErrorToString(StreamError);
30 |     static std::variant<StreamErrorElement, QXmppError> fromDom(const QDomElement &);
31 | 
32 |     Condition condition;
33 |     QString text;
34 | 
35 |     bool operator==(const StreamErrorElement &o) const { return condition == o.condition && text == o.text; }
36 | };
37 | 
38 | }  // namespace QXmpp::Private
39 | 
40 | #endif  // QXMPPSTREAMERROR_P_H
41 | 


--------------------------------------------------------------------------------
/src/base/QXmppStreamInitiationIq_p.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2012 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPSTREAMINITIATIONIQ_P_H
 6 | #define QXMPPSTREAMINITIATIONIQ_P_H
 7 | 
 8 | #include "QXmppDataForm.h"
 9 | #include "QXmppIq.h"
10 | #include "QXmppTransferManager.h"
11 | 
12 | #include <QDateTime>
13 | 
14 | //
15 | //  W A R N I N G
16 | //  -------------
17 | //
18 | // This file is not part of the QXmpp API.  It exists for the convenience
19 | // of the QXmppTransferManager class.
20 | //
21 | // This header file may change from version to version without notice,
22 | // or even be removed.
23 | //
24 | // We mean it.
25 | //
26 | 
27 | /// \cond
28 | class QXMPP_AUTOTEST_EXPORT QXmppStreamInitiationIq : public QXmppIq
29 | {
30 | public:
31 |     enum Profile {
32 |         None = 0,
33 |         FileTransfer
34 |     };
35 | 
36 |     QXmppDataForm featureForm() const;
37 |     void setFeatureForm(const QXmppDataForm &form);
38 | 
39 |     QXmppTransferFileInfo fileInfo() const;
40 |     void setFileInfo(const QXmppTransferFileInfo &info);
41 | 
42 |     QString mimeType() const;
43 |     void setMimeType(const QString &mimeType);
44 | 
45 |     QXmppStreamInitiationIq::Profile profile() const;
46 |     void setProfile(QXmppStreamInitiationIq::Profile profile);
47 | 
48 |     QString siId() const;
49 |     void setSiId(const QString &id);
50 | 
51 |     static bool isStreamInitiationIq(const QDomElement &element);
52 | 
53 | protected:
54 |     void parseElementFromChild(const QDomElement &element) override;
55 |     void toXmlElementFromChild(QXmlStreamWriter *writer) const override;
56 | 
57 | private:
58 |     QXmppDataForm m_featureForm;
59 |     QXmppTransferFileInfo m_fileInfo;
60 |     QString m_mimeType;
61 |     Profile m_profile;
62 |     QString m_siId;
63 | };
64 | /// \endcond
65 | 
66 | #endif
67 | 


--------------------------------------------------------------------------------
/src/base/QXmppThumbnail.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPTHUMBNAIL_H
 6 | #define QXMPPTHUMBNAIL_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <optional>
11 | 
12 | #include <QSharedDataPointer>
13 | 
14 | class QDomElement;
15 | class QMimeType;
16 | class QXmlStreamWriter;
17 | class QXmppThumbnailPrivate;
18 | 
19 | class QXMPP_EXPORT QXmppThumbnail
20 | {
21 | public:
22 |     QXmppThumbnail();
23 |     QXmppThumbnail(const QXmppThumbnail &);
24 |     QXmppThumbnail(QXmppThumbnail &&) noexcept;
25 |     ~QXmppThumbnail();
26 | 
27 |     QXmppThumbnail &operator=(const QXmppThumbnail &);
28 |     QXmppThumbnail &operator=(QXmppThumbnail &&) noexcept;
29 | 
30 |     const QString &uri() const;
31 |     void setUri(const QString &newUri);
32 | 
33 |     const QMimeType &mediaType() const;
34 |     void setMediaType(const QMimeType &);
35 | 
36 |     std::optional<uint32_t> width() const;
37 |     void setWidth(std::optional<uint32_t>);
38 | 
39 |     std::optional<uint32_t> height() const;
40 |     void setHeight(std::optional<uint32_t>);
41 | 
42 |     /// \cond
43 |     bool parse(const QDomElement &);
44 |     void toXml(QXmlStreamWriter *writer) const;
45 |     /// \endcond
46 | 
47 | private:
48 |     QSharedDataPointer<QXmppThumbnailPrivate> d;
49 | };
50 | 
51 | #endif  // QXMPPTHUMBNAIL_H
52 | 


--------------------------------------------------------------------------------
/src/base/QXmppTrustMessageElement.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2021 Melvin Keskin <melvo@olomono.de>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPTRUSTMESSAGEELEMENT_H
 6 | #define QXMPPTRUSTMESSAGEELEMENT_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <QSharedDataPointer>
11 | 
12 | class QDomElement;
13 | class QXmlStreamWriter;
14 | class QXmppTrustMessageElementPrivate;
15 | class QXmppTrustMessageKeyOwner;
16 | 
17 | class QXMPP_EXPORT QXmppTrustMessageElement
18 | {
19 | public:
20 |     QXmppTrustMessageElement();
21 |     QXmppTrustMessageElement(const QXmppTrustMessageElement &other);
22 |     QXmppTrustMessageElement(QXmppTrustMessageElement &&);
23 |     ~QXmppTrustMessageElement();
24 | 
25 |     QXmppTrustMessageElement &operator=(const QXmppTrustMessageElement &other);
26 |     QXmppTrustMessageElement &operator=(QXmppTrustMessageElement &&);
27 | 
28 |     QString usage() const;
29 |     void setUsage(const QString &usage);
30 | 
31 |     QString encryption() const;
32 |     void setEncryption(const QString &encryption);
33 | 
34 |     QList<QXmppTrustMessageKeyOwner> keyOwners() const;
35 |     void setKeyOwners(const QList<QXmppTrustMessageKeyOwner> &keyOwners);
36 |     void addKeyOwner(const QXmppTrustMessageKeyOwner &keyOwner);
37 | 
38 |     /// \cond
39 |     void parse(const QDomElement &element);
40 |     void toXml(QXmlStreamWriter *writer) const;
41 |     /// \endcond
42 | 
43 |     static bool isTrustMessageElement(const QDomElement &element);
44 | 
45 | private:
46 |     QSharedDataPointer<QXmppTrustMessageElementPrivate> d;
47 | };
48 | 
49 | Q_DECLARE_TYPEINFO(QXmppTrustMessageElement, Q_MOVABLE_TYPE);
50 | 
51 | #endif  // QXMPPTRUSTMESSAGEELEMENT_H
52 | 


--------------------------------------------------------------------------------
/src/base/QXmppTrustMessageKeyOwner.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2021 Melvin Keskin <melvo@olomono.de>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPTRUSTMESSAGEKEYOWNER_H
 6 | #define QXMPPTRUSTMESSAGEKEYOWNER_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <QSharedDataPointer>
11 | 
12 | class QDomElement;
13 | class QXmlStreamWriter;
14 | class QXmppTrustMessageKeyOwnerPrivate;
15 | 
16 | class QXMPP_EXPORT QXmppTrustMessageKeyOwner
17 | {
18 | public:
19 |     QXmppTrustMessageKeyOwner();
20 |     QXmppTrustMessageKeyOwner(const QXmppTrustMessageKeyOwner &other);
21 |     QXmppTrustMessageKeyOwner(QXmppTrustMessageKeyOwner &&);
22 |     ~QXmppTrustMessageKeyOwner();
23 | 
24 |     QXmppTrustMessageKeyOwner &operator=(const QXmppTrustMessageKeyOwner &other);
25 |     QXmppTrustMessageKeyOwner &operator=(QXmppTrustMessageKeyOwner &&);
26 | 
27 |     QString jid() const;
28 |     void setJid(const QString &jid);
29 | 
30 |     QList<QByteArray> trustedKeys() const;
31 |     void setTrustedKeys(const QList<QByteArray> &keyIds);
32 | 
33 |     QList<QByteArray> distrustedKeys() const;
34 |     void setDistrustedKeys(const QList<QByteArray> &keyIds);
35 | 
36 |     /// \cond
37 |     void parse(const QDomElement &element);
38 |     void toXml(QXmlStreamWriter *writer) const;
39 |     /// \endcond
40 | 
41 |     static bool isTrustMessageKeyOwner(const QDomElement &element);
42 | 
43 | private:
44 |     QSharedDataPointer<QXmppTrustMessageKeyOwnerPrivate> d;
45 | };
46 | 
47 | Q_DECLARE_TYPEINFO(QXmppTrustMessageKeyOwner, Q_MOVABLE_TYPE);
48 | 
49 | #endif  // QXMPPTRUSTMESSAGEKEYOWNER_H
50 | 


--------------------------------------------------------------------------------
/src/base/QXmppTrustMessages.h:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 Melvin Keskin <melvo@olomono.de>
2 | //
3 | // SPDX-License-Identifier: LGPL-2.1-or-later
4 | 
5 | #include "QXmppTrustMessageElement.h"
6 | #include "QXmppTrustMessageKeyOwner.h"
7 | 


--------------------------------------------------------------------------------
/src/base/QXmppUtils.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2009 Manjeet Dahiya <manjeetdahiya@gmail.com>
 2 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 3 | //
 4 | // SPDX-License-Identifier: LGPL-2.1-or-later
 5 | 
 6 | #ifndef QXMPPUTILS_H
 7 | #define QXMPPUTILS_H
 8 | 
 9 | // forward declarations of QXmlStream* classes will not work on Mac, we need to
10 | // include the whole header.
11 | // See http://lists.trolltech.com/qt-interest/2008-07/thread00798-0.html
12 | // for an explanation.
13 | #include "QXmppGlobal.h"
14 | 
15 | #include <QXmlStreamWriter>
16 | 
17 | class QByteArray;
18 | class QDateTime;
19 | class QDomElement;
20 | class QString;
21 | 
22 | /// \brief The QXmppUtils class contains static utility functions.
23 | ///
24 | class QXMPP_EXPORT QXmppUtils
25 | {
26 | public:
27 |     // XEP-0082: XMPP Date and Time Profiles
28 |     static QDateTime datetimeFromString(QStringView str);
29 |     /// \cond
30 |     static QDateTime datetimeFromString(const QString &str);
31 |     /// \endcond
32 |     static QString datetimeToString(const QDateTime &dt);
33 |     static int timezoneOffsetFromString(const QString &str);
34 |     static QString timezoneOffsetToString(int secs);
35 | 
36 |     static QString jidToDomain(const QString &jid);
37 |     static QString jidToResource(const QString &jid);
38 |     static QString jidToUser(const QString &jid);
39 |     static QString jidToBareJid(const QString &jid);
40 | 
41 |     static quint32 generateCrc32(const QByteArray &input);
42 |     static QByteArray generateHmacMd5(const QByteArray &key, const QByteArray &text);
43 |     static QByteArray generateHmacSha1(const QByteArray &key, const QByteArray &text);
44 |     static int generateRandomInteger(int N);
45 |     static QByteArray generateRandomBytes(int length);
46 |     static QString generateStanzaUuid();
47 |     static QString generateStanzaHash(int length = 36);
48 | };
49 | 
50 | #endif  // QXMPPUTILS_H
51 | 


--------------------------------------------------------------------------------
/src/base/QXmppVersionIq.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPVERSIONIQ_H
 6 | #define QXMPPVERSIONIQ_H
 7 | 
 8 | #include "QXmppIq.h"
 9 | 
10 | /// \brief The QXmppVersionIq class represents an IQ for conveying a software
11 | /// version as defined by \xep{0092}: Software Version.
12 | ///
13 | /// \ingroup Stanzas
14 | 
15 | class QXMPP_EXPORT QXmppVersionIq : public QXmppIq
16 | {
17 | public:
18 |     QString name() const;
19 |     void setName(const QString &name);
20 | 
21 |     QString os() const;
22 |     void setOs(const QString &os);
23 | 
24 |     QString version() const;
25 |     void setVersion(const QString &version);
26 | 
27 |     /// \cond
28 |     static bool isVersionIq(const QDomElement &element);
29 |     static bool checkIqType(const QString &tagName, const QString &xmlNamespace);
30 |     /// \endcond
31 | 
32 | protected:
33 |     /// \cond
34 |     void parseElementFromChild(const QDomElement &element) override;
35 |     void toXmlElementFromChild(QXmlStreamWriter *writer) const override;
36 |     /// \endcond
37 | 
38 | private:
39 |     QString m_name;
40 |     QString m_os;
41 |     QString m_version;
42 | };
43 | 
44 | #endif
45 | 


--------------------------------------------------------------------------------
/src/base/Stream.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2024 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef STREAM_H
 6 | #define STREAM_H
 7 | 
 8 | #include <optional>
 9 | 
10 | #include <QString>
11 | 
12 | class QDomElement;
13 | class QXmlStreamWriter;
14 | 
15 | namespace QXmpp::Private {
16 | 
17 | struct StreamOpen {
18 |     void toXml(QXmlStreamWriter *) const;
19 | 
20 |     QString to;
21 |     QString from;
22 |     QStringView xmlns;
23 | };
24 | 
25 | struct StarttlsRequest {
26 |     static std::optional<StarttlsRequest> fromDom(const QDomElement &);
27 |     void toXml(QXmlStreamWriter *) const;
28 | };
29 | 
30 | struct StarttlsProceed {
31 |     static std::optional<StarttlsProceed> fromDom(const QDomElement &);
32 |     void toXml(QXmlStreamWriter *) const;
33 | };
34 | 
35 | struct CsiActive {
36 |     void toXml(QXmlStreamWriter *w) const;
37 | };
38 | 
39 | struct CsiInactive {
40 |     void toXml(QXmlStreamWriter *w) const;
41 | };
42 | 
43 | }  // namespace QXmpp::Private
44 | 
45 | #endif  // STREAM_H
46 | 


--------------------------------------------------------------------------------
/src/base/StringLiterals.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2021 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef STRINGLITERALS_H
 6 | #define STRINGLITERALS_H
 7 | 
 8 | #include <QString>
 9 | 
10 | #if QT_VERSION >= QT_VERSION_CHECK(6, 4, 0)
11 | using namespace Qt::Literals::StringLiterals;
12 | #elif QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
13 | inline QString operator"" _s(const char16_t *str, size_t size) noexcept
14 | {
15 |     return QString(QStringPrivate(nullptr, const_cast<char16_t *>(str), qsizetype(size)));
16 | }
17 | 
18 | constexpr inline QLatin1String operator"" _L1(const char *str, size_t size) noexcept
19 | {
20 |     return QLatin1String { str, int(size) };
21 | }
22 | #else
23 | namespace QXmpp::Private {
24 | 
25 | template<std::size_t N>
26 | struct StringLiteralData {
27 |     char16_t data[N];
28 |     std::size_t size = N;
29 | 
30 |     constexpr StringLiteralData(const char16_t (&str)[N])
31 |     {
32 |         std::ranges::copy(str, data);
33 |     }
34 | };
35 | 
36 | template<std::size_t N>
37 | struct StaticStringData {
38 |     QArrayData str = Q_STATIC_STRING_DATA_HEADER_INITIALIZER(N - 1);
39 |     char16_t data[N];
40 | 
41 |     StaticStringData(const char16_t (&str)[N])
42 |     {
43 |         std::ranges::copy(str, data);
44 |     }
45 | 
46 |     QStringData *data_ptr() const
47 |     {
48 |         return const_cast<QStringData *>(static_cast<const QStringData *>(&str));
49 |     }
50 | };
51 | 
52 | }  // namespace QXmpp::Private
53 | 
54 | template<QXmpp::Private::StringLiteralData str>
55 | QString operator""_s()
56 | {
57 |     static const auto staticData = QXmpp::Private::StaticStringData<str.size>(str.data);
58 |     return QString(QStringDataPtr { staticData.data_ptr() });
59 | }
60 | 
61 | constexpr inline QLatin1String operator"" _L1(const char *str, size_t size) noexcept
62 | {
63 |     return QLatin1String { str, int(size) };
64 | }
65 | #endif
66 | 
67 | #endif  // STRINGLITERALS_H
68 | 


--------------------------------------------------------------------------------
/src/base/XmppSocket.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2024 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef XMPPSOCKET_H
 6 | #define XMPPSOCKET_H
 7 | 
 8 | #include "QXmppLogger.h"
 9 | 
10 | class QDomElement;
11 | class QSslSocket;
12 | class TestStream;
13 | class tst_QXmppStream;
14 | 
15 | namespace QXmpp::Private {
16 | 
17 | struct ServerAddress {
18 |     enum ConnectionType {
19 |         Tcp,
20 |         Tls,
21 |     };
22 | 
23 |     ConnectionType type;
24 |     QString host;
25 |     quint16 port;
26 | };
27 | 
28 | class SendDataInterface
29 | {
30 | public:
31 |     virtual bool sendData(const QByteArray &) = 0;
32 | };
33 | 
34 | class QXMPP_EXPORT XmppSocket : public QXmppLoggable, public SendDataInterface
35 | {
36 |     Q_OBJECT
37 | public:
38 |     XmppSocket(QObject *parent);
39 |     ~XmppSocket() override = default;
40 | 
41 |     QSslSocket *socket() const { return m_socket; }
42 |     void setSocket(QSslSocket *socket);
43 | 
44 |     bool isConnected() const;
45 |     void connectToHost(const ServerAddress &);
46 |     void disconnectFromHost();
47 |     bool sendData(const QByteArray &) override;
48 | 
49 |     Q_SIGNAL void started();
50 |     Q_SIGNAL void stanzaReceived(const QDomElement &);
51 |     Q_SIGNAL void streamReceived(const QDomElement &);
52 |     Q_SIGNAL void streamClosed();
53 | 
54 | private:
55 |     void processData(const QString &data);
56 | 
57 |     friend class ::tst_QXmppStream;
58 | 
59 |     QString m_dataBuffer;
60 |     bool m_directTls = false;
61 |     QSslSocket *m_socket = nullptr;
62 | 
63 |     // incoming stream state
64 |     QString m_streamOpenElement;
65 | };
66 | 
67 | }  // namespace QXmpp::Private
68 | 
69 | #endif  // XMPPSOCKET_H
70 | 


--------------------------------------------------------------------------------
/src/base/compat/QXmppPubSubItem.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPPUBSUBITEM_H
 6 | #define QXMPPPUBSUBITEM_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <QSharedDataPointer>
11 | 
12 | class QDomElement;
13 | class QXmlStreamWriter;
14 | 
15 | class QXmppElement;
16 | class QXmppPubSubItemPrivate;
17 | 
18 | #if QXMPP_DEPRECATED_SINCE(1, 5)
19 | class QXMPP_EXPORT QXmppPubSubItem
20 | {
21 | public:
22 |     [[deprecated]] QXmppPubSubItem();
23 |     QXmppPubSubItem(const QXmppPubSubItem &iq);
24 |     ~QXmppPubSubItem();
25 | 
26 |     QXmppPubSubItem &operator=(const QXmppPubSubItem &iq);
27 | 
28 |     [[deprecated]] QString id() const;
29 |     [[deprecated]] void setId(const QString &id);
30 | 
31 |     [[deprecated]] QXmppElement contents() const;
32 |     [[deprecated]] void setContents(const QXmppElement &contents);
33 | 
34 |     [[deprecated]] void parse(const QDomElement &element);
35 |     [[deprecated]] void toXml(QXmlStreamWriter *writer) const;
36 | 
37 | private:
38 |     QSharedDataPointer<QXmppPubSubItemPrivate> d;
39 | };
40 | #endif
41 | 
42 | #endif  // QXMPPPUBSUBITEM_H
43 | 


--------------------------------------------------------------------------------
/src/base/compat/QXmppSessionIq.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2011 Manjeet Dahiya <manjeetdahiya@gmail.com>
 2 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 3 | //
 4 | // SPDX-License-Identifier: LGPL-2.1-or-later
 5 | 
 6 | #ifndef QXMPPSESSIONIQ_H
 7 | #define QXMPPSESSIONIQ_H
 8 | 
 9 | #include "QXmppIq.h"
10 | 
11 | #if QXMPP_DEPRECATED_SINCE(1, 7)
12 | class QXMPP_EXPORT QXmppSessionIq : public QXmppIq
13 | {
14 | public:
15 |     [[deprecated]] static bool isSessionIq(const QDomElement &element);
16 | 
17 | private:
18 |     [[deprecated]] void toXmlElementFromChild(QXmlStreamWriter *writer) const override;
19 | };
20 | #endif
21 | 
22 | #endif  // QXMPPSESSION_H
23 | 


--------------------------------------------------------------------------------
/src/base/compat/QXmppStartTlsPacket.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2019 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPSTARTTLSPACKET_H
 6 | #define QXMPPSTARTTLSPACKET_H
 7 | 
 8 | #include "QXmppStanza.h"
 9 | 
10 | ///
11 | /// \brief The QXmppStartTlsPacket represents packets used for initiating
12 | /// STARTTLS negotiation when connecting.
13 | ///
14 | /// \ingroup Stanzas
15 | ///
16 | /// \deprecated STARTTLS packets will be removed from the public API.
17 | ///
18 | class QXMPP_EXPORT QXmppStartTlsPacket : public QXmppNonza
19 | {
20 | public:
21 |     /// The type of the STARTTLS packet.
22 |     enum Type {
23 |         StartTls,  ///< Used by the client to initiate STARTTLS.
24 |         Proceed,   ///< Used by the server to accept STARTTLS.
25 |         Failure,   ///< Used by the server to reject STARTTLS.
26 |         Invalid,   ///< Invalid type
27 |     };
28 | 
29 |     [[deprecated]] QXmppStartTlsPacket(Type type = StartTls);
30 |     ~QXmppStartTlsPacket() override;
31 | 
32 |     Type type() const;
33 |     void setType(Type type);
34 | 
35 |     /// \cond
36 |     void parse(const QDomElement &element) override;
37 |     void toXml(QXmlStreamWriter *writer) const override;
38 |     /// \endcond
39 | 
40 |     [[deprecated]] static bool isStartTlsPacket(const QDomElement &element);
41 |     [[deprecated]] static bool isStartTlsPacket(const QDomElement &element, Type type);
42 | 
43 | private:
44 |     Type m_type;
45 | };
46 | 
47 | Q_DECLARE_METATYPE(QXmppStartTlsPacket::Type);
48 | 
49 | #endif  // QXMPPSTARTTLSPACKET_H
50 | 


--------------------------------------------------------------------------------
/src/client/QXmppAtmTrustMemoryStorage.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Melvin Keskin <melvo@olomono.de>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPATMTRUSTMEMORYSTORAGE_H
 6 | #define QXMPPATMTRUSTMEMORYSTORAGE_H
 7 | 
 8 | #include "QXmppAtmTrustStorage.h"
 9 | #include "QXmppTrustMemoryStorage.h"
10 | 
11 | class QXmppAtmTrustMemoryStoragePrivate;
12 | 
13 | class QXMPP_EXPORT QXmppAtmTrustMemoryStorage : virtual public QXmppAtmTrustStorage, public QXmppTrustMemoryStorage
14 | {
15 | public:
16 |     QXmppAtmTrustMemoryStorage();
17 |     ~QXmppAtmTrustMemoryStorage();
18 | 
19 |     /// \cond
20 |     QXmppTask<void> addKeysForPostponedTrustDecisions(const QString &encryption, const QByteArray &senderKeyId, const QList<QXmppTrustMessageKeyOwner> &keyOwners) override;
21 |     QXmppTask<void> removeKeysForPostponedTrustDecisions(const QString &encryption, const QList<QByteArray> &keyIdsForAuthentication, const QList<QByteArray> &keyIdsForDistrusting) override;
22 |     QXmppTask<void> removeKeysForPostponedTrustDecisions(const QString &encryption, const QList<QByteArray> &senderKeyIds) override;
23 |     QXmppTask<void> removeKeysForPostponedTrustDecisions(const QString &encryption) override;
24 |     QXmppTask<QHash<bool, QMultiHash<QString, QByteArray>>> keysForPostponedTrustDecisions(const QString &encryption, const QList<QByteArray> &senderKeyIds = {}) override;
25 | 
26 |     QXmppTask<void> resetAll(const QString &encryption) override;
27 |     /// \endcond
28 | 
29 | private:
30 |     const std::unique_ptr<QXmppAtmTrustMemoryStoragePrivate> d;
31 | };
32 | 
33 | #endif  // QXMPPATMTRUSTMEMORYSTORAGE_H
34 | 


--------------------------------------------------------------------------------
/src/client/QXmppAtmTrustStorage.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Melvin Keskin <melvo@olomono.de>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPATMTRUSTSTORAGE_H
 6 | #define QXMPPATMTRUSTSTORAGE_H
 7 | 
 8 | #include "QXmppTrustStorage.h"
 9 | 
10 | #include <QList>
11 | 
12 | class QXmppTrustMessageKeyOwner;
13 | 
14 | class QXMPP_EXPORT QXmppAtmTrustStorage : virtual public QXmppTrustStorage
15 | {
16 | public:
17 |     virtual ~QXmppAtmTrustStorage() = default;
18 | 
19 |     virtual QXmppTask<void> addKeysForPostponedTrustDecisions(const QString &encryption, const QByteArray &senderKeyId, const QList<QXmppTrustMessageKeyOwner> &keyOwners) = 0;
20 |     virtual QXmppTask<void> removeKeysForPostponedTrustDecisions(const QString &encryption, const QList<QByteArray> &keyIdsForAuthentication, const QList<QByteArray> &keyIdsForDistrusting) = 0;
21 |     virtual QXmppTask<void> removeKeysForPostponedTrustDecisions(const QString &encryption, const QList<QByteArray> &senderKeyIds) = 0;
22 |     virtual QXmppTask<void> removeKeysForPostponedTrustDecisions(const QString &encryption) = 0;
23 |     virtual QXmppTask<QHash<bool, QMultiHash<QString, QByteArray>>> keysForPostponedTrustDecisions(const QString &encryption, const QList<QByteArray> &senderKeyIds = {}) = 0;
24 | };
25 | 
26 | #endif  // QXMPPATMTRUSTSTORAGE_H
27 | 


--------------------------------------------------------------------------------
/src/client/QXmppAttentionManager.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2020 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPATTENTIONMANAGER_H
 6 | #define QXMPPATTENTIONMANAGER_H
 7 | 
 8 | #include "QXmppClientExtension.h"
 9 | 
10 | #include <QTime>
11 | 
12 | class QXmppAttentionManagerPrivate;
13 | class QXmppMessage;
14 | 
15 | class QXMPP_EXPORT QXmppAttentionManager : public QXmppClientExtension
16 | {
17 |     Q_OBJECT
18 | 
19 | public:
20 |     QXmppAttentionManager(quint8 allowedAttempts = 3, QTime timeFrame = QTime(0, 15, 0));
21 |     ~QXmppAttentionManager();
22 | 
23 |     QStringList discoveryFeatures() const override;
24 | 
25 |     quint8 allowedAttempts() const;
26 |     void setAllowedAttempts(quint8 allowedAttempts);
27 | 
28 |     QTime allowedAttemptsTimeInterval() const;
29 |     void setAllowedAttemptsTimeInterval(QTime interval);
30 | 
31 | public Q_SLOTS:
32 |     QString requestAttention(const QString &jid, const QString &message = {});
33 | 
34 | Q_SIGNALS:
35 |     void attentionRequested(const QXmppMessage &message, bool isTrusted);
36 |     void attentionRequestRateLimited(const QXmppMessage &message);
37 | 
38 | protected:
39 |     void onRegistered(QXmppClient *client) override;
40 |     void onUnregistered(QXmppClient *client) override;
41 | 
42 | private Q_SLOTS:
43 |     void handleMessageReceived(const QXmppMessage &message);
44 | 
45 | private:
46 |     const std::unique_ptr<QXmppAttentionManagerPrivate> d;
47 | };
48 | 
49 | #endif  // QXMPPATTENTIONMANAGER_H
50 | 


--------------------------------------------------------------------------------
/src/client/QXmppAuthenticationError.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2024 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPAUTHENTICATIONERROR_H
 6 | #define QXMPPAUTHENTICATIONERROR_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <any>
11 | 
12 | namespace QXmpp {
13 | 
14 | ///
15 | /// Indicates an authentication error
16 | ///
17 | /// \since QXmpp 1.7
18 | ///
19 | struct AuthenticationError {
20 |     /// Describes the type of the authentication error.
21 |     enum Type {
22 |         /// The provided credentials have been rejected by the server.
23 |         NotAuthorized,
24 |         /// The server did not allow authentication because the account is currently disabled.
25 |         AccountDisabled,
26 |         /// Used credentials are not valid anymore.
27 |         CredentialsExpired,
28 |         /// Authentication is only allowed with an encrypted connection.
29 |         EncryptionRequired,
30 |         /// Authenticated could not be completed because the server did not offer a compatible
31 |         /// authentication mechanism.
32 |         MechanismMismatch,
33 |         /// Local error while processing authentication challenges
34 |         ProcessingError,
35 |         /// The server requested for tasks that are not supported
36 |         RequiredTasks,
37 |     };
38 |     /// Type of the authentication error
39 |     Type type;
40 |     /// Error message from the server
41 |     QString text;
42 |     /// Protocol-specific details provided to the error
43 |     std::any details;
44 | };
45 | 
46 | }  // namespace QXmpp
47 | 
48 | #endif  // QXMPPAUTHENTICATIONERROR_H
49 | 


--------------------------------------------------------------------------------
/src/client/QXmppBindError.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2024 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPBINDERROR_H
 6 | #define QXMPPBINDERROR_H
 7 | 
 8 | #include "QXmppStanza.h"
 9 | 
10 | namespace QXmpp {
11 | 
12 | ///
13 | /// Indicates a resource binding error
14 | ///
15 | /// \since QXmpp 1.7
16 | ///
17 | struct BindError {
18 |     /// Stanza error returned by the server
19 |     QXmppStanza::Error stanzaError;
20 | };
21 | 
22 | }  // namespace QXmpp
23 | 
24 | #endif  // QXMPPBINDERROR_H
25 | 


--------------------------------------------------------------------------------
/src/client/QXmppBookmarkManager.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2012 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPBOOKMARKMANAGER_H
 6 | #define QXMPPBOOKMARKMANAGER_H
 7 | 
 8 | #include "QXmppClientExtension.h"
 9 | 
10 | #include <QUrl>
11 | 
12 | class QXmppBookmarkManagerPrivate;
13 | class QXmppBookmarkSet;
14 | 
15 | /// \brief The QXmppBookmarkManager class allows you to store and retrieve
16 | /// bookmarks as defined by \xep{0048}: Bookmarks.
17 | ///
18 | 
19 | class QXMPP_EXPORT QXmppBookmarkManager : public QXmppClientExtension
20 | {
21 |     Q_OBJECT
22 | 
23 | public:
24 |     QXmppBookmarkManager();
25 |     ~QXmppBookmarkManager() override;
26 | 
27 |     bool areBookmarksReceived() const;
28 |     QXmppBookmarkSet bookmarks() const;
29 |     bool setBookmarks(const QXmppBookmarkSet &bookmarks);
30 | 
31 |     /// \cond
32 |     bool handleStanza(const QDomElement &stanza) override;
33 |     /// \endcond
34 | 
35 | Q_SIGNALS:
36 |     /// This signal is emitted when bookmarks are received.
37 |     void bookmarksReceived(const QXmppBookmarkSet &bookmarks);
38 | 
39 | protected:
40 |     /// \cond
41 |     void onRegistered(QXmppClient *client) override;
42 |     void onUnregistered(QXmppClient *client) override;
43 |     /// \endcond
44 | 
45 | private Q_SLOTS:
46 |     void slotConnected();
47 |     void slotDisconnected();
48 | 
49 | private:
50 |     const std::unique_ptr<QXmppBookmarkManagerPrivate> d;
51 | };
52 | 
53 | #endif
54 | 


--------------------------------------------------------------------------------
/src/client/QXmppCallManager_p.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2019 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPCALLMANAGER_P_H
 6 | #define QXMPPCALLMANAGER_P_H
 7 | 
 8 | #include "QXmppCall.h"
 9 | 
10 | #include <QHostAddress>
11 | #include <QList>
12 | 
13 | class QXmppCallManager;
14 | 
15 | //  W A R N I N G
16 | //  -------------
17 | //
18 | // This file is not part of the QXmpp API.
19 | // This header file may change from version to version without notice,
20 | // or even be removed.
21 | //
22 | // We mean it.
23 | //
24 | 
25 | class QXmppCallManagerPrivate
26 | {
27 | public:
28 |     QXmppCallManagerPrivate(QXmppCallManager *qq);
29 |     QXmppCall *findCall(const QString &sid) const;
30 |     QXmppCall *findCall(const QString &sid, QXmppCall::Direction direction) const;
31 | 
32 |     QList<QXmppCall *> calls;
33 |     QList<QPair<QHostAddress, quint16>> stunServers;
34 |     QHostAddress turnHost;
35 |     quint16 turnPort;
36 |     QString turnUser;
37 |     QString turnPassword;
38 | 
39 | private:
40 |     QXmppCallManager *q;
41 | };
42 | 
43 | #endif
44 | 


--------------------------------------------------------------------------------
/src/client/QXmppCallStream.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2019 Niels Ole Salscheider <niels_ole@salscheider-online.de>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPCALLSTREAM_H
 6 | #define QXMPPCALLSTREAM_H
 7 | 
 8 | #include <QXmppGlobal.h>
 9 | 
10 | #include <functional>
11 | 
12 | #include <QObject>
13 | 
14 | typedef struct _GstPad GstPad;
15 | typedef struct _GstElement GstElement;
16 | 
17 | class QXmppCallStreamPrivate;
18 | class QXmppIceConnection;
19 | class QXmppCall;
20 | class QXmppCallPrivate;
21 | 
22 | class QXMPP_EXPORT QXmppCallStream : public QObject
23 | {
24 |     Q_OBJECT
25 | 
26 | public:
27 |     QString creator() const;
28 |     QString media() const;
29 |     QString name() const;
30 |     int id() const;
31 |     void setReceivePadCallback(std::function<void(GstPad *)> cb);
32 |     void setSendPadCallback(std::function<void(GstPad *)> cb);
33 | 
34 | private:
35 |     QXmppCallStream(GstElement *pipeline, GstElement *rtpbin,
36 |                     QString media, QString creator, QString name, int id);
37 | 
38 |     QXmppCallStreamPrivate *d;
39 | 
40 |     friend class QXmppCall;
41 |     friend class QXmppCallPrivate;
42 | };
43 | 
44 | #endif
45 | 


--------------------------------------------------------------------------------
/src/client/QXmppCarbonManager.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2016 Manjeet Dahiya <manjeetdahiya@gmail.com>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPCARBONMANAGER_H
 6 | #define QXMPPCARBONMANAGER_H
 7 | 
 8 | #include "QXmppClientExtension.h"
 9 | 
10 | class QXmppMessage;
11 | 
12 | ///
13 | /// \brief The QXmppCarbonManager class handles message carbons
14 | /// as described in \xep{0280}: Message Carbons.
15 | ///
16 | /// This class emits signals whenever another resource of the
17 | /// currently connected client account sent or received a message.
18 | ///
19 | /// \warning This manager does not decrypt e2ee messages. You can use QXmppCarbonManagerV2.
20 | ///
21 | /// \ingroup Managers
22 | ///
23 | /// \since QXmpp 1.0
24 | ///
25 | class QXMPP_EXPORT QXmppCarbonManager : public QXmppClientExtension
26 | {
27 |     Q_OBJECT
28 | 
29 | public:
30 |     QXmppCarbonManager();
31 |     ~QXmppCarbonManager() override;
32 | 
33 |     bool carbonsEnabled() const;
34 |     void setCarbonsEnabled(bool enabled);
35 | 
36 |     /// \cond
37 |     QStringList discoveryFeatures() const override;
38 |     bool handleStanza(const QDomElement &element) override;
39 |     /// \endcond
40 | 
41 | Q_SIGNALS:
42 |     void messageReceived(const QXmppMessage &);
43 |     void messageSent(const QXmppMessage &);
44 | 
45 | private:
46 |     bool m_carbonsEnabled;
47 | };
48 | 
49 | #endif  // QXMPPCARBONMANAGER_H
50 | 


--------------------------------------------------------------------------------
/src/client/QXmppCarbonManagerV2.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPCARBONMANAGERV2_H
 6 | #define QXMPPCARBONMANAGERV2_H
 7 | 
 8 | #include "QXmppClientExtension.h"
 9 | 
10 | class QXMPP_EXPORT QXmppCarbonManagerV2 : public QXmppClientExtension
11 | {
12 |     Q_OBJECT
13 | public:
14 |     QXmppCarbonManagerV2();
15 |     ~QXmppCarbonManagerV2();
16 | 
17 |     bool handleStanza(const QDomElement &, const std::optional<QXmppE2eeMetadata> &) override;
18 | 
19 | protected:
20 |     void onRegistered(QXmppClient *client) override;
21 |     void onUnregistered(QXmppClient *client) override;
22 | 
23 | private:
24 |     void enableCarbons();
25 | 
26 |     // placeholder (we may need a d-ptr in the future)
27 |     void *d;
28 | };
29 | 
30 | #endif  // QXMPPCARBONMANAGERV2_H
31 | 


--------------------------------------------------------------------------------
/src/client/QXmppClientExtension.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPCLIENTEXTENSION_H
 6 | #define QXMPPCLIENTEXTENSION_H
 7 | 
 8 | #include "QXmppDiscoveryIq.h"
 9 | #include "QXmppExtension.h"
10 | #include "QXmppLogger.h"
11 | 
12 | #include <memory>
13 | 
14 | class QDomElement;
15 | 
16 | class QXmppClient;
17 | class QXmppClientExtensionPrivate;
18 | class QXmppMessage;
19 | 
20 | ///
21 | /// \brief The QXmppClientExtension class is the base class for QXmppClient
22 | /// extensions.
23 | ///
24 | /// If you want to extend QXmppClient, for instance to support an IQ type
25 | /// which is not natively supported, you can subclass QXmppClientExtension
26 | /// and implement handleStanza(). You can then add your extension to the
27 | /// client instance using QXmppClient::addExtension().
28 | ///
29 | /// \ingroup Core
30 | ///
31 | class QXMPP_EXPORT QXmppClientExtension : public QXmppLoggable, public QXmppExtension
32 | {
33 |     Q_OBJECT
34 | 
35 | public:
36 |     QXmppClientExtension();
37 |     ~QXmppClientExtension() override;
38 | 
39 |     virtual QStringList discoveryFeatures() const;
40 |     virtual QList<QXmppDiscoveryIq::Identity> discoveryIdentities() const;
41 | 
42 |     virtual bool handleStanza(const QDomElement &stanza);
43 |     virtual bool handleStanza(const QDomElement &stanza, const std::optional<QXmppE2eeMetadata> &e2eeMetadata);
44 | 
45 | protected:
46 |     QXmppClient *client() const;
47 |     virtual void setClient(QXmppClient *client);
48 | 
49 |     virtual void onRegistered(QXmppClient *client);
50 |     virtual void onUnregistered(QXmppClient *client);
51 | 
52 |     void injectIq(const QDomElement &element, const std::optional<QXmppE2eeMetadata> &e2eeMetadata);
53 |     bool injectMessage(QXmppMessage &&message);
54 | 
55 | private:
56 |     // m_client can be replaced with a d-ptr if needed (same size)
57 |     QXmppClient *m_client;
58 | 
59 |     friend class QXmppClient;
60 | };
61 | 
62 | #endif
63 | 


--------------------------------------------------------------------------------
/src/client/QXmppClient_p.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2020 Manjeet Dahiya <manjeetdahiya@gmail.com>
 2 | // SPDX-FileCopyrightText: 2020 Linus Jahn <lnj@kaidan.im>
 3 | // SPDX-FileCopyrightText: 2023 Melvin Keskin <melvo@olomono.de>
 4 | //
 5 | // SPDX-License-Identifier: LGPL-2.1-or-later
 6 | 
 7 | //
 8 | //  W A R N I N G
 9 | //  -------------
10 | //
11 | // This file is not part of the QXmpp API.
12 | //
13 | // This header file may change from version to version without notice,
14 | // or even be removed.
15 | //
16 | // We mean it.
17 | //
18 | 
19 | #ifndef QXMPPCLIENT_P_H
20 | #define QXMPPCLIENT_P_H
21 | 
22 | #include "QXmppOutgoingClient.h"
23 | #include "QXmppPresence.h"
24 | 
25 | #include <chrono>
26 | 
27 | class QXmppClient;
28 | class QXmppClientExtension;
29 | class QXmppE2eeExtension;
30 | class QXmppLogger;
31 | class QTimer;
32 | 
33 | class QXmppClientPrivate
34 | {
35 | public:
36 |     QXmppClientPrivate(QXmppClient *qq);
37 | 
38 |     /// Current presence of the client
39 |     QXmppPresence clientPresence;
40 |     QList<QXmppClientExtension *> extensions;
41 |     QXmppLogger *logger;
42 |     /// Pointer to the XMPP stream
43 |     QXmppOutgoingClient *stream;
44 |     QVector<QXmpp::StreamError> ignoredStreamErrors;
45 | 
46 |     QXmppE2eeExtension *encryptionExtension;
47 | 
48 |     // reconnection
49 |     bool receivedConflict;
50 |     int reconnectionTries;
51 |     QTimer *reconnectionTimer;
52 | 
53 |     void addProperCapability(QXmppPresence &presence);
54 |     std::chrono::milliseconds getNextReconnectTime() const;
55 | 
56 |     static QStringList discoveryFeatures();
57 |     void onErrorOccurred(const QString &text, const QXmppOutgoingClient::ConnectionError &err, QXmppClient::Error oldError);
58 | 
59 | private:
60 |     QXmppClient *q;
61 | };
62 | 
63 | #endif  // QXMPPCLIENT_P_H
64 | 


--------------------------------------------------------------------------------
/src/client/QXmppCredentials.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2024 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPCREDENTIALS_H
 6 | #define QXMPPCREDENTIALS_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <optional>
11 | 
12 | #include <QSharedDataPointer>
13 | 
14 | struct QXmppCredentialsPrivate;
15 | class QXmlStreamReader;
16 | class QXmlStreamWriter;
17 | 
18 | class QXMPP_EXPORT QXmppCredentials
19 | {
20 | public:
21 |     QXmppCredentials();
22 |     QXMPP_PRIVATE_DECLARE_RULE_OF_SIX(QXmppCredentials)
23 | 
24 |     static std::optional<QXmppCredentials> fromXml(QXmlStreamReader &);
25 |     void toXml(QXmlStreamWriter &) const;
26 | 
27 |     /// Comparison operator
28 |     bool operator==(const QXmppCredentials &other) const;
29 |     /// Comparison operator
30 |     bool operator!=(const QXmppCredentials &other) const = default;
31 | 
32 | private:
33 |     friend class QXmppConfiguration;
34 | 
35 |     QSharedDataPointer<QXmppCredentialsPrivate> d;
36 | };
37 | 
38 | #endif  // QXMPPCREDENTIALS_H
39 | 


--------------------------------------------------------------------------------
/src/client/QXmppE2eeExtension.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2021 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPE2EEEXTENSION_H
 6 | #define QXMPPE2EEEXTENSION_H
 7 | 
 8 | #include "QXmppError.h"
 9 | #include "QXmppExtension.h"
10 | #include "QXmppSendResult.h"
11 | #include "QXmppSendStanzaParams.h"
12 | 
13 | #include <memory>
14 | #include <optional>
15 | 
16 | class QDomElement;
17 | class QXmppMessage;
18 | class QXmppIq;
19 | template<typename T>
20 | class QXmppTask;
21 | 
22 | class QXmppE2eeExtension : public QXmppExtension
23 | {
24 | public:
25 |     struct NotEncrypted { };
26 | 
27 |     using MessageEncryptResult = std::variant<std::unique_ptr<QXmppMessage>, QXmppError>;
28 |     using MessageDecryptResult = std::variant<QXmppMessage, NotEncrypted, QXmppError>;
29 |     using IqEncryptResult = std::variant<std::unique_ptr<QXmppIq>, QXmppError>;
30 |     using IqDecryptResult = std::variant<QDomElement, NotEncrypted, QXmppError>;
31 | 
32 |     virtual QXmppTask<MessageEncryptResult> encryptMessage(QXmppMessage &&, const std::optional<QXmppSendStanzaParams> &) = 0;
33 |     virtual QXmppTask<MessageDecryptResult> decryptMessage(QXmppMessage &&) = 0;
34 |     virtual QXmppTask<IqEncryptResult> encryptIq(QXmppIq &&, const std::optional<QXmppSendStanzaParams> &) = 0;
35 |     virtual QXmppTask<IqDecryptResult> decryptIq(const QDomElement &) = 0;
36 |     virtual bool isEncrypted(const QDomElement &) = 0;
37 |     virtual bool isEncrypted(const QXmppMessage &) = 0;
38 | };
39 | 
40 | #endif  // QXMPPE2EEEXTENSION_H
41 | 


--------------------------------------------------------------------------------
/src/client/QXmppEncryptedFileSharingProvider.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Jonah Brüchert <jbb@kaidan.im>
 2 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 3 | //
 4 | // SPDX-License-Identifier: LGPL-2.1-or-later
 5 | 
 6 | #ifndef QXMPPENCRYPTEDHTTPFILESHARINGPROVIDER_H
 7 | #define QXMPPENCRYPTEDHTTPFILESHARINGPROVIDER_H
 8 | 
 9 | #include "QXmppEncryptedFileSource.h"
10 | #include "QXmppHttpFileSharingProvider.h"
11 | 
12 | class QXmppFileSharingManager;
13 | class QXmppEncryptedFileSharingProviderPrivate;
14 | 
15 | class QXMPP_EXPORT QXmppEncryptedFileSharingProvider : public QXmppFileSharingProvider
16 | {
17 | public:
18 |     /// \cond
19 |     using SourceType = QXmppEncryptedFileSource;
20 |     /// \endcond
21 | 
22 |     QXmppEncryptedFileSharingProvider(QXmppFileSharingManager *manager, std::shared_ptr<QXmppFileSharingProvider> uploadBaseProvider);
23 |     ~QXmppEncryptedFileSharingProvider() override;
24 | 
25 |     auto downloadFile(const std::any &source,
26 |                       std::unique_ptr<QIODevice> target,
27 |                       std::function<void(quint64, quint64)> reportProgress,
28 |                       std::function<void(DownloadResult)> reportFinished) -> std::shared_ptr<Download> override;
29 | 
30 |     auto uploadFile(std::unique_ptr<QIODevice> source,
31 |                     const QXmppFileMetadata &info,
32 |                     std::function<void(quint64, quint64)> reportProgress,
33 |                     std::function<void(UploadResult)> reportFinished) -> std::shared_ptr<Upload> override;
34 | 
35 | private:
36 |     std::unique_ptr<QXmppEncryptedFileSharingProviderPrivate> d;
37 | };
38 | 
39 | #endif  // QXMPPENCRYPTEDHTTPFILESHARINGPROVIDER_H
40 | 


--------------------------------------------------------------------------------
/src/client/QXmppEntityTimeManager.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2010 Manjeet Dahiya <manjeetdahiya@gmail.com>
 2 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 3 | //
 4 | // SPDX-License-Identifier: LGPL-2.1-or-later
 5 | 
 6 | #ifndef QXMPPENTITYTIMEMANAGER_H
 7 | #define QXMPPENTITYTIMEMANAGER_H
 8 | 
 9 | #include "QXmppClientExtension.h"
10 | 
11 | #include <variant>
12 | 
13 | template<class T>
14 | class QXmppTask;
15 | class QXmppEntityTimeIq;
16 | struct QXmppError;
17 | 
18 | ///
19 | /// \brief The QXmppEntityTimeManager class provided the functionality to get
20 | /// the local time of an entity as defined by \xep{0202}: Entity Time.
21 | ///
22 | /// \ingroup Managers
23 | ///
24 | class QXMPP_EXPORT QXmppEntityTimeManager : public QXmppClientExtension
25 | {
26 |     Q_OBJECT
27 | 
28 | public:
29 |     QString requestTime(const QString &jid);
30 | 
31 |     using EntityTimeResult = std::variant<QXmppEntityTimeIq, QXmppError>;
32 |     QXmppTask<EntityTimeResult> requestEntityTime(const QString &jid);
33 | 
34 |     /// \cond
35 |     QStringList discoveryFeatures() const override;
36 |     bool handleStanza(const QDomElement &element) override;
37 |     std::variant<QXmppEntityTimeIq, QXmppStanza::Error> handleIq(QXmppEntityTimeIq iq);
38 |     /// \endcond
39 | 
40 | Q_SIGNALS:
41 |     /// \brief This signal is emitted when a time response is received. It's not
42 |     /// emitted when the QFuture-based request is used.
43 |     void timeReceived(const QXmppEntityTimeIq &);
44 | };
45 | 
46 | #endif  // QXMPPENTITYTIMEMANAGER_H
47 | 


--------------------------------------------------------------------------------
/src/client/QXmppExternalServiceDiscoveryManager.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2023 Tibor Csötönyi <work@taibsu.de>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #include "QXmppExternalServiceDiscoveryManager.h"
 6 | 
 7 | #include "QXmppClient.h"
 8 | #include "QXmppConstants_p.h"
 9 | #include "QXmppExternalServiceDiscoveryIq.h"
10 | #include "QXmppIqHandling.h"
11 | 
12 | using namespace QXmpp::Private;
13 | 
14 | ///
15 | /// \brief The QXmppExternalServiceDiscoveryManager class makes it possible to
16 | /// discover information about external services from providers
17 | /// as defined by \xep{0215, External Service Discovery}.
18 | ///
19 | /// To make use of this manager, you need to instantiate it and load it into
20 | /// the QXmppClient instance as follows:
21 | ///
22 | /// \code
23 | /// auto *manager = client->addNewExtension<QXmppExternalServiceDiscoveryManager>();
24 | /// \endcode
25 | ///
26 | /// \ingroup Managers
27 | ///
28 | /// \since QXmpp 1.6
29 | ///
30 | QXmppExternalServiceDiscoveryManager::QXmppExternalServiceDiscoveryManager()
31 | {
32 | }
33 | 
34 | QXmppExternalServiceDiscoveryManager::~QXmppExternalServiceDiscoveryManager() = default;
35 | 
36 | ///
37 | /// Requests external services from the specified XMPP entity.
38 | ///
39 | /// \param jid  The target entity's JID.
40 | /// \param node The target node (optional).
41 | ///
42 | /// \since QXmpp 1.6
43 | ///
44 | QXmppTask<QXmppExternalServiceDiscoveryManager::ServicesResult> QXmppExternalServiceDiscoveryManager::requestServices(const QString &jid, const QString &node)
45 | {
46 |     QXmppExternalServiceDiscoveryIq request;
47 |     request.setType(QXmppIq::Get);
48 |     request.setTo(jid);
49 | 
50 |     return chainIq(client()->sendIq(std::move(request)), this, [](QXmppExternalServiceDiscoveryIq &&iq) -> ServicesResult {
51 |         return iq.externalServices();
52 |     });
53 | }
54 | 
55 | /// \cond
56 | QStringList QXmppExternalServiceDiscoveryManager::discoveryFeatures() const
57 | {
58 |     return { ns_external_service_discovery.toString() };
59 | }
60 | /// \endcond
61 | 


--------------------------------------------------------------------------------
/src/client/QXmppExternalServiceDiscoveryManager.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2023 Tibor Csötönyi <work@taibsu.de>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPEXTERNALSERVICEDISCOVERYMANAGER_H
 6 | #define QXMPPEXTERNALSERVICEDISCOVERYMANAGER_H
 7 | 
 8 | #include "QXmppClientExtension.h"
 9 | #include "QXmppError.h"
10 | #include "QXmppExternalService.h"
11 | #include "QXmppTask.h"
12 | 
13 | #include <variant>
14 | 
15 | class QDateTime;
16 | class QXmppExternalServicePrivate;
17 | class QXMPP_EXPORT QXmppExternalServiceDiscoveryManager : public QXmppClientExtension
18 | {
19 |     Q_OBJECT
20 | 
21 | public:
22 |     QXmppExternalServiceDiscoveryManager();
23 |     ~QXmppExternalServiceDiscoveryManager();
24 | 
25 |     using ServicesResult = std::variant<QVector<QXmppExternalService>, QXmppError>;
26 | 
27 |     QXmppTask<ServicesResult> requestServices(const QString &jid, const QString &node = {});
28 | 
29 |     /// \cond
30 |     QStringList discoveryFeatures() const override;
31 |     /// \endcond
32 | };
33 | 
34 | #endif  // QXMPPEXTERNALSERVICEDISCOVERYMANAGER_H
35 | 


--------------------------------------------------------------------------------
/src/client/QXmppHttpFileSharingProvider.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Jonah Brüchert <jbb@kaidan.im>
 2 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 3 | //
 4 | // SPDX-License-Identifier: LGPL-2.1-or-later
 5 | 
 6 | #ifndef QXMPPHTTPFILESHARINGPROVIDER_H
 7 | #define QXMPPHTTPFILESHARINGPROVIDER_H
 8 | 
 9 | #include "QXmppFileSharingProvider.h"
10 | #include "QXmppHttpFileSource.h"
11 | 
12 | class QXmppHttpUploadManager;
13 | class QNetworkAccessManager;
14 | 
15 | class QXmppHttpFileSharingProviderPrivate;
16 | 
17 | class QXMPP_EXPORT QXmppHttpFileSharingProvider : public QXmppFileSharingProvider
18 | {
19 | public:
20 |     /// \cond
21 |     using SourceType = QXmppHttpFileSource;
22 |     /// \endcond
23 | 
24 |     QXmppHttpFileSharingProvider(QXmppHttpUploadManager *manager, QNetworkAccessManager *netManager);
25 |     ~QXmppHttpFileSharingProvider() override;
26 | 
27 |     auto downloadFile(const std::any &source,
28 |                       std::unique_ptr<QIODevice> target,
29 |                       std::function<void(quint64, quint64)> reportProgress,
30 |                       std::function<void(DownloadResult)> reportFinished) -> std::shared_ptr<Download> override;
31 |     auto uploadFile(std::unique_ptr<QIODevice> source,
32 |                     const QXmppFileMetadata &info,
33 |                     std::function<void(quint64, quint64)> reportProgress,
34 |                     std::function<void(UploadResult)> reportFinished) -> std::shared_ptr<Upload> override;
35 | 
36 | private:
37 |     std::unique_ptr<QXmppHttpFileSharingProviderPrivate> d;
38 | };
39 | 
40 | #endif  // QXMPPHTTPFILESHARINGPROVIDER_H
41 | 


--------------------------------------------------------------------------------
/src/client/QXmppInvokable.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2009 Ian Reinhart Geiser <geiseri@kde.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPINVOKABLE_H
 6 | #define QXMPPINVOKABLE_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <QHash>
11 | #include <QObject>
12 | #include <QStringList>
13 | #include <QVariant>
14 | #include <QWriteLocker>
15 | 
16 | /**
17 | This is the base class for all objects that will be invokable via RPC.  All public slots of objects derived from this class will be exposed to the RPC interface.  As a note for all methods, they can only understand types that QVariant knows about.
18 | 
19 |         @author Ian Reinhart Geiser <geiseri@kde.org>
20 | */
21 | class QXMPP_EXPORT QXmppInvokable : public QObject
22 | {
23 |     Q_OBJECT
24 | public:
25 |     QXmppInvokable(QObject *parent = nullptr);
26 | 
27 |     ~QXmppInvokable() override;
28 | 
29 |     /**
30 |      * Execute a method on an object. with a set of arguments. This method is reentrant, and the method
31 |      * that is invoked will be done in a thread safe manner.  It should be noted that while this method
32 |      * is threadsafe and reentrant the side affects of the methods invoked may not be.
33 |      */
34 |     QVariant dispatch(const QByteArray &method, const QList<QVariant> &args = QList<QVariant>());
35 | 
36 |     /**
37 |      * Utility method to convert a QList<QVariant> to a list of types for type
38 |      * checking.
39 |      */
40 |     static QList<QByteArray> paramTypes(const QList<QVariant> &params);
41 | 
42 |     /**
43 |      * Reimplement this method to return a true if the invoking JID is allowed to execute the method.
44 |      */
45 |     virtual bool isAuthorized(const QString &jid) const = 0;
46 | 
47 | public Q_SLOTS:
48 |     /**
49 |      * This provides a list of interfaces for introspection of the presented interface.
50 |      */
51 |     QStringList interfaces() const;
52 | 
53 | private:
54 |     void buildMethodHash();
55 |     QHash<QByteArray, int> m_methodHash;
56 |     QReadWriteLock m_lock;
57 | };
58 | 
59 | #endif
60 | 


--------------------------------------------------------------------------------
/src/client/QXmppIqHandling.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #include "QXmppIqHandling.h"
 6 | 
 7 | #include "StringLiterals.h"
 8 | 
 9 | void QXmpp::Private::sendIqReply(QXmppClient *client,
10 |                                  const QString &requestId,
11 |                                  const QString &requestFrom,
12 |                                  const std::optional<QXmppE2eeMetadata> &e2eeMetadata,
13 |                                  QXmppIq &&iq)
14 | {
15 |     // default type is 'result'
16 |     switch (iq.type()) {
17 |     case QXmppIq::Get:
18 |     case QXmppIq::Set:
19 |         iq.setType(QXmppIq::Result);
20 |         break;
21 |     case QXmppIq::Error:
22 |     case QXmppIq::Result:
23 |         break;
24 |     }
25 | 
26 |     iq.setTo(requestFrom);
27 |     iq.setId(requestId);
28 |     client->reply(std::move(iq), e2eeMetadata);
29 | }
30 | 
31 | std::tuple<bool, QString, QString> QXmpp::Private::checkIsIqRequest(const QDomElement &el)
32 | {
33 |     if (el.tagName() != u"iq") {
34 |         return { false, {}, {} };
35 |     }
36 |     auto queryElement = el.firstChildElement();
37 |     auto iqType = el.attribute(u"type"_s);
38 |     if (iqType != u"get" && iqType != u"set") {
39 |         return { false, {}, {} };
40 |     }
41 |     return { true, queryElement.tagName(), queryElement.namespaceURI() };
42 | }
43 | 


--------------------------------------------------------------------------------
/src/client/QXmppMessageHandler.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | ///
 6 | /// \class QXmppMessageHandler
 7 | ///
 8 | /// Interface for handling messages.
 9 | ///
10 | /// \since QXmpp 1.5
11 | ///
12 | 
13 | ///
14 | /// \fn QXmppMessageHandler::handleMessage()
15 | ///
16 | /// Handles the message.
17 | ///
18 | /// \returns Whether the message has been handled and no other extensions should process it.
19 | ///
20 | 


--------------------------------------------------------------------------------
/src/client/QXmppMessageHandler.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPMESSAGEHANDLER_H
 6 | #define QXMPPMESSAGEHANDLER_H
 7 | 
 8 | #include "QXmppExtension.h"
 9 | #include "QXmppMessage.h"
10 | 
11 | #include <variant>
12 | 
13 | #include <QFuture>
14 | 
15 | class QXMPP_EXPORT QXmppMessageHandler : public QXmppExtension
16 | {
17 | public:
18 |     virtual bool handleMessage(const QXmppMessage &) = 0;
19 | };
20 | 
21 | #endif  // QXMPPMESSAGEHANDLER_H
22 | 


--------------------------------------------------------------------------------
/src/client/QXmppMessageReceiptManager.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2019 Georg Rudoy <0xd34df00d@gmail.com>
 2 | // SPDX-FileCopyrightText: 2012 Jeremy Lainé <jeremy.laine@m4x.org>
 3 | //
 4 | // SPDX-License-Identifier: LGPL-2.1-or-later
 5 | 
 6 | #ifndef QXMPPMESSAGERECEIPTMANAGER_H
 7 | #define QXMPPMESSAGERECEIPTMANAGER_H
 8 | 
 9 | #include "QXmppClientExtension.h"
10 | #include "QXmppMessageHandler.h"
11 | 
12 | ///
13 | /// \brief The QXmppMessageReceiptManager class makes it possible to
14 | /// send and receive message delivery receipts as defined in
15 | /// \xep{0184}: Message Delivery Receipts.
16 | ///
17 | /// \ingroup Managers
18 | ///
19 | class QXMPP_EXPORT QXmppMessageReceiptManager : public QXmppClientExtension, public QXmppMessageHandler
20 | {
21 |     Q_OBJECT
22 | public:
23 |     QXmppMessageReceiptManager();
24 | 
25 |     /// \cond
26 |     QStringList discoveryFeatures() const override;
27 |     bool handleMessage(const QXmppMessage &) override;
28 |     /// \endcond
29 | 
30 | Q_SIGNALS:
31 |     /// This signal is emitted when receipt for the message with the
32 |     /// given id is received. The id could be previously obtained by
33 |     /// calling QXmppMessage::id().
34 |     void messageDelivered(const QString &jid, const QString &id);
35 | };
36 | 
37 | #endif  // QXMPPMESSAGERECEIPTMANAGER_H
38 | 


--------------------------------------------------------------------------------
/src/client/QXmppMovedItem_p.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2024 Filipe Azevedo <pasnox@gmail.com>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPMOVEDITEM_P_H
 6 | #define QXMPPMOVEDITEM_P_H
 7 | 
 8 | #include <QXmppPubSubBaseItem.h>
 9 | 
10 | class QXmppMovedItem : public QXmppPubSubBaseItem
11 | {
12 | public:
13 |     QXmppMovedItem(const QString &newJid = {});
14 | 
15 |     QString newJid() const { return m_newJid; }
16 |     void setNewJid(const QString &newJid) { m_newJid = newJid; }
17 | 
18 |     static bool isItem(const QDomElement &itemElement);
19 | 
20 | protected:
21 |     void parsePayload(const QDomElement &payloadElement) override;
22 |     void serializePayload(QXmlStreamWriter *writer) const override;
23 | 
24 | private:
25 |     QString m_newJid;
26 | };
27 | 
28 | #endif  // QXMPPMOVEDITEM_P_H
29 | 


--------------------------------------------------------------------------------
/src/client/QXmppMovedManager.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2024 Filipe Azevedo <pasnox@gmail.com>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPMOVEDMANAGER_H
 6 | #define QXMPPMOVEDMANAGER_H
 7 | 
 8 | #include "QXmppClientExtension.h"
 9 | #include "QXmppSendResult.h"
10 | #include "QXmppTask.h"
11 | 
12 | class QXmppPresence;
13 | struct QXmppError;
14 | class QXmppMovedManagerPrivate;
15 | 
16 | class QXMPP_EXPORT QXmppMovedManager : public QXmppClientExtension
17 | {
18 |     Q_OBJECT
19 |     Q_PROPERTY(bool supportedByServer READ supportedByServer NOTIFY supportedByServerChanged)
20 | 
21 | public:
22 |     using Result = std::variant<QXmpp::Success, QXmppError>;
23 | 
24 |     explicit QXmppMovedManager();
25 |     ~QXmppMovedManager() override;
26 | 
27 |     QStringList discoveryFeatures() const override;
28 | 
29 |     bool supportedByServer() const;
30 |     Q_SIGNAL void supportedByServerChanged();
31 | 
32 |     QXmppTask<Result> publishStatement(const QString &newBareJid);
33 |     QXmppTask<Result> verifyStatement(const QString &oldBareJid, const QString &newBareJid);
34 | 
35 |     QXmppTask<QXmpp::SendResult> notifyContact(const QString &contactBareJid, const QString &oldBareJid, bool sensitive = true, const QString &reason = {});
36 | 
37 | protected:
38 |     /// \cond
39 |     void onRegistered(QXmppClient *client) override;
40 |     void onUnregistered(QXmppClient *client) override;
41 |     /// \endcond
42 | 
43 | private:
44 |     QXmppTask<QXmppPresence> processSubscriptionRequest(QXmppPresence presence);
45 |     void handleDiscoInfo(const QXmppDiscoveryIq &iq);
46 |     Result movedJidsMatch(const QString &newBareJid, const QString &pepBareJid) const;
47 | 
48 |     void setSupportedByServer(bool supportedByServer);
49 |     void resetCachedData();
50 | 
51 |     const std::unique_ptr<QXmppMovedManagerPrivate> d;
52 | 
53 |     friend class QXmppRosterManager;
54 |     friend class tst_QXmppMovedManager;
55 | };
56 | 
57 | #endif  // QXMPPMOVEDMANAGER_H
58 | 


--------------------------------------------------------------------------------
/src/client/QXmppPubSubEventHandler.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPPUBSUBEVENTHANDLER_H
 6 | #define QXMPPPUBSUBEVENTHANDLER_H
 7 | 
 8 | #include "QXmppExtension.h"
 9 | 
10 | class QDomElement;
11 | class QXmppPubSubManager;
12 | 
13 | // Documented in QXmppPubSubManager.cpp.
14 | class QXMPP_EXPORT QXmppPubSubEventHandler : public QXmppExtension
15 | {
16 | public:
17 |     virtual bool handlePubSubEvent(const QDomElement &element, const QString &pubSubService, const QString &nodeName) = 0;
18 | };
19 | 
20 | #endif  // QXMPPPUBSUBEVENTHANDLER_H
21 | 


--------------------------------------------------------------------------------
/src/client/QXmppRemoteMethod.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2009 Ian Reinhart Geiser <geiseri@kde.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #include "QXmppRemoteMethod.h"
 6 | 
 7 | #include "QXmppClient.h"
 8 | #include "QXmppUtils.h"
 9 | 
10 | #include <QDebug>
11 | #include <QEventLoop>
12 | #include <QTimer>
13 | 
14 | QXmppRemoteMethod::QXmppRemoteMethod(const QString &jid, const QString &method, const QVariantList &args, QXmppClient *client) : QObject(client), m_client(client)
15 | {
16 |     m_payload.setTo(jid);
17 |     m_payload.setFrom(client->configuration().jid());
18 |     m_payload.setMethod(method);
19 |     m_payload.setArguments(args);
20 | }
21 | 
22 | QXmppRemoteMethodResult QXmppRemoteMethod::call()
23 | {
24 |     // FIXME : spinning an event loop is a VERY bad idea, it can cause
25 |     // us to lose incoming packets
26 |     QEventLoop loop(this);
27 |     connect(this, &QXmppRemoteMethod::callDone, &loop, &QEventLoop::quit);
28 |     QTimer::singleShot(30000, &loop, &QEventLoop::quit);  // Timeout in case the other end hangs...
29 | 
30 |     m_client->sendPacket(m_payload);
31 | 
32 |     loop.exec(QEventLoop::ExcludeUserInputEvents | QEventLoop::WaitForMoreEvents);
33 |     return m_result;
34 | }
35 | 
36 | void QXmppRemoteMethod::gotError(const QXmppRpcErrorIq &iq)
37 | {
38 |     if (iq.id() == m_payload.id()) {
39 |         m_result.hasError = true;
40 |         m_result.errorMessage = iq.error().text();
41 |         m_result.code = iq.error().type();
42 |         Q_EMIT callDone();
43 |     }
44 | }
45 | 
46 | void QXmppRemoteMethod::gotResult(const QXmppRpcResponseIq &iq)
47 | {
48 |     if (iq.id() == m_payload.id()) {
49 |         m_result.hasError = false;
50 |         // FIXME: we don't handle multiple responses
51 |         const auto values = iq.values();
52 |         m_result.result = values.first();
53 |         Q_EMIT callDone();
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/client/QXmppRemoteMethod.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2009 Ian Reinhart Geiser <geiseri@kde.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPREMOTEMETHOD_H
 6 | #define QXMPPREMOTEMETHOD_H
 7 | 
 8 | #include "QXmppRpcIq.h"
 9 | 
10 | #include <QObject>
11 | #include <QVariant>
12 | 
13 | class QXmppClient;
14 | 
15 | struct QXmppRemoteMethodResult {
16 |     QXmppRemoteMethodResult() : hasError(false), code(0) { }
17 |     bool hasError;
18 |     int code;
19 |     QString errorMessage;
20 |     QVariant result;
21 | };
22 | 
23 | class QXMPP_EXPORT QXmppRemoteMethod : public QObject
24 | {
25 |     Q_OBJECT
26 | public:
27 |     QXmppRemoteMethod(const QString &jid, const QString &method, const QVariantList &args, QXmppClient *client);
28 |     QXmppRemoteMethodResult call();
29 | 
30 | private Q_SLOTS:
31 |     void gotError(const QXmppRpcErrorIq &iq);
32 |     void gotResult(const QXmppRpcResponseIq &iq);
33 | 
34 | Q_SIGNALS:
35 |     void callDone();
36 | 
37 | private:
38 |     QXmppRpcInvokeIq m_payload;
39 |     QXmppClient *m_client;
40 |     QXmppRemoteMethodResult m_result;
41 | };
42 | 
43 | #endif  // QXMPPREMOTEMETHOD_H
44 | 


--------------------------------------------------------------------------------
/src/client/QXmppSendStanzaParams.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPSENDSTANZAPARAMS_H
 6 | #define QXMPPSENDSTANZAPARAMS_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | #include "QXmppTrustLevel.h"
10 | 
11 | #include <optional>
12 | 
13 | #include <QSharedDataPointer>
14 | 
15 | class QXmppSendStanzaParamsPrivate;
16 | 
17 | class QXMPP_EXPORT QXmppSendStanzaParams
18 | {
19 | public:
20 |     QXmppSendStanzaParams();
21 |     QXmppSendStanzaParams(const QXmppSendStanzaParams &other);
22 |     QXmppSendStanzaParams(QXmppSendStanzaParams &&);
23 |     ~QXmppSendStanzaParams();
24 |     QXmppSendStanzaParams &operator=(const QXmppSendStanzaParams &);
25 |     QXmppSendStanzaParams &operator=(QXmppSendStanzaParams &&);
26 | 
27 |     QVector<QString> encryptionJids() const;
28 |     void setEncryptionJids(QVector<QString>);
29 | 
30 |     std::optional<QXmpp::TrustLevels> acceptedTrustLevels() const;
31 |     void setAcceptedTrustLevels(std::optional<QXmpp::TrustLevels> trustLevels);
32 | 
33 | private:
34 |     QSharedDataPointer<QXmppSendStanzaParamsPrivate> d;
35 | };
36 | 
37 | #endif  // QXMPPSENDSTANZAPARAMS_H
38 | 


--------------------------------------------------------------------------------
/src/client/QXmppTransferManager_p.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2012 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPTRANSFERMANAGER_P_H
 6 | #define QXMPPTRANSFERMANAGER_P_H
 7 | 
 8 | #include "QXmppByteStreamIq.h"
 9 | #include "QXmppTransferManager.h"
10 | 
11 | //
12 | //  W A R N I N G
13 | //  -------------
14 | //
15 | // This file is not part of the QXmpp API.  It exists for the convenience
16 | // of the QXmppTransferManager class.  This header file may change from
17 | // version to version without notice, or even be removed.
18 | //
19 | // We mean it.
20 | //
21 | 
22 | class QTimer;
23 | class QXmppSocksClient;
24 | 
25 | class QXmppTransferIncomingJob : public QXmppTransferJob
26 | {
27 |     Q_OBJECT
28 | 
29 | public:
30 |     QXmppTransferIncomingJob(const QString &jid, QXmppClient *client, QObject *parent);
31 |     void checkData();
32 |     void connectToHosts(const QXmppByteStreamIq &iq);
33 |     bool writeData(const QByteArray &data);
34 | 
35 | private Q_SLOTS:
36 |     void _q_candidateDisconnected();
37 |     void _q_candidateReady();
38 |     void _q_disconnected();
39 |     void _q_receiveData();
40 | 
41 | private:
42 |     void connectToNextHost();
43 | 
44 |     QXmppByteStreamIq::StreamHost m_candidateHost;
45 |     QXmppSocksClient *m_candidateClient;
46 |     QTimer *m_candidateTimer;
47 |     QList<QXmppByteStreamIq::StreamHost> m_streamCandidates;
48 |     QString m_streamOfferId;
49 |     QString m_streamOfferFrom;
50 | };
51 | 
52 | class QXmppTransferOutgoingJob : public QXmppTransferJob
53 | {
54 |     Q_OBJECT
55 | 
56 | public:
57 |     QXmppTransferOutgoingJob(const QString &jid, QXmppClient *client, QObject *parent);
58 |     void connectToProxy();
59 |     void startSending();
60 | 
61 | public Q_SLOTS:
62 |     void _q_disconnected();
63 | 
64 | private Q_SLOTS:
65 |     void _q_proxyReady();
66 |     void _q_sendData();
67 | };
68 | 
69 | #endif
70 | 


--------------------------------------------------------------------------------
/src/client/QXmppTrustLevel.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2021 Melvin Keskin <melvo@olomono.de>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPTRUSTLEVEL_H
 6 | #define QXMPPTRUSTLEVEL_H
 7 | 
 8 | #include <QFlags>
 9 | #include <QHashFunctions>
10 | 
11 | namespace QXmpp {
12 | 
13 | ///
14 | /// Trust level of public long-term keys used by end-to-end encryption
15 | /// protocols
16 | ///
17 | /// \since QXmpp 1.5
18 | ///
19 | enum class TrustLevel {
20 |     /// The key's trust is not decided.
21 |     Undecided = 1,
22 |     /// The key is automatically distrusted (e.g., by the security policy TOAKAFA).
23 |     /// \see SecurityPolicy
24 |     AutomaticallyDistrusted = 2,
25 |     /// The key is manually distrusted (e.g., by clicking a button or \xep{0450, Automatic Trust
26 |     /// Management (ATM)}).
27 |     ManuallyDistrusted = 4,
28 |     /// The key is automatically trusted (e.g., by the client for all keys of a bare JID until one
29 |     /// of it is authenticated).
30 |     AutomaticallyTrusted = 8,
31 |     /// The key is manually trusted (e.g., by clicking a button).
32 |     ManuallyTrusted = 16,
33 |     /// The key is authenticated (e.g., by QR code scanning or \xep{0450, Automatic Trust
34 |     /// Management (ATM)}).
35 |     Authenticated = 32,
36 | };
37 | 
38 | Q_DECLARE_FLAGS(TrustLevels, TrustLevel)
39 | Q_DECLARE_OPERATORS_FOR_FLAGS(TrustLevels)
40 | 
41 | /// \cond
42 | // Scoped enums (enum class) are not implicitly converted to int
43 | inline auto qHash(QXmpp::TrustLevel key, uint seed) noexcept { return ::qHash(std::underlying_type_t<QXmpp::TrustLevel>(key), seed); }
44 | /// \endcond
45 | 
46 | }  // namespace QXmpp
47 | 
48 | #endif  // QXMPPTRUSTLEVEL_H
49 | 


--------------------------------------------------------------------------------
/src/client/QXmppTrustSecurityPolicy.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2021 Melvin Keskin <melvo@olomono.de>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPTRUSTSECURITYPOLICY_H
 6 | #define QXMPPTRUSTSECURITYPOLICY_H
 7 | 
 8 | #include <QMetaType>
 9 | 
10 | namespace QXmpp {
11 | 
12 | ///
13 | /// Security policy to decide which public long-term keys are used for encryption because they are
14 | /// trusted
15 | ///
16 | /// \since QXmpp 1.5
17 | ///
18 | enum TrustSecurityPolicy {
19 |     /// New keys must be trusted manually.
20 |     NoSecurityPolicy,
21 |     /// New keys are trusted automatically until the first authentication but automatically
22 |     /// distrusted afterwards. \see \xep{0450, Automatic Trust Management (ATM)}
23 |     Toakafa,
24 | };
25 | 
26 | }  // namespace QXmpp
27 | 
28 | Q_DECLARE_METATYPE(QXmpp::TrustSecurityPolicy)
29 | 
30 | #endif  // QXMPPTRUSTSECURITYPOLICY_H
31 | 


--------------------------------------------------------------------------------
/src/client/QXmppUserLocationManager.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | // SPDX-FileCopyrightText: 2022 Cochise César <cochisecesar@zoho.com>
 3 | //
 4 | // SPDX-License-Identifier: LGPL-2.1-or-later
 5 | 
 6 | #ifndef QXMPPUSERLOCATIONMANAGER_H
 7 | #define QXMPPUSERLOCATIONMANAGER_H
 8 | 
 9 | #include "QXmppClientExtension.h"
10 | #include "QXmppError.h"
11 | #include "QXmppPubSubEventHandler.h"
12 | 
13 | #include <variant>
14 | 
15 | template<typename T>
16 | class QXmppTask;
17 | class QXmppGeolocItem;
18 | 
19 | class QXMPP_EXPORT QXmppUserLocationManager : public QXmppClientExtension, public QXmppPubSubEventHandler
20 | {
21 |     Q_OBJECT
22 | 
23 | public:
24 |     using Item = QXmppGeolocItem;
25 |     using GetResult = std::variant<Item, QXmppError>;
26 |     using PublishResult = std::variant<QString, QXmppError>;
27 | 
28 |     QXmppUserLocationManager();
29 | 
30 |     QStringList discoveryFeatures() const override;
31 | 
32 |     QXmppTask<GetResult> request(const QString &jid);
33 |     QXmppTask<PublishResult> publish(const Item &);
34 | 
35 |     Q_SIGNAL void itemReceived(const QString &jid, const QXmppGeolocItem &);
36 | 
37 | protected:
38 |     /// \cond
39 |     bool handlePubSubEvent(const QDomElement &element, const QString &pubSubService, const QString &nodeName) override;
40 |     /// \endcond
41 | };
42 | 
43 | #endif  // QXMPPUSERLOCATIONMANAGER_H
44 | 


--------------------------------------------------------------------------------
/src/client/QXmppUserTuneManager.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2021 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPUSERTUNEMANAGER_H
 6 | #define QXMPPUSERTUNEMANAGER_H
 7 | 
 8 | #include "QXmppClientExtension.h"
 9 | #include "QXmppError.h"
10 | #include "QXmppPubSubEventHandler.h"
11 | 
12 | #include <variant>
13 | 
14 | class QXmppTuneItem;
15 | template<typename T>
16 | class QXmppTask;
17 | 
18 | class QXMPP_EXPORT QXmppUserTuneManager : public QXmppClientExtension, public QXmppPubSubEventHandler
19 | {
20 |     Q_OBJECT
21 | 
22 | public:
23 |     using Item = QXmppTuneItem;
24 |     using GetResult = std::variant<Item, QXmppError>;
25 |     using PublishResult = std::variant<QString, QXmppError>;
26 | 
27 |     QXmppUserTuneManager();
28 | 
29 |     QStringList discoveryFeatures() const override;
30 | 
31 |     QXmppTask<GetResult> request(const QString &jid);
32 |     QXmppTask<PublishResult> publish(const QXmppTuneItem &);
33 | 
34 |     Q_SIGNAL void itemReceived(const QString &jid, const QXmppTuneItem &item);
35 | 
36 | protected:
37 |     /// \cond
38 |     bool handlePubSubEvent(const QDomElement &element, const QString &pubSubService, const QString &nodeName) override;
39 |     /// \endcond
40 | };
41 | 
42 | #endif  // QXMPPUSERTUNEMANAGER_H
43 | 


--------------------------------------------------------------------------------
/src/client/QXmppVersionManager.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2010 Manjeet Dahiya <manjeetdahiya@gmail.com>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPVERSIONMANAGER_H
 6 | #define QXMPPVERSIONMANAGER_H
 7 | 
 8 | #include "QXmppClientExtension.h"
 9 | 
10 | class QXmppVersionIq;
11 | class QXmppVersionManagerPrivate;
12 | 
13 | ///
14 | /// \brief The QXmppVersionManager class makes it possible to request for
15 | /// the software version of an entity as defined by \xep{0092}: Software Version.
16 | ///
17 | /// \note Its object should not be created using its constructor. Instead
18 | /// \c QXmppClient::findExtension<QXmppVersionManager>() should be used to get
19 | /// the instantiated object of this class.
20 | ///
21 | /// \ingroup Managers
22 | ///
23 | class QXMPP_EXPORT QXmppVersionManager : public QXmppClientExtension
24 | {
25 |     Q_OBJECT
26 | 
27 | public:
28 |     QXmppVersionManager();
29 |     ~QXmppVersionManager() override;
30 | 
31 |     QString requestVersion(const QString &jid);
32 | 
33 |     void setClientName(const QString &);
34 |     void setClientVersion(const QString &);
35 |     void setClientOs(const QString &);
36 | 
37 |     QString clientName() const;
38 |     QString clientVersion() const;
39 |     QString clientOs() const;
40 | 
41 |     /// \cond
42 |     QStringList discoveryFeatures() const override;
43 |     bool handleStanza(const QDomElement &element) override;
44 |     QXmppVersionIq handleIq(QXmppVersionIq &&iq);
45 |     /// \endcond
46 | 
47 | Q_SIGNALS:
48 |     /// \brief This signal is emitted when a version response is received.
49 |     void versionReceived(const QXmppVersionIq &);
50 | 
51 | private:
52 |     const std::unique_ptr<QXmppVersionManagerPrivate> d;
53 | };
54 | 
55 | #endif  // QXMPPVERSIONMANAGER_H
56 | 


--------------------------------------------------------------------------------
/src/client/QcaInitializer.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #include "QcaInitializer_p.h"
 6 | 
 7 | #include <QtCrypto>
 8 | 
 9 | using namespace QCA;
10 | 
11 | namespace QXmpp::Private {
12 | 
13 | /// \cond
14 | QcaInitializer::QcaInitializer()
15 |     : d(createInitializer())
16 | {
17 | }
18 | 
19 | std::shared_ptr<Initializer> QcaInitializer::createInitializer()
20 | {
21 |     static std::weak_ptr<Initializer> initializer;
22 |     if (initializer.expired()) {
23 |         auto newInitializer = std::make_shared<Initializer>();
24 |         initializer = newInitializer;
25 |         return newInitializer;
26 |     }
27 |     return initializer.lock();
28 | }
29 | /// \endcond
30 | 
31 | }  // namespace QXmpp::Private
32 | 


--------------------------------------------------------------------------------
/src/client/QcaInitializer_p.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QCAINITIALIZER_P_H
 6 | #define QCAINITIALIZER_P_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <memory>
11 | 
12 | namespace QCA {
13 | class Initializer;
14 | }
15 | 
16 | namespace QXmpp::Private {
17 | 
18 | // export required for tests
19 | class QXMPP_EXPORT QcaInitializer
20 | {
21 | public:
22 |     QcaInitializer();
23 | 
24 | private:
25 |     static std::shared_ptr<QCA::Initializer> createInitializer();
26 |     std::shared_ptr<QCA::Initializer> d;
27 | };
28 | 
29 | }  // namespace QXmpp::Private
30 | 
31 | #endif  // QCAINITIALIZER_P_H
32 | 


--------------------------------------------------------------------------------
/src/omemo/OmemoCryptoProvider.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef OMEMOCRYPTOPROVIDER_H
 6 | #define OMEMOCRYPTOPROVIDER_H
 7 | 
 8 | #include <signal_protocol.h>
 9 | 
10 | class QXmppOmemoManagerPrivate;
11 | 
12 | namespace QXmpp::Omemo::Private {
13 | 
14 | signal_crypto_provider createOmemoCryptoProvider(QXmppOmemoManagerPrivate *d);
15 | }
16 | 
17 | #endif  // OMEMOCRYPTOPROVIDER_H
18 | 


--------------------------------------------------------------------------------
/src/omemo/QXmppOmemoConfig.cmake.in:
--------------------------------------------------------------------------------
 1 | # SPDX-FileCopyrightText: 2017 Niels Ole Salscheider <niels_ole@salscheider-online.de>
 2 | #
 3 | # SPDX-License-Identifier: CC0-1.0
 4 | 
 5 | @PACKAGE_INIT@
 6 | 
 7 | include(CMakeFindDependencyMacro)
 8 | find_dependency(QXmppQt@QT_VERSION_MAJOR@)
 9 | 
10 | include("${CMAKE_CURRENT_LIST_DIR}/QXmppOmemo.cmake")
11 | 
12 | check_required_components(QXmppOmemoQt@QT_VERSION_MAJOR@)
13 | 


--------------------------------------------------------------------------------
/src/omemo/QXmppOmemoDeviceBundle_p.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2021 Germán Márquez Mejía <mancho@olomono.de>
 2 | // SPDX-FileCopyrightText: 2021 Melvin Keskin <melvo@olomono.de>
 3 | //
 4 | // SPDX-License-Identifier: LGPL-2.1-or-later
 5 | 
 6 | #ifndef QXMPPOMEMODEVICEBUNDLE_H
 7 | #define QXMPPOMEMODEVICEBUNDLE_H
 8 | 
 9 | #include "QXmppGlobal.h"
10 | 
11 | #include <QHash>
12 | 
13 | class QDomElement;
14 | class QXmlStreamWriter;
15 | 
16 | class QXMPP_AUTOTEST_EXPORT QXmppOmemoDeviceBundle
17 | {
18 | public:
19 |     QByteArray publicIdentityKey() const;
20 |     void setPublicIdentityKey(const QByteArray &key);
21 | 
22 |     QByteArray signedPublicPreKey() const;
23 |     void setSignedPublicPreKey(const QByteArray &key);
24 | 
25 |     uint32_t signedPublicPreKeyId() const;
26 |     void setSignedPublicPreKeyId(uint32_t id);
27 | 
28 |     QByteArray signedPublicPreKeySignature() const;
29 |     void setSignedPublicPreKeySignature(const QByteArray &signature);
30 | 
31 |     QHash<uint32_t, QByteArray> publicPreKeys() const;
32 |     void addPublicPreKey(uint32_t id, const QByteArray &key);
33 |     void removePublicPreKey(uint32_t id);
34 | 
35 |     /// \cond
36 |     void parse(const QDomElement &element);
37 |     void toXml(QXmlStreamWriter *writer) const;
38 |     /// \endcond
39 | 
40 |     static bool isOmemoDeviceBundle(const QDomElement &element);
41 | 
42 | private:
43 |     QByteArray m_publicIdentityKey;
44 |     QByteArray m_signedPublicPreKey;
45 |     uint32_t m_signedPublicPreKeyId = 0;
46 |     QByteArray m_signedPublicPreKeySignature;
47 |     QHash<uint32_t, QByteArray> m_publicPreKeys;
48 | };
49 | 
50 | Q_DECLARE_TYPEINFO(QXmppOmemoDeviceBundle, Q_MOVABLE_TYPE);
51 | 
52 | #endif  // QXMPPOMEMODEVICEBUNDLE_H
53 | 


--------------------------------------------------------------------------------
/src/omemo/QXmppOmemoDeviceElement_p.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2021 Germán Márquez Mejía <mancho@olomono.de>
 2 | // SPDX-FileCopyrightText: 2021 Melvin Keskin <melvo@olomono.de>
 3 | //
 4 | // SPDX-License-Identifier: LGPL-2.1-or-later
 5 | 
 6 | #ifndef QXMPPOMEMODEVICEELEMENT_H
 7 | #define QXMPPOMEMODEVICEELEMENT_H
 8 | 
 9 | #include "QXmppGlobal.h"
10 | 
11 | class QDomElement;
12 | class QXmlStreamWriter;
13 | 
14 | class QXMPP_AUTOTEST_EXPORT QXmppOmemoDeviceElement
15 | {
16 | public:
17 |     bool operator==(const QXmppOmemoDeviceElement &other) const;
18 | 
19 |     uint32_t id() const;
20 |     void setId(uint32_t id);
21 | 
22 |     QString label() const;
23 |     void setLabel(const QString &label);
24 | 
25 |     /// \cond
26 |     void parse(const QDomElement &element);
27 |     void toXml(QXmlStreamWriter *writer) const;
28 |     /// \endcond
29 | 
30 |     static bool isOmemoDeviceElement(const QDomElement &element);
31 | 
32 | private:
33 |     uint32_t m_id = 0;
34 |     QString m_label;
35 | };
36 | 
37 | Q_DECLARE_TYPEINFO(QXmppOmemoDeviceElement, Q_MOVABLE_TYPE);
38 | 
39 | #endif  // QXMPPOMEMODEVICEELEMENT_H
40 | 


--------------------------------------------------------------------------------
/src/omemo/QXmppOmemoDeviceList_p.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2021 Germán Márquez Mejía <mancho@olomono.de>
 2 | // SPDX-FileCopyrightText: 2021 Melvin Keskin <melvo@olomono.de>
 3 | //
 4 | // SPDX-License-Identifier: LGPL-2.1-or-later
 5 | 
 6 | #ifndef QXMPPOMEMODEVICELIST_H
 7 | #define QXMPPOMEMODEVICELIST_H
 8 | 
 9 | #include "QXmppGlobal.h"
10 | #include "QXmppOmemoDeviceElement_p.h"
11 | 
12 | #include "QList"
13 | 
14 | class QDomElement;
15 | class QXmlStreamWriter;
16 | 
17 | class QXMPP_AUTOTEST_EXPORT QXmppOmemoDeviceList : public QList<QXmppOmemoDeviceElement>
18 | {
19 | public:
20 |     /// \cond
21 |     void parse(const QDomElement &element);
22 |     void toXml(QXmlStreamWriter *writer) const;
23 |     /// \endcond
24 | 
25 |     static bool isOmemoDeviceList(const QDomElement &element);
26 | };
27 | 
28 | Q_DECLARE_TYPEINFO(QXmppOmemoDeviceList, Q_MOVABLE_TYPE);
29 | 
30 | #endif  // QXMPPOMEMODEVICELIST_H
31 | 


--------------------------------------------------------------------------------
/src/omemo/QXmppOmemoIq_p.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Melvin Keskin <melvo@olomono.de>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPOMEMOIQ_H
 6 | #define QXMPPOMEMOIQ_H
 7 | 
 8 | #include "QXmppIq.h"
 9 | #include "QXmppOmemoElement_p.h"
10 | 
11 | class QXMPP_AUTOTEST_EXPORT QXmppOmemoIq : public QXmppIq
12 | {
13 | public:
14 |     QXmppOmemoElement omemoElement();
15 |     void setOmemoElement(const QXmppOmemoElement &omemoElement);
16 | 
17 |     /// \cond
18 |     void parseElementFromChild(const QDomElement &element) override;
19 |     void toXmlElementFromChild(QXmlStreamWriter *writer) const override;
20 |     /// \endcond
21 | 
22 |     static bool isOmemoIq(const QDomElement &element);
23 | 
24 | private:
25 |     QXmppOmemoElement m_omemoElement;
26 | };
27 | 
28 | #endif  // QXMPPOMEMOIQ_H
29 | 


--------------------------------------------------------------------------------
/src/omemo/QXmppOmemoItems_p.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Melvin Keskin <melvo@olomono.de>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPOMEMOITEMS_H
 6 | #define QXMPPOMEMOITEMS_H
 7 | 
 8 | #include "QXmppOmemoDeviceBundle_p.h"
 9 | #include "QXmppOmemoDeviceList_p.h"
10 | #include "QXmppPubSubBaseItem.h"
11 | 
12 | class QXmppOmemoDeviceBundleItem : public QXmppPubSubBaseItem
13 | {
14 | public:
15 |     QXmppOmemoDeviceBundle deviceBundle() const;
16 |     void setDeviceBundle(const QXmppOmemoDeviceBundle &deviceBundle);
17 | 
18 |     static bool isItem(const QDomElement &itemElement);
19 | 
20 | protected:
21 |     void parsePayload(const QDomElement &payloadElement) override;
22 |     void serializePayload(QXmlStreamWriter *writer) const override;
23 | 
24 | private:
25 |     QXmppOmemoDeviceBundle m_deviceBundle;
26 | };
27 | 
28 | class QXmppOmemoDeviceListItem : public QXmppPubSubBaseItem
29 | {
30 | public:
31 |     QXmppOmemoDeviceList deviceList() const;
32 |     void setDeviceList(const QXmppOmemoDeviceList &deviceList);
33 | 
34 |     static bool isItem(const QDomElement &itemElement);
35 | 
36 | protected:
37 |     void parsePayload(const QDomElement &payloadElement) override;
38 |     void serializePayload(QXmlStreamWriter *writer) const override;
39 | 
40 | private:
41 |     QXmppOmemoDeviceList m_deviceList;
42 | };
43 | 
44 | #endif  // QXMPPOMEMOITEMS_H
45 | 


--------------------------------------------------------------------------------
/src/omemo/QXmppOmemoMemoryStorage.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2022 Melvin Keskin <melvo@olomono.de>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPOMEMOMEMORYSTORAGE_H
 6 | #define QXMPPOMEMOMEMORYSTORAGE_H
 7 | 
 8 | #include "QXmppOmemoStorage.h"
 9 | #include "QXmppTask.h"
10 | #include "qxmppomemo_export.h"
11 | 
12 | #include <memory>
13 | 
14 | class QXmppOmemoMemoryStoragePrivate;
15 | 
16 | class QXMPPOMEMO_EXPORT QXmppOmemoMemoryStorage : public QXmppOmemoStorage
17 | {
18 | public:
19 |     QXmppOmemoMemoryStorage();
20 |     ~QXmppOmemoMemoryStorage() override;
21 | 
22 |     /// \cond
23 |     QXmppTask<OmemoData> allData() override;
24 | 
25 |     QXmppTask<void> setOwnDevice(const std::optional<OwnDevice> &device) override;
26 | 
27 |     QXmppTask<void> addSignedPreKeyPair(uint32_t keyId, const SignedPreKeyPair &keyPair) override;
28 |     QXmppTask<void> removeSignedPreKeyPair(uint32_t keyId) override;
29 | 
30 |     QXmppTask<void> addPreKeyPairs(const QHash<uint32_t, QByteArray> &keyPairs) override;
31 |     QXmppTask<void> removePreKeyPair(uint32_t keyId) override;
32 | 
33 |     QXmppTask<void> addDevice(const QString &jid, uint32_t deviceId, const Device &device) override;
34 |     QXmppTask<void> removeDevice(const QString &jid, uint32_t deviceId) override;
35 |     QXmppTask<void> removeDevices(const QString &jid) override;
36 | 
37 |     QXmppTask<void> resetAll() override;
38 |     /// \endcond
39 | 
40 | private:
41 |     std::unique_ptr<QXmppOmemoMemoryStoragePrivate> d;
42 | };
43 | 
44 | #endif  // QXMPPOMEMOMEMORYSTORAGE_H
45 | 


--------------------------------------------------------------------------------
/src/omemo/README.md:
--------------------------------------------------------------------------------
 1 | <!--
 2 | SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
 3 | 
 4 | SPDX-License-Identifier: CC0-1.0
 5 | -->
 6 | 
 7 | QXmpp OMEMO module
 8 | ==================
 9 | 
10 | The QXmpp OMEMO module adds support for OMEMO (v0.8+) end-to-end encryption by
11 | providing the `QXmppOmemoManager`.
12 | 
13 | Dependencies
14 | ------------
15 | 
16 |  * [QCA (Qt Cryptographic Architecture)](https://invent.kde.org/libraries/qca)
17 |  * [libomemo-c](https://github.com/dino/libomemo-c) (built with `-DBUILD_SHARED_LIBS=ON`)
18 | 
19 | Building
20 | --------
21 | 
22 | By default QXmpp is built without the OMEMO module. To enable it you need to
23 | provide `-DBUILD_OMEMO=ON` to cmake:
24 | 
25 |     cmake <qxmpp folder> -DBUILD_OMEMO=ON
26 | 
27 | Usage
28 | -----
29 | 
30 | QXmpp OMEMO is available as a CMake module. You can use it like this:
31 | 
32 | ```cmake
33 | find_package(QXmpp COMPONENTS Omemo)
34 | target_link_libraries(${PROJECT} PRIVATE QXmpp::QXmpp QXmpp::Omemo)
35 | ```
36 | 
37 | How to use the OMEMO Manager is explained in the code documentation.
38 | 
39 | Licensing issues
40 | ----------------
41 | 
42 | QXmppOmemo itself is (like the core) licensed under LGPL-2.1-or-later. However,
43 | as of today it is linking to `libomemo-c` which uses GPL-3.0. *This means that
44 | the resulting binaries must be used under the terms of the **GPL-3.0**.*
45 | 
46 | We might move to a different, more permissive OMEMO library in the future and
47 | in that case no relicensing would be necessary.
48 | 
49 | 


--------------------------------------------------------------------------------
/src/server/QXmppDialback.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPDIALBACK_H
 6 | #define QXMPPDIALBACK_H
 7 | 
 8 | #include "QXmppStanza.h"
 9 | 
10 | /// \brief The QXmppDialback class represents a stanza used for the Server
11 | /// Dialback protocol as specified by \xep{0220}: Server Dialback.
12 | ///
13 | /// \ingroup Stanzas
14 | 
15 | class QXMPP_EXPORT QXmppDialback : public QXmppStanza
16 | {
17 | public:
18 |     /// This enum is used to describe a dialback command.
19 |     enum Command {
20 |         Result,  ///< A dialback command between the originating server
21 |                  ///< and the receiving server.
22 |         Verify   ///< A dialback command between the receiving server
23 |                  ///< and the authoritative server.
24 |     };
25 | 
26 |     QXmppDialback();
27 | 
28 |     Command command() const;
29 |     void setCommand(Command command);
30 | 
31 |     QString key() const;
32 |     void setKey(const QString &key);
33 | 
34 |     QString type() const;
35 |     void setType(const QString &type);
36 | 
37 |     /// \cond
38 |     void parse(const QDomElement &element) override;
39 |     void toXml(QXmlStreamWriter *writer) const override;
40 | 
41 |     static bool isDialback(const QDomElement &element);
42 |     /// \endcond
43 | 
44 | private:
45 |     Command m_command;
46 |     QString m_key;
47 |     QString m_type;
48 | };
49 | 
50 | #endif
51 | 


--------------------------------------------------------------------------------
/src/server/QXmppIncomingClient.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPINCOMINGCLIENT_H
 6 | #define QXMPPINCOMINGCLIENT_H
 7 | 
 8 | #include "QXmppLogger.h"
 9 | 
10 | #include <memory>
11 | 
12 | class QDomElement;
13 | class QSslSocket;
14 | class QXmppNonza;
15 | class QXmppIncomingClientPrivate;
16 | class QXmppPasswordChecker;
17 | 
18 | ///
19 | /// \brief The QXmppIncomingClient class represents an incoming XMPP stream
20 | /// from an XMPP client.
21 | ///
22 | class QXMPP_EXPORT QXmppIncomingClient : public QXmppLoggable
23 | {
24 |     Q_OBJECT
25 | public:
26 |     QXmppIncomingClient(QSslSocket *socket, const QString &domain, QObject *parent = nullptr);
27 |     ~QXmppIncomingClient() override;
28 | 
29 |     bool isConnected() const;
30 |     QString jid() const;
31 | 
32 |     bool sendPacket(const QXmppNonza &);
33 |     Q_SLOT bool sendData(const QByteArray &);
34 |     void disconnectFromHost();
35 | 
36 |     void setInactivityTimeout(int secs);
37 |     void setPasswordChecker(QXmppPasswordChecker *checker);
38 | 
39 |     /// This signal is emitted when an element is received.
40 |     Q_SIGNAL void elementReceived(const QDomElement &element);
41 | 
42 |     /// This signal is emitted when the stream is connected.
43 |     Q_SIGNAL void connected();
44 | 
45 |     /// This signal is emitted when the stream is disconnected.
46 |     Q_SIGNAL void disconnected();
47 | 
48 | protected:
49 |     /// \cond
50 |     void handleStart();
51 |     void handleStream(const QDomElement &element);
52 |     void handleStanza(const QDomElement &element);
53 |     /// \endcond
54 | 
55 | private Q_SLOTS:
56 |     void onDigestReply();
57 |     void onPasswordReply();
58 |     void onSocketDisconnected();
59 |     void onTimeout();
60 | 
61 | private:
62 |     void onSasl2Authenticated();
63 |     void sendStreamFeatures();
64 | 
65 |     const std::unique_ptr<QXmppIncomingClientPrivate> d;
66 |     friend class QXmppIncomingClientPrivate;
67 | };
68 | 
69 | #endif
70 | 


--------------------------------------------------------------------------------
/src/server/QXmppIncomingServer.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPINCOMINGSERVER_H
 6 | #define QXMPPINCOMINGSERVER_H
 7 | 
 8 | #include "QXmppLogger.h"
 9 | 
10 | #include <memory>
11 | 
12 | class QDomElement;
13 | class QSslSocket;
14 | class QXmppDialback;
15 | class QXmppIncomingServerPrivate;
16 | class QXmppNonza;
17 | 
18 | ///
19 | /// \brief The QXmppIncomingServer class represents an incoming XMPP stream
20 | /// from an XMPP server.
21 | ///
22 | class QXMPP_EXPORT QXmppIncomingServer : public QXmppLoggable
23 | {
24 |     Q_OBJECT
25 | 
26 | public:
27 |     QXmppIncomingServer(QSslSocket *socket, const QString &domain, QObject *parent);
28 |     ~QXmppIncomingServer() override;
29 | 
30 |     bool isConnected() const;
31 |     void disconnectFromHost();
32 | 
33 |     QString localStreamId() const;
34 | 
35 |     bool sendPacket(const QXmppNonza &);
36 |     Q_SLOT bool sendData(const QByteArray &);
37 | 
38 |     /// This signal is emitted when the stream is connected.
39 |     Q_SIGNAL void connected();
40 |     /// This signal is emitted when the stream is disconnected.
41 |     Q_SIGNAL void disconnected();
42 |     /// This signal is emitted when a dialback verify request is received.
43 |     Q_SIGNAL void dialbackRequestReceived(const QXmppDialback &result);
44 |     /// This signal is emitted when an element is received.
45 |     Q_SIGNAL void elementReceived(const QDomElement &element);
46 | 
47 | private:
48 |     void handleStart();
49 |     void handleStanza(const QDomElement &element);
50 |     void handleStream(const QDomElement &element);
51 | 
52 |     void slotDialbackResponseReceived(const QXmppDialback &dialback);
53 |     void slotSocketDisconnected();
54 | 
55 |     const std::unique_ptr<QXmppIncomingServerPrivate> d;
56 |     friend class QXmppIncomingServerPrivate;
57 | };
58 | 
59 | #endif
60 | 


--------------------------------------------------------------------------------
/src/server/QXmppServerExtension.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPSERVEREXTENSION_H
 6 | #define QXMPPSERVEREXTENSION_H
 7 | 
 8 | #include "QXmppLogger.h"
 9 | 
10 | #include <QVariant>
11 | 
12 | class QDomElement;
13 | 
14 | class QXmppServer;
15 | class QXmppServerExtensionPrivate;
16 | 
17 | ///
18 | /// \brief The QXmppServerExtension class is the base class for QXmppServer
19 | /// extensions.
20 | ///
21 | /// If you want to extend QXmppServer, for instance to support an IQ type
22 | /// which is not natively supported, you can subclass QXmppServerExtension
23 | /// and implement handleStanza(). You can then add your extension to the
24 | /// client instance using QXmppServer::addExtension().
25 | ///
26 | /// \ingroup Core
27 | ///
28 | class QXMPP_EXPORT QXmppServerExtension : public QXmppLoggable
29 | {
30 |     Q_OBJECT
31 | 
32 | public:
33 |     QXmppServerExtension();
34 |     ~QXmppServerExtension() override;
35 |     virtual QString extensionName() const;
36 |     virtual int extensionPriority() const;
37 | 
38 |     virtual QStringList discoveryFeatures() const;
39 |     virtual QStringList discoveryItems() const;
40 |     virtual bool handleStanza(const QDomElement &stanza);
41 |     virtual QSet<QString> presenceSubscribers(const QString &jid);
42 |     virtual QSet<QString> presenceSubscriptions(const QString &jid);
43 | 
44 |     virtual bool start();
45 |     virtual void stop();
46 | 
47 | protected:
48 |     QXmppServer *server() const;
49 | 
50 | private:
51 |     void setServer(QXmppServer *server);
52 |     const std::unique_ptr<QXmppServerExtensionPrivate> d;
53 | 
54 |     friend class QXmppServer;
55 | };
56 | 
57 | #endif
58 | 


--------------------------------------------------------------------------------
/src/server/QXmppServerPlugin.cpp:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2017 Niels Ole Salscheider <niels_ole@salscheider-online.de>
2 | //
3 | // SPDX-License-Identifier: LGPL-2.1-or-later
4 | 
5 | #include "QXmppServerPlugin.h"
6 | 


--------------------------------------------------------------------------------
/src/server/QXmppServerPlugin.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef QXMPPSERVERPLUGIN_H
 6 | #define QXMPPSERVERPLUGIN_H
 7 | 
 8 | #include "QXmppGlobal.h"
 9 | 
10 | #include <QtPlugin>
11 | 
12 | class QXmppServer;
13 | class QXmppServerExtension;
14 | 
15 | class QXMPP_EXPORT QXmppServerPluginInterface
16 | {
17 | public:
18 |     /// Creates the server extension identified by \a key.
19 |     virtual QXmppServerExtension *create(const QString &key) = 0;
20 | 
21 |     /// Returns a list of valid extension keys.
22 |     virtual QStringList keys() const = 0;
23 | };
24 | 
25 | Q_DECLARE_INTERFACE(QXmppServerPluginInterface, "com.googlecode.qxmpp.ServerPlugin/1.0")
26 | 
27 | /// \brief The QXmppServerPlugin class is the base class for QXmppServer plugins.
28 | ///
29 | 
30 | class QXMPP_EXPORT QXmppServerPlugin : public QObject, public QXmppServerPluginInterface
31 | {
32 |     Q_OBJECT
33 |     Q_INTERFACES(QXmppServerPluginInterface)
34 | 
35 | public:
36 |     /// Creates and returns the specified QXmppServerExtension.
37 |     ///
38 |     /// \param key The key for the QXmppServerExtension.
39 |     QXmppServerExtension *create(const QString &key) override = 0;
40 | 
41 |     /// Returns the list of keys supported by this plugin.
42 |     ///
43 |     QStringList keys() const override = 0;
44 | };
45 | 
46 | #endif
47 | 


--------------------------------------------------------------------------------
/tests/IntegrationTesting.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2021 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef INTEGRATIONTESTING_H
 6 | #define INTEGRATIONTESTING_H
 7 | 
 8 | #include "QXmppConfiguration.h"
 9 | 
10 | #include <QDebug>
11 | #include <QtGlobal>
12 | 
13 | #define ENV_ENABLED "QXMPP_TESTS_INTEGRATION_ENABLED"
14 | #define ENV_JID "QXMPP_TESTS_JID"
15 | #define ENV_PASSWORD "QXMPP_TESTS_PASSWORD"
16 | 
17 | #define SKIP_IF_INTEGRATION_TESTS_DISABLED()                            \
18 |     if (!IntegrationTests::enabled()) {                                 \
19 |         QSKIP("Export 'QXMPP_TESTS_INTEGRATION_ENABLED=1' to enable."); \
20 |     } else if (!IntegrationTests::credentialsAvailable()) {             \
21 |         QFAIL("No credentials for integration tests provided! "         \
22 |               "Export 'QXMPP_TESTS_JID' and 'QXMPP_TESTS_PASSWORD'.");  \
23 |     }
24 | 
25 | class IntegrationTests
26 | {
27 | public:
28 |     static QString environmentVariable(const char *varName, const QString &defaultValue = {})
29 |     {
30 |         return qEnvironmentVariable(varName, defaultValue);
31 |     }
32 | 
33 |     static bool enabled()
34 |     {
35 |         return environmentVariable(ENV_ENABLED, "0") == "1";
36 |     }
37 | 
38 |     static bool credentialsAvailable()
39 |     {
40 |         return !qEnvironmentVariableIsEmpty(ENV_JID) && !qEnvironmentVariableIsEmpty(ENV_PASSWORD);
41 |     }
42 | 
43 |     static QXmppConfiguration clientConfiguration()
44 |     {
45 |         QXmppConfiguration config;
46 |         config.setJid(environmentVariable(ENV_JID));
47 |         config.setPassword(environmentVariable(ENV_PASSWORD));
48 |         return config;
49 |     }
50 | };
51 | 
52 | #undef ENV_ENABLED
53 | #undef ENV_JID
54 | #undef ENV_PASSWORD
55 | 
56 | #endif  // INTEGRATIONTESTING_H
57 | 


--------------------------------------------------------------------------------
/tests/pubsubutil.h:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2020 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #ifndef PUBSUBUTIL_H
 6 | #define PUBSUBUTIL_H
 7 | 
 8 | #include "QXmppPubSubBaseItem.h"
 9 | 
10 | #include <QDomElement>
11 | #include <QXmlStreamWriter>
12 | #include <QtTest/QTest>
13 | 
14 | class TestItem : public QXmppPubSubBaseItem
15 | {
16 | public:
17 |     TestItem(const QString &id = {})
18 |         : QXmppPubSubBaseItem(id)
19 |     {
20 |     }
21 | 
22 |     void parsePayload(const QDomElement &payloadElement) override
23 |     {
24 |         parseCalled = true;
25 |         QCOMPARE(payloadElement.tagName(), QStringLiteral("test-payload"));
26 |     }
27 | 
28 |     void serializePayload(QXmlStreamWriter *writer) const override
29 |     {
30 |         serializeCalled = true;
31 |         writer->writeEmptyElement("test-payload");
32 |     }
33 | 
34 |     static bool isItem(const QDomElement &element)
35 |     {
36 |         isItemCalled = true;
37 |         return QXmppPubSubBaseItem::isItem(element, [](const QDomElement &payload) {
38 |             return payload.tagName() == "test-payload";
39 |         });
40 |     }
41 | 
42 |     bool parseCalled = false;
43 |     mutable bool serializeCalled = false;
44 |     static bool isItemCalled;
45 | };
46 | 
47 | bool TestItem::isItemCalled = false;
48 | 
49 | #endif  // PUBSUBUTIL_H
50 | 


--------------------------------------------------------------------------------
/tests/qxmpphttpuploadmanager/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | # SPDX-FileCopyrightText: 2019 Yury Gubich <blue@macaw.me>
2 | #
3 | # SPDX-License-Identifier: CC0-1.0
4 | 
5 | include_directories(${CMAKE_CURRENT_BINARY_DIR})
6 | add_executable(tst_qxmpphttpuploadmanager tst_qxmpphttpuploadmanager.cpp tst_qxmpphttpuploadmanager.qrc ../TestClient.h)
7 | add_test(tst_qxmpphttpuploadmanager tst_qxmpphttpuploadmanager)
8 | target_link_libraries(tst_qxmpphttpuploadmanager Qt${QT_VERSION_MAJOR}::Test ${QXMPP_TARGET})
9 | 


--------------------------------------------------------------------------------
/tests/qxmpphttpuploadmanager/test.svg.license:
--------------------------------------------------------------------------------
1 | SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
2 | 
3 | SPDX-License-Identifier: CC0-1.0
4 | 


--------------------------------------------------------------------------------
/tests/qxmpphttpuploadmanager/tst_qxmpphttpuploadmanager.qrc:
--------------------------------------------------------------------------------
 1 | <!--
 2 | SPDX-FileCopyrightText: 2019 Yury Gubich <blue@macaw.me>
 3 | 
 4 | SPDX-License-Identifier: CC0-1.0
 5 | -->
 6 | 
 7 | <!DOCTYPE RCC><RCC version="1.0">
 8 | <qresource>
 9 |     <file>test.svg</file>
10 | </qresource>
11 | </RCC>
12 | 


--------------------------------------------------------------------------------
/tests/qxmppiq/tst_qxmppiq.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2012 Jeremy Lainé <jeremy.laine@m4x.org>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #include "QXmppIq.h"
 6 | 
 7 | #include "util.h"
 8 | 
 9 | #include <QObject>
10 | 
11 | class tst_QXmppIq : public QObject
12 | {
13 |     Q_OBJECT
14 | 
15 | private:
16 |     Q_SLOT void testBasic_data();
17 |     Q_SLOT void testBasic();
18 | };
19 | 
20 | void tst_QXmppIq::testBasic_data()
21 | {
22 |     QTest::addColumn<QByteArray>("xml");
23 |     QTest::addColumn<int>("type");
24 | 
25 |     QTest::newRow("get")
26 |         << QByteArray(R"(<iq to="foo@example.com/QXmpp" from="bar@example.com/QXmpp" type="get"/>)")
27 |         << int(QXmppIq::Get);
28 | 
29 |     QTest::newRow("set")
30 |         << QByteArray(R"(<iq to="foo@example.com/QXmpp" from="bar@example.com/QXmpp" type="set"/>)")
31 |         << int(QXmppIq::Set);
32 | 
33 |     QTest::newRow("result")
34 |         << QByteArray(R"(<iq to="foo@example.com/QXmpp" from="bar@example.com/QXmpp" type="result"/>)")
35 |         << int(QXmppIq::Result);
36 | 
37 |     QTest::newRow("error")
38 |         << QByteArray(R"(<iq to="foo@example.com/QXmpp" from="bar@example.com/QXmpp" type="error"/>)")
39 |         << int(QXmppIq::Error);
40 | }
41 | 
42 | void tst_QXmppIq::testBasic()
43 | {
44 |     QFETCH(QByteArray, xml);
45 |     QFETCH(int, type);
46 | 
47 |     QXmppIq iq;
48 |     parsePacket(iq, xml);
49 |     QCOMPARE(iq.to(), u"foo@example.com/QXmpp"_s);
50 |     QCOMPARE(iq.from(), u"bar@example.com/QXmpp"_s);
51 |     QCOMPARE(int(iq.type()), type);
52 |     serializePacket(iq, xml);
53 | }
54 | 
55 | QTEST_MAIN(tst_QXmppIq)
56 | #include "tst_qxmppiq.moc"
57 | 


--------------------------------------------------------------------------------
/tests/qxmpppubsubforms/tst_qxmpppubsubforms.cpp:
--------------------------------------------------------------------------------
 1 | // SPDX-FileCopyrightText: 2020 Linus Jahn <lnj@kaidan.im>
 2 | //
 3 | // SPDX-License-Identifier: LGPL-2.1-or-later
 4 | 
 5 | #include "QXmppDataFormBase.h"
 6 | #include "QXmppPubSubSubAuthorization.h"
 7 | 
 8 | #include "util.h"
 9 | 
10 | #include <QObject>
11 | 
12 | class tst_QXmppPubSubForms : public QObject
13 | {
14 |     Q_OBJECT
15 | 
16 | private:
17 |     Q_SLOT void subAuthorization();
18 | };
19 | 
20 | void tst_QXmppPubSubForms::subAuthorization()
21 | {
22 |     QByteArray xml(R"(
23 | <x xmlns="jabber:x:data" type="form">
24 | <field type="hidden" var="FORM_TYPE">
25 | <value>http://jabber.org/protocol/pubsub#subscribe_authorization</value>
26 | </field>
27 | <field type="boolean" var="pubsub#allow"><value>0</value></field>
28 | <field type="text-single" var="pubsub#node"><value>princely_musings</value></field>
29 | <field type="text-single" var="pubsub#subid"><value>123-abc</value></field>
30 | <field type="jid-single" var="pubsub#subscriber_jid"><value>horatio@denmark.lit</value></field>
31 | </x>)");
32 | 
33 |     QXmppDataForm form;
34 |     parsePacket(form, xml);
35 | 
36 |     auto subAuthForm = QXmppPubSubSubAuthorization::fromDataForm(form);
37 |     QVERIFY(subAuthForm.has_value());
38 |     QCOMPARE(subAuthForm->subid(), u"123-abc"_s);
39 |     QCOMPARE(subAuthForm->node(), u"princely_musings"_s);
40 |     QCOMPARE(subAuthForm->subscriberJid(), u"horatio@denmark.lit"_s);
41 |     QVERIFY(subAuthForm->allowSubscription().has_value());
42 |     QCOMPARE(subAuthForm->allowSubscription().value(), false);
43 | 
44 |     form = subAuthForm->toDataForm();
45 |     QVERIFY(!form.isNull());
46 |     xml = QString::fromUtf8(xml).remove(QChar('\n')).toUtf8();
47 |     serializePacket(form, xml);
48 | }
49 | 
50 | QTEST_MAIN(tst_QXmppPubSubForms)
51 | #include "tst_qxmpppubsubforms.moc"
52 | 


--------------------------------------------------------------------------------
/tests/qxmppstream/cd:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qxmpp-project/qxmpp/8476ee8e9edae40e909d01d85f25c7239a6b30d4/tests/qxmppstream/cd


--------------------------------------------------------------------------------
/tests/qxmpptransfermanager/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | # SPDX-FileCopyrightText: 2017 Niels Ole Salscheider <niels_ole@salscheider-online.de>
2 | #
3 | # SPDX-License-Identifier: CC0-1.0
4 | 
5 | include_directories(${CMAKE_CURRENT_BINARY_DIR})
6 | add_executable(tst_qxmpptransfermanager tst_qxmpptransfermanager.cpp tst_qxmpptransfermanager.qrc)
7 | add_test(tst_qxmpptransfermanager tst_qxmpptransfermanager)
8 | target_link_libraries(tst_qxmpptransfermanager Qt${QT_VERSION_MAJOR}::Test ${QXMPP_TARGET})
9 | 


--------------------------------------------------------------------------------
/tests/qxmpptransfermanager/test.svg.license:
--------------------------------------------------------------------------------
1 | SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
2 | 
3 | SPDX-License-Identifier: CC0-1.0
4 | 


--------------------------------------------------------------------------------
/tests/qxmpptransfermanager/tst_qxmpptransfermanager.qrc:
--------------------------------------------------------------------------------
 1 | <!--
 2 | SPDX-FileCopyrightText: 2015 Jeremy Lainé <jeremy.laine@m4x.org>
 3 | 
 4 | SPDX-License-Identifier: CC0-1.0
 5 | -->
 6 | 
 7 | <!DOCTYPE RCC><RCC version="1.0">
 8 | <qresource>
 9 |     <file>test.svg</file>
10 | </qresource>
11 | </RCC>
12 | 


--------------------------------------------------------------------------------
/tests/qxmpputils/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | # SPDX-FileCopyrightText: 2017 Niels Ole Salscheider <niels_ole@salscheider-online.de>
2 | #
3 | # SPDX-License-Identifier: CC0-1.0
4 | 
5 | include_directories(${CMAKE_CURRENT_BINARY_DIR})
6 | add_executable(tst_qxmpputils tst_qxmpputils.cpp tst_qxmpputils.qrc)
7 | add_test(tst_qxmpputils tst_qxmpputils)
8 | target_link_libraries(tst_qxmpputils Qt${QT_VERSION_MAJOR}::Test ${QXMPP_TARGET})
9 | 


--------------------------------------------------------------------------------
/tests/qxmpputils/test.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qxmpp-project/qxmpp/8476ee8e9edae40e909d01d85f25c7239a6b30d4/tests/qxmpputils/test.bmp


--------------------------------------------------------------------------------
/tests/qxmpputils/test.bmp.license:
--------------------------------------------------------------------------------
1 | SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
2 | 
3 | SPDX-License-Identifier: CC0-1.0


--------------------------------------------------------------------------------
/tests/qxmpputils/test.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qxmpp-project/qxmpp/8476ee8e9edae40e909d01d85f25c7239a6b30d4/tests/qxmpputils/test.gif


--------------------------------------------------------------------------------
/tests/qxmpputils/test.gif.license:
--------------------------------------------------------------------------------
1 | SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
2 | 
3 | SPDX-License-Identifier: CC0-1.0


--------------------------------------------------------------------------------
/tests/qxmpputils/test.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qxmpp-project/qxmpp/8476ee8e9edae40e909d01d85f25c7239a6b30d4/tests/qxmpputils/test.jpg


--------------------------------------------------------------------------------
/tests/qxmpputils/test.jpg.license:
--------------------------------------------------------------------------------
1 | SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
2 | 
3 | SPDX-License-Identifier: CC0-1.0


--------------------------------------------------------------------------------
/tests/qxmpputils/test.mng:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qxmpp-project/qxmpp/8476ee8e9edae40e909d01d85f25c7239a6b30d4/tests/qxmpputils/test.mng


--------------------------------------------------------------------------------
/tests/qxmpputils/test.mng.license:
--------------------------------------------------------------------------------
1 | SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
2 | 
3 | SPDX-License-Identifier: CC0-1.0


--------------------------------------------------------------------------------
/tests/qxmpputils/test.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qxmpp-project/qxmpp/8476ee8e9edae40e909d01d85f25c7239a6b30d4/tests/qxmpputils/test.png


--------------------------------------------------------------------------------
/tests/qxmpputils/test.png.license:
--------------------------------------------------------------------------------
1 | SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
2 | 
3 | SPDX-License-Identifier: CC0-1.0


--------------------------------------------------------------------------------
/tests/qxmpputils/test.svg.license:
--------------------------------------------------------------------------------
1 | SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
2 | 
3 | SPDX-License-Identifier: CC0-1.0


--------------------------------------------------------------------------------
/tests/qxmpputils/test.xpm:
--------------------------------------------------------------------------------
 1 | /* XPM */
 2 | static char * test_xpm[] = {
 3 | "6 6 3 1",
 4 | " 	c #FF0000",
 5 | ".	c #00FF00",
 6 | "+	c #0000FF",
 7 | "  ..++",
 8 | "  ..++",
 9 | "  ..++",
10 | "  ..++",
11 | "  ..++",
12 | "  ..++"};
13 | 


--------------------------------------------------------------------------------
/tests/qxmpputils/test.xpm.license:
--------------------------------------------------------------------------------
1 | SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
2 | 
3 | SPDX-License-Identifier: CC0-1.0


--------------------------------------------------------------------------------
/tests/qxmpputils/tst_qxmpputils.qrc:
--------------------------------------------------------------------------------
 1 | <!--
 2 | SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
 3 | 
 4 | SPDX-License-Identifier: CC0-1.0
 5 | -->
 6 | 
 7 | <!DOCTYPE RCC><RCC version="1.0">
 8 | <qresource>
 9 |     <file>test.bmp</file>
10 |     <file>test.gif</file>
11 |     <file>test.jpg</file>
12 |     <file>test.mng</file>
13 |     <file>test.png</file>
14 |     <file>test.svg</file>
15 |     <file>test.xpm</file>
16 | </qresource>
17 | </RCC>
18 | 


--------------------------------------------------------------------------------
/tests/travis/build-and-test:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # SPDX-FileCopyrightText: 2014 Boris Pek <tehnick-8@yandex.ru>
 4 | # SPDX-FileCopyrightText: 2014 Jeremy Lainé <jeremy.laine@m4x.org>
 5 | #
 6 | # SPDX-License-Identifier: CC0-1.0
 7 | 
 8 | set -e
 9 | 
10 | HOST_SYSTEM=$(uname -s)
11 | CMAKE_ARGS="-DBUILD_TESTS:BOOL=True"
12 | 
13 | case "$CONFIG" in
14 | full*)
15 |     CMAKE_ARGS="-DBUILD_DOCUMENTATION:BOOL=True -DBUILD_EXAMPLES:BOOL=True -DWITH_GSTREAMER:BOOL=True"
16 | 
17 |     # Enable OMEMO
18 |     if [ $HOST_SYSTEM = "Linux" ]; then
19 |         CMAKE_ARGS="$CMAKE_ARGS -DBUILD_OMEMO=ON"
20 |     fi
21 |     ;;
22 | *debug*)
23 |     CMAKE_ARGS="$CMAKE_ARGS -DCMAKE_BUILD_TYPE:STRING=Debug -DBUILD_INTERNAL_TESTS:BOOL=True"
24 |     ;;
25 | esac
26 | 
27 | # build with code coverage
28 | if [ "$CONFIG" = "full-debug" ]; then
29 |     export CXXFLAGS="-fprofile-arcs -ftest-coverage"
30 | fi
31 | 
32 | # Skip currently broken call manager test on macOS
33 | if [ $HOST_SYSTEM = "Darwin" ]; then
34 |     export QXMPP_TESTS_SKIP_CALL_MANAGER=1
35 | fi
36 | 
37 | # compile
38 | mkdir build
39 | cd build
40 | cmake .. $CMAKE_ARGS
41 | 
42 | if [ $HOST_SYSTEM = "Darwin" ]; then
43 |     make -k -j$(sysctl -n hw.logicalcpu)
44 | else
45 |     make -k -j$(nproc)
46 | fi
47 | 
48 | # run tests
49 | make test ARGS="--rerun-failed --output-on-failure"
50 | 


--------------------------------------------------------------------------------
/tests/travis/build-documentation:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # SPDX-FileCopyrightText: 2024 Linus Jahn <lnj@kaidan.im>
 4 | #
 5 | # SPDX-License-Identifier: CC0-1.0
 6 | 
 7 | set -e
 8 | 
 9 | # Make warnings errors
10 | echo "WARN_AS_ERROR = FAIL_ON_WARNINGS" >> doc/Doxyfile.in
11 | 
12 | mkdir build
13 | cd build
14 | cmake .. -DBUILD_DOCUMENTATION=ON
15 | 
16 | make doc
17 | 


--------------------------------------------------------------------------------
/tests/travis/install-build-depends-debian:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # SPDX-FileCopyrightText: 2014 Boris Pek <tehnick-8@yandex.ru>
 4 | # SPDX-FileCopyrightText: 2018 Jeremy Lainé <jeremy.laine@m4x.org>
 5 | #
 6 | # SPDX-License-Identifier: CC0-1.0
 7 | 
 8 | set -e
 9 | 
10 | install_cmake() {
11 |     NAME=$1
12 |     URL=$2
13 |     OPTS=$3
14 |     CURRENT_DIR=$(pwd)
15 | 
16 |     cd
17 |     git clone $URL $NAME
18 |     mkdir -p $NAME-build
19 |     cmake $NAME -B./$NAME-build/ -DCMAKE_INSTALL_PREFIX="/usr/local" -DCMAKE_BUILD_TYPE=Release $OPTS
20 |     cmake --build $NAME-build --parallel
21 |     sudo cmake --build $NAME-build --target install
22 | 
23 |     cd $CURRENT_DIR
24 | }
25 | 
26 | # Used for QCA cmake options
27 | case "$QT_VERSION" in
28 | 6*)
29 |     BUILD_WITH_QT6="ON"
30 |     ;;
31 | 5*)
32 |     BUILD_WITH_QT6="OFF"
33 |     ;;
34 | esac
35 | 
36 | # install base tools
37 | sudo apt-get update -qq
38 | sudo apt-get install -qq clang cmake git curl
39 | 
40 | # install extra dependencies
41 | case "$CONFIG" in
42 | full*)
43 |     sudo apt-get install -qq \
44 |         doxygen graphviz \
45 |         libgstreamer1.0-dev gstreamer1.0-plugins-base gstreamer1.0-plugins-good gstreamer1.0-plugins-ugly \
46 |         libprotobuf-c-dev \
47 |         libssl-dev
48 | 
49 |     # Build and install qca and libomemo-c
50 |     install_cmake libomemo-c https://github.com/dino/libomemo-c "-DBUILD_SHARED_LIBS=ON"
51 |     install_cmake qca https://invent.kde.org/libraries/qca "-DBUILD_TESTS=OFF -DBUILD_TOOLS=OFF -DBUILD_WITH_QT6=${BUILD_WITH_QT6}"
52 |     ;;
53 | esac
54 | 


--------------------------------------------------------------------------------
/tests/travis/install-build-depends-macos:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # SPDX-FileCopyrightText: 2014 Boris Pek <tehnick-8@yandex.ru>
 4 | # SPDX-FileCopyrightText: 2018 Jeremy Lainé <jeremy.laine@m4x.org>
 5 | #
 6 | # SPDX-License-Identifier: CC0-1.0
 7 | 
 8 | set -e
 9 | 
10 | brew update
11 | 
12 | case "$CONFIG" in
13 | full*)
14 |     brew install --overwrite doxygen \
15 |         gstreamer gst-plugins-base gst-plugins-good gst-plugins-ugly || true
16 |     ;;
17 | esac
18 | 


--------------------------------------------------------------------------------
/tests/travis/push-documentation:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # SPDX-FileCopyrightText: 2020 Linus Jahn <lnj@kaidan.im>
 4 | #
 5 | # SPDX-License-Identifier: CC0-1.0
 6 | 
 7 | # Add ssh push key
 8 | eval "$(ssh-agent -s)"
 9 | echo $PUSH_KEY_REPO_DOC_QXMPP_ORG | base64 -d | unxz | ssh-add -
10 | 
11 | # Set up git
12 | git config --global user.email "docsbot@qxmpp.org"
13 | git config --global user.name "QXmpp Docs Bot"
14 | 
15 | #
16 | # Build documentation
17 | #
18 | 
19 | echo '-------------------------------------------'
20 | echo 'Building documentation'
21 | echo '-------------------------------------------'
22 | 
23 | mkdir build
24 | cd build
25 | 
26 | cmake .. -DBUILD_DOCUMENTATION=ON
27 | 
28 | make doc
29 | 
30 | #
31 | # Push documentation
32 | #
33 | 
34 | echo '-------------------------------------------'
35 | echo 'Cloning doc.qxmpp.org repository'
36 | echo '-------------------------------------------'
37 | 
38 | export GIT_SSH_COMMAND="ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no"
39 | git clone ssh://git@github.com/qxmpp-project/doc.qxmpp.org
40 | 
41 | echo '-------------------------------------------'
42 | echo 'Commiting and pushing documentation'
43 | echo '-------------------------------------------'
44 | 
45 | # delete old dev docs
46 | rm -rf doc.qxmpp.org/qxmpp-dev
47 | cp -r doc/html doc.qxmpp.org/qxmpp-dev
48 | 
49 | git -C doc.qxmpp.org add .
50 | git -C doc.qxmpp.org commit -m "Add documentation for QXmpp master"
51 | git -C doc.qxmpp.org push
52 | 
53 | 


--------------------------------------------------------------------------------
/utils/pre-commit.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh -e
 2 | 
 3 | # SPDX-FileCopyrightText: 2023 Melvin Keskin <melvo@olomono.de>
 4 | #
 5 | # SPDX-License-Identifier: CC0-1.0
 6 | 
 7 | # This script runs all Git pre-commit hook scripts.
 8 | 
 9 | git-clang-format
10 | 


--------------------------------------------------------------------------------
/utils/render-graphics.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # SPDX-FileCopyrightText: 2023 Melvin Keskin <melvo@olomono.de>
 4 | #
 5 | # SPDX-License-Identifier: LGPL-2.1-or-later
 6 | 
 7 | QXMPP_SOURCES=$(dirname "$(readlink -f "${0}")")/..
 8 | 
 9 | echo "*****************************************"
10 | echo "Rendering graphics"
11 | echo "*****************************************"
12 | 
13 | render_support_chat_avatar() {
14 |     render_svg_with_margin $QXMPP_SOURCES/logo.svg $QXMPP_SOURCES/support-chat-avatar.png 300 300 18
15 | }
16 | 
17 | # $1 - $4: see render_svg()
18 | # $5: margin
19 | render_svg_with_margin() {
20 |     output_directory=$(dirname $2)
21 |     mkdir -p $output_directory
22 |     tmp_file=$output_directory/rendered_tmp.svg
23 |     inkscape -o $tmp_file --export-margin=$5 $1
24 |     render_svg $tmp_file $2 $3 $4
25 |     rm $tmp_file
26 | }
27 | 
28 | # $1: input file
29 | # $2: output file
30 | # $3: width
31 | # $4: height
32 | render_svg() {
33 |     inkscape -o $2 -w $3 -h $4 $1 >/dev/null
34 |     optipng -quiet -o7 $2 >/dev/null
35 |     advpng -z4 $2 >/dev/null
36 |     echo "Created "$2
37 | }
38 | 
39 | render_support_chat_avatar
40 | 


--------------------------------------------------------------------------------
/utils/setup-hooks.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # SPDX-FileCopyrightText: 2023 Melvin Keskin <melvo@olomono.de>
 4 | #
 5 | # SPDX-License-Identifier: CC0-1.0
 6 | 
 7 | # This script sets up useful git hooks in the local repository.
 8 | 
 9 | REPO_ROOT=$(dirname "$(readlink -f "${0}")")/..
10 | 
11 | cp $REPO_ROOT/utils/pre-commit.sh .git/hooks/pre-commit
12 | 


--------------------------------------------------------------------------------