ksocketbase.cpp00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include <config.h>
00026 #include <qmutex.h>
00027 #include "klocale.h"
00028
00029 #include "ksocketbase.h"
00030 #include "ksocketdevice.h"
00031
00032 using namespace KNetwork;
00033
00034 class KNetwork::KSocketBasePrivate
00035 {
00036 public:
00037 int socketOptions;
00038 int socketError;
00039 int capabilities;
00040
00041 mutable KSocketDevice* device;
00042
00043 QMutex mutex;
00044
00045 KSocketBasePrivate()
00046 : mutex(true)
00047 { }
00048 };
00049
00050 KSocketBase::KSocketBase()
00051 : d(new KSocketBasePrivate)
00052 {
00053 d->socketOptions = Blocking;
00054 d->socketError = 0;
00055 d->device = 0L;
00056 d->capabilities = 0;
00057 }
00058
00059 KSocketBase::~KSocketBase()
00060 {
00061 delete d->device;
00062 delete d;
00063 }
00064
00065 bool KSocketBase::setSocketOptions(int opts)
00066 {
00067 d->socketOptions = opts;
00068 return true;
00069 }
00070
00071 int KSocketBase::socketOptions() const
00072 {
00073 return d->socketOptions;
00074 }
00075
00076 bool KSocketBase::setBlocking(bool enable)
00077 {
00078 return setSocketOptions((socketOptions() & ~Blocking) | (enable ? Blocking : 0));
00079 }
00080
00081 bool KSocketBase::blocking() const
00082 {
00083 return socketOptions() & Blocking;
00084 }
00085
00086 bool KSocketBase::setAddressReuseable(bool enable)
00087 {
00088 return setSocketOptions((socketOptions() & ~AddressReuseable) | (enable ? AddressReuseable : 0));
00089 }
00090
00091 bool KSocketBase::addressReuseable() const
00092 {
00093 return socketOptions() & AddressReuseable;
00094 }
00095
00096 bool KSocketBase::setIPv6Only(bool enable)
00097 {
00098 return setSocketOptions((socketOptions() & ~IPv6Only) | (enable ? IPv6Only : 0));
00099 }
00100
00101 bool KSocketBase::isIPv6Only() const
00102 {
00103 return socketOptions() & IPv6Only;
00104 }
00105
00106 bool KSocketBase::setBroadcast(bool enable)
00107 {
00108 return setSocketOptions((socketOptions() & ~Broadcast) | (enable ? Broadcast : 0));
00109 }
00110
00111 bool KSocketBase::broadcast() const
00112 {
00113 return socketOptions() & Broadcast;
00114 }
00115
00116 KSocketDevice* KSocketBase::socketDevice() const
00117 {
00118 if (d->device)
00119 return d->device;
00120
00121
00122 QMutexLocker locker(mutex());
00123 if (d->device)
00124 return d->device;
00125
00126 KSocketBase* that = const_cast<KSocketBase*>(this);
00127 KSocketDevice* dev = 0;
00128 if (d->capabilities)
00129 dev = KSocketDevice::createDefault(that, d->capabilities);
00130 if (!dev)
00131 dev = KSocketDevice::createDefault(that);
00132 that->setSocketDevice(dev);
00133 return d->device;
00134 }
00135
00136 void KSocketBase::setSocketDevice(KSocketDevice* device)
00137 {
00138 QMutexLocker locker(mutex());
00139 if (d->device == 0L)
00140 d->device = device;
00141 }
00142
00143 int KSocketBase::setRequestedCapabilities(int add, int remove)
00144 {
00145 d->capabilities |= add;
00146 d->capabilities &= ~remove;
00147 return d->capabilities;
00148 }
00149
00150 bool KSocketBase::hasDevice() const
00151 {
00152 return d->device != 0L;
00153 }
00154
00155 void KSocketBase::setError(SocketError error)
00156 {
00157 d->socketError = error;
00158 }
00159
00160 KSocketBase::SocketError KSocketBase::error() const
00161 {
00162 return static_cast<KSocketBase::SocketError>(d->socketError);
00163 }
00164
00165
00166 QString KSocketBase::errorString(KSocketBase::SocketError code)
00167 {
00168 QString reason;
00169 switch (code)
00170 {
00171 case NoError:
00172 reason = i18n("Socket error code NoError", "no error");
00173 break;
00174
00175 case LookupFailure:
00176 reason = i18n("Socket error code LookupFailure",
00177 "name lookup has failed");
00178 break;
00179
00180 case AddressInUse:
00181 reason = i18n("Socket error code AddressInUse",
00182 "address already in use");
00183 break;
00184
00185 case AlreadyBound:
00186 reason = i18n("Socket error code AlreadyBound",
00187 "socket is already bound");
00188 break;
00189
00190 case AlreadyCreated:
00191 reason = i18n("Socket error code AlreadyCreated",
00192 "socket is already created");
00193 break;
00194
00195 case NotBound:
00196 reason = i18n("Socket error code NotBound",
00197 "socket is not bound");
00198 break;
00199
00200 case NotCreated:
00201 reason = i18n("Socket error code NotCreated",
00202 "socket has not been created");
00203 break;
00204
00205 case WouldBlock:
00206 reason = i18n("Socket error code WouldBlock",
00207 "operation would block");
00208 break;
00209
00210 case ConnectionRefused:
00211 reason = i18n("Socket error code ConnectionRefused",
00212 "connection actively refused");
00213 break;
00214
00215 case ConnectionTimedOut:
00216 reason = i18n("Socket error code ConnectionTimedOut",
00217 "connection timed out");
00218 break;
00219
00220 case InProgress:
00221 reason = i18n("Socket error code InProgress",
00222 "operation is already in progress");
00223 break;
00224
00225 case NetFailure:
00226 reason = i18n("Socket error code NetFailure",
00227 "network failure occurred");
00228 break;
00229
00230 case NotSupported:
00231 reason = i18n("Socket error code NotSupported",
00232 "operation is not supported");
00233 break;
00234
00235 case Timeout:
00236 reason = i18n("Socket error code Timeout",
00237 "timed operation timed out");
00238 break;
00239
00240 case UnknownError:
00241 reason = i18n("Socket error code UnknownError",
00242 "an unknown/unexpected error has happened");
00243 break;
00244
00245 case RemotelyDisconnected:
00246 reason = i18n("Socket error code RemotelyDisconnected",
00247 "remote host closed connection");
00248 break;
00249
00250 default:
00251 reason = QString::null;
00252 break;
00253 }
00254
00255 return reason;
00256 }
00257
00258
00259 bool KSocketBase::isFatalError(int code)
00260 {
00261 switch (code)
00262 {
00263 case WouldBlock:
00264 case InProgress:
00265 case NoError:
00266 case RemotelyDisconnected:
00267 return false;
00268 }
00269
00270 return true;
00271 }
00272
00273 void KSocketBase::unsetSocketDevice()
00274 {
00275 d->device = 0L;
00276 }
00277
00278 QMutex* KSocketBase::mutex() const
00279 {
00280 return &d->mutex;
00281 }
00282
00283 KActiveSocketBase::KActiveSocketBase()
00284 {
00285 }
00286
00287 KActiveSocketBase::~KActiveSocketBase()
00288 {
00289 }
00290
00291 int KActiveSocketBase::getch()
00292 {
00293 unsigned char c;
00294 if (readBlock((char*)&c, 1) != 1)
00295 return -1;
00296
00297 return c;
00298 }
00299
00300 int KActiveSocketBase::putch(int ch)
00301 {
00302 unsigned char c = (unsigned char)ch;
00303 if (writeBlock((char*)&c, 1) != 1)
00304 return -1;
00305
00306 return c;
00307 }
00308
00309 void KActiveSocketBase::setError(int status, SocketError error)
00310 {
00311 KSocketBase::setError(error);
00312 setStatus(status);
00313 }
00314
00315 void KActiveSocketBase::resetError()
00316 {
00317 KSocketBase::setError(NoError);
00318 resetStatus();
00319 }
00320
00321 KPassiveSocketBase::KPassiveSocketBase()
00322 {
00323 }
00324
00325 KPassiveSocketBase::~KPassiveSocketBase()
00326 {
00327 }
|