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