src/linux/tipc.hpp

   1 #ifndef POSIXX_LINUX_TIPC_HPP_
   2 #define POSIXX_LINUX_TIPC_HPP_
   3
   4 #include "../socket/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         /**
 110          * Constructor.
 111          *
 112          * @param type Type of the named port.
 113          * @param instance Instance of the named port.
 114          */
 115         name(__u32 type, __u32 instance) throw ();
 116
 117 };
 118
 119 /**
 120  * Port sequence.
 121  *
 122  * @see tipc_name_seq struct from linux/tipc.h.
 123  */
 124 struct nameseq: tipc_name_seq
 125 {
 126
 127         /**
 128          * Constructor.
 129          *
 130          * @param type Type of the sequence.
 131          * @param lower Lower bound.
 132          * @param upper Upper bound.
 133          */
 134
 135         nameseq(__u32 type, __u32 lower, __u32 upper) throw ();
 136         /**
 137          * Constructor.
 138          *
 139          * @param type Type of the sequence.
 140          * @param instance Lower and upper bound.
 141          */
 142         nameseq(__u32 type, __u32 instance) throw ();
 143
 144 };
 145
 146 /**
 147  * Reasons for returned messages when recvmsg() is used.
 148  *
 149  * @see recvmsg(2) of TIPC documentation
 150  */
 151 enum reason_t
 152 {
 153         /// Not a returned message.
 154         OK = TIPC_OK,
 155         /// Port name doesn't exist.
 156         ERR_NO_NAME = TIPC_ERR_NO_NAME,
 157         /// Port ID doesn't exist.
 158         ERR_NO_PORT = TIPC_ERR_NO_PORT,
 159         /// Node doesn't exist.
 160         ERR_NO_NODE = TIPC_ERR_NO_NODE,
 161         /// Reception queue is full.
 162         ERR_OVERLOAD = TIPC_ERR_OVERLOAD,
 163         /// Connection shutted down.
 164         CONN_SHUTDOWN = TIPC_CONN_SHUTDOWN
 165 };
 166
 167 /**
 168  * Subscription filter type.
 169  *
 170  * @see TIPC documentation: 1.4.3 Name Subscriptions
 171  */
 172 enum subscr_t
 173 {
 174
 175         /**
 176          * Causes the topology service to generate a PUBLISHED event
 177          * for each port name or port name sequence it finds that overlaps
 178          * the specified port name sequence; a WITHDRAWN event is issued
 179          * each time a previously reported name becomes unavailable.
 180          *
 181          * Allows the topology service to inform the application if there
 182          * are @b any ports of interest.
 183          */
 184         SUB_PORTS = TIPC_SUB_PORTS,
 185
 186         /**
 187          * Causes the topology service to generate a single publish event for
 188          * the first port it finds with an overlapping name and a single
 189          * withdraw event when the last such port becomes unavailable.
 190          *
 191          * Allows the topology service to inform the application about
 192          * @b all ports of interest.
 193          */
 194         SUB_SERVICE = TIPC_SUB_SERVICE,
 195
 196         /**
 197          * Instruct the topology service to cancel a previously requested
 198          * subscription.
 199          *
 200          * The application simply resends the original subscription request
 201          * with SUB_CANCEL logically OR'd into the event filter.
 202          *
 203          * @note This is implemented in TIPC 1.7+ only (according to TIPC
 204          *       documentation).
 205          */
 206         SUB_CANCEL = TIPC_SUB_CANCEL
 207
 208 };
 209
 210 /**
 211  * Subscription request message.
 212  *
 213  * @see TIPC documentation: 1.4.3 Name Subscriptions
 214  */
 215 struct subscr: tipc_subscr
 216 {
 217
 218         /**
 219          * Constructor.
 220          *
 221          * @param seq The port name sequence of interest to the application.
 222          * @param timeout A subscription timeout value, in ms
 223          *                (or WAIT_FOREVER).
 224          * @param filter An event filter specifying which events are of
 225          *               interest to the application (see subscr_t).
 226          * @param usr_handle An 8 byte user handle that is application-defined.
 227          */
 228         subscr(nameseq seq, __u32 timeout, __u32 filter,
 229                         const char* usr_handle = "") throw ();
 230
 231 };
 232
 233 /// Type of events.
 234 enum event_t
 235 {
 236
 237         /// The port has been published.
 238         PUBLISHED = TIPC_PUBLISHED,
 239
 240         /// The port has been withdrawn.
 241         WITHDRAWN = TIPC_WITHDRAWN,
 242
 243         /// The event has timed out.
 244         TIMEOUT = TIPC_SUBSCR_TIMEOUT
 245
 246 };
 247
 248 /**
 249  * Event message.
 250  *
 251  * @see TIPC documentation: 1.4.3 Name Subscriptions
 252  */
 253 struct subscr_event: tipc_event
 254 {
 255 };
 256
 257 /**
 258  * TIPC socket address (name).
 259  *
 260  * @see bind(2), Socket::bind()
 261  * @see connect(2), Socket::connect()
 262  * @see getsockaddr(2), Socket::getsockaddr()
 263  * @see setsockaddr(2), Socket::setsockaddr()
 264  * @see accept(2), Socket::accept()
 265  * @see sendto(2), Socket::send()
 266  * @see recvfrom(2), Socket::recv()
 267  */
 268 struct sockaddr: sockaddr_tipc
 269 {
 270
 271         /// Type of TIPC address
 272         enum type_t
 273         {
 274                 ID = TIPC_ADDR_ID, ///< Port ID
 275                 NAME = TIPC_ADDR_NAME, ///< Port name
 276                 NAMESEQ = TIPC_ADDR_NAMESEQ ///< Name sequence or multicast
 277         };
 278
 279         /**
 280          * Bind scope.
 281          *
 282          * @see TIPC documentation: 2.1.2 bind
 283          */
 284         enum scope_t
 285         {
 286                 ZONE = TIPC_ZONE_SCOPE,       ///< Zone scope.
 287                 CLUSTER = TIPC_CLUSTER_SCOPE, ///< Cluster scope.
 288                 NODE = TIPC_NODE_SCOPE        ///< Node scope.
 289         };
 290
 291         /// Constructor.
 292         sockaddr() throw ();
 293
 294         /**
 295          * Constructor using a port ID.
 296          *
 297          * @param port Port ID.
 298          * @param scope Bind scope.
 299          */
 300         sockaddr(portid port, scope_t scope = ZONE) throw ();
 301
 302         /**
 303          * Constructor using a port name.
 304          *
 305          * @param name Port name.
 306          * @param scope Bind scope.
 307          * @param domain Domain lookup.
 308          *
 309          * @see Documentación de TIPC: 1.4.1 Address Resolution
 310          */
 311         sockaddr(name name, scope_t scope = ZONE,
 312                         tipc::addr domain = tipc::addr(0u))
 313                 throw ();
 314
 315         /**
 316          * Constructor using a port name sequence.
 317          *
 318          * @param nameseq Port name sequence.
 319          * @param scope Bind scope.
 320          */
 321         sockaddr(nameseq nameseq, scope_t scope = ZONE) throw ();
 322
 323         /// Type of TIPC address
 324         type_t type() const throw ();
 325
 326         /// Length of this unix socket address
 327         socklen_t length() const throw ();
 328
 329         /// Compare two TIPC socket addresses
 330         bool operator == (const sockaddr& other) const throw ();
 331
 332 };
 333
 334 /// TIPC socket traits.
 335 struct traits
 336 {
 337
 338         /// Socket address type.
 339         typedef tipc::sockaddr sockaddr;
 340
 341         /// Protocol family.
 342         enum { PF = PF_TIPC };
 343
 344 };
 345
 346 /// TIPC socket
 347 typedef posixx::socket::basic_socket< traits > socket;
 348
 349 } } } // namespace posixx::linux::tipc
 350
 351
 352 inline
 353 posixx::linux::tipc::addr::addr() throw (): address(0u)
 354 {
 355 }
 356
 357 inline
 358 posixx::linux::tipc::addr::addr(__u32 address) throw (): address(address)
 359 {
 360 }
 361
 362 inline
 363 posixx::linux::tipc::addr::addr(unsigned int zone, unsigned int cluster,
 364                 unsigned int node) throw ():
 365         address(tipc_addr(zone, cluster, node))
 366 {
 367 }
 368
 369 inline
 370 void posixx::linux::tipc::addr::zone(unsigned int zone) throw ()
 371 {
 372         address = tipc_addr(zone, cluster(), node());
 373 }
 374
 375 inline
 376 unsigned int posixx::linux::tipc::addr::zone() const throw ()
 377 {
 378         return tipc_zone(address);
 379 }
 380
 381 inline
 382 void posixx::linux::tipc::addr::cluster(unsigned int cluster) throw ()
 383 {
 384         address = tipc_addr(zone(), cluster, node());
 385 }
 386
 387 inline
 388 unsigned int posixx::linux::tipc::addr::cluster() const throw ()
 389 {
 390         return tipc_cluster(address);
 391 }
 392
 393 inline
 394 void posixx::linux::tipc::addr::node(unsigned int node) throw ()
 395 {
 396         address = tipc_addr(zone(), cluster(), node);
 397 }
 398
 399 inline
 400 unsigned int posixx::linux::tipc::addr::node() const throw ()
 401 {
 402         return tipc_node(address);
 403 }
 404
 405 inline
 406 posixx::linux::tipc::addr::operator __u32 () const throw ()
 407 {
 408         return address;
 409 }
 410
 411 inline
 412 posixx::linux::tipc::portid::portid(__u32 r, addr n) throw ()
 413 {
 414         ref = r;
 415         node = n;
 416 }
 417
 418 inline
 419 posixx::linux::tipc::name::name(__u32 t, __u32 i) throw ()
 420 {
 421         type = t;
 422         instance = i;
 423 }
 424
 425 inline
 426 posixx::linux::tipc::nameseq::nameseq(__u32 t, __u32 low, __u32 up) throw ()
 427 {
 428         type = t;
 429         lower = low;
 430         upper = up;
 431 }
 432
 433 inline
 434 posixx::linux::tipc::nameseq::nameseq(__u32 t, __u32 instance) throw ()
 435 {
 436         type = t;
 437         lower = instance;
 438         upper = instance;
 439 }
 440
 441 inline
 442 posixx::linux::tipc::subscr::subscr(nameseq s, __u32 t, __u32 f,
 443                 const char* uh) throw ()
 444 {
 445         seq = s;
 446         timeout = t;
 447         filter = f;
 448         std::memcpy(usr_handle, uh, sizeof(usr_handle));
 449 }
 450
 451 inline
 452 posixx::linux::tipc::sockaddr::sockaddr() throw ()
 453 {
 454 }
 455
 456 inline
 457 posixx::linux::tipc::sockaddr::sockaddr(portid port, scope_t s) throw ()
 458 {
 459         family = AF_TIPC;
 460         addrtype = TIPC_ADDR_ID;
 461         scope = s;
 462         addr.id = port;
 463 }
 464
 465 inline
 466 posixx::linux::tipc::sockaddr::sockaddr(name name, scope_t s, tipc::addr d)
 467                 throw ()
 468 {
 469         family = AF_TIPC;
 470         addrtype = TIPC_ADDR_NAME;
 471         scope = s;
 472         addr.name.name = name;
 473         addr.name.domain = d;
 474 }
 475
 476 inline
 477 posixx::linux::tipc::sockaddr::sockaddr(nameseq nameseq, scope_t s) throw ()
 478 {
 479         family = AF_TIPC;
 480         addrtype = TIPC_ADDR_NAMESEQ;
 481         scope = s;
 482         addr.nameseq = nameseq;
 483 }
 484
 485 inline
 486 posixx::linux::tipc::sockaddr::type_t posixx::linux::tipc::sockaddr::type()
 487                 const throw ()
 488 {
 489         return static_cast< type_t >(addrtype);
 490 }
 491
 492 inline
 493 socklen_t posixx::linux::tipc::sockaddr::length() const throw ()
 494 {
 495         return sizeof(sockaddr_tipc);
 496 }
 497
 498 inline
 499 bool posixx::linux::tipc::sockaddr::operator == (const sockaddr& other) const
 500                 throw ()
 501 {
 502         return !memcmp(this, &other, sizeof(*this));
 503 }
 504
 505 #endif // POSIXX_LINUX_TIPC_HPP_