• Skip to content
  • Skip to link menu
  • KDE API Reference
  • kdelibs-4.14.38 API Reference
  • KDE Home
  • Contact Us
 

KDECore

  • kdecore
  • network
k3socketbase.cpp
Go to the documentation of this file.
1/* -*- C++ -*-
2 * Copyright (C) 2003-2005 Thiago Macieira <thiago@kde.org>
3 *
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining
6 * a copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sublicense, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
20 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
21 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25#include "k3socketbase.h"
26
27#include <config.h>
28#include <config-network.h>
29#include <QMutex>
30#include <klocale.h>
31
32#include "k3socketdevice.h"
33
34#ifdef Q_WS_WIN
35#include <winsock2.h>
36
37void KNetwork_initSocket()
38{
39 static bool hasStarted = false;
40 if (!hasStarted)
41 {
42 WSADATA wsaData;
43 WORD wVersionRequested = MAKEWORD( 2, 2 );
44 WSAStartup( wVersionRequested, &wsaData );
45 hasStarted = true;
46 }
47}
48#endif
49
50using namespace KNetwork;
51
52class KNetwork::KSocketBasePrivate
53{
54public:
55 int socketOptions;
56 int socketError;
57 int capabilities;
58
59 mutable KSocketDevice* device;
60
61 QMutex mutex;
62
63 KSocketBasePrivate()
64 : mutex(QMutex::Recursive) // create recursive
65 { }
66};
67
68KSocketBase::KSocketBase()
69 : d(new KSocketBasePrivate)
70{
71 d->socketOptions = Blocking;
72 d->socketError = 0;
73 d->device = 0L;
74 d->capabilities = 0;
75#ifdef Q_WS_WIN
76 KNetwork_initSocket();
77#endif
78}
79
80KSocketBase::~KSocketBase()
81{
82 delete d->device;
83 delete d;
84}
85
86bool KSocketBase::setSocketOptions(int opts)
87{
88 d->socketOptions = opts;
89 return true;
90}
91
92int KSocketBase::socketOptions() const
93{
94 return d->socketOptions;
95}
96
97bool KSocketBase::setBlocking(bool enable)
98{
99 return setSocketOptions((socketOptions() & ~Blocking) | (enable ? Blocking : 0));
100}
101
102bool KSocketBase::blocking() const
103{
104 return socketOptions() & Blocking;
105}
106
107bool KSocketBase::setAddressReuseable(bool enable)
108{
109 return setSocketOptions((socketOptions() & ~AddressReuseable) | (enable ? AddressReuseable : 0));
110}
111
112bool KSocketBase::addressReuseable() const
113{
114 return socketOptions() & AddressReuseable;
115}
116
117bool KSocketBase::setIPv6Only(bool enable)
118{
119 return setSocketOptions((socketOptions() & ~IPv6Only) | (enable ? IPv6Only : 0));
120}
121
122bool KSocketBase::isIPv6Only() const
123{
124 return socketOptions() & IPv6Only;
125}
126
127bool KSocketBase::setBroadcast(bool enable)
128{
129 return setSocketOptions((socketOptions() & ~Broadcast) | (enable ? Broadcast : 0));
130}
131
132bool KSocketBase::broadcast() const
133{
134 return socketOptions() & Broadcast;
135}
136
137bool KSocketBase::setNoDelay(bool enable)
138{
139 return setSocketOptions((socketOptions() & ~NoDelay) | (enable ? NoDelay : 0));
140}
141
142bool KSocketBase::noDelay() const
143{
144 return socketOptions() & NoDelay;
145}
146
147
148KSocketDevice* KSocketBase::socketDevice() const
149{
150 if (d->device)
151 return d->device;
152
153 // it doesn't exist, so create it
154 QMutexLocker locker(mutex());
155 if (d->device)
156 return d->device;
157
158 KSocketBase* that = const_cast<KSocketBase*>(this);
159 KSocketDevice* dev = 0;
160 if (d->capabilities)
161 dev = KSocketDevice::createDefault(that, d->capabilities);
162 if (!dev)
163 dev = KSocketDevice::createDefault(that);
164 that->setSocketDevice(dev);
165 return d->device;
166}
167
168void KSocketBase::setSocketDevice(KSocketDevice* device)
169{
170 QMutexLocker locker(mutex());
171 if (d->device == 0L)
172 d->device = device;
173}
174
175int KSocketBase::setRequestedCapabilities(int add, int remove)
176{
177 d->capabilities |= add;
178 d->capabilities &= ~remove;
179 return d->capabilities;
180}
181
182bool KSocketBase::hasDevice() const
183{
184 return d->device != 0L;
185}
186
187void KSocketBase::setError(SocketError error)
188{
189 d->socketError = error;
190}
191
192void KSocketBase::resetError()
193{
194 d->socketError = NoError;
195}
196
197KSocketBase::SocketError KSocketBase::error() const
198{
199 return static_cast<KSocketBase::SocketError>(d->socketError);
200}
201
202QString KSocketBase::errorString() const
203{
204 return errorString(error());
205}
206
207// static
208QString KSocketBase::errorString(KSocketBase::SocketError code)
209{
210 QString reason;
211 switch (code)
212 {
213 case NoError:
214 reason = i18nc("Socket error code NoError", "no error");
215 break;
216
217 case LookupFailure:
218 reason = i18nc("Socket error code LookupFailure",
219 "name lookup has failed");
220 break;
221
222 case AddressInUse:
223 reason = i18nc("Socket error code AddressInUse",
224 "address already in use");
225 break;
226
227 case AlreadyBound:
228 reason = i18nc("Socket error code AlreadyBound",
229 "socket is already bound");
230 break;
231
232 case AlreadyCreated:
233 reason = i18nc("Socket error code AlreadyCreated",
234 "socket is already created");
235 break;
236
237 case NotBound:
238 reason = i18nc("Socket error code NotBound",
239 "socket is not bound");
240 break;
241
242 case NotCreated:
243 reason = i18nc("Socket error code NotCreated",
244 "socket has not been created");
245 break;
246
247 case WouldBlock:
248 reason = i18nc("Socket error code WouldBlock",
249 "operation would block");
250 break;
251
252 case ConnectionRefused:
253 reason = i18nc("Socket error code ConnectionRefused",
254 "connection actively refused");
255 break;
256
257 case ConnectionTimedOut:
258 reason = i18nc("Socket error code ConnectionTimedOut",
259 "connection timed out");
260 break;
261
262 case InProgress:
263 reason = i18nc("Socket error code InProgress",
264 "operation is already in progress");
265 break;
266
267 case NetFailure:
268 reason = i18nc("Socket error code NetFailure",
269 "network failure occurred");
270 break;
271
272 case NotSupported:
273 reason = i18nc("Socket error code NotSupported",
274 "operation is not supported");
275 break;
276
277 case Timeout:
278 reason = i18nc("Socket error code Timeout",
279 "timed operation timed out");
280 break;
281
282 case UnknownError:
283 reason = i18nc("Socket error code UnknownError",
284 "an unknown/unexpected error has happened");
285 break;
286
287 case RemotelyDisconnected:
288 reason = i18nc("Socket error code RemotelyDisconnected",
289 "remote host closed connection");
290 break;
291
292 default:
293 reason.clear();
294 break;
295 }
296
297 return reason;
298}
299
300// static
301bool KSocketBase::isFatalError(int code)
302{
303 switch (code)
304 {
305 case WouldBlock:
306 case InProgress:
307 case NoError:
308 case RemotelyDisconnected:
309 return false;
310 }
311
312 return true;
313}
314
315void KSocketBase::unsetSocketDevice()
316{
317 d->device = 0L;
318}
319
320QMutex* KSocketBase::mutex() const
321{
322 return &d->mutex;
323}
324
325KActiveSocketBase::KActiveSocketBase(QObject* parent)
326 : QIODevice(parent)
327{
328}
329
330KActiveSocketBase::~KActiveSocketBase()
331{
332}
333
334QString KActiveSocketBase::errorString() const
335{
336 return QIODevice::errorString();
337}
338
339bool KActiveSocketBase::open(OpenMode mode)
340{
341 QIODevice::open(mode);
342 if ( mode != QIODevice::NotOpen )
343 QIODevice::seek(0); // clear unget buffers
344 return true;
345}
346
347void KActiveSocketBase::setSocketDevice(KSocketDevice* dev)
348{
349 KSocketBase::setSocketDevice(dev);
350 KActiveSocketBase::open(dev->openMode());
351}
352
353bool KActiveSocketBase::isSequential() const
354{
355 return true;
356}
357
358qint64 KActiveSocketBase::size() const
359{
360 return 0;
361}
362
363qint64 KActiveSocketBase::pos() const
364{
365 return 0;
366}
367
368bool KActiveSocketBase::seek(qint64)
369{
370 return false;
371}
372
373bool KActiveSocketBase::atEnd() const
374{
375 return true;
376}
377
378qint64 KActiveSocketBase::read(char *data, qint64 maxlen)
379{
380 return QIODevice::read(data, maxlen);
381}
382
383QByteArray KActiveSocketBase::read(qint64 len)
384{
385 return QIODevice::read(len);
386}
387
388qint64 KActiveSocketBase::read(char *data, qint64 len, KSocketAddress& from)
389{
390 // FIXME TODO: implement unget buffers
391 return readData(data, len, &from);
392}
393
394qint64 KActiveSocketBase::peek(char *data, qint64 len)
395{
396 return peekData(data, len, 0L);
397}
398
399qint64 KActiveSocketBase::peek(char *data, qint64 len, KSocketAddress& from)
400{
401 return peekData(data, len, &from);
402}
403
404qint64 KActiveSocketBase::write(const char *data, qint64 len)
405{
406 return QIODevice::write(data, len);
407}
408
409qint64 KActiveSocketBase::write(const QByteArray& data)
410{
411 return QIODevice::write(data);
412}
413
414qint64 KActiveSocketBase::write(const char *data, qint64 len,
415 const KSocketAddress& to)
416{
417 return writeData(data, len, &to);
418}
419
420void KActiveSocketBase::ungetChar(char)
421{
422 return;
423}
424
425qint64 KActiveSocketBase::readData(char *data, qint64 len)
426{
427 return readData(data, len, 0L);
428}
429
430qint64 KActiveSocketBase::writeData(const char *data, qint64 len)
431{
432 return writeData(data, len, 0L);
433}
434
435void KActiveSocketBase::setError(SocketError error)
436{
437 KSocketBase::setError(error);
438 setErrorString(KSocketBase::errorString());
439}
440
441void KActiveSocketBase::resetError()
442{
443 KSocketBase::setError(NoError);
444 setErrorString(QString());
445}
446
447KPassiveSocketBase::KPassiveSocketBase()
448{
449}
450
451KPassiveSocketBase::~KPassiveSocketBase()
452{
453}
454
455#include "k3socketbase.moc"
456
KNetwork::KActiveSocketBase::isSequential
virtual bool isSequential() const
Sockets are sequential.
Definition: k3socketbase.cpp:353
KNetwork::KActiveSocketBase::seek
virtual bool seek(qint64)
This call is not supported on sockets.
Definition: k3socketbase.cpp:368
KNetwork::KActiveSocketBase::~KActiveSocketBase
virtual ~KActiveSocketBase()
Destructor.
Definition: k3socketbase.cpp:330
KNetwork::KActiveSocketBase::ungetChar
void ungetChar(char)
This call is not supported on sockets.
Definition: k3socketbase.cpp:420
KNetwork::KActiveSocketBase::writeData
virtual qint64 writeData(const char *data, qint64 len)
Writes the given data to the socket.
Definition: k3socketbase.cpp:430
KNetwork::KActiveSocketBase::KActiveSocketBase
KActiveSocketBase(QObject *parent)
Constructor.
Definition: k3socketbase.cpp:325
KNetwork::KActiveSocketBase::read
qint64 read(char *data, qint64 maxlen)
Reads data from the socket.
Definition: k3socketbase.cpp:378
KNetwork::KActiveSocketBase::resetError
void resetError()
Resets the socket error code and the I/O Device's status.
Definition: k3socketbase.cpp:441
KNetwork::KActiveSocketBase::size
virtual qint64 size() const
This call is not supported on sockets.
Definition: k3socketbase.cpp:358
KNetwork::KActiveSocketBase::write
qint64 write(const char *data, qint64 len)
Writes the given data to the socket.
Definition: k3socketbase.cpp:404
KNetwork::KActiveSocketBase::peekData
virtual qint64 peekData(char *data, qint64 maxlen, KSocketAddress *from)=0
Peeks the data in the socket and the source address.
KNetwork::KActiveSocketBase::atEnd
virtual bool atEnd() const
This call is not supported on sockets.
Definition: k3socketbase.cpp:373
KNetwork::KActiveSocketBase::peek
qint64 peek(char *data, qint64 maxlen)
Peeks the data in the socket and the source address.
Definition: k3socketbase.cpp:394
KNetwork::KActiveSocketBase::errorString
QString errorString() const
Unshadow errorString from QIODevice.
Definition: k3socketbase.cpp:334
KNetwork::KActiveSocketBase::readData
virtual qint64 readData(char *data, qint64 len)
Reads data from the socket.
Definition: k3socketbase.cpp:425
KNetwork::KActiveSocketBase::open
virtual bool open(OpenMode mode)
Reimplemented from QIODevice.
Definition: k3socketbase.cpp:339
KNetwork::KActiveSocketBase::setError
void setError(SocketError error)
Sets the socket's error code.
Definition: k3socketbase.cpp:435
KNetwork::KActiveSocketBase::setSocketDevice
virtual void setSocketDevice(KSocketDevice *device)
Definition: k3socketbase.cpp:347
KNetwork::KActiveSocketBase::pos
virtual qint64 pos() const
This call is not supported on sockets.
Definition: k3socketbase.cpp:363
KNetwork::KPassiveSocketBase::KPassiveSocketBase
KPassiveSocketBase()
Constructor.
Definition: k3socketbase.cpp:447
KNetwork::KPassiveSocketBase::~KPassiveSocketBase
virtual ~KPassiveSocketBase()
Destructor.
Definition: k3socketbase.cpp:451
KNetwork::KSocketAddress
A generic socket address.
Definition: k3socketaddress.h:415
KNetwork::KSocketBase
Basic socket functionality.
Definition: k3socketbase.h:86
KNetwork::KSocketBase::errorString
QString errorString() const
Returns the error string corresponding to this error condition.
Definition: k3socketbase.cpp:202
KNetwork::KSocketBase::resetError
void resetError()
Resets the socket error code and the I/O Device's status.
Definition: k3socketbase.cpp:192
KNetwork::KSocketBase::isFatalError
static bool isFatalError(int code)
Returns true if the given error code is a fatal one, false otherwise.
Definition: k3socketbase.cpp:301
KNetwork::KSocketBase::setRequestedCapabilities
int setRequestedCapabilities(int add, int remove=0)
Sets the internally requested capabilities for a socket device.
Definition: k3socketbase.cpp:175
KNetwork::KSocketBase::isIPv6Only
bool isIPv6Only() const
Retrieves this socket's IPv6 Only flag.
Definition: k3socketbase.cpp:122
KNetwork::KSocketBase::setBroadcast
virtual bool setBroadcast(bool enable)
Sets this socket Broadcast flag.
Definition: k3socketbase.cpp:127
KNetwork::KSocketBase::broadcast
bool broadcast() const
Retrieves this socket's Broadcast flag.
Definition: k3socketbase.cpp:132
KNetwork::KSocketBase::setSocketOptions
virtual bool setSocketOptions(int opts)
Set the given socket options.
Definition: k3socketbase.cpp:86
KNetwork::KSocketBase::hasDevice
bool hasDevice() const
Returns true if the socket device has been initialised in this object, either by calling socketDevice...
Definition: k3socketbase.cpp:182
KNetwork::KSocketBase::socketOptions
virtual int socketOptions() const
Retrieves the socket options that have been set.
Definition: k3socketbase.cpp:92
KNetwork::KSocketBase::setSocketDevice
virtual void setSocketDevice(KSocketDevice *device)
Sets the socket implementation to be used on this socket.
Definition: k3socketbase.cpp:168
KNetwork::KSocketBase::KSocketBase
KSocketBase()
Default constructor.
Definition: k3socketbase.cpp:68
KNetwork::KSocketBase::setIPv6Only
virtual bool setIPv6Only(bool enable)
Sets this socket's IPv6 Only flag.
Definition: k3socketbase.cpp:117
KNetwork::KSocketBase::~KSocketBase
virtual ~KSocketBase()
Destructor.
Definition: k3socketbase.cpp:80
KNetwork::KSocketBase::noDelay
bool noDelay() const
Retrieves this socket's NoDelay flag.
Definition: k3socketbase.cpp:142
KNetwork::KSocketBase::AddressReuseable
@ AddressReuseable
Definition: k3socketbase.h:111
KNetwork::KSocketBase::IPv6Only
@ IPv6Only
Definition: k3socketbase.h:112
KNetwork::KSocketBase::Broadcast
@ Broadcast
Definition: k3socketbase.h:114
KNetwork::KSocketBase::NoDelay
@ NoDelay
Definition: k3socketbase.h:115
KNetwork::KSocketBase::Blocking
@ Blocking
Definition: k3socketbase.h:110
KNetwork::KSocketBase::SocketError
SocketError
Possible socket error codes.
Definition: k3socketbase.h:144
KNetwork::KSocketBase::NotSupported
@ NotSupported
Definition: k3socketbase.h:159
KNetwork::KSocketBase::AlreadyCreated
@ AlreadyCreated
Definition: k3socketbase.h:148
KNetwork::KSocketBase::InProgress
@ InProgress
Definition: k3socketbase.h:157
KNetwork::KSocketBase::NotCreated
@ NotCreated
Definition: k3socketbase.h:153
KNetwork::KSocketBase::NotBound
@ NotBound
Definition: k3socketbase.h:152
KNetwork::KSocketBase::NoError
@ NoError
Definition: k3socketbase.h:145
KNetwork::KSocketBase::UnknownError
@ UnknownError
Definition: k3socketbase.h:161
KNetwork::KSocketBase::ConnectionRefused
@ ConnectionRefused
Definition: k3socketbase.h:155
KNetwork::KSocketBase::AddressInUse
@ AddressInUse
Definition: k3socketbase.h:147
KNetwork::KSocketBase::LookupFailure
@ LookupFailure
Definition: k3socketbase.h:146
KNetwork::KSocketBase::RemotelyDisconnected
@ RemotelyDisconnected
Definition: k3socketbase.h:162
KNetwork::KSocketBase::NetFailure
@ NetFailure
Definition: k3socketbase.h:158
KNetwork::KSocketBase::ConnectionTimedOut
@ ConnectionTimedOut
Definition: k3socketbase.h:156
KNetwork::KSocketBase::Timeout
@ Timeout
Definition: k3socketbase.h:160
KNetwork::KSocketBase::WouldBlock
@ WouldBlock
Definition: k3socketbase.h:154
KNetwork::KSocketBase::AlreadyBound
@ AlreadyBound
Definition: k3socketbase.h:149
KNetwork::KSocketBase::blocking
bool blocking() const
Retrieves this socket's blocking mode.
Definition: k3socketbase.cpp:102
KNetwork::KSocketBase::error
SocketError error() const
Retrieves the socket error code.
Definition: k3socketbase.cpp:197
KNetwork::KSocketBase::setBlocking
virtual bool setBlocking(bool enable)
Sets this socket's blocking mode.
Definition: k3socketbase.cpp:97
KNetwork::KSocketBase::setAddressReuseable
virtual bool setAddressReuseable(bool enable)
Sets this socket's address reuseable flag.
Definition: k3socketbase.cpp:107
KNetwork::KSocketBase::setNoDelay
virtual bool setNoDelay(bool enable)
Sets this socket's NoDelay flag.
Definition: k3socketbase.cpp:137
KNetwork::KSocketBase::socketDevice
KSocketDevice * socketDevice() const
Retrieves the socket implementation used on this socket.
Definition: k3socketbase.cpp:148
KNetwork::KSocketBase::addressReuseable
bool addressReuseable() const
Retrieves this socket's address reuseability flag.
Definition: k3socketbase.cpp:112
KNetwork::KSocketBase::setError
void setError(SocketError error)
Sets the socket's error code.
Definition: k3socketbase.cpp:187
KNetwork::KSocketBase::mutex
QMutex * mutex() const
Returns the internal mutex for this class.
Definition: k3socketbase.cpp:320
KNetwork::KSocketDevice
Low-level socket functionality.
Definition: k3socketdevice.h:52
KNetwork::KSocketDevice::createDefault
static KSocketDevice * createDefault(KSocketBase *parent)
Creates a new default KSocketDevice object given the parent object.
Definition: k3socketdevice.cpp:877
QIODevice
QObject
QString
qint64
KNetwork_initSocket
void KNetwork_initSocket()
Definition: k3socketbase.cpp:37
k3socketbase.h
k3socketdevice.h
klocale.h
i18nc
QString i18nc(const char *ctxt, const char *text)
Returns a localized version of a string and a context.
Definition: klocalizedstring.h:797
KNetwork
A namespace to store all networking-related (socket) classes.
Definition: k3bufferedsocket.h:35
This file is part of the KDE documentation.
Documentation copyright © 1996-2023 The KDE developers.
Generated on Mon Feb 20 2023 00:00:00 by doxygen 1.9.6 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

KDECore

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

kdelibs-4.14.38 API Reference

Skip menu "kdelibs-4.14.38 API Reference"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDEWebKit
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • kio
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • KPty
  • Kross
  • KUnitConversion
  • KUtils
  • Nepomuk
  • Plasma
  • Solid
  • Sonnet
  • ThreadWeaver
Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal