src/linux/tipc.hpp

   1 #ifndef POSIXX_LINUX_TIPC_HPP_
   2 #define POSIXX_LINUX_TIPC_HPP_
   3
   4 #include "../basic_socket.hpp" // posixx::socket
   5
   6 #include <linux/tipc.h> // all tipc stuff
   7 #include <cstring> // memcpy
   8
   9 /// @file
  10
  11 namespace posixx {
  12
  13 /// Linux specific functionality
  14 namespace linux {
  15
  16 /// TIPC socket domain.
  17 namespace tipc {
  18
  19 enum
  20 {
  21         /// Configuration port name.
  22         CFG_SRV = TIPC_CFG_SRV,
  23         /// Topology discovery port name.
  24         TOP_SRV = TIPC_TOP_SRV,
  25         /// Name of the last reserved port.
  26         RESERVED_TYPES = TIPC_RESERVED_TYPES,
  27         /// Maximum message size.
  28         MAX_USER_MSG_SIZE = TIPC_MAX_USER_MSG_SIZE,
  29         /// Wait forever (for subscriptions).
  30         WAIT_FOREVER = TIPC_WAIT_FOREVER
  31 };
  32
  33 /// TIPC Address
  34 struct addr
  35 {
  36
  37         /// 32-bit address.
  38         __u32 address;
  39
  40         /// Constructor
  41         addr() throw ();
  42
  43         /**
  44          * Constructor from a raw 32-bit address.
  45          *
  46          * @param addr Raw 32-bit address.
  47          */
  48         explicit addr(__u32 addr) throw ();
  49
  50         /**
  51          * Constructor from a zone, cluster and node information.
  52          *
  53          * @param zone Zone.
  54          * @param cluster Cluster.
  55          * @param node Node.
  56          */
  57         addr(unsigned int zone, unsigned int cluster, unsigned int node)
  58                 throw ();
  59
  60         /// Set zone.
  61         void zone(unsigned int zone) throw ();
  62
  63         /// Get zone.
  64         unsigned int zone() const throw ();
  65
  66         /// Set cluster.
  67         void cluster(unsigned int cluster) throw ();
  68
  69         /// Get cluster.
  70         unsigned int cluster() const throw ();
  71
  72         /// Set node.
  73         void node(unsigned int node) throw ();
  74
  75         /// Get node.
  76         unsigned int node() const throw ();
  77
  78         /// Cast to a raw 32-bit address.
  79         operator __u32 () const throw ();
  80
  81 };
  82
  83 /**
  84  * Port Identificator.
  85  *
  86  * @see tipc_portid struct from linux/tipc.h.
  87  */
  88 struct portid: tipc_portid
  89 {
  90
  91         /**
  92          * Constructor.
  93          *
  94          * @param ref Unique ID fo the port in the address.
  95          * @param node Node address.
  96          */
  97         portid(__u32 ref, addr node) throw ();
  98
  99 };
 100
 101 /**
 102  * Named port.
 103  *
 104  * @see tipc_name struct from linux/tipc.h.
 105  */
 106 struct name: tipc_name
 107 {
 108         /**
 109          * Constructor.
 110          *
 111          * @param type Type of the named port.
 112          * @param instance Instance of the named port.
 113          */
 114         name(__u32 type, __u32 instance) throw ();
 115 };
 116
 117 /**
 118  * Port sequence.
 119  *
 120  * @see Multicast
 121  * @see tipc_name_seq struct from linux/tipc.h.
 122  */
 123 struct nameseq: tipc_name_seq
 124 {
 125         /**
 126          * Constructor.
 127          *
 128          * @param type Type of the sequence.
 129          * @param lower Lower bound.
 130          * @param upper Upper bound.
 131          */
 132         nameseq(__u32 type, __u32 lower, __u32 upper) throw ();
 133         /**
 134          * Constructor.
 135          *
 136          * @param type Type of the sequence.
 137          * @param instance Lower and upper bound.
 138          */
 139         nameseq(__u32 type, __u32 instance) throw ();
 140 };
 141
 142 /**
 143  * Multicast port sequence.
 144  *
 145  * It's a port sequence just like nameseq used to simplify the use of the
 146  * sockaddr.
 147  *
 148  * @see nameseq
 149  * @see Estructura tipc_name_seq de linux/tipc.h
 150  */
 151 struct multicast: tipc_name_seq
 152 {
 153         /**
 154          * Constructor.
 155          *
 156          * @param type Type of the multicast sequence.
 157          * @param lower Lower bound.
 158          * @param upper Upper bound.
 159          */
 160         multicast(__u32 type, __u32 lower, __u32 upper) throw ();
 161         /**
 162          * Constructor.
 163          *
 164          * @param type Type of the multicast sequence.
 165          * @param instance Lower and upper bound.
 166          */
 167         multicast(__u32 type, __u32 instance) throw ();
 168 };
 169
 170 /**
 171  * Reasons for returned messages when recvmsg() is used.
 172  *
 173  * @see recvmsg(2) of TIPC documentation
 174  */
 175 enum reason_t
 176 {
 177         /// Not a returned message.
 178         OK = TIPC_OK,
 179         /// Port name doesn't exist.
 180         ERR_NO_NAME = TIPC_ERR_NO_NAME,
 181         /// Port ID doesn't exist.
 182         ERR_NO_PORT = TIPC_ERR_NO_PORT,
 183         /// Node doesn't exist.
 184         ERR_NO_NODE = TIPC_ERR_NO_NODE,
 185         /// Reception queue is full.
 186         ERR_OVERLOAD = TIPC_ERR_OVERLOAD,
 187         /// Connection shutted down.
 188         CONN_SHUTDOWN = TIPC_CONN_SHUTDOWN
 189 };
 190
 191 /**
 192  * Subscription filter type.
 193  *
 194  * @see TIPC documentation: 1.4.3 Name Subscriptions
 195  */
 196 enum subcription_t
 197 {
 198         /**
 199          * Causes the topology service to generate a event::PUBLISHED event
 200          * for each port name or port name sequence it finds that overlaps
 201          * the specified port name sequence; a TIPC_WITHDRAWN event is issued
 202          * each time a previously reported name becomes unavailable.
 203          *
 204          * Allows the topology service to inform the application if there
 205          * are @b any ports of interest.
 206          */
 207         SUB_PORTS = TIPC_SUB_PORTS,
 208         /**
 209          * Causes the topology service to generate a single publish event for
 210          * the first port it finds with an overlapping name and a single
 211          * withdraw event when the last such port becomes unavailable.
 212          *
 213          * Allows the topology service to inform the application about
 214          * @b all ports of interest.
 215          */
 216         SUB_SERVICE = TIPC_SUB_SERVICE
 217 };
 218
 219 /**
 220  * Subscription request message.
 221  *
 222  * @see TIPC documentation: 1.4.3 Name Subscriptions
 223  */
 224 struct subscription: tipc_subscr
 225 {
 226         /**
 227          * Constructor.
 228          *
 229          * @param seq The port name sequence of interest to the application.
 230          * @param timeout A subscription timeout value, in ms
 231          *                (or WAIT_FOREVER).
 232          * @param filter An event filter specifying which events are of
 233          *               interest to the application (see subscription_t).
 234          * @param usr_handle An 8 byte user handle that is application-defined.
 235          */
 236         subscription(nameseq seq, __u32 timeout, __u32 filter,
 237                         const char* usr_handle = "") throw ();
 238 };
 239
 240 /**
 241  * Event message.
 242  *
 243  * @see TIPC documentation: 1.4.3 Name Subscriptions
 244  */
 245 struct event: tipc_event
 246 {
 247         /// Type of events.
 248         enum type_t
 249         {
 250                 /// The port has been published.
 251                 PUBLISHED = TIPC_PUBLISHED,
 252                 /// The port has been withdrawn.
 253                 WITHDRAWN = TIPC_WITHDRAWN,
 254                 /// The event has timed out.
 255                 TIMEOUT = TIPC_SUBSCR_TIMEOUT
 256         };
 257 };
 258
 259 /**
 260  * TIPC socket address (name).
 261  *
 262  * @see bind(2), Socket::bind()
 263  * @see connect(2), Socket::connect()
 264  * @see getsockaddr(2), Socket::getsockaddr()
 265  * @see setsockaddr(2), Socket::setsockaddr()
 266  * @see accept(2), Socket::accept()
 267  * @see sendto(2), Socket::send()
 268  * @see recvfrom(2), Socket::recv()
 269  */
 270 struct sockaddr: sockaddr_tipc
 271 {
 272
 273         /// Type of TIPC address
 274         enum type_t
 275         {
 276                 ID = TIPC_ADDR_ID, ///< Port ID
 277                 NAME = TIPC_ADDR_NAME, ///< Port name
 278                 NAMESEQ = TIPC_ADDR_NAMESEQ ///< Name sequence or multicast
 279         };
 280
 281         /**
 282          * Bind scope.
 283          *
 284          * @see TIPC documentation: 2.1.2 bind
 285          */
 286         enum scope_t
 287         {
 288                 ZONE = TIPC_ZONE_SCOPE,       ///< Zone scope.
 289                 CLUSTER = TIPC_CLUSTER_SCOPE, ///< Cluster scope.
 290                 NODE = TIPC_NODE_SCOPE        ///< Node scope.
 291         };
 292
 293         /// Constructor.
 294         sockaddr() throw ();
 295
 296         /**
 297          * Constructor using a port ID.
 298          *
 299          * @param port Port ID.
 300          * @param scope Bind scope.
 301          */
 302         sockaddr(portid port, scope_t scope = ZONE) throw ();
 303
 304         /**
 305          * Constructor using a port name.
 306          *
 307          * @param name Port name.
 308          * @param scope Bind scope.
 309          * @param domain Domain lookup.
 310          *
 311          * @see Documentación de TIPC: 1.4.1 Address Resolution
 312          */
 313         sockaddr(name name, scope_t scope = ZONE,
 314                         tipc::addr domain = tipc::addr(0u))
 315                 throw ();
 316
 317         /**
 318          * Constructor using a port name sequence.
 319          *
 320          * @param nameseq Port name sequence.
 321          * @param scope Bind scope.
 322          */
 323         sockaddr(nameseq nameseq, scope_t scope = ZONE) throw ();
 324
 325         /**
 326          * Constructor using a multicast port name sequence.
 327          *
 328          * @param mcast Multicast port name sequence.
 329          * @param scope Bind scope.
 330          */
 331         sockaddr(multicast mcast, scope_t scope = ZONE) throw ();
 332
 333         /// Type of TIPC address
 334         type_t type() const throw ();
 335
 336         /// Length of this unix socket address
 337         socklen_t length() const throw ();
 338
 339         /// Compare two TIPC socket addresses
 340         bool operator == (const sockaddr& other) const throw ();
 341
 342 };
 343
 344 /// TIPC socket traits.
 345 struct traits
 346 {
 347
 348         /// Socket address type.
 349         typedef tipc::sockaddr sockaddr;
 350
 351         /// Protocol family.
 352         enum { PF = PF_TIPC };
 353
 354 };
 355
 356 /// TIPC socket
 357 typedef posixx::socket::basic_socket< traits > socket;
 358
 359 } } } // namespace posixx::linux::tipc
 360
 361
 362 inline
 363 posixx::linux::tipc::addr::addr() throw (): address(0u)
 364 {
 365 }
 366
 367 inline
 368 posixx::linux::tipc::addr::addr(__u32 address) throw (): address(address)
 369 {
 370 }
 371
 372 inline
 373 posixx::linux::tipc::addr::addr(unsigned int zone, unsigned int cluster,
 374                 unsigned int node) throw ():
 375         address(tipc_addr(zone, cluster, node))
 376 {
 377 }
 378
 379 inline
 380 void posixx::linux::tipc::addr::zone(unsigned int zone) throw ()
 381 {
 382         address = tipc_addr(zone, cluster(), node());
 383 }
 384
 385 inline
 386 unsigned int posixx::linux::tipc::addr::zone() const throw ()
 387 {
 388         return tipc_zone(address);
 389 }
 390
 391 inline
 392 void posixx::linux::tipc::addr::cluster(unsigned int cluster) throw ()
 393 {
 394         address = tipc_addr(zone(), cluster, node());
 395 }
 396
 397 inline
 398 unsigned int posixx::linux::tipc::addr::cluster() const throw ()
 399 {
 400         return tipc_cluster(address);
 401 }
 402
 403 inline
 404 void posixx::linux::tipc::addr::node(unsigned int node) throw ()
 405 {
 406         address = tipc_addr(zone(), cluster(), node);
 407 }
 408
 409 inline
 410 unsigned int posixx::linux::tipc::addr::node() const throw ()
 411 {
 412         return tipc_node(address);
 413 }
 414
 415 inline
 416 posixx::linux::tipc::addr::operator __u32 () const throw ()
 417 {
 418         return address;
 419 }
 420
 421 inline
 422 posixx::linux::tipc::portid::portid(__u32 r, addr n) throw ()
 423 {
 424         ref = r;
 425         node = n;
 426 }
 427
 428 inline
 429 posixx::linux::tipc::name::name(__u32 t, __u32 i) throw ()
 430 {
 431         type = t;
 432         instance = i;
 433 }
 434
 435 inline
 436 posixx::linux::tipc::nameseq::nameseq(__u32 t, __u32 low, __u32 up) throw ()
 437 {
 438         type = t;
 439         lower = low;
 440         upper = up;
 441 }
 442
 443 inline
 444 posixx::linux::tipc::nameseq::nameseq(__u32 t, __u32 instance) throw ()
 445 {
 446         type = t;
 447         lower = instance;
 448         upper = instance;
 449 }
 450
 451 inline
 452 posixx::linux::tipc::multicast::multicast(__u32 t, __u32 low, __u32 up)
 453         throw ()
 454 {
 455         type = t;
 456         lower = low;
 457         upper = up;
 458 }
 459
 460 inline
 461 posixx::linux::tipc::multicast::multicast(__u32 t, __u32 instance) throw ()
 462 {
 463         type = t;
 464         lower = instance;
 465         upper = instance;
 466 }
 467
 468 inline
 469 posixx::linux::tipc::subscription::subscription(nameseq s, __u32 t, __u32 f,
 470                 const char* uh) throw ()
 471 {
 472         seq = s;
 473         timeout = t;
 474         filter = f;
 475         std::memcpy(usr_handle, uh, sizeof(usr_handle));
 476 }
 477
 478 inline
 479 posixx::linux::tipc::sockaddr::sockaddr() throw ()
 480 {
 481 }
 482
 483 inline
 484 posixx::linux::tipc::sockaddr::sockaddr(portid port, scope_t s) throw ()
 485 {
 486         family = AF_TIPC;
 487         addrtype = TIPC_ADDR_ID;
 488         scope = s;
 489         addr.id = port;
 490 }
 491
 492 inline
 493 posixx::linux::tipc::sockaddr::sockaddr(name name, scope_t s, tipc::addr d)
 494                 throw ()
 495 {
 496         family = AF_TIPC;
 497         addrtype = TIPC_ADDR_NAME;
 498         scope = s;
 499         addr.name.name = name;
 500         addr.name.domain = d;
 501 }
 502
 503 inline
 504 posixx::linux::tipc::sockaddr::sockaddr(nameseq nameseq, scope_t s) throw ()
 505 {
 506         family = AF_TIPC;
 507         addrtype = TIPC_ADDR_NAMESEQ;
 508         scope = s;
 509         addr.nameseq = nameseq;
 510 }
 511
 512 inline
 513 posixx::linux::tipc::sockaddr::sockaddr(multicast mcast, scope_t s) throw ()
 514 {
 515         family = AF_TIPC;
 516         addrtype = TIPC_ADDR_MCAST;
 517         scope = s;
 518         addr.nameseq = mcast;
 519 }
 520
 521 inline
 522 posixx::linux::tipc::sockaddr::type_t posixx::linux::tipc::sockaddr::type()
 523                 const throw ()
 524 {
 525         return static_cast< type_t >(addrtype);
 526 }
 527
 528 inline
 529 socklen_t posixx::linux::tipc::sockaddr::length() const throw ()
 530 {
 531         return sizeof(sockaddr_tipc);
 532 }
 533
 534 inline
 535 bool posixx::linux::tipc::sockaddr::operator == (const sockaddr& other) const
 536                 throw ()
 537 {
 538         return !memcmp(this, &other, sizeof(*this));
 539 }
 540
 541 #endif // POSIXX_LINUX_TIPC_HPP_