net/cor/neighbor.c

   1 /*
   2  *      Connection oriented routing
   3  *      Copyright (C) 2007-2009 Michael Blizek
   4  *
   5  *      This program is free software; you can redistribute it and/or
   6  *      modify it under the terms of the GNU General Public License
   7  *      as published by the Free Software Foundation; either version 2
   8  *      of the License, or (at your option) any later version.
   9  *
  10  *      This program is distributed in the hope that it will be useful,
  11  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *      GNU General Public License for more details.
  14  *
  15  *      You should have received a copy of the GNU General Public License
  16  *      along with this program; if not, write to the Free Software
  17  *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18  *      02110-1301, USA.
  19  */
  20
  21 #include "cor.h"
  22
  23 /**
  24  * Splited packet data format:
  25  * announce proto version [4]
  26  *   is 0, may be increased if format changes
  27  * packet version [4]
  28  *   starts with 0, increments every time the data field changes
  29  * total size [4]
  30  *   total data size of all merged packets
  31  * offset [4]
  32  *   used to determine the order when merging the split packet
  33  *   unit is bytes
  34  * [data]
  35  * commulative checksum [8] (not yet)
  36  *   chunk 1 contains the checksum of the data in chunk 1
  37  *   chunk 2 contains the checksum of the data in chunk 1+2
  38  *   ...
  39  *
  40  * Data format of the announce packet "data" field:
  41  * min_announce_proto_version [4]
  42  * max_announce_proto_version [4]
  43  * min_cor_proto_version [4]
  44  * max_cor_proto_version [4]
  45  *   versions which are understood
  46  *
  47  * command [4]
  48  * commandlength [4]
  49  * commanddata [commandlength]
  50  */
  51
  52 /* Commands */
  53
  54 #define NEIGHCMD_ADDADDR 1
  55
  56 /**
  57  * Parameter:
  58  * addrtypelen [2]
  59  * addrtype [addrtypelen]
  60  * addrlen [2]
  61  * addr [addrlen]
  62  */
  63
  64 #warning todo
  65 /**
  66  * "I hear you" data format:
  67  * challange [todo]
  68  */
  69
  70
  71 DEFINE_MUTEX(neighbor_operation_lock);
  72
  73 char *addrtype = "id";
  74 char *addr;
  75 int addrlen;
  76
  77
  78 LIST_HEAD(nb_list);
  79 struct kmem_cache *nb_slab;
  80
  81 LIST_HEAD(announce_out_list);
  82
  83 struct notifier_block netdev_notify;
  84
  85
  86 #define ADDRTYPE_UNKNOWN 0
  87 #define ADDRTYPE_ID 1
  88
  89 static int get_addrtype(__u32 addrtypelen, char *addrtype)
  90 {
  91         if (addrtypelen == 2 &&
  92                         (addrtype[0] == 'i' || addrtype[0] == 'I') &&
  93                         (addrtype[1] == 'd' || addrtype[1] == 'D'))
  94                 return ADDRTYPE_ID;
  95
  96         return ADDRTYPE_UNKNOWN;
  97 }
  98
  99 static struct neighbor *alloc_neighbor(gfp_t allocflags)
 100 {
 101         struct neighbor *nb = kmem_cache_alloc(nb_slab, allocflags);
 102
 103         if (nb == 0)
 104                 return 0;
 105
 106         memset(nb, 0, sizeof(struct neighbor));
 107
 108         spin_lock_init(&(nb->cmsg_lock));
 109         /*struct control_msg_out *first_cm;
 110         struct control_msg_out *last_cm;
 111         unsigned long timedue;*/
 112         nb->latency = 10;
 113         mutex_init(&(nb->conn_list_lock));
 114         INIT_LIST_HEAD(&(nb->rcv_conn_list));
 115         INIT_LIST_HEAD(&(nb->snd_conn_list));
 116         spin_lock_init(&(nb->retrans_lock));
 117
 118         skb_queue_head_init(&(nb->retrans_list));
 119
 120         return nb;
 121 }
 122
 123 static void add_neighbor(struct neighbor *nb)
 124 {
 125         struct list_head *currlh = nb_list.next;
 126
 127         BUG_ON((nb->addr == 0) != (nb->addrlen == 0));
 128
 129         while (currlh != &nb_list) {
 130                 struct neighbor *curr = container_of(currlh, struct neighbor,
 131                                 nb_list);
 132
 133                 if (curr->addrlen == nb->addrlen && memcmp(curr->addr, nb->addr,
 134                                 curr->addrlen) == 0)
 135                         goto already_present;
 136
 137                 currlh = currlh->next;
 138         }
 139
 140         list_add_tail(&(nb->nb_list), &nb_list);
 141         setup_timer(&(nb->cmsg_timer), controlmsg_timerfunc,
 142                         (unsigned long) nb);
 143         setup_timer(&(nb->retrans_timer), retransmit_timerfunc,
 144                         (unsigned long) nb);
 145
 146         if (0) {
 147 already_present:
 148                 kmem_cache_free(nb_slab, nb);
 149         }
 150 }
 151
 152 struct neighbor *find_neigh(__u16 addrtypelen, __u8 *addrtype,
 153                 __u16 addrlen, __u8 *addr)
 154 {
 155         struct list_head *currlh;
 156         struct neighbor *ret = 0;
 157
 158         if (get_addrtype(addrtypelen, addrtype) != ADDRTYPE_ID)
 159                 return 0;
 160
 161         mutex_lock(&(neighbor_operation_lock));
 162
 163         currlh = nb_list.next;
 164
 165         while (currlh != &nb_list) {
 166                 struct neighbor *curr = container_of(currlh, struct neighbor,
 167                                 nb_list);
 168
 169                 if (curr->addrlen == addrlen && memcmp(curr->addr, addr,
 170                                 addrlen) == 0) {
 171                         #warning todo refcnt
 172                         ret = curr;
 173                         goto out;
 174                 }
 175
 176                 currlh = currlh->next;
 177         }
 178
 179 out:
 180         mutex_unlock(&(neighbor_operation_lock));
 181
 182         return ret;
 183 }
 184
 185 __u32 generate_neigh_list(char *buf, __u32 buflen, __u32 limit, __u32 offset)
 186 {
 187         struct list_head *currlh;
 188
 189         char *p_totalneighs = buf;
 190         char *p_response_rows = buf + 4;
 191
 192         __u32 total = 0;
 193         __u32 cnt = 0;
 194
 195         __u32 buf_offset = 8;
 196
 197         BUG_ON(buf == 0);
 198         BUG_ON(buflen < 8);
 199
 200         mutex_lock(&(neighbor_operation_lock));
 201
 202         currlh = nb_list.next;
 203
 204         while (currlh != &nb_list) {
 205                 struct neighbor *curr = container_of(currlh, struct neighbor,
 206                                 nb_list);
 207
 208                 if (total != cnt)
 209                         goto cont;
 210
 211                 if (buflen - buf_offset - 6 - 2 - curr->addrlen < 0)
 212                         goto cont;
 213
 214                 put_u16(buf + buf_offset, 1, 1);/* numaddr */
 215                 buf_offset += 2;
 216                 put_u16(buf + buf_offset, 2, 1);/* addrtypelen */
 217                 buf_offset += 2;
 218                 put_u16(buf + buf_offset, curr->addrlen, 1);/* addren */
 219                 buf_offset += 2;
 220                 buf[buf_offset] = 'i'; /* addrtype */
 221                 buf_offset += 1;
 222                 buf[buf_offset] = 'd';
 223                 buf_offset += 1;
 224                 memcpy(buf + buf_offset, curr->addr, curr->addrlen); /* addr */
 225                 buf_offset += curr->addrlen;
 226
 227                 BUG_ON(buf_offset > buflen);
 228
 229                 cnt++;
 230
 231 cont:
 232                 total++;
 233                 currlh = currlh->next;
 234         }
 235
 236         mutex_unlock(&(neighbor_operation_lock));
 237
 238         put_u32(p_totalneighs, total, 1);
 239         put_u32(p_response_rows, cnt, 1);
 240
 241         return buf_offset;
 242 }
 243
 244 static __u32 pull_u32(struct sk_buff *skb, int convbo)
 245 {
 246         char *ptr = cor_pull_skb(skb, 4);
 247
 248         __u32 ret = 0;
 249
 250         BUG_ON(0 == ptr);
 251
 252         ((char *)&ret)[0] = ptr[0];
 253         ((char *)&ret)[1] = ptr[1];
 254         ((char *)&ret)[2] = ptr[2];
 255         ((char *)&ret)[3] = ptr[3];
 256
 257         if (convbo)
 258                 return be32_to_cpu(ret);
 259         return ret;
 260 }
 261
 262 static int apply_announce_addaddr(struct neighbor *nb, __u32 cmd, __u32 len,
 263                 char *cmddata)
 264 {
 265         __u16 addrtypelen;
 266         char *addrtype;
 267         __u16 addrlen;
 268         char *addr;
 269
 270         BUG_ON((nb->addr == 0) != (nb->addrlen == 0));
 271
 272         if (nb->addr != 0)
 273                 return 0;
 274
 275         if (len < 4)
 276                 return 0;
 277
 278         addrtypelen = be16_to_cpu(*((__u16 *) cmddata));
 279         cmddata += 2;
 280         len -= 2;
 281
 282         if (len < 2)
 283                 return 0;
 284
 285         addrlen = be16_to_cpu(*((__u16 *) cmddata));
 286         cmddata += 2;
 287         len -= 2;
 288
 289         addrtype = cmddata;
 290         cmddata += addrtypelen;
 291         len -= addrtypelen;
 292
 293         addr = cmddata;
 294         cmddata += addrlen;
 295         len -= addrlen;
 296
 297         if (len < 0)
 298                 return 0;
 299
 300         if (get_addrtype(addrtypelen, addrtype) != ADDRTYPE_ID)
 301                 return 0;
 302
 303         nb->addr = kmalloc(addrlen, GFP_KERNEL);
 304         if (nb->addr == 0)
 305                 return 1;
 306
 307         memcpy(nb->addr, addr, addrlen);
 308         nb->addrlen = addrlen;
 309
 310         return 0;
 311 }
 312
 313 static void apply_announce_cmd(struct neighbor *nb, __u32 cmd, __u32 len,
 314                 char *cmddata)
 315 {
 316         if (cmd == NEIGHCMD_ADDADDR) {
 317                 apply_announce_addaddr(nb, cmd, len, cmddata);
 318         } else {
 319                 /* ignore unknown cmds */
 320         }
 321 }
 322
 323 static void apply_announce_cmds(char *msg, __u32 len, struct net_device *dev,
 324                 char *source_hw)
 325 {
 326         struct neighbor *nb = alloc_neighbor(GFP_KERNEL);
 327
 328         if (nb == 0)
 329                 return;
 330
 331         while (len >= 8) {
 332                 __u32 cmd;
 333                 __u32 cmdlen;
 334
 335                 cmd = be32_to_cpu(*((__u32 *) msg));
 336                 msg += 4;
 337                 len -= 4;
 338                 cmdlen = be32_to_cpu(*((__u32 *) msg));
 339                 msg += 4;
 340                 len -= 4;
 341
 342                 BUG_ON(cmdlen > len);
 343
 344                 apply_announce_cmd(nb, cmd, cmdlen, msg);
 345
 346                 msg += cmdlen;
 347                 len -= cmdlen;
 348         }
 349
 350         BUG_ON(len != 0);
 351
 352         dev_hold(dev);
 353         nb->dev = dev;
 354         add_neighbor(nb);
 355
 356 }
 357
 358 static int check_announce_cmds(char *msg, __u32 len)
 359 {
 360         while (len >= 8) {
 361                 __u32 cmd;
 362                 __u32 cmdlen;
 363
 364                 cmd = be32_to_cpu(*((__u32 *) msg));
 365                 msg += 4;
 366                 len -= 4;
 367                 cmdlen = be32_to_cpu(*((__u32 *) msg));
 368                 msg += 4;
 369                 len -= 4;
 370
 371                 /* malformated packet */
 372                 if (cmdlen > len)
 373                         return 1;
 374
 375                 msg += cmdlen;
 376                 len -= cmdlen;
 377         }
 378
 379         if (len != 0)
 380                 return 1;
 381
 382         return 0;
 383 }
 384
 385 static void parse_announce(char *msg, __u32 len, struct net_device *dev,
 386                 char *source_hw)
 387 {
 388         __u32 min_announce_version;
 389         __u32 max_announce_version;
 390         __u32 min_cor_version;
 391         __u32 max_cor_version;
 392
 393         if (len < 16)
 394                 return;
 395
 396         min_announce_version = be32_to_cpu(*((__u32 *) msg));
 397         msg += 4;
 398         len -= 4;
 399         max_announce_version = be32_to_cpu(*((__u32 *) msg));
 400         msg += 4;
 401         len -= 4;
 402         min_cor_version = be32_to_cpu(*((__u32 *) msg));
 403         msg += 4;
 404         len -= 4;
 405         max_cor_version = be32_to_cpu(*((__u32 *) msg));
 406         msg += 4;
 407         len -= 4;
 408
 409         if (min_announce_version != 0)
 410                 return;
 411         if (min_cor_version != 0)
 412                 return;
 413
 414         if (check_announce_cmds(msg, len))
 415                 return;
 416
 417         apply_announce_cmds(msg, len, dev, source_hw);
 418 }
 419
 420 struct announce_in {
 421         /* lh has to be first */
 422         struct list_head lh;
 423         struct sk_buff_head skbs; /* sorted by offset */
 424         struct net_device *dev;
 425         char source_hw[MAX_ADDR_LEN];
 426         __u32 announce_proto_version;
 427         __u32 packet_version;
 428         __u32 total_size;
 429         __u32 received_size;
 430         __u64 last_received_packet;
 431 };
 432
 433 LIST_HEAD(announce_list);
 434
 435 struct kmem_cache *announce_in_slab;
 436
 437 static void merge_announce(struct announce_in *ann)
 438 {
 439         char *msg = kmalloc(GFP_KERNEL, ann->total_size);
 440         __u32 copy = 0;
 441
 442         if (msg == 0) {
 443                 /* try again when next packet arrives */
 444                 return;
 445         }
 446
 447         while (copy != ann->total_size) {
 448                 __u32 currcpy;
 449                 struct sk_buff *skb;
 450
 451                 if (skb_queue_empty(&(ann->skbs))) {
 452                         printk(KERN_ERR "net/cor/neighbor.c: sk_head ran "
 453                                         "empty while merging packets\n");
 454                         goto free;
 455                 }
 456
 457                 skb = skb_dequeue(&(ann->skbs));
 458
 459                 currcpy = skb->len;
 460
 461                 if (currcpy + copy > ann->total_size)
 462                         goto free;
 463
 464                 #warning todo overlapping skbs
 465                 memcpy(msg + copy, skb->data, currcpy);
 466                 copy += currcpy;
 467                 kfree_skb(skb);
 468         }
 469
 470         parse_announce(msg, ann->total_size, ann->dev, ann->source_hw);
 471
 472 free:
 473         if (msg != 0)
 474                 kfree(msg);
 475
 476         dev_put(ann->dev);
 477         list_del(&(ann->lh));
 478         kmem_cache_free(announce_in_slab, ann);
 479 }
 480
 481 static int _rcv_announce(struct sk_buff *skb, struct announce_in *ann)
 482 {
 483         struct skb_procstate *ps = skb_pstate(skb);
 484
 485         __u32 offset = ps->funcstate.announce.offset;
 486         __u32 len = skb->len;
 487
 488         __u32 curroffset = 0;
 489         __u32 prevoffset = 0;
 490         __u32 prevlen = 0;
 491
 492         struct sk_buff *curr = ann->skbs.next;
 493
 494         if (len + offset > ann->total_size) {
 495                 /* invalid header */
 496                 kfree_skb(skb);
 497                 return 0;
 498         }
 499
 500         /**
 501          * Try to find the right place to insert in the sorted list. This
 502          * means to process the list until we find a skb which has a greater
 503          * offset, so we can insert before it to keep the sort order. However,
 504          * this is complicated by the fact that the new skb must not be inserted
 505          * between 2 skbs if there is no data missing in between. So the loop
 506          * runs has to keep running until there is either a gap to insert or
 507          * we see that this data has already been received.
 508          */
 509         while ((void *) curr != (void *) &(ann->skbs)) {
 510                 struct skb_procstate *currps = skb_pstate(skb);
 511
 512                 curroffset = currps->funcstate.announce.offset;
 513
 514                 if (curroffset > offset && (prevoffset + prevlen) < curroffset)
 515                         break;
 516
 517                 prevoffset = curroffset;
 518                 prevlen = curr->len;
 519                 curr = curr->next;
 520
 521                 if ((offset+len) <= (prevoffset+prevlen)) {
 522                         /* we already have this data */
 523                         kfree_skb(skb);
 524                         return 0;
 525                 }
 526         }
 527
 528         /**
 529          * Calculate how much data was really received, by substracting
 530          * the bytes we already have.
 531          */
 532         if (unlikely(prevoffset + prevlen > offset)) {
 533                 len -= (prevoffset + prevlen) - offset;
 534                 offset = prevoffset + prevlen;
 535         }
 536
 537         if (unlikely((void *) curr != (void *) &(ann->skbs) &&
 538                         (offset + len) > curroffset))
 539                 len = curroffset - offset;
 540
 541         ann->received_size += len;
 542         BUG_ON(ann->received_size > ann->total_size);
 543         __skb_queue_before(&(ann->skbs), curr, skb);
 544         ann->last_received_packet = get_jiffies_64();
 545
 546         if (ann->received_size == ann->total_size)
 547                 merge_announce(ann);
 548         else if (ann->skbs.qlen >= 16)
 549                 return 1;
 550
 551         return 0;
 552 }
 553
 554 void rcv_announce(struct sk_buff *skb)
 555 {
 556         struct skb_procstate *ps = skb_pstate(skb);
 557         struct announce_in *curr = 0;
 558         struct announce_in *leastactive = 0;
 559         __u32 list_size = 0;
 560
 561         __u32 announce_proto_version = pull_u32(skb, 1);
 562         __u32 packet_version = pull_u32(skb, 1);
 563         __u32 total_size = pull_u32(skb, 1);
 564
 565         char source_hw[MAX_ADDR_LEN];
 566         memset(source_hw, 0, MAX_ADDR_LEN);
 567         if (skb->dev->header_ops != 0 &&
 568                         skb->dev->header_ops->parse != 0)
 569                 skb->dev->header_ops->parse(skb, source_hw);
 570
 571         ps->funcstate.announce.offset = pull_u32(skb, 1);
 572
 573         if (total_size > 8192)
 574                 goto discard;
 575
 576         mutex_lock(&(neighbor_operation_lock));
 577
 578         if (announce_proto_version != 0)
 579                 goto discard;
 580
 581         curr = (struct announce_in *) announce_list.next;
 582
 583         while (((struct list_head *) curr) != &(announce_list)) {
 584                 list_size++;
 585                 if (curr->dev == skb->dev &&
 586                                 memcmp(curr->source_hw, source_hw, MAX_ADDR_LEN) == 0 &&
 587                                 curr->announce_proto_version == announce_proto_version &&
 588                                 curr->packet_version == packet_version &&
 589                                 curr->total_size == total_size)
 590                         goto found;
 591
 592                 if (leastactive == 0 || curr->last_received_packet <
 593                                 leastactive->last_received_packet)
 594                         leastactive = curr;
 595
 596                 curr = (struct announce_in *) curr->lh.next;
 597         }
 598
 599         if (list_size >= 128) {
 600                 BUG_ON(leastactive == 0);
 601                 curr = leastactive;
 602
 603                 curr->last_received_packet = get_jiffies_64();
 604
 605                 while (!skb_queue_empty(&(curr->skbs))) {
 606                         struct sk_buff *skb2 = skb_dequeue(&(curr->skbs));
 607                         kfree_skb(skb2);
 608                 }
 609
 610                 dev_put(curr->dev);
 611         } else {
 612                 curr = kmem_cache_alloc(announce_in_slab,
 613                                 GFP_KERNEL);
 614                 if (curr == 0)
 615                         goto discard;
 616
 617                 skb_queue_head_init(&(curr->skbs));
 618                 list_add_tail((struct list_head *) curr, &announce_list);
 619         }
 620
 621         curr->packet_version = packet_version;
 622         curr->total_size = total_size;
 623         curr->received_size = 0;
 624         curr->announce_proto_version = announce_proto_version;
 625         curr->dev = skb->dev;
 626         dev_hold(curr->dev);
 627         memcpy(curr->source_hw, source_hw, MAX_ADDR_LEN);
 628
 629  found:
 630         if (_rcv_announce(skb, curr)) {
 631                 list_del((struct list_head *) curr);
 632                 dev_put(curr->dev);
 633                 kmem_cache_free(announce_in_slab, curr);
 634         }
 635
 636         if (0) {
 637  discard:
 638                 kfree_skb(skb);
 639         }
 640
 641         mutex_unlock(&(neighbor_operation_lock));
 642 }
 643
 644 struct announce {
 645         struct ref_counter refs;
 646
 647         __u32 packet_version;
 648         char *announce_msg;
 649         __u32 announce_msg_len;
 650 };
 651
 652 struct announce *last_announce;
 653
 654 struct announce_data {
 655         struct delayed_work announce_work;
 656
 657         struct net_device *dev;
 658
 659         struct announce *ann;
 660
 661         struct list_head lh;
 662
 663         __u32 curr_announce_msg_offset;
 664         __u64 scheduled_announce_timer;
 665 };
 666
 667 static void _splitsend_announce(struct announce_data *ann)
 668 {
 669         struct sk_buff *skb;
 670         __u32 packet_size = 256;
 671         __u32 remainingdata = ann->ann->announce_msg_len -
 672                         ann->curr_announce_msg_offset;
 673         __u32 headroom = LL_ALLOCATED_SPACE(ann->dev);
 674         __u32 overhead = 17 + headroom;
 675         char *header;
 676         char *ptr;
 677
 678         if (remainingdata < packet_size)
 679                 packet_size = remainingdata;
 680
 681         skb = alloc_skb(packet_size + overhead, GFP_KERNEL);
 682         if (unlikely(0 == skb))
 683                 return;
 684
 685         skb->protocol = htons(ETH_P_COR);
 686         skb->dev = ann->dev;
 687         skb_reserve(skb, overhead);
 688
 689         if(unlikely(dev_hard_header(skb, ann->dev, ETH_P_COR,
 690                         ann->dev->broadcast, ann->dev->dev_addr, skb->len) < 0))
 691                 goto out_err;
 692
 693         skb_reset_network_header(skb);
 694
 695         header = skb_put(skb, 17);
 696         if (unlikely(header == 0))
 697                 goto out_err;
 698
 699         header[0] = PACKET_TYPE_ANNOUNCE;
 700
 701         put_u32(header + 1, 0, 1); /* announce proto version */
 702         put_u32(header + 5, ann->ann->packet_version, 1); /* packet version */
 703         put_u32(header + 9, ann->ann->announce_msg_len, 1); /* total size */
 704         put_u32(header + 13, ann->curr_announce_msg_offset, 1); /* offset */
 705
 706         ptr = skb_put(skb, packet_size);
 707         if (unlikely(ptr == 0))
 708                 goto out_err;
 709
 710         memcpy(ptr, ann->ann->announce_msg + ann->curr_announce_msg_offset, packet_size);
 711         dev_queue_xmit(skb);
 712
 713         ann->curr_announce_msg_offset += packet_size;
 714
 715         if (ann->curr_announce_msg_offset == ann->ann->announce_msg_len)
 716                 ann->curr_announce_msg_offset = 0;
 717
 718         if (0) {
 719 out_err:
 720                 if (skb != 0)
 721                         kfree_skb(skb);
 722         }
 723 }
 724
 725 static void splitsend_announce(struct work_struct *work)
 726 {
 727         struct announce_data *ann = (struct announce_data *) work;
 728         int reschedule = 0;
 729
 730         mutex_lock(&(neighbor_operation_lock));
 731
 732         if (ann->dev == 0)
 733                 goto out;
 734
 735         reschedule = 1;
 736
 737         if (ann->ann == 0 && last_announce == 0)
 738                 goto out;
 739
 740         if (ann->curr_announce_msg_offset == 0 && ann->ann != last_announce) {
 741                 if (ann->ann != 0)
 742                         ref_counter_decr(&(ann->ann->refs));
 743                 ann->ann = last_announce;
 744                 ref_counter_incr(&(ann->ann->refs));
 745         }
 746
 747         _splitsend_announce(ann);
 748 out:
 749         mutex_unlock(&(neighbor_operation_lock));
 750
 751         if (reschedule) {
 752                 int target_delay_ms = 100;
 753                 int target_delay_jiffies = msecs_to_jiffies(target_delay_ms);
 754                 __u64 jiffies = get_jiffies_64();
 755                 int delay;
 756
 757                 ann->scheduled_announce_timer += target_delay_jiffies;
 758
 759                 delay = ann->scheduled_announce_timer - jiffies;
 760                 if (delay < 0)
 761                         delay = 0;
 762
 763                 INIT_DELAYED_WORK(&(ann->announce_work), splitsend_announce);
 764                 schedule_delayed_work(&(ann->announce_work), delay);
 765         }
 766 }
 767
 768 static void announce_free(struct ref_counter *ref)
 769 {
 770         struct announce *ann = container_of(ref, struct announce, refs);
 771         kfree(&(ann->announce_msg));
 772         kfree(ann);
 773 }
 774
 775 static struct ref_counter_def announce_ref = {
 776         .free = announce_free
 777 };
 778
 779
 780 void blacklist_neighbor(struct neighbor *nb)
 781 {
 782         #warning todo
 783 }
 784
 785 static struct announce_data *get_announce_by_netdev(struct net_device *dev)
 786 {
 787         struct list_head *lh = announce_out_list.next;
 788
 789         while (lh != &announce_out_list) {
 790                 struct announce_data *curr = (struct announce_data *)(
 791                                 ((char *) lh) -
 792                                 offsetof(struct announce_data, lh));
 793
 794                 if (curr->dev == dev)
 795                         return curr;
 796         }
 797
 798         return 0;
 799 }
 800
 801 static void announce_sent_adddev(struct net_device *dev)
 802 {
 803         struct announce_data *ann;
 804
 805         ann = kmalloc(sizeof(struct announce_data), GFP_KERNEL);
 806
 807         if (ann == 0) {
 808                 printk(KERN_ERR "cor cannot allocate memory for sending "
 809                                 "announces");
 810                 return;
 811         }
 812
 813         memset(ann, 0, sizeof(struct announce_data));
 814
 815         dev_hold(dev);
 816         ann->dev = dev;
 817
 818         mutex_lock(&(neighbor_operation_lock));
 819         list_add_tail(&(ann->lh), &announce_out_list);
 820         mutex_unlock(&(neighbor_operation_lock));
 821
 822         ann->scheduled_announce_timer = get_jiffies_64();
 823         INIT_DELAYED_WORK(&(ann->announce_work), splitsend_announce);
 824         schedule_delayed_work(&(ann->announce_work), 1);
 825 }
 826
 827 static void announce_sent_rmdev(struct net_device *dev)
 828 {
 829         struct announce_data *ann;
 830
 831         mutex_lock(&(neighbor_operation_lock));
 832
 833         ann = get_announce_by_netdev(dev);
 834
 835         if (ann == 0)
 836                 goto out;
 837
 838         dev_put(ann->dev);
 839         ann->dev = 0;
 840
 841 out:
 842         mutex_unlock(&(neighbor_operation_lock));
 843 }
 844
 845 int netdev_notify_func(struct notifier_block *not, unsigned long event,
 846                 void *ptr)
 847 {
 848         struct net_device *dev = (struct net_device *) ptr;
 849
 850         switch(event){
 851         case NETDEV_UP:
 852                 announce_sent_adddev(dev);
 853                 break;
 854         case NETDEV_DOWN:
 855                 announce_sent_rmdev(dev);
 856                 break;
 857         case NETDEV_REBOOT:
 858         case NETDEV_CHANGE:
 859         case NETDEV_REGISTER:
 860         case NETDEV_UNREGISTER:
 861         case NETDEV_CHANGEMTU:
 862         case NETDEV_CHANGEADDR:
 863         case NETDEV_GOING_DOWN:
 864         case NETDEV_CHANGENAME:
 865         case NETDEV_FEAT_CHANGE:
 866         case NETDEV_BONDING_FAILOVER:
 867                 break;
 868         default:
 869                 return 1;
 870         }
 871
 872         return 0;
 873 }
 874
 875 static int set_announce(char *msg, __u32 len)
 876 {
 877         struct announce *ann = kmalloc(sizeof(struct announce), GFP_KERNEL);
 878
 879         if (ann == 0) {
 880                 kfree(msg);
 881                 return 1;
 882         }
 883
 884         memset(ann, 0, sizeof(struct announce));
 885
 886         ann->announce_msg = msg;
 887         ann->announce_msg_len = len;
 888
 889         ref_counter_init(&(ann->refs), &announce_ref);
 890
 891         mutex_lock(&(neighbor_operation_lock));
 892
 893         if (last_announce != 0) {
 894                 ann->packet_version = last_announce->packet_version + 1;
 895                 ref_counter_decr(&(last_announce->refs));
 896         }
 897
 898         last_announce = ann;
 899
 900         mutex_unlock(&(neighbor_operation_lock));
 901
 902         return 0;
 903 }
 904
 905 static int generate_announce(void)
 906 {
 907         __u32 addrtypelen = strlen(addrtype);
 908
 909         __u32 hdr_len = 16;
 910         __u32 cmd_hdr_len = 8;
 911         __u32 cmd_len = 2 + 2 + addrtypelen + addrlen;
 912
 913         __u32 len = hdr_len + cmd_hdr_len + cmd_len;
 914         __u32 offset = 0;
 915
 916         char *msg = kmalloc(len, GFP_KERNEL);
 917         if (msg == 0)
 918                 return 1;
 919
 920         put_u32(msg + offset, 0, 1); /* min_announce_proto_version */
 921         offset += 4;
 922         put_u32(msg + offset, 0, 1); /* max_announce_proto_version */
 923         offset += 4;
 924         put_u32(msg + offset, 0, 1); /* min_cor_proto_version */
 925         offset += 4;
 926         put_u32(msg + offset, 0, 1); /* max_cor_proto_version */
 927         offset += 4;
 928
 929
 930         put_u32(msg + offset, NEIGHCMD_ADDADDR, 1); /* command */
 931         offset += 4;
 932         put_u32(msg + offset, cmd_len, 1); /* command length */
 933         offset += 4;
 934
 935         /* addrtypelen, addrlen */
 936         put_u16(msg + offset, addrtypelen, 1);
 937         offset += 2;
 938         put_u16(msg + offset, addrlen, 1);
 939         offset += 2;
 940
 941         /* addrtype, addr */
 942         memcpy(msg + offset, addrtype, addrtypelen);
 943         offset += addrtypelen;
 944         memcpy(msg + offset, addr, addrlen);
 945         offset += addrlen;
 946
 947         BUG_ON(offset != len);
 948
 949         return set_announce(msg, len);
 950 }
 951
 952 int __init cor_neighbor_init(void)
 953 {
 954         addrlen = 16;
 955
 956         addr = kmalloc(addrlen, GFP_KERNEL);
 957         if (addr == 0)
 958                 goto error_free2;
 959
 960         get_random_bytes(addr, addrlen);
 961
 962         nb_slab = kmem_cache_create("cor_neighbor", sizeof(struct neighbor), 8,
 963                         0, 0);
 964         announce_in_slab = kmem_cache_create("cor_announce_in",
 965                         sizeof(struct announce_in), 8, 0, 0);
 966
 967         if (generate_announce())
 968                 goto error_free1;
 969
 970         memset(&netdev_notify, 0, sizeof(netdev_notify));
 971         netdev_notify.notifier_call = netdev_notify_func;
 972         register_netdevice_notifier(&netdev_notify);
 973
 974         return 0;
 975
 976 error_free1:
 977         kfree(addr);
 978
 979 error_free2:
 980         return -ENOMEM;
 981 }
 982
 983 MODULE_LICENSE("GPL");