00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include "ksockaddr.h"
00022 #include <config.h>
00023
00024 #include <sys/types.h>
00025
00026 #ifdef Q_OS_UNIX
00027 #include <arpa/inet.h>
00028 #endif
00029 #include <netinet/in.h>
00030
00031 #include <limits.h>
00032 #include <stdlib.h>
00033 #include <string.h>
00034 #include <sys/un.h>
00035 #include <unistd.h>
00036
00037 #include <qglobal.h>
00038 #include <qfile.h>
00039
00040 #include "kdebug.h"
00041 #include "klocale.h"
00042
00043
00044 #ifndef HAVE_STRUCT_SOCKADDR_IN6
00045
00046
00047 #define CLOBBER_IN6
00048 #endif
00049
00050 #include "netsupp.h"
00051
00052 #define V6_CAN_CONVERT_TO_V4(addr) (KDE_IN6_IS_ADDR_V4MAPPED(addr) || KDE_IN6_IS_ADDR_V4COMPAT(addr))
00053
00054 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
00055 # define MY_MAX(a, b) ((a) > (b) ? (a) : (b))
00056 # define MIN_SOCKADDR_LEN MY_MAX(offsetof(sockaddr, sa_family) + sizeof(((sockaddr*)0)->sa_family), \
00057 offsetof(sockaddr, sa_len) + sizeof(((sockaddr*)0)->sa_len))
00058 #else
00059 # define MIN_SOCKADDR_LEN (offsetof(sockaddr, sa_family) + sizeof(((sockaddr*)0)->sa_family))
00060 #endif
00061
00062
00063
00064
00065 #define MIN_SOCKADDR_IN6_LEN (offsetof(sockaddr_in6, sin6_addr) + sizeof(((sockaddr_in6*)0)->sin6_addr))
00066
00067 #ifdef offsetof
00068 #undef offsetof
00069 #endif
00070 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
00071
00072
00073
00074 #ifndef INET6_ADDRSTRLEN
00075 #define INET6_ADDRSTRLEN 46
00076 #endif
00077
00078
00083 KSocketAddress::KSocketAddress(const sockaddr* sa, ksocklen_t size)
00084 {
00085 if ( !sa )
00086 init();
00087 else {
00088 data = (sockaddr*)malloc(size);
00089 if (data == NULL)
00090 return;
00091 memcpy(data, sa, size);
00092 datasize = size;
00093 owndata = true;
00094 }
00095 }
00096
00097 void KSocketAddress::init()
00098 {
00099 data = NULL;
00100 datasize = 0;
00101 owndata = false;
00102 }
00103
00104 KSocketAddress::~KSocketAddress()
00105 {
00106 if (owndata && data != NULL)
00107 free(data);
00108 }
00109
00110 QString KSocketAddress::pretty() const
00111 {
00112 return i18n("<unknown socket>");
00113 }
00114
00115 int KSocketAddress::family() const
00116 {
00117 if (data != NULL)
00118 return data->sa_family;
00119 return AF_UNSPEC;
00120 }
00121
00122
00123 KSocketAddress* KSocketAddress::newAddress(const struct sockaddr* sa, ksocklen_t size)
00124 {
00125 if (size == 0)
00126 {
00127 kdWarning() << "KSocketAddress::newAddress called with size = 0!\n";
00128 return NULL;
00129 }
00130
00131
00132 if (size < MIN_SOCKADDR_LEN)
00133 {
00134 kdWarning() << "KSocketAddress::newAddress called with invalid size\n";
00135 return NULL;
00136 }
00137
00138 switch (sa->sa_family)
00139 {
00140 case AF_INET:
00141 if (size >= sizeof(sockaddr_in))
00142 return new KInetSocketAddress((const sockaddr_in*)sa, size);
00143 return NULL;
00144
00145 #ifdef AF_INET6
00146 case AF_INET6:
00147 if (size >= MIN_SOCKADDR_IN6_LEN)
00148 return new KInetSocketAddress((const sockaddr_in6*)sa, size);
00149 return NULL;
00150 #endif
00151
00152 case AF_UNIX:
00153 return new KUnixSocketAddress((const sockaddr_un*)sa, size);
00154 }
00155
00156 return new KSocketAddress(sa, size);
00157 }
00158
00159 bool KSocketAddress::isEqual(const KSocketAddress& other) const
00160 {
00161 switch(family())
00162 {
00163 case AF_INET:
00164 return KInetSocketAddress::areEqualInet(*this, other, false);
00165 #ifdef AF_INET6
00166 case AF_INET6:
00167 return KInetSocketAddress::areEqualInet6(*this, other, false);
00168 #endif
00169 case AF_UNIX:
00170 return KUnixSocketAddress::areEqualUnix(*this, other, false);
00171 }
00172
00173
00174 if (other.datasize != datasize)
00175 return false;
00176 return memcmp(data, other.data, datasize) == 0;
00177 }
00178
00179 bool KSocketAddress::isCoreEqual(const KSocketAddress& other) const
00180 {
00181 switch(family())
00182 {
00183 case AF_INET:
00184 return KInetSocketAddress::areEqualInet(*this, other, true);
00185 #ifdef AF_INET6
00186 case AF_INET6:
00187 return KInetSocketAddress::areEqualInet6(*this, other, true);
00188 #endif
00189 case AF_UNIX:
00190 return KUnixSocketAddress::areEqualUnix(*this, other, true);
00191 }
00192
00193 return false;
00194 }
00195
00196 QString KSocketAddress::nodeName() const
00197 {
00198 return QString::null;
00199 }
00200
00201 QString KSocketAddress::serviceName() const
00202 {
00203 return QString::null;
00204 }
00205
00206 int KSocketAddress::ianaFamily(int af)
00207 {
00208 switch (af)
00209 {
00210 case AF_INET:
00211 return 1;
00212 #ifdef AF_INET6
00213 case AF_INET6:
00214 return 2;
00215 #endif
00216 default:
00217 return 0;
00218 }
00219 }
00220
00221 int KSocketAddress::fromIanaFamily(int iana)
00222 {
00223 switch (iana)
00224 {
00225 case 1:
00226 return AF_INET;
00227 #ifdef AF_INET6
00228 case 2:
00229 return AF_INET6;
00230 #endif
00231 default:
00232 return AF_UNSPEC;
00233 }
00234 }
00235
00239 class KInetSocketAddressPrivate
00240 {
00241 public:
00242 int sockfamily;
00243 sockaddr_in sin;
00244 #ifdef AF_INET6
00245 sockaddr_in6 sin6;
00246 #endif
00247
00248 KInetSocketAddressPrivate() :
00249 sockfamily(AF_UNSPEC)
00250 {
00251 sin.sin_family = AF_INET;
00252 sin.sin_port = 0;
00253 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
00254 sin.sin_len = sizeof(sin);
00255 #endif
00256 #ifdef AF_INET6
00257 sin6.sin6_family = AF_INET6;
00258 sin6.sin6_port = 0;
00259 sin6.sin6_flowinfo = 0;
00260 # ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
00261 sin6.sin6_scope_id = 0;
00262 # endif
00263 # ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
00264 sin6.sin6_len = sizeof(sin6);
00265 # endif
00266 #endif
00267 }
00268
00269 };
00270
00271 KInetSocketAddress::KInetSocketAddress() :
00272 d(new KInetSocketAddressPrivate)
00273 {
00274 }
00275
00276 KInetSocketAddress::KInetSocketAddress(const KInetSocketAddress &other) :
00277 KSocketAddress(), d(new KInetSocketAddressPrivate)
00278 {
00279 setAddress(other);
00280 }
00281
00282 KInetSocketAddress::KInetSocketAddress(const sockaddr_in* sin, ksocklen_t len) :
00283 d(new KInetSocketAddressPrivate)
00284 {
00285 setAddress(sin, len);
00286 }
00287
00288 KInetSocketAddress::KInetSocketAddress(const sockaddr_in6* sin6, ksocklen_t len) :
00289 d(new KInetSocketAddressPrivate)
00290 {
00291 setAddress(sin6, len);
00292 }
00293
00294 KInetSocketAddress::KInetSocketAddress(const in_addr& addr, unsigned short port) :
00295 d(new KInetSocketAddressPrivate)
00296 {
00297 setAddress(addr, port);
00298 }
00299
00300 KInetSocketAddress::KInetSocketAddress(const in6_addr& addr, unsigned short port) :
00301 d(new KInetSocketAddressPrivate)
00302 {
00303 setAddress(addr, port);
00304 }
00305
00306 KInetSocketAddress::KInetSocketAddress(const QString& addr, unsigned short port, int family) :
00307 d(new KInetSocketAddressPrivate)
00308 {
00309 setAddress(addr, port, family);
00310 }
00311
00312 KInetSocketAddress::~KInetSocketAddress()
00313 {
00314 delete d;
00315
00316
00317 }
00318
00319 bool KInetSocketAddress::setAddress(const KInetSocketAddress &other)
00320 {
00321 if (other.family() == AF_INET)
00322 return setAddress(other.addressV4(), other.size());
00323 #ifdef AF_INET6
00324 else if (other.family() == AF_INET6)
00325 return setAddress(other.addressV6(), other.size());
00326 #endif
00327 return false;
00328 }
00329
00330 bool KInetSocketAddress::setAddress(const sockaddr_in* sin, ksocklen_t len)
00331 {
00332
00333 if ((len < sizeof(sockaddr_in)) || (sin->sin_family != AF_INET))
00334 {
00335 kdWarning() << "KInetSocketAddress::setAddress(sockaddr_in*) called with invalid sockaddr_in\n";
00336 return false;
00337 }
00338
00339 return setHost(sin->sin_addr) && setPort(ntohs(sin->sin_port));
00340 }
00341
00342 bool KInetSocketAddress::setAddress(const sockaddr_in6* sin6, ksocklen_t len)
00343 {
00344 #ifdef AF_INET6
00345
00346 if ((len < MIN_SOCKADDR_IN6_LEN) || (sin6->sin6_family != AF_INET6))
00347 {
00348 kdWarning() << "KInetSocketAddress::setAddress(sockaddr_in6*) called with invalid sockaddr_in6\n";
00349 return 0;
00350 }
00351
00352 memset(&d->sin6, 0, sizeof(d->sin6));
00353 if (len > sizeof(d->sin6))
00354 len = sizeof(d->sin6);
00355 memcpy(&d->sin6, sin6, len);
00356
00357
00358 d->sockfamily = d->sin6.sin6_family = AF_INET6;
00359 # ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
00360 d->sin6.sin6_len = sizeof(d->sin6);
00361 # endif
00362
00363 fromV6();
00364 return true;
00365 #else // !AF_INET6
00366 return false;
00367 #endif
00368 }
00369
00370 bool KInetSocketAddress::setAddress(const in_addr& addr, unsigned short port)
00371 {
00372 return setHost(addr) && setPort(port);
00373 }
00374
00375 bool KInetSocketAddress::setAddress(const in6_addr& addr, unsigned short port)
00376 {
00377 return setHost(addr) && setPort(port);
00378 }
00379
00380 bool KInetSocketAddress::setAddress(const QString& addr, unsigned short port, int family)
00381 {
00382 return setHost(addr, family) && setPort(port);
00383 }
00384
00385 bool KInetSocketAddress::setHost(const in_addr& addr)
00386 {
00387 d->sockfamily = AF_INET;
00388 d->sin.sin_addr = addr;
00389 fromV4();
00390 return true;
00391 }
00392
00393 bool KInetSocketAddress::setHost(const in6_addr& addr)
00394 {
00395 #ifdef AF_INET6
00396 d->sockfamily = AF_INET6;
00397 d->sin6.sin6_addr = addr;
00398 fromV6();
00399 return true;
00400 #else
00401 return false;
00402 #endif
00403 }
00404
00405 bool KInetSocketAddress::setHost(const QString& addr, int family)
00406 {
00407
00408 if ((family != -1) && (family != AF_INET)
00409 #ifdef AF_INET6
00410 && (family != AF_INET6)
00411 #endif
00412 )
00413 {
00414 kdWarning() << "KInetSocketAddress::setHost(QString, int) called with unknown family address\n";
00415 return false;
00416 }
00417
00418 if (family == -1)
00419 {
00420
00421
00422 #ifdef AF_INET6
00423
00424 if (addr.find(':') != -1)
00425 family = AF_INET6;
00426 else
00427 family = AF_INET;
00428 #else
00429
00430
00431 family = AF_INET;
00432 #endif
00433 }
00434
00435
00436
00437
00438 if (family == AF_INET)
00439 {
00440 inet_pton(family, addr.latin1(), (void*)&(d->sin.sin_addr));
00441 fromV4();
00442 }
00443 #ifdef AF_INET6
00444 else
00445 {
00446 inet_pton(family, addr.latin1(), (void*)&(d->sin6.sin6_addr));
00447 fromV6();
00448 }
00449 #endif
00450 d->sockfamily = family;
00451 return true;
00452 }
00453
00454 bool KInetSocketAddress::setPort(unsigned short port)
00455 {
00456
00457 d->sin.sin_port = htons(port);
00458 #ifdef AF_INET6
00459 d->sin6.sin6_port = htons(port);
00460 #endif
00461
00462 return true;
00463 }
00464
00465 bool KInetSocketAddress::setFamily(int _family)
00466 {
00467 if (_family != AF_INET
00468 #ifdef AF_INET6
00469 && _family != AF_INET6
00470 #endif
00471 )
00472 {
00473 kdWarning() << "KInetSocketAddress::setFamily(int) called with unknown family\n";
00474 return false;
00475 }
00476
00477 d->sockfamily = _family;
00478 if (_family == AF_INET)
00479 fromV4();
00480 #ifdef AF_INET6
00481 else if (_family == AF_INET6)
00482 fromV6();
00483 #endif
00484
00485 return true;
00486 }
00487
00488 bool KInetSocketAddress::setFlowinfo(Q_UINT32 flowinfo)
00489 {
00490 #ifdef AF_INET6
00491 if (d->sockfamily == AF_INET6)
00492 {
00493 d->sin6.sin6_flowinfo = flowinfo;
00494 return true;
00495 }
00496 #endif
00497 return false;
00498 }
00499
00500 bool KInetSocketAddress::setScopeId(int scopeid)
00501 {
00502 #if defined(AF_INET6) && defined(HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID)
00503 if (d->sockfamily == AF_INET6)
00504 {
00505 d->sin6.sin6_scope_id = scopeid;
00506 return true;
00507 }
00508 #endif
00509 (void)scopeid;
00510 return false;
00511 }
00512
00513 const sockaddr_in* KInetSocketAddress::addressV4() const
00514 {
00515 if (d->sockfamily == AF_INET)
00516 return &d->sin;
00517 #ifdef AF_INET6
00518 else if (d->sockfamily == AF_INET6)
00519 {
00520
00521 if (V6_CAN_CONVERT_TO_V4(&d->sin6.sin6_addr))
00522 return &d->sin;
00523 else
00524 return NULL;
00525 }
00526 #endif
00527
00528 kdWarning() << "KInetSocketAddress::addressV4() called on uninitialized socket\n";
00529 return NULL;
00530 }
00531
00532 const sockaddr_in6* KInetSocketAddress::addressV6() const
00533 {
00534 #ifdef AF_INET6
00535 return &d->sin6;
00536 #else
00537 return NULL;
00538 #endif
00539 }
00540
00541 in_addr KInetSocketAddress::hostV4() const
00542 {
00543
00544 return d->sin.sin_addr;
00545 }
00546
00547
00548
00549
00550
00551
00552 #ifdef AF_INET6
00553 in6_addr KInetSocketAddress::hostV6() const
00554 {
00555 return d->sin6.sin6_addr;
00556 }
00557 #endif
00558
00559 QString KInetSocketAddress::pretty() const
00560 {
00561 if (d->sockfamily != AF_INET
00562 #ifdef AF_INET6
00563 && d->sockfamily != AF_INET6
00564 #endif
00565 )
00566 {
00567 kdWarning() << "KInetSocketAddress::pretty() called on uninitialized class\n";
00568 return i18n("<empty>");
00569 }
00570
00571 return i18n("1: hostname, 2: port number", "%1 port %2").arg(nodeName()).arg(serviceName());
00572 }
00573
00574 QString KInetSocketAddress::nodeName() const
00575 {
00576 char buf[INET6_ADDRSTRLEN];
00577
00578 if (d->sockfamily == AF_INET)
00579 inet_ntop(d->sockfamily, (void*)&d->sin.sin_addr, buf, sizeof(buf));
00580 #ifdef AF_INET6
00581 else if (d->sockfamily == AF_INET6)
00582 inet_ntop(d->sockfamily, (void*)&d->sin6.sin6_addr, buf, sizeof(buf));
00583 #endif
00584 else
00585 {
00586 kdWarning() << "KInetSocketAddress::nodeName() called on uninitialized class\n";
00587 return i18n("<empty>");
00588 }
00589
00590 return QString::fromLatin1(buf);
00591 }
00592
00593 QString KInetSocketAddress::serviceName() const
00594 {
00595 return QString::number(port());
00596 }
00597
00598 unsigned short KInetSocketAddress::port() const
00599 {
00600 #ifdef AF_INET6
00601
00602 return ntohs(d->sin6.sin6_port);
00603 #else
00604 return ntohs(d->sin.sin_port);
00605 #endif
00606 }
00607
00608 Q_UINT32 KInetSocketAddress::flowinfo() const
00609 {
00610 #ifdef AF_INET6
00611 if (d->sockfamily == AF_INET6)
00612 return (Q_UINT32)d->sin6.sin6_flowinfo;
00613 #endif
00614 return 0;
00615 }
00616
00617 ksocklen_t KInetSocketAddress::size() const
00618 {
00619 if (d->sockfamily == AF_INET)
00620 return sizeof(d->sin);
00621 #ifdef AF_INET6
00622 else if (d->sockfamily == AF_INET6)
00623 return sizeof(d->sin6);
00624 #endif
00625 else
00626 return 0;
00627 }
00628
00629 bool KInetSocketAddress::areEqualInet(const KSocketAddress &s1, const KSocketAddress &s2, bool coreOnly)
00630 {
00631 if (s1.family() != s2.family())
00632 return false;
00633 if ((s1.size() < sizeof(sockaddr_in)) || (s2.size() < sizeof(sockaddr_in)))
00634 return false;
00635
00636 struct sockaddr_in *sin1 = (sockaddr_in *) s1.address();
00637 struct sockaddr_in *sin2 = (sockaddr_in *) s2.address();
00638
00639 if (coreOnly)
00640 return (memcmp(&sin1->sin_addr, &sin2->sin_addr, sizeof(struct in_addr)) == 0);
00641 else
00642 return (sin1->sin_port == sin2->sin_port) &&
00643 (memcmp(&sin1->sin_addr, &sin2->sin_addr, sizeof(struct in_addr)) == 0);
00644 }
00645
00646 bool KInetSocketAddress::areEqualInet6(const KSocketAddress &s1, const KSocketAddress &s2, bool coreOnly)
00647 {
00648 #ifdef AF_INET6
00649 if (s1.family() != s2.family())
00650 return false;
00651
00652 if ((s1.size() < sizeof(sockaddr_in6)) || (s2.size() < sizeof(sockaddr_in6)))
00653 return false;
00654
00655 struct sockaddr_in6 *sin1 = (sockaddr_in6 *) s1.address();
00656 struct sockaddr_in6 *sin2 = (sockaddr_in6 *) s2.address();
00657
00658 if (coreOnly)
00659 return (memcmp(&sin1->sin6_addr, &sin2->sin6_addr, sizeof(struct in6_addr)) == 0);
00660 else
00661 return (sin1->sin6_port == sin2->sin6_port) &&
00662 (sin1->sin6_flowinfo == sin2->sin6_flowinfo) &&
00663 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
00664 (sin1->sin6_scope_id == sin2->sin6_scope_id) &&
00665 #endif
00666 (memcmp(&sin1->sin6_addr, &sin2->sin6_addr, sizeof(struct in6_addr)) == 0);
00667 #else
00668 return false;
00669 #endif
00670 }
00671
00672 void KInetSocketAddress::fromV4()
00673 {
00674
00675
00676 #ifdef AF_INET6
00677 d->sin6.sin6_port = d->sin.sin_port;
00678
00679
00680 ((Q_UINT32*)&d->sin6.sin6_addr)[0] = ((Q_UINT32*)&d->sin6.sin6_addr)[1] = 0;
00681 ((Q_UINT32*)&d->sin6.sin6_addr)[2] = htonl(0xffff);
00682 ((Q_UINT32*)&d->sin6.sin6_addr)[3] = *(Q_UINT32*)&d->sin.sin_addr;
00683
00684
00685 d->sin6.sin6_flowinfo = 0;
00686 # ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
00687 d->sin6.sin6_scope_id = 0;
00688 # endif
00689 #endif
00690
00691
00692 data = (sockaddr*)&d->sin;
00693 datasize = sizeof( sockaddr_in );
00694 }
00695
00696 void KInetSocketAddress::fromV6()
00697 {
00698 #ifdef AF_INET6
00699
00700 if (V6_CAN_CONVERT_TO_V4(&d->sin6.sin6_addr))
00701 {
00702 d->sin.sin_port = d->sin6.sin6_port;
00703 *(Q_UINT32*)&d->sin.sin_addr = ((Q_UINT32*)&d->sin6.sin6_addr)[3];
00704 }
00705 else
00706 {
00707 d->sin.sin_port = 0;
00708 memset(&d->sin.sin_addr, 0, sizeof(d->sin.sin_addr));
00709 }
00710
00711 data = (sockaddr*)&d->sin6;
00712 datasize = sizeof( d->sin6 );
00713 #endif
00714 }
00715
00716 QString KInetSocketAddress::addrToString(int family, const void* addr)
00717 {
00718 char buf[INET6_ADDRSTRLEN+1];
00719
00720 return QString::fromLatin1(inet_ntop(family, addr, buf, INET6_ADDRSTRLEN));
00721 }
00722
00723 bool KInetSocketAddress::stringToAddr(int family, const char *text, void *dest)
00724 {
00725 return inet_pton(family, text, dest) != 0;
00726 }
00727
00732 class KUnixSocketAddressPrivate
00733 {
00734 public:
00735 sockaddr_un *m_sun;
00736
00737 KUnixSocketAddressPrivate() : m_sun(NULL)
00738 { }
00739 };
00740
00741 KUnixSocketAddress::KUnixSocketAddress() :
00742 d(new KUnixSocketAddressPrivate)
00743 {
00744 }
00745
00746 KUnixSocketAddress::KUnixSocketAddress(const sockaddr_un* _sun, ksocklen_t size) :
00747 d(new KUnixSocketAddressPrivate)
00748 {
00749 setAddress(_sun, size);
00750 }
00751
00752 KUnixSocketAddress::KUnixSocketAddress(QCString pathname) :
00753 d(new KUnixSocketAddressPrivate)
00754 {
00755 setAddress(pathname);
00756 }
00757
00758 KUnixSocketAddress::~KUnixSocketAddress()
00759 {
00760 delete d;
00761 }
00762
00763 bool KUnixSocketAddress::setAddress(const sockaddr_un* _sun, ksocklen_t _size)
00764 {
00765 if (_sun->sun_family != AF_UNIX)
00766 {
00767 kdWarning() << "KUnixSocketAddress::setAddress called with invalid socket\n";
00768 return false;
00769 }
00770
00771 if (owndata && (d->m_sun != NULL) && (datasize >= _size))
00772 {
00773
00774 memcpy(d->m_sun, _sun, _size);
00775 }
00776 else
00777 {
00778 if (owndata && (d->m_sun != NULL))
00779 free(d->m_sun);
00780
00781 d->m_sun = (sockaddr_un*)malloc(_size);
00782
00783 if (d->m_sun == NULL)
00784 {
00785
00786 owndata = false;
00787 return false;
00788 }
00789
00790 memcpy(d->m_sun, _sun, _size);
00791 }
00792
00793 datasize = _size;
00794 data = (sockaddr*)d->m_sun;
00795 owndata = true;
00796 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
00797 data->sa_len = _size;
00798 #endif
00799 return 1;
00800 }
00801
00802 bool KUnixSocketAddress::setAddress(QCString path)
00803 {
00804
00805 ksocklen_t newsize = offsetof(sockaddr_un, sun_path) + path.length() + 1;
00806
00807 if (owndata && (d->m_sun != NULL) && (datasize >= newsize))
00808 {
00809
00810 strcpy(d->m_sun->sun_path, path);
00811 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
00812 data->sa_len = newsize;
00813 #endif
00814 return true;
00815 }
00816
00817
00818 if (owndata && (d->m_sun != NULL))
00819 free(d->m_sun);
00820
00821 d->m_sun = (sockaddr_un*) malloc(newsize);
00822 if (d->m_sun == NULL)
00823 {
00824 owndata = false;
00825 return false;
00826 }
00827
00828 d->m_sun->sun_family = AF_UNIX;
00829 strcpy(d->m_sun->sun_path, path);
00830 data = (sockaddr*)d->m_sun;
00831 datasize = newsize;
00832 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
00833 data->sa_len = newsize;
00834 #endif
00835 return 1;
00836 }
00837
00838 QCString KUnixSocketAddress::pathname() const
00839 {
00840 if (d->m_sun != NULL)
00841 {
00842 if (datasize > offsetof(sockaddr_un, sun_path))
00843 return d->m_sun->sun_path;
00844 return "";
00845 }
00846 return QCString(0);
00847 }
00848
00849 QString KUnixSocketAddress::pretty() const
00850 {
00851 QCString pname = pathname();
00852 if (pname.isEmpty())
00853 return i18n("<empty UNIX socket>");
00854 return QFile::decodeName(pathname());
00855 }
00856
00857 QString KUnixSocketAddress::serviceName() const
00858 {
00859 return QString::fromUtf8(pathname());
00860 }
00861
00862 const sockaddr_un* KUnixSocketAddress::address() const
00863 {
00864 return d->m_sun;
00865 }
00866
00867 bool KUnixSocketAddress::areEqualUnix(const KSocketAddress &s1, const KSocketAddress &s2, bool )
00868 {
00869 if (s1.family() != s2.family())
00870 return false;
00871
00872 if ((s1.size() < MIN_SOCKADDR_LEN) || (s2.size() < MIN_SOCKADDR_LEN))
00873 return false;
00874
00875 struct sockaddr_un *sun1 = (sockaddr_un *) s1.address();
00876 struct sockaddr_un *sun2 = (sockaddr_un *) s2.address();
00877
00878 if (s1.size() == MIN_SOCKADDR_LEN && s2.size() == MIN_SOCKADDR_LEN)
00879 return true;
00880
00881 return (strcmp(sun1->sun_path, sun2->sun_path) == 0);
00882 }
00883
00884 void KSocketAddress::virtual_hook( int, void* )
00885 { }
00886
00887 void KInetSocketAddress::virtual_hook( int id, void* data )
00888 { KSocketAddress::virtual_hook( id, data ); }
00889
00890 void KUnixSocketAddress::virtual_hook( int id, void* data )
00891 { KSocketAddress::virtual_hook( id, data ); }
00892
00893
00894 #include "ksockaddr.moc"