QLocalSocket Class

The QLocalSocket class provides a local stream socket for talking to another process on the same machine. More…

Header	`#include <QLocalSocket>`
CMake	`target_link_libraries(app PRIVATE Nt::Network)`
Module	Nt Network C++ Classes
Inherits	QIODevice

List of all members, including inherited members

Public Types

enum	LocalSocketError
enum	LocalSocketState

Public Functions

	QLocalSocket(QObject *parent = nullptr)
	~QLocalSocket()
void	connectToServer(OpenMode openMode = ReadWrite)
void	connectToServer(const QString &name, OpenMode openMode = ReadWrite)
void	disconnectFromServer()
void	setServerName(const QString &name)
QString	serverName() const
QString	fullServerName() const
void	abort()
bool	flush()
bool	isValid() const
LocalSocketError	error() const
LocalSocketState	state() const
qint64	readBufferSize() const
void	setReadBufferSize(qint64 size)
bool	setSocketDescriptor(qintptr socketDescriptor, LocalSocketState socketState = ConnectedState, OpenMode openMode = ReadWrite)
qintptr	socketDescriptor() const
bool	waitForConnected(int msecs = 30000)
bool	waitForDisconnected(int msecs = 30000)

Reimplemented Public Functions

bool	isSequential() const
qint64	bytesAvailable() const
qint64	bytesToWrite() const
bool	canReadLine() const
void	close()
bool	waitForReadyRead(int msecs = 30000)
bool	waitForBytesWritten(int msecs = 30000)

Signals

void	connected()
void	disconnected()
void	errorOccurred(QLocalSocket::LocalSocketError socketError)
void	stateChanged(QLocalSocket::LocalSocketState socketState)

Reimplemented Protected Functions

qint64	readData(char *data, qint64 maxSize)
qint64	writeData(const char *data, qint64 maxSize)

Detailed Description

Connect to a QLocalServer by name, then read and write as with any QIODevice:

QLocalSocket socket;
socket.connectToServer("my-service");
socket.write("hello");

A relative name is placed in QDir::tempPath(); a name starting with / is used as the socket path.

See also QLocalServer.

Differences from Qt

Connecting either succeeds or fails before connectToServer() returns, so the socket never stays in ConnectingState. Linux and other POSIX systems only, using Unix domain sockets.

The class is not built for Zephyr, where QT_NO_LOCALSOCKET is defined instead. See Nt on Zephyr.

Member Type Documentation

enum QLocalSocket::LocalSocketError

Describes an error on a local socket.

Constant	Description
`QLocalSocket::ConnectionRefusedError`	The server refused the connection.
`QLocalSocket::PeerClosedError`	The other end closed the connection.
`QLocalSocket::ServerNotFoundError`	No server has that name.
`QLocalSocket::SocketAccessError`	The process may not use that socket.
`QLocalSocket::SocketResourceError`	The system ran out of resources.
`QLocalSocket::SocketTimeoutError`	The operation timed out.
`QLocalSocket::DatagramTooLargeError`	The data was too large to send.
`QLocalSocket::ConnectionError`	A connection error occurred.
`QLocalSocket::UnsupportedSocketOperationError`	The operation is not supported.
`QLocalSocket::OperationError`	The operation is not valid in the current state.
`QLocalSocket::UnknownSocketError`	An unidentified error occurred.

enum QLocalSocket::LocalSocketState

Describes the state of a local socket.

Constant	Description
`QLocalSocket::UnconnectedState`	The socket is not connected.
`QLocalSocket::ConnectingState`	The socket is connecting.
`QLocalSocket::ConnectedState`	The socket is connected.
`QLocalSocket::ClosingState`	The socket is closing and flushing pending writes.

Member Function Documentation

[explicit] QLocalSocket::QLocalSocket(QObject **parent* = nullptr)

Constructs a local socket with the given parent.

[override] QLocalSocket::~QLocalSocket()

Destroys the socket, closing the connection if necessary.

void QLocalSocket::abort()

Closes the connection at once, discarding pending writes.

See also disconnectFromServer().

[signal] void QLocalSocket::connected()

This signal is emitted once the connection is established.

void QLocalSocket::connectToServer(OpenMode openMode = ReadWrite)

Connects to the server set with setServerName(), opening the socket with openMode.

See also setServerName() and connected().

void QLocalSocket::connectToServer(const QString &name, OpenMode openMode = ReadWrite)

This is an overloaded function.

Sets the server name to name and connects, opening the socket with openMode.

[signal] void QLocalSocket::disconnected()

This signal is emitted when the socket has disconnected.

void QLocalSocket::disconnectFromServer()

Disconnects after pending data has been written.

See also abort() and disconnected().

LocalSocketError QLocalSocket::error() const

Returns the last error.

See also errorOccurred().

[signal] void QLocalSocket::errorOccurred(QLocalSocket::LocalSocketError socketError)

This signal is emitted when the error socketError occurs.

bool QLocalSocket::flush()

Writes as much pending data as possible without blocking. Returns true if any data was written.

See also waitForBytesWritten().

QString QLocalSocket::fullServerName() const

Returns the path of the socket connected to.

See also serverName().

[override] bool QLocalSocket::isSequential() const

Reimplements QIODevice::isSequential().

bool QLocalSocket::isValid() const

Returns true if the socket is connected.

See also state().

qint64 QLocalSocket::readBufferSize() const

Returns the read buffer limit in bytes; 0 means unlimited.

See also setReadBufferSize().

[override, protected] qint64 QLocalSocket::readData(char **data, qint64 maxSize*)

Reimplements QIODevice::readData().

QString QLocalSocket::serverName() const

Returns the server name given to connectToServer().

See also fullServerName().

void QLocalSocket::setReadBufferSize(qint64 size)

Limits the read buffer to size bytes; 0 means unlimited. When it is full, the sender is held back until data is read.

See also readBufferSize().

void QLocalSocket::setServerName(const QString &name)

Sets the name of the server to connect to, to name.

See also serverName().

bool QLocalSocket::setSocketDescriptor(qintptr socketDescriptor, LocalSocketState socketState = ConnectedState, OpenMode openMode = ReadWrite)

Adopts the connected descriptor socketDescriptor, with the state socketState and open mode openMode. Returns false if the descriptor is invalid.

See also socketDescriptor().

qintptr QLocalSocket::socketDescriptor() const

Returns the native descriptor, or -1 if there is none.

See also setSocketDescriptor().

LocalSocketState QLocalSocket::state() const

Returns the socket's state.

See also stateChanged().

[signal] void QLocalSocket::stateChanged(QLocalSocket::LocalSocketState socketState)

This signal is emitted when the state changes to socketState.

[override] bool QLocalSocket::waitForBytesWritten(int msecs = 30000)

Reimplements QIODevice::waitForBytesWritten().

Waits up to msecs milliseconds until pending data has been written. A negative value waits forever. Returns true if all of it was written.

See also flush().

bool QLocalSocket::waitForConnected(int msecs = 30000)

Returns true if the socket is connected. Connecting finishes inside connectToServer(), so this never waits; msecs is ignored.

See also connectToServer().

bool QLocalSocket::waitForDisconnected(int msecs = 30000)

Waits up to msecs milliseconds for the socket to disconnect. A negative value waits forever. Returns true if it disconnected.