package/libnl-tiny/src/socket.c

   1 /*
   2  * lib/socket.c         Netlink Socket
   3  *
   4  *      This library is free software; you can redistribute it and/or
   5  *      modify it under the terms of the GNU Lesser General Public
   6  *      License as published by the Free Software Foundation version 2.1
   7  *      of the License.
   8  *
   9  * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
  10  */
  11
  12 /**
  13  * @ingroup core
  14  * @defgroup socket Socket
  15  * @{
  16  */
  17
  18 #include <netlink-local.h>
  19 #include <netlink/netlink.h>
  20 #include <netlink/utils.h>
  21 #include <netlink/handlers.h>
  22 #include <netlink/msg.h>
  23 #include <netlink/attr.h>
  24
  25 static uint32_t used_ports_map[32];
  26
  27 static uint32_t generate_local_port(void)
  28 {
  29         int i, n;
  30         uint32_t pid = getpid() & 0x3FFFFF;
  31
  32         for (i = 0; i < 32; i++) {
  33                 if (used_ports_map[i] == 0xFFFFFFFF)
  34                         continue;
  35
  36                 for (n = 0; n < 32; n++) {
  37                         if (1UL & (used_ports_map[i] >> n))
  38                                 continue;
  39
  40                         used_ports_map[i] |= (1UL << n);
  41                         n += (i * 32);
  42
  43                         /* PID_MAX_LIMIT is currently at 2^22, leaving 10 bit
  44                          * to, i.e. 1024 unique ports per application. */
  45                         return pid + (n << 22);
  46
  47                 }
  48         }
  49
  50         /* Out of sockets in our own PID namespace, what to do? FIXME */
  51         return UINT_MAX;
  52 }
  53
  54 static void release_local_port(uint32_t port)
  55 {
  56         int nr;
  57
  58         if (port == UINT_MAX)
  59                 return;
  60
  61         nr = port >> 22;
  62         used_ports_map[nr / 32] &= ~(1 << nr % 32);
  63 }
  64
  65 /**
  66  * @name Allocation
  67  * @{
  68  */
  69
  70 static struct nl_sock *__alloc_socket(struct nl_cb *cb)
  71 {
  72         struct nl_sock *sk;
  73
  74         sk = calloc(1, sizeof(*sk));
  75         if (!sk)
  76                 return NULL;
  77
  78         sk->s_fd = -1;
  79         sk->s_cb = cb;
  80         sk->s_local.nl_family = AF_NETLINK;
  81         sk->s_peer.nl_family = AF_NETLINK;
  82         sk->s_seq_expect = sk->s_seq_next = time(0);
  83         sk->s_local.nl_pid = generate_local_port();
  84         if (sk->s_local.nl_pid == UINT_MAX) {
  85                 nl_socket_free(sk);
  86                 return NULL;
  87         }
  88
  89         return sk;
  90 }
  91
  92 /**
  93  * Allocate new netlink socket
  94  *
  95  * @return Newly allocated netlink socket or NULL.
  96  */
  97 struct nl_sock *nl_socket_alloc(void)
  98 {
  99         struct nl_cb *cb;
 100
 101         cb = nl_cb_alloc(NL_CB_DEFAULT);
 102         if (!cb)
 103                 return NULL;
 104
 105         return __alloc_socket(cb);
 106 }
 107
 108 /**
 109  * Allocate new socket with custom callbacks
 110  * @arg cb              Callback handler
 111  *
 112  * The reference to the callback handler is taken into account
 113  * automatically, it is released again upon calling nl_socket_free().
 114  *
 115  *@return Newly allocted socket handle or NULL.
 116  */
 117 struct nl_sock *nl_socket_alloc_cb(struct nl_cb *cb)
 118 {
 119         if (cb == NULL)
 120                 BUG();
 121
 122         return __alloc_socket(nl_cb_get(cb));
 123 }
 124
 125 /**
 126  * Free a netlink socket.
 127  * @arg sk              Netlink socket.
 128  */
 129 void nl_socket_free(struct nl_sock *sk)
 130 {
 131         if (!sk)
 132                 return;
 133
 134         if (sk->s_fd >= 0)
 135                 close(sk->s_fd);
 136
 137         if (!(sk->s_flags & NL_OWN_PORT))
 138                 release_local_port(sk->s_local.nl_pid);
 139
 140         nl_cb_put(sk->s_cb);
 141         free(sk);
 142 }
 143
 144 /** @} */
 145
 146 /**
 147  * @name Sequence Numbers
 148  * @{
 149  */
 150
 151 static int noop_seq_check(struct nl_msg *msg, void *arg)
 152 {
 153         return NL_OK;
 154 }
 155
 156
 157 /**
 158  * Disable sequence number checking.
 159  * @arg sk              Netlink socket.
 160  *
 161  * Disables checking of sequence numbers on the netlink socket This is
 162  * required to allow messages to be processed which were not requested by
 163  * a preceding request message, e.g. netlink events.
 164  *
 165  * @note This function modifies the NL_CB_SEQ_CHECK configuration in
 166  * the callback handle associated with the socket.
 167  */
 168 void nl_socket_disable_seq_check(struct nl_sock *sk)
 169 {
 170         nl_cb_set(sk->s_cb, NL_CB_SEQ_CHECK,
 171                   NL_CB_CUSTOM, noop_seq_check, NULL);
 172 }
 173
 174 /** @} */
 175
 176 /**
 177  * Set local port of socket
 178  * @arg sk              Netlink socket.
 179  * @arg port            Local port identifier
 180  *
 181  * Assigns a local port identifier to the socket. If port is 0
 182  * a unique port identifier will be generated automatically.
 183  */
 184 void nl_socket_set_local_port(struct nl_sock *sk, uint32_t port)
 185 {
 186         if (port == 0) {
 187                 port = generate_local_port();
 188                 sk->s_flags &= ~NL_OWN_PORT;
 189         } else  {
 190                 if (!(sk->s_flags & NL_OWN_PORT))
 191                         release_local_port(sk->s_local.nl_pid);
 192                 sk->s_flags |= NL_OWN_PORT;
 193         }
 194
 195         sk->s_local.nl_pid = port;
 196 }
 197
 198 /** @} */
 199
 200 /**
 201  * @name Group Subscriptions
 202  * @{
 203  */
 204
 205 /**
 206  * Join groups
 207  * @arg sk              Netlink socket
 208  * @arg group           Group identifier
 209  *
 210  * Joins the specified groups using the modern socket option which
 211  * is available since kernel version 2.6.14. It allows joining an
 212  * almost arbitary number of groups without limitation.  The list
 213  * of groups has to be terminated by 0 (%NFNLGRP_NONE).
 214  *
 215  * Make sure to use the correct group definitions as the older
 216  * bitmask definitions for nl_join_groups() are likely to still
 217  * be present for backward compatibility reasons.
 218  *
 219  * @return 0 on sucess or a negative error code.
 220  */
 221 int nl_socket_add_memberships(struct nl_sock *sk, int group, ...)
 222 {
 223         int err;
 224         va_list ap;
 225
 226         if (sk->s_fd == -1)
 227                 return -NLE_BAD_SOCK;
 228
 229         va_start(ap, group);
 230
 231         while (group != 0) {
 232                 if (group < 0)
 233                         return -NLE_INVAL;
 234
 235                 err = setsockopt(sk->s_fd, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP,
 236                                                  &group, sizeof(group));
 237                 if (err < 0)
 238                         return -nl_syserr2nlerr(errno);
 239
 240                 group = va_arg(ap, int);
 241         }
 242
 243         va_end(ap);
 244
 245         return 0;
 246 }
 247
 248 /**
 249  * Leave groups
 250  * @arg sk              Netlink socket
 251  * @arg group           Group identifier
 252  *
 253  * Leaves the specified groups using the modern socket option
 254  * which is available since kernel version 2.6.14. The list of groups
 255  * has to terminated by 0 (%NFNLGRP_NONE).
 256  *
 257  * @see nl_socket_add_membership
 258  * @return 0 on success or a negative error code.
 259  */
 260 int nl_socket_drop_memberships(struct nl_sock *sk, int group, ...)
 261 {
 262         int err;
 263         va_list ap;
 264
 265         if (sk->s_fd == -1)
 266                 return -NLE_BAD_SOCK;
 267
 268         va_start(ap, group);
 269
 270         while (group != 0) {
 271                 if (group < 0)
 272                         return -NLE_INVAL;
 273
 274                 err = setsockopt(sk->s_fd, SOL_NETLINK, NETLINK_DROP_MEMBERSHIP,
 275                                                  &group, sizeof(group));
 276                 if (err < 0)
 277                         return -nl_syserr2nlerr(errno);
 278
 279                 group = va_arg(ap, int);
 280         }
 281
 282         va_end(ap);
 283
 284         return 0;
 285 }
 286
 287
 288 /** @} */
 289
 290 /**
 291  * Set file descriptor of socket to non-blocking state
 292  * @arg sk              Netlink socket.
 293  *
 294  * @return 0 on success or a negative error code.
 295  */
 296 int nl_socket_set_nonblocking(struct nl_sock *sk)
 297 {
 298         if (sk->s_fd == -1)
 299                 return -NLE_BAD_SOCK;
 300
 301         if (fcntl(sk->s_fd, F_SETFL, O_NONBLOCK) < 0)
 302                 return -nl_syserr2nlerr(errno);
 303
 304         return 0;
 305 }
 306
 307 /** @} */
 308
 309 /**
 310  * @name Utilities
 311  * @{
 312  */
 313
 314 /**
 315  * Set socket buffer size of netlink socket.
 316  * @arg sk              Netlink socket.
 317  * @arg rxbuf           New receive socket buffer size in bytes.
 318  * @arg txbuf           New transmit socket buffer size in bytes.
 319  *
 320  * Sets the socket buffer size of a netlink socket to the specified
 321  * values \c rxbuf and \c txbuf. Providing a value of \c 0 assumes a
 322  * good default value.
 323  *
 324  * @note It is not required to call this function prior to nl_connect().
 325  * @return 0 on sucess or a negative error code.
 326  */
 327 int nl_socket_set_buffer_size(struct nl_sock *sk, int rxbuf, int txbuf)
 328 {
 329         int err;
 330
 331         if (rxbuf <= 0)
 332                 rxbuf = 32768;
 333
 334         if (txbuf <= 0)
 335                 txbuf = 32768;
 336
 337         if (sk->s_fd == -1)
 338                 return -NLE_BAD_SOCK;
 339
 340         err = setsockopt(sk->s_fd, SOL_SOCKET, SO_SNDBUF,
 341                          &txbuf, sizeof(txbuf));
 342         if (err < 0)
 343                 return -nl_syserr2nlerr(errno);
 344
 345         err = setsockopt(sk->s_fd, SOL_SOCKET, SO_RCVBUF,
 346                          &rxbuf, sizeof(rxbuf));
 347         if (err < 0)
 348                 return -nl_syserr2nlerr(errno);
 349
 350         sk->s_flags |= NL_SOCK_BUFSIZE_SET;
 351
 352         return 0;
 353 }
 354
 355 /**
 356  * Enable/disable credential passing on netlink socket.
 357  * @arg sk              Netlink socket.
 358  * @arg state           New state (0 - disabled, 1 - enabled)
 359  *
 360  * @return 0 on success or a negative error code
 361  */
 362 int nl_socket_set_passcred(struct nl_sock *sk, int state)
 363 {
 364         int err;
 365
 366         if (sk->s_fd == -1)
 367                 return -NLE_BAD_SOCK;
 368
 369         err = setsockopt(sk->s_fd, SOL_SOCKET, SO_PASSCRED,
 370                          &state, sizeof(state));
 371         if (err < 0)
 372                 return -nl_syserr2nlerr(errno);
 373
 374         if (state)
 375                 sk->s_flags |= NL_SOCK_PASSCRED;
 376         else
 377                 sk->s_flags &= ~NL_SOCK_PASSCRED;
 378
 379         return 0;
 380 }
 381
 382 /**
 383  * Enable/disable receival of additional packet information
 384  * @arg sk              Netlink socket.
 385  * @arg state           New state (0 - disabled, 1 - enabled)
 386  *
 387  * @return 0 on success or a negative error code
 388  */
 389 int nl_socket_recv_pktinfo(struct nl_sock *sk, int state)
 390 {
 391         int err;
 392
 393         if (sk->s_fd == -1)
 394                 return -NLE_BAD_SOCK;
 395
 396         err = setsockopt(sk->s_fd, SOL_NETLINK, NETLINK_PKTINFO,
 397                          &state, sizeof(state));
 398         if (err < 0)
 399                 return -nl_syserr2nlerr(errno);
 400
 401         return 0;
 402 }
 403
 404 /** @} */
 405
 406 /** @} */