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

KDECore

  • kdecore
  • network
k3socketaddress.cpp
Go to the documentation of this file.
1/* -*- C++ -*-
2 * Copyright (C) 2003 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 "k3socketaddress.h"
26
27#include <config.h>
28#include <config-network.h>
29
30#include <sys/types.h>
31#include <sys/socket.h>
32#include <sys/un.h>
33#include <arpa/inet.h>
34#include <netinet/in.h>
35#include <string.h>
36#include <stdlib.h>
37#include <unistd.h>
38
39#include <QFile>
40#include <QObject>
41
42#include "klocale.h"
43
44#ifndef Q_CC_MSVC
45#include "netsupp.h"
46#endif
47
48using namespace KNetwork;
49
50#if 0
51class KIpAddress_localhostV4 : public KIpAddress
52{
53public:
54 KIpAddress_localhostV4()
55 {
56 *m_data = htonl(0x7f000001);
57 m_version = 4;
58 }
59};
60
61class KIpAddress_localhostV6 : public KIpAddress
62{
63public:
64 KIpAddress_localhostV6()
65 : KIpAddress(0L, 6)
66 {
67 m_data[3] = htonl(1);
68 }
69};
70#endif
71
72static const char localhostV4_data[] = { 127, 0, 0, 1 };
73static const char localhostV6_data[] = { 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,1 };
74
75const KIpAddress KIpAddress::localhostV4(&localhostV4_data, 4);
76const KIpAddress KIpAddress::localhostV6(&localhostV6_data, 6);
77const KIpAddress KIpAddress::anyhostV4(0L, 4);
78const KIpAddress KIpAddress::anyhostV6(0L, 6);
79
80// helper function to test if an IPv6 v4-mapped address is equal to its IPv4 counterpart
81static bool check_v4mapped(const quint32* v6addr, quint32 v4addr)
82{
83 // check that the v6 is a v4-mapped address
84 if (!(v6addr[0] == 0 && v6addr[1] == 0 && v6addr[2] == htonl(0x0000ffff)))
85 return false; // not a v4-mapped address
86
87 return v6addr[3] == v4addr;
88}
89
90// copy operator
91KIpAddress& KIpAddress::operator =(const KIpAddress& other)
92{
93 m_version = other.m_version;
94 if (m_version == 4 || m_version == 6)
95 memcpy(m_data, other.m_data, sizeof(m_data));
96 return *this;
97}
98
99// comparison
100bool KIpAddress::compare(const KIpAddress& other, bool checkMapped) const
101{
102 if (m_version == other.m_version)
103 switch (m_version)
104 {
105 case 0:
106 // both objects are empty
107 return true;
108
109 case 4:
110 // IPv4 address
111 return *m_data == *other.m_data;
112
113 case 6:
114 // IPv6 address
115 // they are 128-bit long, that is, 16 bytes
116 return memcmp(m_data, other.m_data, 16) == 0;
117 }
118
119 if (checkMapped)
120 {
121 // check the possibility of a v4-mapped address being compared to an IPv4 one
122 if (m_version == 6 && other.m_version == 4 && check_v4mapped(m_data, *other.m_data))
123 return true;
124
125 if (other.m_version == 6 && m_version == 4 && check_v4mapped(other.m_data, *m_data))
126 return true;
127 }
128
129 return false;
130}
131
132// sets the address to the given address
133bool KIpAddress::setAddress(const QString& address)
134{
135 m_version = 0;
136
137 // try to guess the address version
138 if (address.indexOf(QLatin1Char(':')) != -1)
139 {
140#ifdef AF_INET6
141 // guessing IPv6
142
143 quint32 buf[4];
144 if (inet_pton(AF_INET6, address.toLatin1(), buf))
145 {
146 memcpy(m_data, buf, sizeof(m_data));
147 m_version = 6;
148 return true;
149 }
150#endif
151
152 return false;
153 }
154 else
155 {
156 quint32 buf;
157 if (inet_pton(AF_INET, address.toLatin1(), &buf))
158 {
159 *m_data = buf;
160 m_version = 4;
161 return true;
162 }
163
164 return false;
165 }
166
167 return false; // can never happen!
168}
169
170bool KIpAddress::setAddress(const char* address)
171{
172 return setAddress(QLatin1String(address));
173}
174
175// set from binary data
176bool KIpAddress::setAddress(const void* raw, int version)
177{
178 // this always succeeds
179 // except if version is invalid
180 if (version != 4 && version != 6)
181 return false;
182
183 m_version = version;
184 if (raw != 0L)
185 memcpy(m_data, raw, version == 4 ? 4 : 16);
186 else
187 memset(m_data, 0, 16);
188
189 return true;
190}
191
192// presentation form
193QString KIpAddress::toString() const
194{
195 char buf[sizeof "1111:2222:3333:4444:5555:6666:255.255.255.255" + 2];
196 buf[0] = '\0';
197 switch (m_version)
198 {
199 case 4:
200 inet_ntop(AF_INET, (void*)m_data, buf, sizeof(buf) - 1);
201 return QLatin1String(buf);
202
203 case 6:
204#ifdef AF_INET6
205 inet_ntop(AF_INET6, (void*)m_data, buf, sizeof(buf) - 1);
206#endif
207 return QLatin1String(buf);
208 }
209
210 return QString();
211}
212
213/*
214 * An IPv6 socket address
215 * This is taken from RFC 2553.
216 */
217struct our_sockaddr_in6
218{
219# ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
220 quint8 sin6_len;
221 quint8 sin6_family;
222# else
223 quint16 sin6_family;
224# endif
225 quint16 sin6_port; /* RFC says in_port_t */
226 quint32 sin6_flowinfo;
227 quint8 sin6_addr[16]; // 24 bytes up to here
228 quint32 sin6_scope_id; // 28 bytes total
229};
230
231// useful definitions
232#define MIN_SOCKADDR_LEN sizeof(quint16)
233#define SOCKADDR_IN_LEN sizeof(sockaddr_in)
234#define MIN_SOCKADDR_IN6_LEN ((quintptr) &(((our_sockaddr_in6*)0)->sin6_scope_id))
235#define SOCKADDR_IN6_LEN sizeof(our_sockaddr_in6)
236#define MIN_SOCKADDR_UN_LEN (sizeof(quint16) + sizeof(char))
237
238
239class KNetwork::KSocketAddressData
240{
241public:
242 /*
243 * Note: maybe this should be virtual
244 * But since the data is shared via the d pointer, it doesn't really matter
245 * what one class sees, so will the other
246 */
247 class QMixSocketAddressRef : public KInetSocketAddress, public KUnixSocketAddress
248 {
249 public:
250 QMixSocketAddressRef(KSocketAddressData* d)
251 : KInetSocketAddress(d), KUnixSocketAddress(d)
252 {
253 }
254 };
255 QMixSocketAddressRef ref;
256
257 union
258 {
259 struct sockaddr *generic;
260 struct sockaddr_in *in;
261 struct our_sockaddr_in6 *in6;
262 struct sockaddr_un *un;
263 } addr;
264 quint16 curlen, reallen;
265
266 KSocketAddressData()
267 : ref(this)
268 {
269 addr.generic = 0L;
270 curlen = 0;
271 invalidate();
272 }
273
274 ~KSocketAddressData()
275 {
276 if (addr.generic != 0L)
277 free(addr.generic);
278 }
279
280 inline bool invalid() const
281 { return reallen == 0; }
282
283 inline void invalidate()
284 { reallen = 0; }
285
286 void dup(const sockaddr* sa, quint16 len, bool clear = true);
287
288 void makeipv4()
289 {
290 short oldport = 0;
291 if (!invalid())
292 switch (addr.generic->sa_family)
293 {
294 case AF_INET:
295 return; // nothing to do here
296#ifdef AF_INET6
297 case AF_INET6:
298 oldport = addr.in6->sin6_port;
299 break;
300#endif
301 }
302
303 // create new space
304 dup(0L, SOCKADDR_IN_LEN);
305
306 addr.in->sin_family = AF_INET;
307#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
308 addr.in->sin_len = SOCKADDR_IN_LEN;
309#endif
310 addr.in->sin_port = oldport;
311 }
312
313 void makeipv6()
314 {
315 short oldport = 0;
316 if (!invalid())
317 switch (addr.generic->sa_family)
318 {
319 case AF_INET:
320 oldport = addr.in->sin_port;
321 break;
322
323#ifdef AF_INET6
324 case AF_INET6:
325 return; // nothing to do here
326#endif
327 }
328
329 // make room
330 dup(0L, SOCKADDR_IN6_LEN);
331#ifdef AF_INET6
332 addr.in6->sin6_family = AF_INET6;
333#endif
334#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
335 addr.in6->sin6_len = SOCKADDR_IN6_LEN;
336#endif
337 addr.in6->sin6_port = oldport;
338 // sin6_scope_id and sin6_flowid are zero
339 }
340
341};
342
343// create duplicates of
344void KSocketAddressData::dup(const sockaddr* sa, quint16 len, bool clear)
345{
346 if (len < MIN_SOCKADDR_LEN)
347 {
348 // certainly invalid
349 invalidate();
350 return;
351 }
352
353 if (sa && ((sa->sa_family == AF_INET && len < SOCKADDR_IN_LEN) ||
354#ifdef AF_INET6
355 (sa->sa_family == AF_INET6 && len < MIN_SOCKADDR_IN6_LEN) ||
356#endif
357 (sa->sa_family == AF_UNIX && len < MIN_SOCKADDR_UN_LEN)))
358 {
359 // also invalid
360 invalidate();
361 return;
362 }
363
364 // good
365 reallen = len;
366 if (len > curlen)
367 {
368 if (len < 32)
369 curlen = 32; // big enough for sockaddr_in and sockaddr_in6
370 else
371 curlen = len;
372 addr.generic = (sockaddr*)realloc(addr.generic, curlen);
373 }
374
375 if (sa != 0L)
376 {
377 memcpy(addr.generic, sa, len); // copy
378
379 // now, normalise the data
380 if (addr.generic->sa_family == AF_INET)
381 reallen = SOCKADDR_IN_LEN; // no need to be larger
382#ifdef AF_INET6
383 else if (addr.generic->sa_family == AF_INET6)
384 {
385 // set the extra field (sin6_scope_id)
386
387 // the buffer is never smaller than 32 bytes, so this is always
388 // allowed
389 if (reallen < SOCKADDR_IN6_LEN)
390 addr.in6->sin6_scope_id = 0;
391
392 reallen = SOCKADDR_IN6_LEN;
393 }
394#endif
395 else if (addr.generic->sa_family == AF_UNIX)
396 reallen = MIN_SOCKADDR_UN_LEN + strlen(addr.un->sun_path);
397 }
398 else if (clear)
399 {
400 memset(addr.generic, 0, len);
401 addr.generic->sa_family = AF_UNSPEC;
402 }
403}
404
405// default constructor
406KSocketAddress::KSocketAddress()
407 : d(new KSocketAddressData)
408{
409}
410
411// constructor from binary data
412KSocketAddress::KSocketAddress(const sockaddr *sa, quint16 len)
413 : d(new KSocketAddressData)
414{
415 setAddress(sa, len);
416}
417
418KSocketAddress::KSocketAddress(const KSocketAddress& other)
419 : d(new(KSocketAddressData))
420{
421 *this = other;
422}
423
424KSocketAddress::KSocketAddress(KSocketAddressData *d2)
425 : d(d2)
426{
427}
428
429KSocketAddress::~KSocketAddress()
430{
431 // prevent double-deletion, since we're already being deleted
432 if (d)
433 {
434 d->ref.KInetSocketAddress::d = 0L;
435 d->ref.KUnixSocketAddress::d = 0L;
436 delete d;
437 }
438}
439
440KSocketAddress& KSocketAddress::operator =(const KSocketAddress& other)
441{
442 if (other.d && !other.d->invalid())
443 d->dup(other.d->addr.generic, other.d->reallen);
444 else
445 d->invalidate();
446 return *this;
447}
448
449const sockaddr* KSocketAddress::address() const
450{
451 if (d->invalid())
452 return 0L;
453 return d->addr.generic;
454}
455
456sockaddr* KSocketAddress::address()
457{
458 if (d->invalid())
459 return 0L;
460 return d->addr.generic;
461}
462
463KSocketAddress& KSocketAddress::setAddress(const sockaddr* sa, quint16 len)
464{
465 if (sa != 0L && len >= MIN_SOCKADDR_LEN)
466 d->dup(sa, len);
467 else
468 d->invalidate();
469
470 return *this;
471}
472
473quint16 KSocketAddress::length() const
474{
475 if (d->invalid())
476 return 0;
477 return d->reallen;
478}
479
480KSocketAddress& KSocketAddress::setLength(quint16 len)
481{
482 d->dup((sockaddr*)0L, len, false);
483
484 return *this;
485}
486
487int KSocketAddress::family() const
488{
489 if (d->invalid())
490 return AF_UNSPEC;
491 return d->addr.generic->sa_family;
492}
493
494KSocketAddress& KSocketAddress::setFamily(int family)
495{
496 if (d->invalid())
497 d->dup((sockaddr*)0L, MIN_SOCKADDR_LEN);
498 d->addr.generic->sa_family = family;
499
500 return *this;
501}
502
503bool KSocketAddress::operator ==(const KSocketAddress& other) const
504{
505 // if this is invalid, it's only equal if the other one is invalid as well
506 if (d->invalid())
507 return other.d->invalid();
508
509 // check the family to make sure we don't do unnecessary comparison
510 if (d->addr.generic->sa_family != other.d->addr.generic->sa_family)
511 return false; // not the same family, not equal
512
513 // same family then
514 // check the ones we know already
515 switch (d->addr.generic->sa_family)
516 {
517 case AF_INET:
518 Q_ASSERT(d->reallen == SOCKADDR_IN_LEN);
519 Q_ASSERT(other.d->reallen == SOCKADDR_IN_LEN);
520 return memcmp(d->addr.in, other.d->addr.in, SOCKADDR_IN_LEN) == 0;
521
522#ifdef AF_INET6
523 case AF_INET6:
524 Q_ASSERT(d->reallen >= MIN_SOCKADDR_IN6_LEN);
525 Q_ASSERT(other.d->reallen >= MIN_SOCKADDR_IN6_LEN);
526
527# if !defined(HAVE_STRUCT_SOCKADDR_IN6) || defined(HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID)
528 // check for the case where sin6_scope_id isn't present
529 if (d->reallen != other.d->reallen)
530 {
531 if (memcmp(d->addr.in6, other.d->addr.in6, MIN_SOCKADDR_IN6_LEN) != 0)
532 return false; // not equal
533 if (d->reallen > other.d->reallen)
534 return d->addr.in6->sin6_scope_id == 0;
535 else
536 return other.d->addr.in6->sin6_scope_id == 0;
537 }
538# endif
539
540 return memcmp(d->addr.in6, other.d->addr.in6, d->reallen) == 0;
541#endif
542
543 case AF_UNIX:
544 Q_ASSERT(d->reallen >= MIN_SOCKADDR_UN_LEN);
545 Q_ASSERT(other.d->reallen >= MIN_SOCKADDR_UN_LEN);
546
547 // do a string comparison here
548 return strcmp(d->addr.un->sun_path, other.d->addr.un->sun_path) == 0;
549
550 default:
551 // something else we don't know about
552 // they are equal if and only if they are exactly equal
553 if (d->reallen == other.d->reallen)
554 return memcmp(d->addr.generic, other.d->addr.generic, d->reallen) == 0;
555 }
556
557 return false; // not equal in any other case
558}
559
560QString KSocketAddress::nodeName() const
561{
562 if (d->invalid())
563 return QString();
564
565 switch (d->addr.generic->sa_family)
566 {
567 case AF_INET:
568#ifdef AF_INET6
569 case AF_INET6:
570
571 QString scopeid(QLatin1Char('%'));
572 if (d->addr.generic->sa_family == AF_INET6 && d->addr.in6->sin6_scope_id)
573 scopeid += QString::number(d->addr.in6->sin6_scope_id);
574 else
575 scopeid.truncate(0);
576 return d->ref.ipAddress().toString() + scopeid;
577#else
578 return d->ref.ipAddress().toString();
579#endif
580 }
581
582 // any other case, including AF_UNIX
583 return QString();
584}
585
586QString KSocketAddress::serviceName() const
587{
588 if (d->invalid())
589 return QString();
590
591 switch (d->addr.generic->sa_family)
592 {
593 case AF_INET:
594#ifdef AF_INET6
595 case AF_INET6:
596#endif
597 return QString::number(d->ref.port());
598
599 case AF_UNIX:
600 return d->ref.pathname();
601 }
602
603 return QString();
604}
605
606QString KSocketAddress::toString() const
607{
608 if (d->invalid())
609 return QString();
610
611 QString fmt;
612
613 if (d->addr.generic->sa_family == AF_INET)
614 fmt = QLatin1String("%1:%2");
615#ifdef AF_INET6
616 else if (d->addr.generic->sa_family == AF_INET6)
617 fmt = QLatin1String("[%1]:%2");
618#endif
619 else if (d->addr.generic->sa_family == AF_UNIX)
620 return QString(QLatin1String("unix:%1")).arg(serviceName());
621 else
622 return i18nc("1: the unknown socket address family number",
623 "Unknown family %1", d->addr.generic->sa_family);
624
625 return fmt.arg(nodeName()).arg(serviceName());
626}
627
628KInetSocketAddress& KSocketAddress::asInet()
629{
630 return d->ref;
631}
632
633KInetSocketAddress KSocketAddress::asInet() const
634{
635 return d->ref;
636}
637
638KUnixSocketAddress& KSocketAddress::asUnix()
639{
640 return d->ref;
641}
642
643KUnixSocketAddress KSocketAddress::asUnix() const
644{
645 return d->ref;
646}
647
648int KSocketAddress::ianaFamily(int af)
649{
650 switch (af)
651 {
652 case AF_INET:
653 return 1;
654
655#ifdef AF_INET6
656 case AF_INET6:
657 return 2;
658#endif
659
660 default:
661 return 0;
662 }
663}
664
665int KSocketAddress::fromIanaFamily(int iana)
666{
667 switch (iana)
668 {
669 case 1:
670 return AF_INET;
671
672#ifdef AF_INET6
673 case 2:
674 return AF_INET6;
675#endif
676
677 default:
678 return AF_UNSPEC;
679 }
680}
681
682// default constructor
683KInetSocketAddress::KInetSocketAddress()
684{
685}
686
687// binary data constructor
688KInetSocketAddress::KInetSocketAddress(const sockaddr* sa, quint16 len)
689 : KSocketAddress(sa, len)
690{
691 if (!d->invalid())
692 update();
693}
694
695// create from IP and port
696KInetSocketAddress::KInetSocketAddress(const KIpAddress& host, quint16 port)
697{
698 setHost(host);
699 setPort(port);
700}
701
702// copy constructor
703KInetSocketAddress::KInetSocketAddress(const KInetSocketAddress& other)
704 : KSocketAddress(other)
705{
706}
707
708// special copy constructor
709KInetSocketAddress::KInetSocketAddress(const KSocketAddress& other)
710 : KSocketAddress(other)
711{
712 if (!d->invalid())
713 update();
714}
715
716// special constructor
717KInetSocketAddress::KInetSocketAddress(KSocketAddressData *d)
718 : KSocketAddress(d)
719{
720}
721
722// destructor
723KInetSocketAddress::~KInetSocketAddress()
724{
725 /* nothing to do */
726}
727
728// copy operator
729KInetSocketAddress& KInetSocketAddress::operator =(const KInetSocketAddress& other)
730{
731 KSocketAddress::operator =(other);
732 return *this;
733}
734
735// IP version
736int KInetSocketAddress::ipVersion() const
737{
738 if (d->invalid())
739 return 0;
740
741 switch (d->addr.generic->sa_family)
742 {
743 case AF_INET:
744 return 4;
745
746#ifdef AF_INET6
747 case AF_INET6:
748 return 6;
749#endif
750 }
751
752 return 0; // for all other cases
753}
754
755KIpAddress KInetSocketAddress::ipAddress() const
756{
757 if (d->invalid())
758 return KIpAddress(); // return an empty address as well
759
760 switch (d->addr.generic->sa_family)
761 {
762 case AF_INET:
763 return KIpAddress(&d->addr.in->sin_addr, 4);
764#ifdef AF_INET6
765 case AF_INET6:
766 return KIpAddress(&d->addr.in6->sin6_addr, 6);
767#endif
768 }
769
770 return KIpAddress(); // empty in all other cases
771}
772
773KInetSocketAddress& KInetSocketAddress::setHost(const KIpAddress& ip)
774{
775 switch (ip.version())
776 {
777 case 4:
778 makeIPv4();
779 memcpy(&d->addr.in->sin_addr, ip.addr(), sizeof(d->addr.in->sin_addr));
780 break;
781
782 case 6:
783 makeIPv6();
784 memcpy(&d->addr.in6->sin6_addr, ip.addr(), sizeof(d->addr.in6->sin6_addr));
785 break;
786
787 default:
788 // empty
789 d->invalidate();
790 }
791
792 return *this;
793}
794
795// returns the port
796quint16 KInetSocketAddress::port() const
797{
798 if (d->invalid())
799 return 0;
800
801 switch (d->addr.generic->sa_family)
802 {
803 case AF_INET:
804 return ntohs(d->addr.in->sin_port);
805
806#ifdef AF_INET6
807 case AF_INET6:
808 return ntohs(d->addr.in6->sin6_port);
809#endif
810 }
811
812 return 0;
813}
814
815KInetSocketAddress& KInetSocketAddress::setPort(quint16 port)
816{
817 if (d->invalid())
818 makeIPv4();
819
820 switch (d->addr.generic->sa_family)
821 {
822 case AF_INET:
823 d->addr.in->sin_port = htons(port);
824 break;
825
826#ifdef AF_INET6
827 case AF_INET6:
828 d->addr.in6->sin6_port = htons(port);
829 break;
830#endif
831
832 default:
833 d->invalidate(); // setting the port on something else
834 }
835
836 return *this;
837}
838
839KInetSocketAddress& KInetSocketAddress::makeIPv4()
840{
841 d->makeipv4();
842 return *this;
843}
844
845KInetSocketAddress& KInetSocketAddress::makeIPv6()
846{
847 d->makeipv6();
848 return *this;
849}
850
851quint32 KInetSocketAddress::flowinfo() const
852{
853#ifndef AF_INET6
854 return 0;
855#else
856
857 if (!d->invalid() && d->addr.in6->sin6_family == AF_INET6)
858 return d->addr.in6->sin6_flowinfo;
859 return 0;
860#endif
861}
862
863KInetSocketAddress& KInetSocketAddress::setFlowinfo(quint32 flowinfo)
864{
865 makeIPv6(); // must set here
866 d->addr.in6->sin6_flowinfo = flowinfo;
867 return *this;
868}
869
870int KInetSocketAddress::scopeId() const
871{
872#ifndef AF_INET6
873 return 0;
874#else
875
876 if (!d->invalid() && d->addr.in6->sin6_family == AF_INET6)
877 return d->addr.in6->sin6_scope_id;
878 return 0;
879#endif
880}
881
882KInetSocketAddress& KInetSocketAddress::setScopeId(int scopeid)
883{
884 makeIPv6(); // must set here
885 d->addr.in6->sin6_scope_id = scopeid;
886 return *this;
887}
888
889void KInetSocketAddress::update()
890{
891 if (d->addr.generic->sa_family == AF_INET)
892 return;
893#ifdef AF_INET6
894 else if (d->addr.generic->sa_family == AF_INET6)
895 return;
896#endif
897 else
898 d->invalidate();
899}
900
901KUnixSocketAddress::KUnixSocketAddress()
902{
903}
904
905KUnixSocketAddress::KUnixSocketAddress(const sockaddr* sa, quint16 len)
906 : KSocketAddress(sa, len)
907{
908 if (!d->invalid() && d->addr.un->sun_family != AF_UNIX)
909 d->invalidate();
910}
911
912KUnixSocketAddress::KUnixSocketAddress(const KUnixSocketAddress& other)
913 : KSocketAddress(other)
914{
915}
916
917KUnixSocketAddress::KUnixSocketAddress(const QString& pathname)
918{
919 setPathname(pathname);
920}
921
922KUnixSocketAddress::KUnixSocketAddress(KSocketAddressData* d)
923 : KSocketAddress(d)
924{
925}
926
927KUnixSocketAddress::~KUnixSocketAddress()
928{
929}
930
931KUnixSocketAddress& KUnixSocketAddress::operator =(const KUnixSocketAddress& other)
932{
933 KSocketAddress::operator =(other);
934 return *this;
935}
936
937QString KUnixSocketAddress::pathname() const
938{
939 if (!d->invalid() && d->addr.un->sun_family == AF_UNIX)
940 return QFile::decodeName(d->addr.un->sun_path);
941 return QString();
942}
943
944KUnixSocketAddress& KUnixSocketAddress::setPathname(const QString& path)
945{
946 d->dup(0L, MIN_SOCKADDR_UN_LEN + path.length());
947 d->addr.un->sun_family = AF_UNIX;
948 strcpy(d->addr.un->sun_path, QFile::encodeName(path));
949
950#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
951 d->addr.un->sun_len = d->reallen;
952#endif
953
954 return *this;
955}
KNetwork::KInetSocketAddress
an Internet socket address
Definition: k3socketaddress.h:644
KNetwork::KInetSocketAddress::~KInetSocketAddress
virtual ~KInetSocketAddress()
Destroys this object.
Definition: k3socketaddress.cpp:723
KNetwork::KInetSocketAddress::makeIPv6
KInetSocketAddress & makeIPv6()
Converts this object to an IPv6 socket address.
Definition: k3socketaddress.cpp:845
KNetwork::KInetSocketAddress::KInetSocketAddress
KInetSocketAddress()
Public constructor.
Definition: k3socketaddress.cpp:683
KNetwork::KInetSocketAddress::setScopeId
KInetSocketAddress & setScopeId(int scopeid)
Sets the scope id for this IPv6 object.
Definition: k3socketaddress.cpp:882
KNetwork::KInetSocketAddress::operator=
KInetSocketAddress & operator=(const KInetSocketAddress &other)
Copy operator.
Definition: k3socketaddress.cpp:729
KNetwork::KInetSocketAddress::ipVersion
int ipVersion() const
Returns the IP version of the address this object holds.
Definition: k3socketaddress.cpp:736
KNetwork::KInetSocketAddress::scopeId
int scopeId() const
Returns the scope id this IPv6 socket is bound to.
Definition: k3socketaddress.cpp:870
KNetwork::KInetSocketAddress::ipAddress
KIpAddress ipAddress() const
Returns the IP address component.
Definition: k3socketaddress.cpp:755
KNetwork::KInetSocketAddress::flowinfo
quint32 flowinfo() const
Returns the flowinfo information from the IPv6 socket address.
Definition: k3socketaddress.cpp:851
KNetwork::KInetSocketAddress::setHost
KInetSocketAddress & setHost(const KIpAddress &addr)
Sets the IP address to the given raw address.
Definition: k3socketaddress.cpp:773
KNetwork::KInetSocketAddress::setPort
KInetSocketAddress & setPort(quint16 port)
Sets the port number.
Definition: k3socketaddress.cpp:815
KNetwork::KInetSocketAddress::setFlowinfo
KInetSocketAddress & setFlowinfo(quint32 flowinfo)
Sets the flowinfo information for an IPv6 socket address.
Definition: k3socketaddress.cpp:863
KNetwork::KInetSocketAddress::makeIPv4
KInetSocketAddress & makeIPv4()
Converts this object to an IPv4 socket address.
Definition: k3socketaddress.cpp:839
KNetwork::KInetSocketAddress::port
quint16 port() const
Retrieves the port number stored in this object.
Definition: k3socketaddress.cpp:796
KNetwork::KIpAddress
An IP address.
Definition: k3socketaddress.h:63
KNetwork::KIpAddress::version
int version() const
Retrieves the IP version in this object.
Definition: k3socketaddress.h:171
KNetwork::KIpAddress::operator=
KIpAddress & operator=(const KIpAddress &other)
Copy operator.
Definition: k3socketaddress.cpp:91
KNetwork::KIpAddress::addr
const void * addr() const
Returns a pointer to binary raw data representing the address.
Definition: k3socketaddress.h:220
KNetwork::KIpAddress::localhostV4
static const KIpAddress localhostV4
localhost in IPv4 (127.0.0.1)
Definition: k3socketaddress.h:394
KNetwork::KIpAddress::anyhostV6
static const KIpAddress anyhostV6
the any host or undefined address in IPv6 (::)
Definition: k3socketaddress.h:401
KNetwork::KIpAddress::localhostV6
static const KIpAddress localhostV6
localhost in IPv6 (::1)
Definition: k3socketaddress.h:399
KNetwork::KIpAddress::anyhostV4
static const KIpAddress anyhostV4
the any host or undefined address in IPv4 (0.0.0.0)
Definition: k3socketaddress.h:396
KNetwork::KIpAddress::toString
QString toString() const
Returns the address as a string.
Definition: k3socketaddress.cpp:193
KNetwork::KIpAddress::m_version
char m_version
Definition: k3socketaddress.h:390
KNetwork::KIpAddress::m_data
quint32 m_data[4]
Definition: k3socketaddress.h:388
KNetwork::KIpAddress::setAddress
bool setAddress(const QString &address)
Sets the address to the given string representation.
Definition: k3socketaddress.cpp:133
KNetwork::KIpAddress::compare
bool compare(const KIpAddress &other, bool checkMapped=true) const
Compares this address against the other, supplied one and return true if they match.
Definition: k3socketaddress.cpp:100
KNetwork::KSocketAddress
A generic socket address.
Definition: k3socketaddress.h:415
KNetwork::KSocketAddress::operator=
KSocketAddress & operator=(const KSocketAddress &other)
Performs a shallow copy of the other object into this one.
Definition: k3socketaddress.cpp:440
KNetwork::KSocketAddress::nodeName
virtual QString nodeName() const
Returns the node name of this socket.
Definition: k3socketaddress.cpp:560
KNetwork::KSocketAddress::operator==
bool operator==(const KSocketAddress &other) const
Returns true if this equals the other socket.
Definition: k3socketaddress.cpp:503
KNetwork::KSocketAddress::address
const sockaddr * address() const
Returns the socket address structure, to be passed down to low level functions.
Definition: k3socketaddress.cpp:449
KNetwork::KSocketAddress::setAddress
KSocketAddress & setAddress(const sockaddr *sa, quint16 len)
Sets the address to the given address.
Definition: k3socketaddress.cpp:463
KNetwork::KSocketAddress::serviceName
virtual QString serviceName() const
Returns the service name for this socket.
Definition: k3socketaddress.cpp:586
KNetwork::KSocketAddress::fromIanaFamily
static int fromIanaFamily(int iana)
Returns the address family of the given IANA family number.
Definition: k3socketaddress.cpp:665
KNetwork::KSocketAddress::d
KSocketAddressData * d
Definition: k3socketaddress.h:609
KNetwork::KSocketAddress::asUnix
KUnixSocketAddress & asUnix()
Returns an object reference that can be used to manipulate this socket as a Unix socket address.
Definition: k3socketaddress.cpp:638
KNetwork::KSocketAddress::length
quint16 length() const
Returns the length of this socket address structure.
Definition: k3socketaddress.cpp:473
KNetwork::KSocketAddress::setLength
KSocketAddress & setLength(quint16 len)
Sets the length of this socket structure.
Definition: k3socketaddress.cpp:480
KNetwork::KSocketAddress::family
int family() const
Returns the family of this address.
Definition: k3socketaddress.cpp:487
KNetwork::KSocketAddress::~KSocketAddress
virtual ~KSocketAddress()
Destructor.
Definition: k3socketaddress.cpp:429
KNetwork::KSocketAddress::ianaFamily
int ianaFamily() const
Returns the IANA family number of this address.
Definition: k3socketaddress.h:541
KNetwork::KSocketAddress::toString
virtual QString toString() const
Returns this socket address as a string suitable for printing.
Definition: k3socketaddress.cpp:606
KNetwork::KSocketAddress::KSocketAddress
KSocketAddress()
Default constructor.
Definition: k3socketaddress.cpp:406
KNetwork::KSocketAddress::setFamily
virtual KSocketAddress & setFamily(int family)
Sets the family of this object.
Definition: k3socketaddress.cpp:494
KNetwork::KSocketAddress::asInet
KInetSocketAddress & asInet()
Returns an object reference that can be used to manipulate this socket as an Internet socket address.
Definition: k3socketaddress.cpp:628
KNetwork::KUnixSocketAddress
A Unix (local) socket address.
Definition: k3socketaddress.h:834
KNetwork::KUnixSocketAddress::pathname
QString pathname() const
Returns the pathname associated with this object.
Definition: k3socketaddress.cpp:937
KNetwork::KUnixSocketAddress::~KUnixSocketAddress
virtual ~KUnixSocketAddress()
Destructor.
Definition: k3socketaddress.cpp:927
KNetwork::KUnixSocketAddress::setPathname
KUnixSocketAddress & setPathname(const QString &path)
Sets the pathname for the object.
Definition: k3socketaddress.cpp:944
KNetwork::KUnixSocketAddress::KUnixSocketAddress
KUnixSocketAddress()
Default constructor.
Definition: k3socketaddress.cpp:901
KNetwork::KUnixSocketAddress::operator=
KUnixSocketAddress & operator=(const KUnixSocketAddress &other)
Copy operator.
Definition: k3socketaddress.cpp:931
QString
quint32
SOCKADDR_IN6_LEN
#define SOCKADDR_IN6_LEN
Definition: k3socketaddress.cpp:235
MIN_SOCKADDR_IN6_LEN
#define MIN_SOCKADDR_IN6_LEN
Definition: k3socketaddress.cpp:234
MIN_SOCKADDR_LEN
#define MIN_SOCKADDR_LEN
Definition: k3socketaddress.cpp:232
check_v4mapped
static bool check_v4mapped(const quint32 *v6addr, quint32 v4addr)
Definition: k3socketaddress.cpp:81
SOCKADDR_IN_LEN
#define SOCKADDR_IN_LEN
Definition: k3socketaddress.cpp:233
MIN_SOCKADDR_UN_LEN
#define MIN_SOCKADDR_UN_LEN
Definition: k3socketaddress.cpp:236
localhostV4_data
static const char localhostV4_data[]
Definition: k3socketaddress.cpp:72
localhostV6_data
static const char localhostV6_data[]
Definition: k3socketaddress.cpp:73
k3socketaddress.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
netsupp.h
inet_ntop
#define inet_ntop
Definition: netsupp.h:330
inet_pton
#define inet_pton
Definition: netsupp.h:319
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