// Copyright (C) 2020 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only

/*!
\page topics-network-connectivity.html
\title Networking and Connectivity
\brief Qt's network and connectivity features

Qt provides classes for both high-level and low-level network communication,
classes for web integration, and classes for interprocess communication.

For high-level network traffic, \l{Qt Network} provides an abstraction layer
over the operations used, showing only high-level classes and functions. Qt
Network can also handle lower level protocols like TCP and UDP. Classes like
QTcpSocket and QUdpSocket enable the developer to send and receive messages
using the TCP or UDP protocol.Name resolution is done with QHostInfo. QHostInfo
is called before creating a network connection with QTcpSocket or QUdpSocket.
Filtering and redistributing network traffic via proxies can handled by the
QNetWorkProxy class.

Qt also offers functionalities for \e{inter-process communication} (IPC). The
class QProcess is used to start external programs. \l{Qt D-Bus} provides support
for D-Bus, an interprocess communication and remoteprocedure calling mechanism.
It mostly communicates via a central server application, called a bus. However,
it is also possible to let applications communicate directly with each other.
QSharedMemory provides access to a shared memory segment by multiple threads
and processes. It is however also possible for a single process to
exclusively lock that shared memory.

\section1 Network Communication

Qt supports a wide range of network communication, with a focus on HTTP, TCP,
and UDP.

At the HTTP level, the \l{Qt Network} module offers the network access API,
which consists mainly of QNetworkRequest, QNetworkAccessManager, and
QNetworkReply. Put simply, the QNetworkRequest resembles an HTTP request, which
gets passed to the QNetworkAccessManager to send the request on the wire; this
class returns a QNetworkReply, which enables parsing the HTTP reply. The network
access API uses the socket classes mentioned below (for TCP and SSL) internally.

For communication at the socket level, QTcpSocket, QUdpSocket and QSslSocket
should be used. These classes offer a synchronous API through the waitFor*
methods as well as an asynchronous API; if possible (i.e. if the event loop is
running), the asynchronous API should always be preferred. Qt also offers
QTcpServer to enable the server-side part of a TCP communication. Please note
that there is no HTTP server class in Qt.

For secure communication via SSL, Qt Network offers a wide range of classes
alongside the central QSslSocket, e.g. QSslCertificate, QSslConfiguration and
QSslError. The only supported backend for SSL in Qt is OpenSSL, which needs to
be installed separately.

Qt also offers HTTP support in QML by either using HTTP explicitly via
XmlHttpRequest, or by transparently using HTTP URLs in e.g. Image sources.

Related Topics:
\list
\li \l{Qt Network} - module documentation
    \list
        \li \l {Network Programming API}
        \li \l {Network Programming with Qt}
        \li \l {Qt Network C++ Classes}
        \li \l {Secure Sockets Layer (SSL) Classes}
    \endlist
\li \l {Resource Loading and Network Transparency} - network and URL transparency in QML
\endlist

\section1 Inter-Process Communication

Qt provides several ways to implement Inter-Process Communication
(IPC) in Qt applications.

The cross-platform \l{Qt Network} module provides classes that make
network programming portable and easy. It offers high-level
classes (e.g., QNetworkAccessManager) that communicate using
specific application-level protocols, and lower-level classes
(e.g., QTcpSocket, QTcpServer, QSslSocket) for implementing
protocols.

The cross-platform shared memory class, QSharedMemory, provides
access to the operating system's shared memory implementation.
It allows safe access to shared memory segments by multiple threads
and processes. Additionally, QSystemSemaphore can be used to control
access to resources shared by the system, as well as to communicate
between processes.

The \l{Qt D-Bus} module is a cross-platform library you can use to
implement IPC using the D-Bus protocol. It extends Qt's
\l{Signals & Slots}{signals and slots} mechanism to the IPC
level, allowing a signal emitted by one process to be connected to
a slot in another process.

The cross-platform class \l{QProcess} can be used to start external
programs as child processes, and to communicate with them. It provides
an API for monitoring and controlling the state of the child
process. QProcess gives access to the input/output channels of child
process by inheriting from QIODevice.

The \l{QLocalSocket} class provides a local socket. On Windows this is
a named pipe and on Unix this is a local domain socket.
The \l{QLocalServer} class provides a local socket based server. This
class makes it possible to accept incoming local socket connections.

Related Topics:

\list
\li \l {Qt D-Bus} - module documentation
    \list
    \li \l {Using Qt D-Bus Adaptors}
    \li \l {Declaring Signals in D-Bus Adaptors}
    \li \l {Declaring Slots in D-Bus Adaptors}
    \li \l {The Qt D-Bus Type System}
    \li \l {Qt D-Bus XML compiler (qdbusxml2cpp)}
    \endlist
\li \l {QLocalSocket}
\li \l {QSharedMemory}
\endlist

*/
