• Skip to content
  • Skip to link menu
Trinity API Reference
  • Trinity API Reference
  • tdecore
 

tdecore

Public Types | Signals | Public Member Functions | Static Public Member Functions | Protected Slots | Protected Member Functions | Protected Attributes | Friends
KExtendedSocket Class Reference

#include <kextsock.h>

Inheritance diagram for KExtendedSocket:
TDEBufferedIO KAsyncIO TQObject TQIODevice

List of all members.

Public Types

enum  Flags {
  anySocket = 0x00, knownSocket = 0x01, unixSocket = knownSocket | 0x02, inetSocket = knownSocket | 0x04,
  ipv4Socket = inetSocket | 0x100, ipv6Socket = inetSocket | 0x200, passiveSocket = 0x1000, canonName = 0x2000,
  noResolve = 0x4000, streamSocket = 0x8000, datagramSocket = 0x10000, rawSocket = 0x20000,
  inputBufferedSocket = 0x200000, outputBufferedSocket = 0x400000, bufferedSocket = 0x600000
}
enum  SockStatus {
  error = -1, nothing = 0, lookupInProgress = 50, lookupDone = 70,
  created = 100, bound = 140, connecting = 200, connected = 220,
  listening = 200, accepting = 220, closing = 350, done = 400
}

Signals

void lookupFinished (int count)
void connectionSuccess ()
void connectionFailed (int error)
void readyAccept ()

Public Member Functions

 KExtendedSocket ()
 KExtendedSocket (const TQString &host, int port, int flags=0)
 KExtendedSocket (const TQString &host, const TQString &service, int flags=0)
virtual ~KExtendedSocket ()
int socketStatus () const
int systemError () const
int setSocketFlags (int flags)
int socketFlags () const
bool setHost (const TQString &host)
TQString host () const
bool setPort (int port)
bool setPort (const TQString &port)
TQString port () const
bool setAddress (const TQString &host, int port)
bool setAddress (const TQString &host, const TQString &serv)
bool setBindHost (const TQString &host)
bool unsetBindHost ()
TQString bindHost () const
bool setBindPort (int port)
bool setBindPort (const TQString &service)
bool unsetBindPort ()
TQString bindPort () const
bool setBindAddress (const TQString &host, int port)
bool setBindAddress (const TQString &host, const TQString &service)
bool unsetBindAddress ()
bool setTimeout (int secs, int usecs=0)
timeval timeout () const
bool setBlockingMode (bool enable)
bool blockingMode ()
bool setAddressReusable (bool enable)
bool addressReusable ()
bool setIPv6Only (bool enable)
bool isIPv6Only ()
virtual bool setBufferSize (int rsize, int wsize=-2)
const ::TDESocketAddress * localAddress ()
const ::TDESocketAddress * peerAddress ()
int fd () const
virtual int lookup ()
virtual int startAsyncLookup ()
virtual void cancelAsyncLookup ()
virtual int listen (int N=5)
virtual int accept (KExtendedSocket *&sock)
virtual int connect ()
virtual int startAsyncConnect ()
virtual void cancelAsyncConnect ()
virtual bool open (TQ_OpenMode mode=(TQ_OpenMode)(IO_Raw|IO_ReadWrite))
virtual void close ()
virtual void closeNow ()
virtual void release ()
virtual void flush ()
virtual TQT_TQIO_LONG tqwriteBlock (const char *data, TQT_TQIO_ULONG len)
virtual int peekBlock (char *data, uint maxlen)
virtual int unreadBlock (const char *data, uint len)
virtual int waitForMore (int msec)
virtual int getch ()
virtual int putch (int ch)
virtual int ungetch (int)
virtual void enableRead (bool enable)
virtual void enableWrite (bool enable)

Static Public Member Functions

static int resolve (sockaddr *sock, ksocklen_t len, TQString &host, TQString &port, int flags=0) KDE_DEPRECATED
static int resolve (::TDESocketAddress *sock, TQString &host, TQString &port, int flags=0) KDE_DEPRECATED
static TQPtrList< KAddressInfo > lookup (const TQString &host, const TQString &port, int flags=0, int *error=0) KDE_DEPRECATED
::TDESocketAddress * localAddress (int fd) KDE_DEPRECATED
::TDESocketAddress * peerAddress (int fd) KDE_DEPRECATED
static TQString strError (int code, int syserr)
static bool setAddressReusable (int fd, bool enable) KDE_DEPRECATED

Protected Slots

void socketActivityRead ()
void socketActivityWrite ()
void dnsResultsReady ()
void startAsyncConnectSlot ()
void connectionEvent ()

Protected Member Functions

TQSocketNotifier * readNotifier ()
TQSocketNotifier * writeNotifier ()
void setError (int errorkind, int error)
void cleanError ()
void setSocketStatus (int status)
virtual void virtual_hook (int id, void *data)

Protected Attributes

int sockfd

Friends

class TDESocket
class TDEServerSocket

Detailed Description

The extended socket class.

This class should be used instead of TDESocket whenever the user needs fine-grained control over the socket being created. Unlike TDESocket, which does everything at once, without much intervention, KExtendedSocket allows intervention at every step of the process and the setting of parameters.

This class allows for the creation of both server and client sockets. The only difference is that the passiveSocket flag must be passed either to the constructor or to setSocketFlags(). If passiveSocket is used, the class will enable functions listen() and accept() and related signals, and will also disable tqreadBlock() and tqwriteBlock().

To create a Unix socket, one would pass flag unixSocket to the constructor or setSocketFlags(). The hostname and service/port can be set to whatever is necessary. If no hostname is given, but a service/port is, the socket created will be implementation dependant (usually in /tmp). In any other case, the fields will be concatenated.

To create an Internet socket, inetSocket flag can be used. If, on the other hand a specific IP protocol is desired, ipv4Socket and/or ipv6Socket can be used.

Note that the socket type selection flags are cumulative. One could select Unix and Internet sockets by using unixSocket | inetSocket. Or, for instance, to make sure only IPv4 and IPv6 sockets are selected, even if future implementations support newer IP protocols, ipv4Socket | ipv6Socket is your guy.

Deprecated:
This class is now deprecated. Please use the classes in KNetwork for new programs. In particular, this class is replaced by KNetwork::KStreamSocket and KNetwork::TDEServerSocket.
Author:
Thiago Macieira <thiago.macieira@kdemail.net> an extended socket

Definition at line 95 of file kextsock.h.


Member Enumeration Documentation

enum KExtendedSocket::Flags

flags that can be passed down to the member functions

Definition at line 104 of file kextsock.h.

enum KExtendedSocket::SockStatus

status of the class The status are sequential.

If a change to one status is requested, all the prior status will be passed and their actions, performed

Definition at line 136 of file kextsock.h.


Constructor & Destructor Documentation

KExtendedSocket::KExtendedSocket ( )

Creates an empty KExtendedSocket.

Definition at line 186 of file kextsock.cpp.

KExtendedSocket::KExtendedSocket ( const TQString &  host,
int  port,
int  flags = 0 
)

Creates a socket with the given hostname and port.

If this is a connecting (active) socket, the hostname and port specify the remote address to which we will connect.

If this is a listening (passive) socket, the hostname and port specify the address to listen on. In order to listen on every interface available on this node, set host to TQString::null. To let the operating system select a port, set it to 0.

See also:
setAddress
Parameters:
hostthe hostname
portthe port number
flagsflags

Definition at line 192 of file kextsock.cpp.

KExtendedSocket::KExtendedSocket ( const TQString &  host,
const TQString &  service,
int  flags = 0 
)

Creates a socket with the given hostname and service.

If this is a connecting (active) socket, the hostname and service specify the remote address to which we will connect.

If this is a listening (passive) socket, the hostname and service specify the address to listen on. In order to listen on every interface available on this node, set host to TQString::null. To let the operating system select a port, set the service to "0".

See also:
setAddress
Parameters:
hostthe hostname
servicethe service
flagsflags

Definition at line 200 of file kextsock.cpp.

KExtendedSocket::~KExtendedSocket ( ) [virtual]

Destroys the socket, disconnecting if still connected and freeing any related resources still being kept.

Definition at line 208 of file kextsock.cpp.


Member Function Documentation

virtual int KExtendedSocket::accept ( KExtendedSocket *&  sock) [virtual]

Accepts an incoming connection from the socket.

If this socket is in blocking mode, this function will block until a connection is received. Otherwise, it might return with error. The sock parameter will be initialised with the newly created socket.

Upon successful acception (i.e., this function returns 0), the newly created socket will be already connected. The socket will be unbuffered and readyRead() and readyWrite() signals will be disabled.

Parameters:
socka pointer to an KExtendedSocket variable
Returns:
0 on success, -1 on system error (errno set) and -2 if this is not a passiveSocket and -3 if this took too long (time out)
bool KExtendedSocket::addressReusable ( )

Returns whether this socket's address can be reused.

Returns:
true if the address can be reused
TQString KExtendedSocket::bindHost ( ) const

Returns the hostname to which the socket will be/is bound.

Returns:
the host or TQString::null if it has not been set.
TQString KExtendedSocket::bindPort ( ) const

Returns the service to which the socket will be/is bound.

Returns:
the host or TQString::null if it has not been set.
bool KExtendedSocket::blockingMode ( )

Returns the current blocking mode for this socket.

Returns:
true if in blocking mode
virtual void KExtendedSocket::cancelAsyncConnect ( ) [virtual]

Cancels any on-going asynchronous connection attempt.

virtual void KExtendedSocket::cancelAsyncLookup ( ) [virtual]

Cancels any on-going asynchronous lookups.

virtual void KExtendedSocket::close ( ) [virtual]

Closes the socket.

If we have data still in the write buffer yet to be sent, the socket won't be closed right now. It'll be closed after we managed to send everything out. If you want to close the socket now, you may want to call flush() first, and then closeNow().

Reimplemented from TQIODevice.

virtual void KExtendedSocket::closeNow ( ) [virtual]

Closes the socket now, discarding the contents of the write buffer, if any.

The read buffer's contents are kept until they are emptied by read operations or the class is destroyed.

Implements TDEBufferedIO.

virtual int KExtendedSocket::connect ( ) [virtual]

Attempts to connect to the remote host.

After successful connection (return value 0), the socket will be ready for I/O operations. Note, however, that not all signals may be enabled for emission by this socket:

  • readyRead and readyWrite signals will be enabled only if enableRead or enableWrite were called. You can still enable them by calling those functions, of course.
  • closed() will only be sent if we are indeed reading from the input stream. That is, if this socket is buffering the input. See setBufferSize

Note that, in general, functions inherited/overridden from TDEBufferedIO will only work on buffered sockets, like bytesAvailable and bytesToWrite.

Returns:
The return values are:
  • 0: success
  • -1: system error, errno was set accordingly
  • -2: this socket cannot connect(); this is a passiveSocket. It can also mean that the function was unable to make a connection with the given bind address or that an asynchronous connection attempt is already in progress.
  • -3: connection timed out
void KExtendedSocket::connectionFailed ( int  error) [signal]

This signal is emitted whenever our asynchronous connection attempt failed to all hosts listed.

Parameters:
errorthe errno code of the last connection attempt
void KExtendedSocket::connectionSuccess ( ) [signal]

This signal is emitted whenever we connected asynchronously to a host.

virtual void KExtendedSocket::enableRead ( bool  enable) [virtual]

Toggles the emission of the readyRead signal.

Note that this signal is emitted every time more data is available to be read, so you might get flooded with it being emitted every time, when in non-buffered mode. However, in buffered mode, this signal will be emitted only when there is data coming in from the wire. By default, this flag is set to false, i.e., signal not being emitted.

Parameters:
enableif true, the signal will be emitted

Implements KAsyncIO.

virtual void KExtendedSocket::enableWrite ( bool  enable) [virtual]

Toggles the emission of the readyWrite signal.

Note that this signal is emitted only when the OS is ready to receive more data, which means that the write buffer is empty. And when that is reached, this signal will possibly be emitted on every loop, so you might want to disable it. By default, this flag is set to false.

Parameters:
enableif true, the signal will be emitted

Implements KAsyncIO.

int KExtendedSocket::fd ( ) const [inline]

Returns the file descriptor.

Returns:
the file descriptor. -1 if there is no fd yet.

Definition at line 508 of file kextsock.h.

virtual void KExtendedSocket::flush ( ) [virtual]

Flushes the socket buffer.

You need not call this method during normal operation as we will try and send everything as soon as possible. However, if you want to make sure that data in the buffer is being sent at this moment, you can call this function. It will try to send as much data as possible, but it will stop as soon as the kernel cannot receive any more data, and would possibly block.

By repeatedly calling this function, the behavior will be like that of a blocking socket. Indeed, if this function is called with the kernel not ready to receive data, it will block, unless this is a non-blocking socket.

This function does not touch the read buffer. You can empty it by calling tqreadBlock() with a null destination buffer.

Reimplemented from TQIODevice.

virtual int KExtendedSocket::getch ( ) [virtual]

Gets a single character (unsigned char) from the stream.

Returns:
the value of the character. Negative if there was an error.

Reimplemented from TQIODevice.

TQString KExtendedSocket::host ( ) const

Returns the hostname.

Returns:
the hostname or TQString::null if no host has been set
bool KExtendedSocket::isIPv6Only ( )

Returns the status of the v6-only flag for IPv6 sockets.

Returns:
true if the flag is set to on; false if it is not. If this socket is not an IPv6 one, the return value is false.
See also:
setIPv6Only
virtual int KExtendedSocket::listen ( int  N = 5) [virtual]

Place the socket in listen mode.

The parameters are the same as for the system listen() call.

Parameters:
Nthe queue length for pending connections
Returns:
0 on success, -1 on system error (errno available) and -2 if this is not a passiveSocket.
const ::TDESocketAddress* KExtendedSocket::localAddress ( )

Returns the local socket address.

Returns:
the local socket address, can be 0 if the connection has not been established yet
::TDESocketAddress* KExtendedSocket::localAddress ( int  fd) [static]

Returns the local socket address Remember to delete the returned object when it is no longer needed.

Parameters:
fdthe file descriptor
Returns:
the local socket address or 0 if an error occurred. Delete after use.
virtual int KExtendedSocket::lookup ( ) [virtual]

Performs lookup on the addresses we were given before.

This will perform lookups on the bind addresses if they were given.

Returns:
0 or an error. Do not rely on the values returned by lookup as of now. They are not specified.
static TQPtrList<KAddressInfo> KExtendedSocket::lookup ( const TQString &  host,
const TQString &  port,
int  flags = 0,
int *  error = 0 
) [static]
Deprecated:
This function is now deprecated.

Please use KNetwork::KResolver::resolve.

Performs lookup on the given hostname/port combination and returns a list of matching addresses. The error code can be transformed into string by KExtendedSocket::strError() with code of IO_LookupError.

IMPORTANT: the result values of the TQPtrList must be deleted after use. So, if you don't copy the KAddressInfo objects, the best way to assure that is to call setAutoDelete(true) on the list right after this function returns. If you do copy the results out, you must assure that the objects get deleted when they are not needed any more.

Parameters:
hostthe hostname to look up
portthe port/service to look up
flagsflags to be used when looking up, Flags
errorpointer to a variable holding the error code
Returns:
a list of KAddressInfos
void KExtendedSocket::lookupFinished ( int  count) [signal]

This signal is emitted whenever an asynchronous lookup process is done.

The parameter count tells

Parameters:
countthe number of results
virtual bool KExtendedSocket::open ( TQ_OpenMode  mode = (TQ_OpenMode)(IO_Raw|IO_ReadWrite)) [virtual]

Implementation of TQIODevice::open() pure virtual function.

This depends on the target host address already being there. If this is a passiveSocket, this is identical to call listen(); else, if this is not a passiveSocket and no connection attempt is in progress, this is like connect(). If one is in progress, this function will fail.

Parameters:
modethe open mode. Must be IO_Raw | IO_ReadWrite
Returns:
true if successful, false when an error occurred or the most was not correct
virtual int KExtendedSocket::peekBlock ( char *  data,
uint  maxlen 
) [virtual]

Peeks at a block of data from the socket.

This is exactly like read, except that the data won't be flushed from the read buffer.

If this socket is not buffered, this function will always return with 0 bytes copied.

Parameters:
datawhere to store the data
maxlenhow many bytes to copy, at most
Returns:
the number of bytes copied. 0 does not mean end-of-file condition.

Implements TDEBufferedIO.

const ::TDESocketAddress* KExtendedSocket::peerAddress ( )

Returns the peer socket address.

Use KExtendedSocket::resolve() to resolve this to a human-readable hostname/service or port.

Returns:
the peer address, can be 0 if the connection has not been established yet or the socket is passive
::TDESocketAddress* KExtendedSocket::peerAddress ( int  fd) [static]

Returns the peer socket address.

Use KExtendedSocket::resolve() to resolve this to a human-readable hostname/service or port. Remember to delete the returned object when it is no longer needed.

Parameters:
fdthe file descriptor
Returns:
the peer socket address or 0 if an error occurred. Delete after use.
TQString KExtendedSocket::port ( ) const

Returns the port/service.

If it is a port, the string contains a number.

Returns:
the port or TQString::null if it has not been set.
virtual int KExtendedSocket::putch ( int  ch) [virtual]

Writes a single character (unsigned char) to the stream.

All other bits will be ignored.

Parameters:
chcharacter to write, converted to char

Reimplemented from TQIODevice.

void KExtendedSocket::readyAccept ( ) [signal]

This signal is emitted whenever this socket is ready to accept another socket.

See also:
accept()
virtual void KExtendedSocket::release ( ) [virtual]

Releases the socket and anything we have holding on it.

The class cannot be used anymore. In other words, this is just like closeNow(), but it does not actually close the socket.

This is useful if you just want to connect and don't need the rest of the class.

Note that the buffers' contents will be discarded.

Use of this method is discouraged, because the socket created might be such that normal library routines can't handle (read, write, close, etc.)

static int KExtendedSocket::resolve ( sockaddr *  sock,
ksocklen_t  len,
TQString &  host,
TQString &  port,
int  flags = 0 
) [static]

Performs resolution on the given socket address.

That is, tries to resolve the raw form of the socket address into a textual representation.

Parameters:
sockthe socket address
lenthe length of the socket address
hostwhere the hostname will be written
portwhere the service-port will be written
flagsthe same flags as getnameinfo()
Returns:
0 on success, nonzero otherwise.
static int KExtendedSocket::resolve ( ::TDESocketAddress *  sock,
TQString &  host,
TQString &  port,
int  flags = 0 
) [static]

Performs resolution on the given socket address.

That is, tries to resolve the raw form of the socket address into a textual representation.

Parameters:
sockthe socket address
hostwhere the hostname will be written
portwhere the service-port will be written
flagsthe same flags as getnameinfo()
Returns:
0 on success, nonzero otherwise.
bool KExtendedSocket::setAddress ( const TQString &  host,
int  port 
)

Sets the address where we will connect to.

See setHost and setPort for information on the parameters.

Parameters:
hostthe hostname
portport number
Returns:
true if successful, false on error (e.g. connection already established)
bool KExtendedSocket::setAddress ( const TQString &  host,
const TQString &  serv 
)

Sets the address where we will connect to.

See setHost and setPort for information on the parameters.

Parameters:
hostthe hostname
servthe service
Returns:
true if successful, false on error (e.g. connection already established)
bool KExtendedSocket::setAddressReusable ( bool  enable)

Sets/unsets address reusing flag for this socket.

This function returns true if the value was set correctly. That is NOT the result of the set.

Parameters:
enableif true, set address reusable
Returns:
true on success, false on failure. If the socket was not yet created, the value is only remembered. In this case the return value is always true.
static bool KExtendedSocket::setAddressReusable ( int  fd,
bool  enable 
) [static]

Sets/unsets address reusing flag for this socket.

This function returns true if the value was set correctly. That is NOT the result of the set.

Parameters:
fdthe file descriptor
enableif true, set address reusable
Returns:
true on success, false on failure.
bool KExtendedSocket::setBindAddress ( const TQString &  host,
int  port 
)

Sets both host and port to which we will bind the socket.

Will return false if this is a passiveSocket.

Parameters:
hostthe hostname
portthe port number
Returns:
true if successful, false on error (e.g. connection already established)
bool KExtendedSocket::setBindAddress ( const TQString &  host,
const TQString &  service 
)

Sets both host and service to which we will bind the socket.

Will return false if this is a passiveSocket.

Parameters:
hostthe hostname
servicethe service
Returns:
true if successful, false on error (e.g. connection already established)
bool KExtendedSocket::setBindHost ( const TQString &  host)

Sets the hostname to which we will bind locally before connecting.

Parameters:
hostthe hostname
Returns:
false if this is a passiveSocket, otherwise true.
bool KExtendedSocket::setBindPort ( int  port)

Sets the port/service to which we will bind before connecting.

Parameters:
portthe port number
Returns:
true if successful, false on error (e.g. connection already established)
bool KExtendedSocket::setBindPort ( const TQString &  service)

Sets the port/service to which we will bind before connecting.

Parameters:
servicethe port number or service name
Returns:
true if successful, false on error (e.g. connection already established)
bool KExtendedSocket::setBlockingMode ( bool  enable)

Sets/unsets blocking mode for the socket.

When non-blocking mode is enabled, I/O operations might return error and set errno to EWOULDBLOCK. Also, it's not recommended to use this when using the class signals.

Parameters:
enableif true, set blocking mode. False, non-blocking mode.
Returns:
false on error.
virtual bool KExtendedSocket::setBufferSize ( int  rsize,
int  wsize = -2 
) [virtual]

Sets the buffer sizes for this socket.

This implementation allows any size for both parameters. The value given will be interpreted as the maximum size allowed for the buffers, after which the I/O functions will stop buffering. The value of -1 will be interpreted as "unlimited" size. The value of -2 means "no change".

Note: changing the buffer size to 0 for any buffer will cause the given buffer's to be discarded. Likewise, setting the size to a value less than the current size will cause the buffer to be shrunk to the wanted value, as if the data had been read.

Parameters:
rsizeread buffer size
wsizewrite buffer size
Returns:
true on success, false if this is not possible in this state (e.g. connection not established yet)

Reimplemented from TDEBufferedIO.

void KExtendedSocket::setError ( int  errorkind,
int  error 
) [protected]

Sets the error code.

bool KExtendedSocket::setHost ( const TQString &  host)

Sets the hostname to the given value.

If this is a listening (passive) socket, the hostname is the host to which the socket will bind in order to listen. If you want to listen in every interface, set it to "*" or TQString::null.

If this is a connecting (active) socket, the hostname is the host to which we will try to connect.

Parameters:
hostthe hostname
Returns:
true on success, false on error
bool KExtendedSocket::setIPv6Only ( bool  enable)

Sets/unsets the v6-only flag for IPv6 sockets.

When an IPv6 socket is in use, communication with IPv4 sockets is guaranteed by translating those IPv4 addresses into IPv6 ones (specifically, the v4-mapped addresses). This flag allows that behavior to be turned on and off.

Note that this does not have any effect on sockets that are not IPv6 and the function will always return false in those cases. Also note that this flag defaults to off in order to accommodate existing applications.

Parameters:
enableif true, no IPv4 translation will be performed; this socket will be restricted to IPv6 communication
Returns:
true on success, false on failure.
See also:
localAddress to find out if this is an IPv6 socket
bool KExtendedSocket::setPort ( int  port)

Sets the port/service.

Parameters:
portthe port
bool KExtendedSocket::setPort ( const TQString &  port)

Sets the port/service.

In the case of Unix-domain sockets, the port is the filename for the socket. If the name is not an absolute path, "/tmp/" will be prepended.

Parameters:
portthe port
Returns:
true if successful, false on error (e.g. connection already established)
int KExtendedSocket::setSocketFlags ( int  flags)

Sets the given flags.

Parameters:
flagsthe flags to be set
Returns:
the new flags status, or -1 if flags can no longer be set
void KExtendedSocket::setSocketStatus ( int  status) [protected]

Sets the socket status.

For derived classes only.

bool KExtendedSocket::setTimeout ( int  secs,
int  usecs = 0 
)

Sets the timeout value for the connection (if this is not passiveSocket) or acception (if it is).

In the event the given function (connect or accept) returns due to time out, it's possible to call it again.

Setting the timeout to 0 disables the timeout feature.

Parameters:
secsthe timeout length, in seconds
usecsthe timeout complement, in microseconds
Returns:
false if setting timeout makes no sense in the context.
int KExtendedSocket::socketFlags ( ) const

Returns the current flags.

Returns:
the current flags
See also:
::Flags
int KExtendedSocket::socketStatus ( ) const

Resets the socket, disconnecting if still connected and freeing any related resources still being kept.

Since:
3.1 Returns the class status.
Returns:
the class status
See also:
::SockStatus
virtual int KExtendedSocket::startAsyncConnect ( ) [virtual]

Starts an asynchronous connect.

This works exactly the same as connect, except that the connection result won't be returned.

Note that those signals might be emitted before this function returns, so your code should be prepared for that condition.

You must call cancelAsyncConnect() before you delete the socket if you call this. Otherwise you will have crashes.

Returns:
0 on successful queuing of the connect or -1 on error. If this function returns 0, then the connectionSuccess() or the connectionFailed() signals will be emitted.
virtual int KExtendedSocket::startAsyncLookup ( ) [virtual]

Starts an asynchronous lookup for the addresses given.

When the lookup is done, the lookupReady signal will be emitted.

Note that, depending on the parameters for the lookup, this function might know the results without the need for blocking or queuing an asynchronous lookup. That means that the lookupReady signal might be emitted by this function, so your code should be prepared for that.

One such case is when noResolve flag is set. If this function is able to determine the results without queuing and the lookup failed, this function will return -1.

Returns:
0 on success or -1 on error. Note that returning 0 means that either we are in the process of doing lookup or that it has finished already.
static TQString KExtendedSocket::strError ( int  code,
int  syserr 
) [static]

Returns the representing text of this error code.

Parameters:
codethe error code, as seen in status()
syserrthe system error, as from systemError()
Returns:
the text for the given error code
int KExtendedSocket::systemError ( ) const

Returns the related system error code Except for IO_LookupError errors, these are codes found in errno.

Returns:
the system error code
timeval KExtendedSocket::timeout ( ) const

Returns the timeout value for the connection.

Returns:
the timeout value. 0 if there is no timeout.
virtual TQT_TQIO_LONG KExtendedSocket::tqwriteBlock ( const char *  data,
TQT_TQIO_ULONG  len 
) [virtual]

Returns length of this socket.

This call is not supported on sockets.

Returns:
the length of this socket, or 0 if unsupported Writes a block of data to the socket.

If the socket is not buffered, this function will simply call the underlying write method. This means that the function might block if that method blocks as well. That situation is possible if we are not in non-blocking mode and the operating system buffers are full for this socket. If we are in non-blocking mode and the operating system buffers are full, this function will return -1 and the system error will be set to EWOULDBLOCK.

If we are buffering, this function will simply transfer the data into the write buffer. This function will then always succeed, as long as there is enough room in the buffer. If the buffer size was limited and that limit is reached, this function will copy no more bytes than that limit. Trying to write with a full buffer will return -1 and set system error to EWOULDBLOCK.

Parameters:
datathe data to write
lenthe length of data to write
Returns:
the number of bytes written from data buffer. The return value might be less than len if the output buffers cannot accommodate that many bytes and -1 in the case of an errro.
virtual int KExtendedSocket::ungetch ( int  ) [inline, virtual]

Unreads one character from the stream.

This is not possible on sockets.

Returns:
always returns -1 on sockets.

Reimplemented from TQIODevice.

Definition at line 843 of file kextsock.h.

virtual int KExtendedSocket::unreadBlock ( const char *  data,
uint  len 
) [virtual]

Reimplementation of unreadBlock() method.

This is so because unreading in sockets doesn't make sense, so this function will always return -1 (error) and set the system error to ENOSYS.

Returns:
always -1 (error)

Reimplemented from TDEBufferedIO.

bool KExtendedSocket::unsetBindAddress ( )

Unsets the bind address for the socket.

That means that we won't attempt to bind to an address before connecting.

Returns:
true if successful, false on error (e.g. connection already established)
bool KExtendedSocket::unsetBindHost ( )

Unsets the bind hostname.

That is, don't request a binding host.

Returns:
true if successful, false on error (e.g. connection already established)
bool KExtendedSocket::unsetBindPort ( )

Unsets the bind port/service.

Returns:
true if successful, false on error (e.g. connection already established)
virtual int KExtendedSocket::waitForMore ( int  msec) [virtual]

Returns the number of available bytes yet to be read via readBlock and family of functions.

Note: as of now, this only works on input-buffered sockets. This will change in the future

Returns:
The number of available bytes, or -1 on error or -2 if this call is invalid in the current state. Waits msec milliseconds for more data to be available (use 0 to wait forever). The return value is the amount of data available for read in the read buffer.
Parameters:
msecmilliseconds to wait
Returns:
-1 in case of system error and -2 in case of invalid socket state

Implements TDEBufferedIO.


The documentation for this class was generated from the following files:
  • kextsock.h
  • kextsock.cpp

tdecore

Skip menu "tdecore"
  • Main Page
  • Modules
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members
  • Related Pages

tdecore

Skip menu "tdecore"
  • arts
  • dcop
  • dnssd
  • interfaces
  •   kspeech
  •     interface
  •     library
  •   tdetexteditor
  • kate
  • kded
  • kdoctools
  • kimgio
  • kjs
  • libtdemid
  • libtdescreensaver
  • tdeabc
  • tdecmshell
  • tdecore
  • tdefx
  • tdehtml
  • tdeinit
  • tdeio
  •   bookmarks
  •   httpfilter
  •   kpasswdserver
  •   kssl
  •   tdefile
  •   tdeio
  •   tdeioexec
  • tdeioslave
  •   http
  • tdemdi
  •   tdemdi
  • tdenewstuff
  • tdeparts
  • tdeprint
  • tderandr
  • tderesources
  • tdespell2
  • tdesu
  • tdeui
  • tdeunittest
  • tdeutils
  • tdewallet
Generated for tdecore by doxygen 1.7.6.1
This website is maintained by Timothy Pearson.