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