net/batman-adv/tvlv.c

   1 /* Copyright (C) 2007-2016  B.A.T.M.A.N. contributors:
   2  *
   3  * Marek Lindner, Simon Wunderlich
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of version 2 of the GNU General Public
   7  * License as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "main.h"
  19
  20 #include <linux/byteorder/generic.h>
  21 #include <linux/etherdevice.h>
  22 #include <linux/fs.h>
  23 #include <linux/if_ether.h>
  24 #include <linux/kernel.h>
  25 #include <linux/kref.h>
  26 #include <linux/list.h>
  27 #include <linux/lockdep.h>
  28 #include <linux/netdevice.h>
  29 #include <linux/pkt_sched.h>
  30 #include <linux/rculist.h>
  31 #include <linux/rcupdate.h>
  32 #include <linux/skbuff.h>
  33 #include <linux/slab.h>
  34 #include <linux/spinlock.h>
  35 #include <linux/stddef.h>
  36 #include <linux/string.h>
  37 #include <linux/types.h>
  38
  39 #include "originator.h"
  40 #include "packet.h"
  41 #include "send.h"
  42 #include "tvlv.h"
  43
  44 /**
  45  * batadv_tvlv_handler_release - release tvlv handler from lists and queue for
  46  *  free after rcu grace period
  47  * @ref: kref pointer of the tvlv
  48  */
  49 static void batadv_tvlv_handler_release(struct kref *ref)
  50 {
  51         struct batadv_tvlv_handler *tvlv_handler;
  52
  53         tvlv_handler = container_of(ref, struct batadv_tvlv_handler, refcount);
  54         kfree_rcu(tvlv_handler, rcu);
  55 }
  56
  57 /**
  58  * batadv_tvlv_handler_put - decrement the tvlv container refcounter and
  59  *  possibly release it
  60  * @tvlv_handler: the tvlv handler to free
  61  */
  62 static void batadv_tvlv_handler_put(struct batadv_tvlv_handler *tvlv_handler)
  63 {
  64         kref_put(&tvlv_handler->refcount, batadv_tvlv_handler_release);
  65 }
  66
  67 /**
  68  * batadv_tvlv_handler_get - retrieve tvlv handler from the tvlv handler list
  69  *  based on the provided type and version (both need to match)
  70  * @bat_priv: the bat priv with all the soft interface information
  71  * @type: tvlv handler type to look for
  72  * @version: tvlv handler version to look for
  73  *
  74  * Return: tvlv handler if found or NULL otherwise.
  75  */
  76 static struct batadv_tvlv_handler *
  77 batadv_tvlv_handler_get(struct batadv_priv *bat_priv, u8 type, u8 version)
  78 {
  79         struct batadv_tvlv_handler *tvlv_handler_tmp, *tvlv_handler = NULL;
  80
  81         rcu_read_lock();
  82         hlist_for_each_entry_rcu(tvlv_handler_tmp,
  83                                  &bat_priv->tvlv.handler_list, list) {
  84                 if (tvlv_handler_tmp->type != type)
  85                         continue;
  86
  87                 if (tvlv_handler_tmp->version != version)
  88                         continue;
  89
  90                 if (!kref_get_unless_zero(&tvlv_handler_tmp->refcount))
  91                         continue;
  92
  93                 tvlv_handler = tvlv_handler_tmp;
  94                 break;
  95         }
  96         rcu_read_unlock();
  97
  98         return tvlv_handler;
  99 }
 100
 101 /**
 102  * batadv_tvlv_container_release - release tvlv from lists and free
 103  * @ref: kref pointer of the tvlv
 104  */
 105 static void batadv_tvlv_container_release(struct kref *ref)
 106 {
 107         struct batadv_tvlv_container *tvlv;
 108
 109         tvlv = container_of(ref, struct batadv_tvlv_container, refcount);
 110         kfree(tvlv);
 111 }
 112
 113 /**
 114  * batadv_tvlv_container_put - decrement the tvlv container refcounter and
 115  *  possibly release it
 116  * @tvlv: the tvlv container to free
 117  */
 118 static void batadv_tvlv_container_put(struct batadv_tvlv_container *tvlv)
 119 {
 120         kref_put(&tvlv->refcount, batadv_tvlv_container_release);
 121 }
 122
 123 /**
 124  * batadv_tvlv_container_get - retrieve tvlv container from the tvlv container
 125  *  list based on the provided type and version (both need to match)
 126  * @bat_priv: the bat priv with all the soft interface information
 127  * @type: tvlv container type to look for
 128  * @version: tvlv container version to look for
 129  *
 130  * Has to be called with the appropriate locks being acquired
 131  * (tvlv.container_list_lock).
 132  *
 133  * Return: tvlv container if found or NULL otherwise.
 134  */
 135 static struct batadv_tvlv_container *
 136 batadv_tvlv_container_get(struct batadv_priv *bat_priv, u8 type, u8 version)
 137 {
 138         struct batadv_tvlv_container *tvlv_tmp, *tvlv = NULL;
 139
 140         lockdep_assert_held(&bat_priv->tvlv.container_list_lock);
 141
 142         hlist_for_each_entry(tvlv_tmp, &bat_priv->tvlv.container_list, list) {
 143                 if (tvlv_tmp->tvlv_hdr.type != type)
 144                         continue;
 145
 146                 if (tvlv_tmp->tvlv_hdr.version != version)
 147                         continue;
 148
 149                 kref_get(&tvlv_tmp->refcount);
 150                 tvlv = tvlv_tmp;
 151                 break;
 152         }
 153
 154         return tvlv;
 155 }
 156
 157 /**
 158  * batadv_tvlv_container_list_size - calculate the size of the tvlv container
 159  *  list entries
 160  * @bat_priv: the bat priv with all the soft interface information
 161  *
 162  * Has to be called with the appropriate locks being acquired
 163  * (tvlv.container_list_lock).
 164  *
 165  * Return: size of all currently registered tvlv containers in bytes.
 166  */
 167 static u16 batadv_tvlv_container_list_size(struct batadv_priv *bat_priv)
 168 {
 169         struct batadv_tvlv_container *tvlv;
 170         u16 tvlv_len = 0;
 171
 172         lockdep_assert_held(&bat_priv->tvlv.container_list_lock);
 173
 174         hlist_for_each_entry(tvlv, &bat_priv->tvlv.container_list, list) {
 175                 tvlv_len += sizeof(struct batadv_tvlv_hdr);
 176                 tvlv_len += ntohs(tvlv->tvlv_hdr.len);
 177         }
 178
 179         return tvlv_len;
 180 }
 181
 182 /**
 183  * batadv_tvlv_container_remove - remove tvlv container from the tvlv container
 184  *  list
 185  * @bat_priv: the bat priv with all the soft interface information
 186  * @tvlv: the to be removed tvlv container
 187  *
 188  * Has to be called with the appropriate locks being acquired
 189  * (tvlv.container_list_lock).
 190  */
 191 static void batadv_tvlv_container_remove(struct batadv_priv *bat_priv,
 192                                          struct batadv_tvlv_container *tvlv)
 193 {
 194         lockdep_assert_held(&bat_priv->tvlv.container_list_lock);
 195
 196         if (!tvlv)
 197                 return;
 198
 199         hlist_del(&tvlv->list);
 200
 201         /* first call to decrement the counter, second call to free */
 202         batadv_tvlv_container_put(tvlv);
 203         batadv_tvlv_container_put(tvlv);
 204 }
 205
 206 /**
 207  * batadv_tvlv_container_unregister - unregister tvlv container based on the
 208  *  provided type and version (both need to match)
 209  * @bat_priv: the bat priv with all the soft interface information
 210  * @type: tvlv container type to unregister
 211  * @version: tvlv container type to unregister
 212  */
 213 void batadv_tvlv_container_unregister(struct batadv_priv *bat_priv,
 214                                       u8 type, u8 version)
 215 {
 216         struct batadv_tvlv_container *tvlv;
 217
 218         spin_lock_bh(&bat_priv->tvlv.container_list_lock);
 219         tvlv = batadv_tvlv_container_get(bat_priv, type, version);
 220         batadv_tvlv_container_remove(bat_priv, tvlv);
 221         spin_unlock_bh(&bat_priv->tvlv.container_list_lock);
 222 }
 223
 224 /**
 225  * batadv_tvlv_container_register - register tvlv type, version and content
 226  *  to be propagated with each (primary interface) OGM
 227  * @bat_priv: the bat priv with all the soft interface information
 228  * @type: tvlv container type
 229  * @version: tvlv container version
 230  * @tvlv_value: tvlv container content
 231  * @tvlv_value_len: tvlv container content length
 232  *
 233  * If a container of the same type and version was already registered the new
 234  * content is going to replace the old one.
 235  */
 236 void batadv_tvlv_container_register(struct batadv_priv *bat_priv,
 237                                     u8 type, u8 version,
 238                                     void *tvlv_value, u16 tvlv_value_len)
 239 {
 240         struct batadv_tvlv_container *tvlv_old, *tvlv_new;
 241
 242         if (!tvlv_value)
 243                 tvlv_value_len = 0;
 244
 245         tvlv_new = kzalloc(sizeof(*tvlv_new) + tvlv_value_len, GFP_ATOMIC);
 246         if (!tvlv_new)
 247                 return;
 248
 249         tvlv_new->tvlv_hdr.version = version;
 250         tvlv_new->tvlv_hdr.type = type;
 251         tvlv_new->tvlv_hdr.len = htons(tvlv_value_len);
 252
 253         memcpy(tvlv_new + 1, tvlv_value, ntohs(tvlv_new->tvlv_hdr.len));
 254         INIT_HLIST_NODE(&tvlv_new->list);
 255         kref_init(&tvlv_new->refcount);
 256
 257         spin_lock_bh(&bat_priv->tvlv.container_list_lock);
 258         tvlv_old = batadv_tvlv_container_get(bat_priv, type, version);
 259         batadv_tvlv_container_remove(bat_priv, tvlv_old);
 260         hlist_add_head(&tvlv_new->list, &bat_priv->tvlv.container_list);
 261         spin_unlock_bh(&bat_priv->tvlv.container_list_lock);
 262 }
 263
 264 /**
 265  * batadv_tvlv_realloc_packet_buff - reallocate packet buffer to accommodate
 266  *  requested packet size
 267  * @packet_buff: packet buffer
 268  * @packet_buff_len: packet buffer size
 269  * @min_packet_len: requested packet minimum size
 270  * @additional_packet_len: requested additional packet size on top of minimum
 271  *  size
 272  *
 273  * Return: true of the packet buffer could be changed to the requested size,
 274  * false otherwise.
 275  */
 276 static bool batadv_tvlv_realloc_packet_buff(unsigned char **packet_buff,
 277                                             int *packet_buff_len,
 278                                             int min_packet_len,
 279                                             int additional_packet_len)
 280 {
 281         unsigned char *new_buff;
 282
 283         new_buff = kmalloc(min_packet_len + additional_packet_len, GFP_ATOMIC);
 284
 285         /* keep old buffer if kmalloc should fail */
 286         if (!new_buff)
 287                 return false;
 288
 289         memcpy(new_buff, *packet_buff, min_packet_len);
 290         kfree(*packet_buff);
 291         *packet_buff = new_buff;
 292         *packet_buff_len = min_packet_len + additional_packet_len;
 293
 294         return true;
 295 }
 296
 297 /**
 298  * batadv_tvlv_container_ogm_append - append tvlv container content to given
 299  *  OGM packet buffer
 300  * @bat_priv: the bat priv with all the soft interface information
 301  * @packet_buff: ogm packet buffer
 302  * @packet_buff_len: ogm packet buffer size including ogm header and tvlv
 303  *  content
 304  * @packet_min_len: ogm header size to be preserved for the OGM itself
 305  *
 306  * The ogm packet might be enlarged or shrunk depending on the current size
 307  * and the size of the to-be-appended tvlv containers.
 308  *
 309  * Return: size of all appended tvlv containers in bytes.
 310  */
 311 u16 batadv_tvlv_container_ogm_append(struct batadv_priv *bat_priv,
 312                                      unsigned char **packet_buff,
 313                                      int *packet_buff_len, int packet_min_len)
 314 {
 315         struct batadv_tvlv_container *tvlv;
 316         struct batadv_tvlv_hdr *tvlv_hdr;
 317         u16 tvlv_value_len;
 318         void *tvlv_value;
 319         bool ret;
 320
 321         spin_lock_bh(&bat_priv->tvlv.container_list_lock);
 322         tvlv_value_len = batadv_tvlv_container_list_size(bat_priv);
 323
 324         ret = batadv_tvlv_realloc_packet_buff(packet_buff, packet_buff_len,
 325                                               packet_min_len, tvlv_value_len);
 326
 327         if (!ret)
 328                 goto end;
 329
 330         if (!tvlv_value_len)
 331                 goto end;
 332
 333         tvlv_value = (*packet_buff) + packet_min_len;
 334
 335         hlist_for_each_entry(tvlv, &bat_priv->tvlv.container_list, list) {
 336                 tvlv_hdr = tvlv_value;
 337                 tvlv_hdr->type = tvlv->tvlv_hdr.type;
 338                 tvlv_hdr->version = tvlv->tvlv_hdr.version;
 339                 tvlv_hdr->len = tvlv->tvlv_hdr.len;
 340                 tvlv_value = tvlv_hdr + 1;
 341                 memcpy(tvlv_value, tvlv + 1, ntohs(tvlv->tvlv_hdr.len));
 342                 tvlv_value = (u8 *)tvlv_value + ntohs(tvlv->tvlv_hdr.len);
 343         }
 344
 345 end:
 346         spin_unlock_bh(&bat_priv->tvlv.container_list_lock);
 347         return tvlv_value_len;
 348 }
 349
 350 /**
 351  * batadv_tvlv_call_handler - parse the given tvlv buffer to call the
 352  *  appropriate handlers
 353  * @bat_priv: the bat priv with all the soft interface information
 354  * @tvlv_handler: tvlv callback function handling the tvlv content
 355  * @ogm_source: flag indicating whether the tvlv is an ogm or a unicast packet
 356  * @orig_node: orig node emitting the ogm packet
 357  * @src: source mac address of the unicast packet
 358  * @dst: destination mac address of the unicast packet
 359  * @tvlv_value: tvlv content
 360  * @tvlv_value_len: tvlv content length
 361  *
 362  * Return: success if handler was not found or the return value of the handler
 363  * callback.
 364  */
 365 static int batadv_tvlv_call_handler(struct batadv_priv *bat_priv,
 366                                     struct batadv_tvlv_handler *tvlv_handler,
 367                                     bool ogm_source,
 368                                     struct batadv_orig_node *orig_node,
 369                                     u8 *src, u8 *dst,
 370                                     void *tvlv_value, u16 tvlv_value_len)
 371 {
 372         if (!tvlv_handler)
 373                 return NET_RX_SUCCESS;
 374
 375         if (ogm_source) {
 376                 if (!tvlv_handler->ogm_handler)
 377                         return NET_RX_SUCCESS;
 378
 379                 if (!orig_node)
 380                         return NET_RX_SUCCESS;
 381
 382                 tvlv_handler->ogm_handler(bat_priv, orig_node,
 383                                           BATADV_NO_FLAGS,
 384                                           tvlv_value, tvlv_value_len);
 385                 tvlv_handler->flags |= BATADV_TVLV_HANDLER_OGM_CALLED;
 386         } else {
 387                 if (!src)
 388                         return NET_RX_SUCCESS;
 389
 390                 if (!dst)
 391                         return NET_RX_SUCCESS;
 392
 393                 if (!tvlv_handler->unicast_handler)
 394                         return NET_RX_SUCCESS;
 395
 396                 return tvlv_handler->unicast_handler(bat_priv, src,
 397                                                      dst, tvlv_value,
 398                                                      tvlv_value_len);
 399         }
 400
 401         return NET_RX_SUCCESS;
 402 }
 403
 404 /**
 405  * batadv_tvlv_containers_process - parse the given tvlv buffer to call the
 406  *  appropriate handlers
 407  * @bat_priv: the bat priv with all the soft interface information
 408  * @ogm_source: flag indicating whether the tvlv is an ogm or a unicast packet
 409  * @orig_node: orig node emitting the ogm packet
 410  * @src: source mac address of the unicast packet
 411  * @dst: destination mac address of the unicast packet
 412  * @tvlv_value: tvlv content
 413  * @tvlv_value_len: tvlv content length
 414  *
 415  * Return: success when processing an OGM or the return value of all called
 416  * handler callbacks.
 417  */
 418 int batadv_tvlv_containers_process(struct batadv_priv *bat_priv,
 419                                    bool ogm_source,
 420                                    struct batadv_orig_node *orig_node,
 421                                    u8 *src, u8 *dst,
 422                                    void *tvlv_value, u16 tvlv_value_len)
 423 {
 424         struct batadv_tvlv_handler *tvlv_handler;
 425         struct batadv_tvlv_hdr *tvlv_hdr;
 426         u16 tvlv_value_cont_len;
 427         u8 cifnotfound = BATADV_TVLV_HANDLER_OGM_CIFNOTFND;
 428         int ret = NET_RX_SUCCESS;
 429
 430         while (tvlv_value_len >= sizeof(*tvlv_hdr)) {
 431                 tvlv_hdr = tvlv_value;
 432                 tvlv_value_cont_len = ntohs(tvlv_hdr->len);
 433                 tvlv_value = tvlv_hdr + 1;
 434                 tvlv_value_len -= sizeof(*tvlv_hdr);
 435
 436                 if (tvlv_value_cont_len > tvlv_value_len)
 437                         break;
 438
 439                 tvlv_handler = batadv_tvlv_handler_get(bat_priv,
 440                                                        tvlv_hdr->type,
 441                                                        tvlv_hdr->version);
 442
 443                 ret |= batadv_tvlv_call_handler(bat_priv, tvlv_handler,
 444                                                 ogm_source, orig_node,
 445                                                 src, dst, tvlv_value,
 446                                                 tvlv_value_cont_len);
 447                 if (tvlv_handler)
 448                         batadv_tvlv_handler_put(tvlv_handler);
 449                 tvlv_value = (u8 *)tvlv_value + tvlv_value_cont_len;
 450                 tvlv_value_len -= tvlv_value_cont_len;
 451         }
 452
 453         if (!ogm_source)
 454                 return ret;
 455
 456         rcu_read_lock();
 457         hlist_for_each_entry_rcu(tvlv_handler,
 458                                  &bat_priv->tvlv.handler_list, list) {
 459                 if ((tvlv_handler->flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND) &&
 460                     !(tvlv_handler->flags & BATADV_TVLV_HANDLER_OGM_CALLED))
 461                         tvlv_handler->ogm_handler(bat_priv, orig_node,
 462                                                   cifnotfound, NULL, 0);
 463
 464                 tvlv_handler->flags &= ~BATADV_TVLV_HANDLER_OGM_CALLED;
 465         }
 466         rcu_read_unlock();
 467
 468         return NET_RX_SUCCESS;
 469 }
 470
 471 /**
 472  * batadv_tvlv_ogm_receive - process an incoming ogm and call the appropriate
 473  *  handlers
 474  * @bat_priv: the bat priv with all the soft interface information
 475  * @batadv_ogm_packet: ogm packet containing the tvlv containers
 476  * @orig_node: orig node emitting the ogm packet
 477  */
 478 void batadv_tvlv_ogm_receive(struct batadv_priv *bat_priv,
 479                              struct batadv_ogm_packet *batadv_ogm_packet,
 480                              struct batadv_orig_node *orig_node)
 481 {
 482         void *tvlv_value;
 483         u16 tvlv_value_len;
 484
 485         if (!batadv_ogm_packet)
 486                 return;
 487
 488         tvlv_value_len = ntohs(batadv_ogm_packet->tvlv_len);
 489         if (!tvlv_value_len)
 490                 return;
 491
 492         tvlv_value = batadv_ogm_packet + 1;
 493
 494         batadv_tvlv_containers_process(bat_priv, true, orig_node, NULL, NULL,
 495                                        tvlv_value, tvlv_value_len);
 496 }
 497
 498 /**
 499  * batadv_tvlv_handler_register - register tvlv handler based on the provided
 500  *  type and version (both need to match) for ogm tvlv payload and/or unicast
 501  *  payload
 502  * @bat_priv: the bat priv with all the soft interface information
 503  * @optr: ogm tvlv handler callback function. This function receives the orig
 504  *  node, flags and the tvlv content as argument to process.
 505  * @uptr: unicast tvlv handler callback function. This function receives the
 506  *  source & destination of the unicast packet as well as the tvlv content
 507  *  to process.
 508  * @type: tvlv handler type to be registered
 509  * @version: tvlv handler version to be registered
 510  * @flags: flags to enable or disable TVLV API behavior
 511  */
 512 void batadv_tvlv_handler_register(struct batadv_priv *bat_priv,
 513                                   void (*optr)(struct batadv_priv *bat_priv,
 514                                                struct batadv_orig_node *orig,
 515                                                u8 flags,
 516                                                void *tvlv_value,
 517                                                u16 tvlv_value_len),
 518                                   int (*uptr)(struct batadv_priv *bat_priv,
 519                                               u8 *src, u8 *dst,
 520                                               void *tvlv_value,
 521                                               u16 tvlv_value_len),
 522                                   u8 type, u8 version, u8 flags)
 523 {
 524         struct batadv_tvlv_handler *tvlv_handler;
 525
 526         tvlv_handler = batadv_tvlv_handler_get(bat_priv, type, version);
 527         if (tvlv_handler) {
 528                 batadv_tvlv_handler_put(tvlv_handler);
 529                 return;
 530         }
 531
 532         tvlv_handler = kzalloc(sizeof(*tvlv_handler), GFP_ATOMIC);
 533         if (!tvlv_handler)
 534                 return;
 535
 536         tvlv_handler->ogm_handler = optr;
 537         tvlv_handler->unicast_handler = uptr;
 538         tvlv_handler->type = type;
 539         tvlv_handler->version = version;
 540         tvlv_handler->flags = flags;
 541         kref_init(&tvlv_handler->refcount);
 542         INIT_HLIST_NODE(&tvlv_handler->list);
 543
 544         spin_lock_bh(&bat_priv->tvlv.handler_list_lock);
 545         hlist_add_head_rcu(&tvlv_handler->list, &bat_priv->tvlv.handler_list);
 546         spin_unlock_bh(&bat_priv->tvlv.handler_list_lock);
 547 }
 548
 549 /**
 550  * batadv_tvlv_handler_unregister - unregister tvlv handler based on the
 551  *  provided type and version (both need to match)
 552  * @bat_priv: the bat priv with all the soft interface information
 553  * @type: tvlv handler type to be unregistered
 554  * @version: tvlv handler version to be unregistered
 555  */
 556 void batadv_tvlv_handler_unregister(struct batadv_priv *bat_priv,
 557                                     u8 type, u8 version)
 558 {
 559         struct batadv_tvlv_handler *tvlv_handler;
 560
 561         tvlv_handler = batadv_tvlv_handler_get(bat_priv, type, version);
 562         if (!tvlv_handler)
 563                 return;
 564
 565         batadv_tvlv_handler_put(tvlv_handler);
 566         spin_lock_bh(&bat_priv->tvlv.handler_list_lock);
 567         hlist_del_rcu(&tvlv_handler->list);
 568         spin_unlock_bh(&bat_priv->tvlv.handler_list_lock);
 569         batadv_tvlv_handler_put(tvlv_handler);
 570 }
 571
 572 /**
 573  * batadv_tvlv_unicast_send - send a unicast packet with tvlv payload to the
 574  *  specified host
 575  * @bat_priv: the bat priv with all the soft interface information
 576  * @src: source mac address of the unicast packet
 577  * @dst: destination mac address of the unicast packet
 578  * @type: tvlv type
 579  * @version: tvlv version
 580  * @tvlv_value: tvlv content
 581  * @tvlv_value_len: tvlv content length
 582  */
 583 void batadv_tvlv_unicast_send(struct batadv_priv *bat_priv, u8 *src,
 584                               u8 *dst, u8 type, u8 version,
 585                               void *tvlv_value, u16 tvlv_value_len)
 586 {
 587         struct batadv_unicast_tvlv_packet *unicast_tvlv_packet;
 588         struct batadv_tvlv_hdr *tvlv_hdr;
 589         struct batadv_orig_node *orig_node;
 590         struct sk_buff *skb;
 591         unsigned char *tvlv_buff;
 592         unsigned int tvlv_len;
 593         ssize_t hdr_len = sizeof(*unicast_tvlv_packet);
 594         int res;
 595
 596         orig_node = batadv_orig_hash_find(bat_priv, dst);
 597         if (!orig_node)
 598                 return;
 599
 600         tvlv_len = sizeof(*tvlv_hdr) + tvlv_value_len;
 601
 602         skb = netdev_alloc_skb_ip_align(NULL, ETH_HLEN + hdr_len + tvlv_len);
 603         if (!skb)
 604                 goto out;
 605
 606         skb->priority = TC_PRIO_CONTROL;
 607         skb_reserve(skb, ETH_HLEN);
 608         tvlv_buff = skb_put(skb, sizeof(*unicast_tvlv_packet) + tvlv_len);
 609         unicast_tvlv_packet = (struct batadv_unicast_tvlv_packet *)tvlv_buff;
 610         unicast_tvlv_packet->packet_type = BATADV_UNICAST_TVLV;
 611         unicast_tvlv_packet->version = BATADV_COMPAT_VERSION;
 612         unicast_tvlv_packet->ttl = BATADV_TTL;
 613         unicast_tvlv_packet->reserved = 0;
 614         unicast_tvlv_packet->tvlv_len = htons(tvlv_len);
 615         unicast_tvlv_packet->align = 0;
 616         ether_addr_copy(unicast_tvlv_packet->src, src);
 617         ether_addr_copy(unicast_tvlv_packet->dst, dst);
 618
 619         tvlv_buff = (unsigned char *)(unicast_tvlv_packet + 1);
 620         tvlv_hdr = (struct batadv_tvlv_hdr *)tvlv_buff;
 621         tvlv_hdr->version = version;
 622         tvlv_hdr->type = type;
 623         tvlv_hdr->len = htons(tvlv_value_len);
 624         tvlv_buff += sizeof(*tvlv_hdr);
 625         memcpy(tvlv_buff, tvlv_value, tvlv_value_len);
 626
 627         res = batadv_send_skb_to_orig(skb, orig_node, NULL);
 628         if (res == -1)
 629                 kfree_skb(skb);
 630 out:
 631         batadv_orig_node_put(orig_node);
 632 }