QSocket

NAME

SYNOPSIS

Inherits QObject and QIODevice.

Public Members

Signals

DESCRIPTION

It provides a totally non-blocking QIODevice, and modifies and extends the API of QIODevice with socket-specific code.

Note that a QApplication must have been constructed before this class can be used.

The functions you're likely to call most are connectToHost(), bytesAvailable(), canReadLine() and the ones it inherits from QIODevice.

connectToHost() is the most-used function. As its name implies, it opens a connection to a named host.

Most network protocols are either packet-oriented or line-oriented. canReadLine() indicates whether a connection contains an entire unread line or not, and bytesAvailable() returns the number of bytes available for reading.

The signals error(), connected(), readyRead() and connectionClosed() inform you of the progress of the connection. There are also some less commonly used signals. hostFound() is emitted when connectToHost() has finished its DNS lookup and is starting its TCP connection. delayedCloseFinished() is emitted when close() succeeds. bytesWritten() is emitted when QSocket moves data from its "to be written" queue into the TCP implementation.

There are several access functions for the socket: state() returns whether the object is idle, is doing a DNS lookup, is connecting, has an operational connection, etc. address() and port() return the IP address and port used for the connection. The peerAddress() and peerPort() functions return the IP address and port used by the peer, and peerName() returns the name of the peer (normally the name that was passed to connectToHost()). socketDevice() returns a pointer to the QSocketDevice used for this socket.

QSocket inherits QIODevice, and reimplements some functions. In general, you can treat it as a QIODevice for writing, and mostly also for reading. The match isn't perfect, since the QIODevice API is designed for devices that are controlled by the same machine, and an asynchronous peer-to-peer network connection isn't quite like that. For example, there is nothing that matches QIODevice::size() exactly. The documentation for open(), close(), flush(), size(), at(), atEnd(), readBlock(), writeBlock(), getch(), putch(), ungetch() and readLine() describes the differences in detail.

Warning: QSocket is not suitable for use in threads. If you need to uses sockets in threads use the lower-level QSocketDevice class.

Warning: Because Qt doesn't use the native socketstream implementation on Mac OS X, QSocket has an implicit transfer latency of 100ms. You can achieve lower latency on Mac OS X by using QSocketDevice instead.

See also QSocketDevice, QHostAddress, QSocketNotifier, and Input/Output and Networking.  

Member Type Documentation

QSocket::Error

QSocket::ErrConnectionRefused - if the connection was refused

QSocket::ErrHostNotFound - if the host was not found

QSocket::ErrSocketRead - if a read from the socket failed

QSocket::State

QSocket::Idle - if there is no connection

QSocket::HostLookup - during a DNS lookup

QSocket::Connecting - during TCP connection establishment

QSocket::Connected - when there is an operational connection

QSocket::Closing - if the socket is closing down, but is not yet closed.

MEMBER FUNCTION DOCUMENTATION

QSocket::QSocket ( QObject * parent = 0, const char * name = 0 )

The parent and name arguments are passed on to the QObject constructor.

Note that a QApplication must have been constructed before sockets can be used.  

QSocket::~QSocket () [virtual]

See also close().  

QHostAddress QSocket::address () const

Offset QSocket::at () const [virtual]

Reimplemented from QIODevice.  

bool QSocket::at ( Offset index ) [virtual]

Moves the read index forward to index and returns TRUE if the operation was successful; otherwise returns FALSE. Moving the index forward means skipping incoming data.

Reimplemented from QIODevice.  

bool QSocket::atEnd () const [virtual]

Reimplemented from QIODevice.  

Q_ULONG QSocket::bytesAvailable () const

This function can trigger the readyRead() signal, if more data has arrived on the socket.

See also bytesToWrite().

Example: network/networkprotocol/nntp.cpp.  

Q_ULONG QSocket::bytesToWrite () const

See also bytesAvailable() and clearPendingData().  

void QSocket::bytesWritten ( int nbytes ) [signal]

The bytesToWrite() function is often used in the same context; it indicates how many buffered bytes there are left to write.

See also writeBlock() and bytesToWrite().  

bool QSocket::canReadLine () const

Note that if the peer closes the connection unexpectedly, this function returns FALSE. This means that loops such as this won't work:

        while( !socket->canReadLine() ) // WRONG


            ;

See also readLine().

Examples:  

void QSocket::clearPendingData ()

See also bytesToWrite(), close(), and delayedCloseFinished().  

void QSocket::close () [virtual]

The read buffer is cleared.

If the output buffer is empty, the state is set to QSocket::Idle and the connection is terminated immediately. If the output buffer still contains data to be written, QSocket goes into the QSocket::Closing state and the rest of the data will be written. When all of the outgoing data have been written, the state is set to QSocket::Idle and the connection is terminated. At this point, the delayedCloseFinished() signal is emitted.

If you don't want that the data of the output buffer is written, call clearPendingData() before you call close().

See also state(), bytesToWrite(), and clearPendingData().

Examples:

Reimplemented from QIODevice.  

void QSocket::connectToHost ( const QString & host, Q_UINT16 port ) [virtual]

Any connection or pending connection is closed immediately, and QSocket goes into the HostLookup state. When the lookup succeeds, it emits hostFound(), starts a TCP connection and goes into the Connecting state. Finally, when the connection succeeds, it emits connected() and goes into the Connected state. If there is an error at any point, it emits error().

host may be an IP address in string form, or it may be a DNS name. QSocket will do a normal DNS lookup if required. Note that port is in native byte order, unlike some other libraries.

See also state().

Examples:  

void QSocket::connected () [signal]

See also connectToHost() and connectionClosed().

Examples:  

void QSocket::connectionClosed () [signal]

See also connectToHost() and close().

Examples:  

void QSocket::delayedCloseFinished () [signal]

If you call close() and there is buffered output data to be written, QSocket goes into the QSocket::Closing state and returns immediately. It will then keep writing to the socket until all the data has been written. Then, the delayedCloseFinished() signal is emitted.

See also close().

Examples:  

void QSocket::error ( int ) [signal]

Examples:  

void QSocket::flush () [virtual]

Reimplemented from QIODevice.  

int QSocket::getch () [virtual]

See also bytesAvailable() and putch().

Reimplemented from QIODevice.  

void QSocket::hostFound () [signal]

See also connected().

Example: network/networkprotocol/nntp.cpp.  

bool QSocket::open ( int m ) [virtual]

See also close().

Reimplemented from QIODevice.  

QHostAddress QSocket::peerAddress () const

QString QSocket::peerName () const

Example: network/mail/smtp.cpp.  

Q_UINT16 QSocket::peerPort () const

Note that Qt always uses native byte order, i.e. 67 is 67 in Qt; there is no need to call htons().  

Q_UINT16 QSocket::port () const

int QSocket::putch ( int ch ) [virtual]

Returns ch, or -1 if an error occurred.

See also getch().

Reimplemented from QIODevice.  

Q_LONG QSocket::readBlock ( char * data, Q_ULONG maxlen ) [virtual]

Example: network/networkprotocol/nntp.cpp.

Reimplemented from QIODevice.  

Q_ULONG QSocket::readBufferSize () const

See also setReadBufferSize().  

QString QSocket::readLine () [virtual]

See also canReadLine().

Examples:  

void QSocket::readyRead () [signal]

Bear in mind that new incoming data is only reported once; if you do not read all the data, this class buffers the data and you can read it later, but no signal is emitted unless new data arrives. A good practice is to read all data in the slot connected to this signal unless you are sure that you need to receive more data to be able to process it.

See also readBlock(), readLine(), and bytesAvailable().

Examples:  

void QSocket::setReadBufferSize ( Q_ULONG bufSize )

Usually QSocket reads all data that is available from the operating system's socket. If the buffer size is limited to a certain size, this means that the QSocket class doesn't buffer more than this size of data.

If the size of the read buffer is 0, the read buffer is unlimited and all incoming data is buffered. This is the default.

If you read the data in the readyRead() signal, you shouldn't use this option since it might slow down your program unnecessary. This option is useful if you only need to read the data at certain points in time, like in a realtime streaming application.

See also readBufferSize().  

void QSocket::setSocket ( int socket ) [virtual]

This allows us to use the QSocket class as a wrapper for other socket types (e.g. Unix Domain Sockets).

Example: network/httpd/httpd.cpp.  

void QSocket::setSocketDevice ( QSocketDevice * device ) [virtual]

The new device should not be connected before being associated with a QSocket; after setting the socket call connectToHost() to make the connection.

This function is useful if you need to subclass QSocketDevice and want to use the QSocket API, for example, to implement Unix domain sockets.  

Offset QSocket::size () const [virtual]

Reimplemented from QIODevice.  

int QSocket::socket () const

QSocketDevice * QSocket::socketDevice ()

There is normally no need to manipulate the socket device directly since this class does the necessary setup for most applications.  

State QSocket::state () const

See also QSocket::State.

Examples:  

int QSocket::ungetch ( int ch ) [virtual]

Reimplemented from QIODevice.  

Q_ULONG QSocket::waitForMore ( int msecs, bool * timeout ) const

If msecs is -1 the call will block indefinitely.

Returns the number of bytes available.

If timeout is non-null and no error occurred (i.e. it does not return -1): this function sets *timeout to TRUE, if the reason for returning was that the timeout was reached; otherwise it sets *timeout to FALSE. This is useful to find out if the peer closed the connection.

Warning: This is a blocking call and should be avoided in event driven applications.

See also bytesAvailable().  

Q_ULONG QSocket::waitForMore ( int msecs ) const

Q_LONG QSocket::writeBlock ( const char * data, Q_ULONG len ) [virtual]

Example: network/networkprotocol/nntp.cpp.

Reimplemented from QIODevice.

SEE ALSO

COPYRIGHT

AUTHOR

BUGS