00001
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
00027
#include <sys/types.h>
00028
#include <sys/socket.h>
00029
#include <sys/un.h>
00030
#include <arpa/inet.h>
00031
#include <netinet/in.h>
00032
#include <string.h>
00033
#include <stdlib.h>
00034
#include <unistd.h>
00035
00036
#include <qfile.h>
00037
#include <qobject.h>
00038
00039
#include "ksocketaddress.h"
00040
00041
#include "netsupp.h"
00042
00043
using namespace KNetwork;
00044
00045
#if 0
00046
class KIpAddress_localhostV4 :
public KIpAddress
00047 {
00048
public:
00049 KIpAddress_localhostV4()
00050 {
00051 *m_data = htonl(0x7f000001);
00052 m_version = 4;
00053 }
00054 };
00055
00056
class KIpAddress_localhostV6 :
public KIpAddress
00057 {
00058
public:
00059 KIpAddress_localhostV6()
00060 :
KIpAddress(0L, 6)
00061 {
00062 m_data[3] = htonl(1);
00063 }
00064 };
00065
#endif
00066
00067
static const char localhostV4_data[] = { 127, 0, 0, 1 };
00068
static const char localhostV6_data[] = { 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,1 };
00069
00070
const KIpAddress KIpAddress::localhostV4(&localhostV4_data, 4);
00071
const KIpAddress KIpAddress::localhostV6(&localhostV6_data, 6);
00072
const KIpAddress KIpAddress::anyhostV4(0L, 4);
00073
const KIpAddress KIpAddress::anyhostV6(0L, 6);
00074
00075
00076
static bool check_v4mapped(
const Q_UINT32* v6addr, Q_UINT32 v4addr)
00077 {
00078
00079
if (!(v6addr[0] == 0 && v6addr[1] == 0 && v6addr[2] == htonl(0x0000ffff)))
00080
return false;
00081
00082
return v6addr[3] == v4addr;
00083 }
00084
00085
00086 KIpAddress& KIpAddress::operator =(
const KIpAddress& other)
00087 {
00088 m_version = other.
m_version;
00089
if (m_version == 4 || m_version == 6)
00090 memcpy(m_data, other.
m_data,
sizeof(m_data));
00091
return *
this;
00092 }
00093
00094
00095 bool KIpAddress::compare(
const KIpAddress& other,
bool checkMapped)
const
00096
{
00097
if (m_version == other.
m_version)
00098
switch (m_version)
00099 {
00100
case 0:
00101
00102
return true;
00103
00104
case 4:
00105
00106
return *m_data == *other.
m_data;
00107
00108
case 6:
00109
00110
00111
return memcmp(m_data, other.
m_data, 16) == 0;
00112 }
00113
00114
if (checkMapped)
00115 {
00116
00117
if (m_version == 6 && other.
m_version == 4 && check_v4mapped(m_data, *other.
m_data))
00118
return true;
00119
00120
if (other.
m_version == 6 && m_version == 4 && check_v4mapped(other.
m_data, *m_data))
00121
return true;
00122 }
00123
00124
return false;
00125 }
00126
00127
00128 bool KIpAddress::setAddress(
const QString& address)
00129 {
00130 m_version = 0;
00131
00132
00133
if (address.find(
':') != -1)
00134 {
00135
#ifdef AF_INET6
00136
00137
00138 Q_UINT32 buf[4];
00139
if (inet_pton(AF_INET6, address.latin1(), buf))
00140 {
00141 memcpy(m_data, buf,
sizeof(m_data));
00142 m_version = 6;
00143
return true;
00144 }
00145
#endif
00146
00147
return false;
00148 }
00149
else
00150 {
00151 Q_UINT32 buf;
00152
if (inet_pton(AF_INET, address.latin1(), &buf))
00153 {
00154 *m_data = buf;
00155 m_version = 4;
00156
return true;
00157 }
00158
00159
return false;
00160 }
00161
00162
return false;
00163 }
00164
00165 bool KIpAddress::setAddress(
const char* address)
00166 {
00167
return setAddress(QString::fromLatin1(address));
00168 }
00169
00170
00171 bool KIpAddress::setAddress(
const void* raw,
int version)
00172 {
00173
00174
00175
if (version != 4 && version != 6)
00176
return false;
00177
00178 m_version = version;
00179
if (raw != 0L)
00180 memcpy(m_data, raw, version == 4 ? 4 : 16);
00181
else
00182 memset(m_data, 0, 16);
00183
00184
return true;
00185 }
00186
00187
00188 QString KIpAddress::toString()
const
00189
{
00190
char buf[
sizeof "1111:2222:3333:4444:5555:6666:255.255.255.255" + 2];
00191 buf[0] =
'\0';
00192
switch (m_version)
00193 {
00194
case 4:
00195 inet_ntop(AF_INET, m_data, buf,
sizeof(buf) - 1);
00196
return QString::fromLatin1(buf);
00197
00198
case 6:
00199
#ifdef AF_INET6
00200
inet_ntop(AF_INET6, m_data, buf,
sizeof(buf) - 1);
00201
#endif
00202
return QString::fromLatin1(buf);
00203 }
00204
00205
return QString::null;
00206 }
00207
00208
00209
00210
00211
00212
struct our_sockaddr_in6
00213 {
00214
# ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
00215
Q_UINT8 sin6_len;
00216 Q_UINT8 sin6_family;
00217
# else
00218
Q_UINT16 sin6_family;
00219
# endif
00220
Q_UINT16 sin6_port;
00221 Q_UINT32 sin6_flowinfo;
00222 Q_UINT8 sin6_addr[16];
00223 Q_UINT32 sin6_scope_id;
00224 };
00225
00226
00227
#define MIN_SOCKADDR_LEN sizeof(Q_UINT16)
00228
#define SOCKADDR_IN_LEN sizeof(sockaddr_in)
00229
#define MIN_SOCKADDR_IN6_LEN ((unsigned long) &(((our_sockaddr_in6*)0)->sin6_scope_id))
00230
#define SOCKADDR_IN6_LEN sizeof(our_sockaddr_in6)
00231
#define MIN_SOCKADDR_UN_LEN (sizeof(Q_UINT16) + sizeof(char))
00232
00233
00234
class KNetwork::KSocketAddressData
00235 {
00236
public:
00237
00238
00239
00240
00241
00242
class QMixSocketAddressRef :
public KInetSocketAddress,
public KUnixSocketAddress
00243 {
00244
public:
00245 QMixSocketAddressRef(KSocketAddressData* d)
00246 :
KInetSocketAddress(d),
KUnixSocketAddress(d)
00247 {
00248 }
00249 };
00250 QMixSocketAddressRef ref;
00251
00252
union
00253
{
00254
struct sockaddr *generic;
00255
struct sockaddr_in *in;
00256
struct our_sockaddr_in6 *in6;
00257
struct sockaddr_un *un;
00258 } addr;
00259 Q_UINT16 curlen, reallen;
00260
00261 KSocketAddressData()
00262 : ref(this)
00263 {
00264 addr.generic = 0L;
00265 curlen = 0;
00266 invalidate();
00267 }
00268
00269 ~KSocketAddressData()
00270 {
00271
if (addr.generic != 0L)
00272 free(addr.generic);
00273 }
00274
00275
inline bool invalid()
const
00276
{
return reallen == 0; }
00277
00278
inline void invalidate()
00279 { reallen = 0; }
00280
00281
void dup(
const sockaddr* sa, Q_UINT16 len,
bool clear =
true);
00282
00283
void makeipv4()
00284 {
00285
short oldport = 0;
00286
if (!invalid())
00287
switch (addr.generic->sa_family)
00288 {
00289
case AF_INET:
00290
return;
00291
#ifdef AF_INET6
00292
case AF_INET6:
00293 oldport = addr.in6->sin6_port;
00294
break;
00295
#endif
00296
}
00297
00298
00299 dup(0L, SOCKADDR_IN_LEN);
00300
00301 addr.in->sin_family = AF_INET;
00302
#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
00303
addr.in->sin_len = SOCKADDR_IN_LEN;
00304
#endif
00305
addr.in->sin_port = oldport;
00306 }
00307
00308
void makeipv6()
00309 {
00310
short oldport = 0;
00311
if (!invalid())
00312
switch (addr.generic->sa_family)
00313 {
00314
case AF_INET:
00315 oldport = addr.in->sin_port;
00316
break;
00317
00318
#ifdef AF_INET6
00319
case AF_INET6:
00320
return;
00321
#endif
00322
}
00323
00324
00325 dup(0L, SOCKADDR_IN6_LEN);
00326
#ifdef AF_INET6
00327
addr.in6->sin6_family = AF_INET6;
00328
#endif
00329
#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
00330
addr.in6->sin6_len = SOCKADDR_IN6_LEN;
00331
#endif
00332
addr.in6->sin6_port = oldport;
00333
00334 }
00335
00336 };
00337
00338
00339
void KSocketAddressData::dup(
const sockaddr* sa, Q_UINT16 len,
bool clear)
00340 {
00341
if (len < MIN_SOCKADDR_LEN)
00342 {
00343
00344 invalidate();
00345
return;
00346 }
00347
00348
if (sa && ((sa->sa_family == AF_INET && len < SOCKADDR_IN_LEN) ||
00349
#ifdef AF_INET6
00350
(sa->sa_family == AF_INET6 && len < MIN_SOCKADDR_IN6_LEN) ||
00351
#endif
00352
(sa->sa_family == AF_UNIX && len < MIN_SOCKADDR_UN_LEN)))
00353 {
00354
00355 invalidate();
00356
return;
00357 }
00358
00359
00360 reallen = len;
00361
if (len > curlen)
00362 {
00363
if (len < 32)
00364 curlen = 32;
00365
else
00366 curlen = len;
00367
addr.generic = (sockaddr*)realloc(
addr.generic, curlen);
00368 }
00369
00370
if (sa != 0L)
00371 {
00372 memcpy(
addr.generic, sa, len);
00373
00374
00375
if (
addr.generic->sa_family == AF_INET)
00376 reallen = SOCKADDR_IN_LEN;
00377
#ifdef AF_INET6
00378
else if (
addr.generic->sa_family == AF_INET6)
00379 {
00380
00381
00382
00383
00384
if (reallen < SOCKADDR_IN6_LEN)
00385
addr.in6->sin6_scope_id = 0;
00386
00387 reallen = SOCKADDR_IN6_LEN;
00388 }
00389
#endif
00390
else if (
addr.generic->sa_family == AF_UNIX)
00391 reallen = MIN_SOCKADDR_UN_LEN + strlen(
addr.un->sun_path);
00392 }
00393
else if (
clear)
00394 {
00395 memset(
addr.generic, 0, len);
00396
addr.generic->sa_family = AF_UNSPEC;
00397 }
00398 }
00399
00400
00401
KSocketAddress::KSocketAddress()
00402 : d(new KSocketAddressData)
00403 {
00404 }
00405
00406
00407
KSocketAddress::KSocketAddress(
const sockaddr *sa, Q_UINT16 len)
00408 : d(new KSocketAddressData)
00409 {
00410
setAddress(sa, len);
00411 }
00412
00413
KSocketAddress::KSocketAddress(
const KSocketAddress& other)
00414 : d(new(KSocketAddressData))
00415 {
00416 *
this = other;
00417 }
00418
00419
KSocketAddress::KSocketAddress(KSocketAddressData *d2)
00420 : d(d2)
00421 {
00422 }
00423
00424
KSocketAddress::~KSocketAddress()
00425 {
00426
00427
if (d)
00428 {
00429 d->ref.KInetSocketAddress::d = 0L;
00430 d->ref.KUnixSocketAddress::d = 0L;
00431
delete d;
00432 }
00433 }
00434
00435
KSocketAddress& KSocketAddress::operator =(
const KSocketAddress& other)
00436 {
00437
if (other.
d && !other.
d->invalid())
00438 d->dup(other.
d->addr.generic, other.
d->reallen);
00439
else
00440 d->invalidate();
00441
return *
this;
00442 }
00443
00444
const sockaddr*
KSocketAddress::address()
const
00445
{
00446
if (d->invalid())
00447
return 0L;
00448
return d->addr.generic;
00449 }
00450
00451 sockaddr*
KSocketAddress::address()
00452 {
00453
if (d->invalid())
00454
return 0L;
00455
return d->addr.generic;
00456 }
00457
00458
KSocketAddress& KSocketAddress::setAddress(
const sockaddr* sa, Q_UINT16 len)
00459 {
00460
if (sa != 0L && len >= MIN_SOCKADDR_LEN)
00461 d->dup(sa, len);
00462
else
00463 d->invalidate();
00464
00465
return *
this;
00466 }
00467
00468 Q_UINT16 KSocketAddress::length()
const
00469
{
00470
if (d->invalid())
00471
return 0;
00472
return d->reallen;
00473 }
00474
00475
KSocketAddress& KSocketAddress::setLength(Q_UINT16 len)
00476 {
00477 d->dup((sockaddr*)0L, len,
false);
00478
00479
return *
this;
00480 }
00481
00482
int KSocketAddress::family()
const
00483
{
00484
if (d->invalid())
00485
return AF_UNSPEC;
00486
return d->addr.generic->sa_family;
00487 }
00488
00489
KSocketAddress& KSocketAddress::setFamily(
int family)
00490 {
00491
if (d->invalid())
00492 d->dup((sockaddr*)0L, MIN_SOCKADDR_LEN);
00493 d->addr.generic->sa_family = family;
00494
00495
return *
this;
00496 }
00497
00498
bool KSocketAddress::operator ==(
const KSocketAddress& other)
const
00499
{
00500
00501
if (d->invalid())
00502
return other.
d->invalid();
00503
00504
00505
if (d->addr.generic->sa_family != other.
d->addr.generic->sa_family)
00506
return false;
00507
00508
00509
00510
switch (d->addr.generic->sa_family)
00511 {
00512
case AF_INET:
00513 Q_ASSERT(d->reallen == SOCKADDR_IN_LEN);
00514 Q_ASSERT(other.
d->reallen == SOCKADDR_IN_LEN);
00515
return memcmp(d->addr.in, other.
d->addr.in, SOCKADDR_IN_LEN) == 0;
00516
00517
#ifdef AF_INET6
00518
case AF_INET6:
00519 Q_ASSERT(d->reallen >= MIN_SOCKADDR_IN6_LEN);
00520 Q_ASSERT(other.
d->reallen >= MIN_SOCKADDR_IN6_LEN);
00521
00522
# if !defined(HAVE_STRUCT_SOCKADDR_IN6) || defined(HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID)
00523
00524
if (d->reallen != other.
d->reallen)
00525 {
00526
if (memcmp(d->addr.in6, other.
d->addr.in6, MIN_SOCKADDR_IN6_LEN) != 0)
00527
return false;
00528
if (d->reallen > other.
d->reallen)
00529
return d->addr.in6->sin6_scope_id == 0;
00530
else
00531
return other.
d->addr.in6->sin6_scope_id == 0;
00532 }
00533
# endif
00534
00535
return memcmp(d->addr.in6, other.
d->addr.in6, d->reallen) == 0;
00536
#endif
00537
00538
case AF_UNIX:
00539 Q_ASSERT(d->reallen >= MIN_SOCKADDR_UN_LEN);
00540 Q_ASSERT(other.
d->reallen >= MIN_SOCKADDR_UN_LEN);
00541
00542
00543
return strcmp(d->addr.un->sun_path, other.
d->addr.un->sun_path) == 0;
00544
00545
default:
00546
00547
00548
if (d->reallen == other.
d->reallen)
00549
return memcmp(d->addr.generic, other.
d->addr.generic, d->reallen) == 0;
00550 }
00551
00552
return false;
00553 }
00554
00555
QString KSocketAddress::nodeName()
const
00556
{
00557
if (d->invalid())
00558
return QString::null;
00559
00560
switch (d->addr.generic->sa_family)
00561 {
00562
case AF_INET:
00563
#ifdef AF_INET6
00564
case AF_INET6:
00565
00566
QString scopeid(
"%");
00567
if (d->addr.generic->sa_family == AF_INET6 && d->addr.in6->sin6_scope_id)
00568 scopeid += QString::number(d->addr.in6->sin6_scope_id);
00569
else
00570 scopeid.truncate(0);
00571
return d->ref.ipAddress().toString() + scopeid;
00572
#else
00573
return d->ref.ipAddress().toString();
00574
#endif
00575
}
00576
00577
00578
return QString::null;
00579 }
00580
00581
QString KSocketAddress::serviceName()
const
00582
{
00583
if (d->invalid())
00584
return QString::null;
00585
00586
switch (d->addr.generic->sa_family)
00587 {
00588
case AF_INET:
00589
#ifdef AF_INET6
00590
case AF_INET6:
00591
#endif
00592
return QString::number(d->ref.port());
00593
00594
case AF_UNIX:
00595
return d->ref.pathname();
00596 }
00597
00598
return QString::null;
00599 }
00600
00601
QString KSocketAddress::toString()
const
00602
{
00603
if (d->invalid())
00604
return QString::null;
00605
00606
QString fmt;
00607
00608
if (d->addr.generic->sa_family == AF_INET)
00609 fmt =
"%1:%2";
00610
#ifdef AF_INET6
00611
else if (d->addr.generic->sa_family == AF_INET6)
00612 fmt =
"[%1]:%2";
00613
#endif
00614
else if (d->addr.generic->sa_family == AF_UNIX)
00615
return QString::fromLatin1(
"unix:%1").arg(
serviceName());
00616
else
00617
return QObject::tr(
"Unknown family %1").arg(d->addr.generic->sa_family);
00618
00619
return fmt.arg(
nodeName()).arg(
serviceName());
00620 }
00621
00622
KInetSocketAddress& KSocketAddress::asInet()
00623 {
00624
return d->ref;
00625 }
00626
00627
KInetSocketAddress KSocketAddress::asInet()
const
00628
{
00629
return d->ref;
00630 }
00631
00632
KUnixSocketAddress& KSocketAddress::asUnix()
00633 {
00634
return d->ref;
00635 }
00636
00637
KUnixSocketAddress KSocketAddress::asUnix()
const
00638
{
00639
return d->ref;
00640 }
00641
00642
int KSocketAddress::ianaFamily(
int af)
00643 {
00644
switch (af)
00645 {
00646
case AF_INET:
00647
return 1;
00648
00649
#ifdef AF_INET6
00650
case AF_INET6:
00651
return 2;
00652
#endif
00653
00654
default:
00655
return 0;
00656 }
00657 }
00658
00659
int KSocketAddress::fromIanaFamily(
int iana)
00660 {
00661
switch (iana)
00662 {
00663
case 1:
00664
return AF_INET;
00665
00666
#ifdef AF_INET6
00667
case 2:
00668
return AF_INET6;
00669
#endif
00670
00671
default:
00672
return AF_UNSPEC;
00673 }
00674 }
00675
00676
00677
KInetSocketAddress::KInetSocketAddress()
00678 {
00679 }
00680
00681
00682
KInetSocketAddress::KInetSocketAddress(
const sockaddr* sa, Q_UINT16 len)
00683 :
KSocketAddress(sa, len)
00684 {
00685
if (!d->invalid())
00686 update();
00687 }
00688
00689
00690
KInetSocketAddress::KInetSocketAddress(
const KIpAddress& host, Q_UINT16 port)
00691 {
00692
setHost(host);
00693
setPort(port);
00694 }
00695
00696
00697
KInetSocketAddress::KInetSocketAddress(
const KInetSocketAddress& other)
00698 :
KSocketAddress(other)
00699 {
00700 }
00701
00702
00703
KInetSocketAddress::KInetSocketAddress(
const KSocketAddress& other)
00704 :
KSocketAddress(other)
00705 {
00706
if (!d->invalid())
00707 update();
00708 }
00709
00710
00711
KInetSocketAddress::KInetSocketAddress(KSocketAddressData *d)
00712 :
KSocketAddress(d)
00713 {
00714 }
00715
00716
00717
KInetSocketAddress::~KInetSocketAddress()
00718 {
00719
00720 }
00721
00722
00723
KInetSocketAddress& KInetSocketAddress::operator =(
const KInetSocketAddress& other)
00724 {
00725 KSocketAddress::operator =(other);
00726
return *
this;
00727 }
00728
00729
00730
int KInetSocketAddress::ipVersion()
const
00731
{
00732
if (d->invalid())
00733
return 0;
00734
00735
switch (d->addr.generic->sa_family)
00736 {
00737
case AF_INET:
00738
return 4;
00739
00740
#ifdef AF_INET6
00741
case AF_INET6:
00742
return 6;
00743
#endif
00744
}
00745
00746
return 0;
00747 }
00748
00749
KIpAddress KInetSocketAddress::ipAddress()
const
00750
{
00751
if (d->invalid())
00752
return KIpAddress();
00753
00754
switch (d->addr.generic->sa_family)
00755 {
00756
case AF_INET:
00757
return KIpAddress(&d->addr.in->sin_addr, 4);
00758
#ifdef AF_INET6
00759
case AF_INET6:
00760
return KIpAddress(&d->addr.in6->sin6_addr, 6);
00761
#endif
00762
}
00763
00764
return KIpAddress();
00765 }
00766
00767
KInetSocketAddress&
KInetSocketAddress::setHost(
const KIpAddress& ip)
00768 {
00769
switch (ip.
version())
00770 {
00771
case 4:
00772 makeIPv4();
00773 memcpy(&d->addr.in->sin_addr, ip.
addr(),
sizeof(d->addr.in->sin_addr));
00774
break;
00775
00776
case 6:
00777 makeIPv6();
00778 memcpy(&d->addr.in6->sin6_addr, ip.
addr(),
sizeof(d->addr.in6->sin6_addr));
00779
break;
00780
00781
default:
00782
00783 d->invalidate();
00784 }
00785
00786
return *
this;
00787 }
00788
00789
00790 Q_UINT16
KInetSocketAddress::port()
const
00791
{
00792
if (d->invalid())
00793
return 0;
00794
00795
switch (d->addr.generic->sa_family)
00796 {
00797
case AF_INET:
00798
return ntohs(d->addr.in->sin_port);
00799
00800
#ifdef AF_INET6
00801
case AF_INET6:
00802
return ntohs(d->addr.in6->sin6_port);
00803
#endif
00804
}
00805
00806
return 0;
00807 }
00808
00809
KInetSocketAddress&
KInetSocketAddress::setPort(Q_UINT16 port)
00810 {
00811
if (d->invalid())
00812 makeIPv4();
00813
00814
switch (d->addr.generic->sa_family)
00815 {
00816
case AF_INET:
00817 d->addr.in->sin_port = htons(port);
00818
break;
00819
00820
#ifdef AF_INET6
00821
case AF_INET6:
00822 d->addr.in6->sin6_port = htons(port);
00823
break;
00824
#endif
00825
00826
default:
00827 d->invalidate();
00828 }
00829
00830
return *
this;
00831 }
00832
00833
KInetSocketAddress& KInetSocketAddress::makeIPv4()
00834 {
00835 d->makeipv4();
00836
return *
this;
00837 }
00838
00839
KInetSocketAddress& KInetSocketAddress::makeIPv6()
00840 {
00841 d->makeipv6();
00842
return *
this;
00843 }
00844
00845 Q_UINT32
KInetSocketAddress::flowinfo()
const
00846
{
00847
#ifndef AF_INET6
00848
return 0;
00849
#else
00850
00851
if (!d->invalid() && d->addr.in6->sin6_family == AF_INET6)
00852
return d->addr.in6->sin6_flowinfo;
00853
return 0;
00854
#endif
00855
}
00856
00857
KInetSocketAddress&
KInetSocketAddress::setFlowinfo(Q_UINT32 flowinfo)
00858 {
00859 makeIPv6();
00860 d->addr.in6->sin6_flowinfo = flowinfo;
00861
return *
this;
00862 }
00863
00864 int KInetSocketAddress::scopeId()
const
00865
{
00866
#ifndef AF_INET6
00867
return 0;
00868
#else
00869
00870
if (!d->invalid() && d->addr.in6->sin6_family == AF_INET6)
00871
return d->addr.in6->sin6_scope_id;
00872
return 0;
00873
#endif
00874
}
00875
00876
KInetSocketAddress& KInetSocketAddress::setScopeId(
int scopeid)
00877 {
00878 makeIPv6();
00879 d->addr.in6->sin6_scope_id = scopeid;
00880
return *
this;
00881 }
00882
00883
void KInetSocketAddress::update()
00884 {
00885
if (d->addr.generic->sa_family == AF_INET)
00886
return;
00887
#ifdef AF_INET6
00888
else if (d->addr.generic->sa_family == AF_INET6)
00889
return;
00890
#endif
00891
else
00892 d->invalidate();
00893 }
00894
00895
KUnixSocketAddress::KUnixSocketAddress()
00896 {
00897 }
00898
00899
KUnixSocketAddress::KUnixSocketAddress(
const sockaddr* sa, Q_UINT16 len)
00900 :
KSocketAddress(sa, len)
00901 {
00902
if (!d->invalid() && d->addr.un->sun_family != AF_UNIX)
00903 d->invalidate();
00904 }
00905
00906
KUnixSocketAddress::KUnixSocketAddress(
const KUnixSocketAddress& other)
00907 :
KSocketAddress(other)
00908 {
00909 }
00910
00911
KUnixSocketAddress::KUnixSocketAddress(
const QString& pathname)
00912 {
00913 setPathname(pathname);
00914 }
00915
00916
KUnixSocketAddress::KUnixSocketAddress(KSocketAddressData* d)
00917 :
KSocketAddress(d)
00918 {
00919 }
00920
00921
KUnixSocketAddress::~KUnixSocketAddress()
00922 {
00923 }
00924
00925
KUnixSocketAddress& KUnixSocketAddress::operator =(
const KUnixSocketAddress& other)
00926 {
00927 KSocketAddress::operator =(other);
00928
return *
this;
00929 }
00930
00931
QString KUnixSocketAddress::pathname()
const
00932
{
00933
if (!d->invalid() && d->addr.un->sun_family == AF_UNIX)
00934
return QFile::decodeName(d->addr.un->sun_path);
00935
return QString::null;
00936 }
00937
00938
KUnixSocketAddress& KUnixSocketAddress::setPathname(
const QString& path)
00939 {
00940 d->dup(0L, MIN_SOCKADDR_UN_LEN + path.length());
00941 d->addr.un->sun_family = AF_UNIX;
00942 strcpy(d->addr.un->sun_path, QFile::encodeName(path));
00943
00944
#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
00945
d->addr.un->sun_len = d->reallen;
00946
#endif
00947
00948
return *
this;
00949 }