net/cor/kpacket_parse.c

   1 /*
   2  *      Connection oriented routing
   3  *      Copyright (C) 2007-2008 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 <asm/byteorder.h>
  22
  23 #include "cor.h"
  24
  25 /* not used, avoid compiler warning
  26  * static __u64 pull_u64(struct sk_buff *skb, int convbo)
  27 {
  28         char *ptr = cor_pull_skb(skb, 8);
  29
  30         __u64 ret = 0;
  31
  32         BUG_ON(0 == ptr);
  33
  34         ((char *)&ret)[0] = ptr[0];
  35         ((char *)&ret)[1] = ptr[1];
  36         ((char *)&ret)[2] = ptr[2];
  37         ((char *)&ret)[3] = ptr[3];
  38         ((char *)&ret)[4] = ptr[4];
  39         ((char *)&ret)[5] = ptr[5];
  40         ((char *)&ret)[6] = ptr[6];
  41         ((char *)&ret)[7] = ptr[7];
  42
  43         if (convbo)
  44                 return be64_to_cpu(ret);
  45         return ret;
  46 } */
  47
  48 static __u32 pull_u32(struct sk_buff *skb, int convbo)
  49 {
  50         char *ptr = cor_pull_skb(skb, 4);
  51
  52         __u32 ret = 0;
  53
  54         BUG_ON(0 == ptr);
  55
  56         ((char *)&ret)[0] = ptr[0];
  57         ((char *)&ret)[1] = ptr[1];
  58         ((char *)&ret)[2] = ptr[2];
  59         ((char *)&ret)[3] = ptr[3];
  60
  61         if (convbo)
  62                 return be32_to_cpu(ret);
  63         return ret;
  64 }
  65
  66 static __u16 pull_u16(struct sk_buff *skb, int convbo)
  67 {
  68         char *ptr = cor_pull_skb(skb, 2);
  69
  70         __u16 ret = 0;
  71
  72         BUG_ON(0 == ptr);
  73
  74         ((char *)&ret)[0] = ptr[0];
  75         ((char *)&ret)[1] = ptr[1];
  76
  77         if (convbo)
  78                 return be16_to_cpu(ret);
  79         return ret;
  80 }
  81
  82 /* not used, avoid compiler warning
  83  * static __u8 pull_u8(struct sk_buff *skb)
  84 {
  85         char *ptr = cor_pull_skb(skb, 1);
  86         BUG_ON(0 == ptr);
  87         return *ptr;
  88 } */
  89
  90 #warning todo
  91 static void parse_speed(struct neighbor *nb, struct sk_buff *skb,
  92                 __u8 code, struct conn *rconn)
  93 {
  94         __u16 speed = pull_u32(skb, 1);
  95 }
  96
  97 static void parse_conn_success(struct neighbor *nb, struct sk_buff *skb,
  98                 __u8 code, struct conn *rconn)
  99 {
 100         struct conn *sconn = rconn->reversedir;
 101
 102         __u32 conn_id = pull_u32(skb, 1);
 103
 104         BUG_ON(sconn == 0);
 105
 106         printk(KERN_ERR "parse_conn_success %d %d %d %d", sconn->targettype,
 107                         (int) sconn->target.out.nb, (int) nb, (int) sconn->target.out.conn_id);
 108
 109         if (unlikely(unlikely(sconn->targettype != TARGET_OUT) ||
 110                         unlikely(sconn->target.out.nb != nb) ||
 111                         unlikely(sconn->target.out.conn_id != 0))) {
 112                 struct control_msg_out *cm = alloc_control_msg();
 113                 if (likely(cm != 0))
 114                         send_reset_conn(cm, nb, conn_id);
 115                 return;
 116         }
 117
 118         mutex_lock(&(sconn->rcv_lock));
 119         sconn->target.out.conn_id = conn_id;
 120         flush_out(sconn);
 121         mutex_unlock(&(sconn->rcv_lock));
 122 }
 123
 124 static void parse_reset(struct neighbor *nb, struct sk_buff *skb,
 125                 __u8 code, struct conn *rconn)
 126 {
 127         rconn->reversedir->isreset = 1;
 128         reset_conn(rconn);
 129 }
 130
 131 static void conn_cmd(struct neighbor *nb, struct sk_buff *skb, __u8 code,
 132                 void (*parsefunc)(struct neighbor *nb, struct sk_buff *skb,
 133                 __u8 code, struct conn *rconn))
 134 {
 135         __u32 conn_id = pull_u32(skb, 1);
 136         struct conn *rconn = get_conn(conn_id);
 137
 138         if (unlikely(rconn == 0))
 139                 return;
 140
 141         BUG_ON(SOURCE_IN != rconn->sourcetype);
 142         BUG_ON(0 == rconn->reversedir);
 143
 144         if (unlikely(rconn->source.in.nb != nb))
 145                 return;
 146
 147         parsefunc(nb, skb, code, rconn);
 148 }
 149
 150 static void parse_conndata(struct neighbor *nb, struct sk_buff *skb)
 151 {
 152         __u32 conn_id = pull_u32(skb, 1);
 153         __u32 seqno = pull_u32(skb, 1);
 154         __u16 datalength = pull_u16(skb, 1);
 155         char *data = cor_pull_skb(skb, datalength);
 156
 157         BUG_ON(data == 0);
 158
 159         conn_rcv_buildskb(data, datalength, conn_id, seqno);
 160 }
 161
 162 static void parse_connect(struct neighbor *nb, struct sk_buff *skb)
 163 {
 164         struct conn *rconn;
 165         __u32 conn_id = pull_u32(skb, 1);
 166         struct control_msg_out *cm = alloc_control_msg();
 167
 168         if (unlikely(cm == 0))
 169                 return;
 170
 171         rconn = alloc_conn(GFP_KERNEL);
 172
 173         if (unlikely(rconn == 0))
 174                 goto err;
 175
 176         if (conn_init_out(rconn->reversedir, nb))
 177                 goto err;
 178
 179         rconn->reversedir->target.out.conn_id = conn_id;
 180
 181         send_connect_success(cm, nb, rconn->reversedir->target.out.conn_id,
 182                         rconn->source.in.conn_id);
 183
 184         if (0) {
 185 err:
 186                 send_reset_conn(cm, nb, conn_id);
 187         }
 188 }
 189
 190 static void kernel_packet2(struct neighbor *nb, struct sk_buff *skb,
 191                 __u32 seqno)
 192 {
 193         struct control_msg_out *cm = alloc_control_msg();
 194         int ack = 0;
 195
 196         if (unlikely(cm == 0))
 197                 return;
 198
 199         while (1) {
 200                 __u32 conn_id;
 201                 __u32 seqno;
 202
 203                 __u8 *codeptr = cor_pull_skb(skb, 1);
 204                 __u8 code;
 205
 206                 if (codeptr == 0)
 207                         break;
 208
 209                 code = *codeptr;
 210
 211                 printk(KERN_ERR "parse2_1 %d", code);
 212
 213                 switch (code) {
 214                 case KP_PADDING:
 215                         break;
 216                 case KP_ACK:
 217                         conn_id = pull_u32(skb, 1);
 218                         seqno = pull_u32(skb, 1);
 219                         ack_received(nb, conn_id, seqno);
 220                         if (conn_id != 0)
 221                                 ack = 1;
 222                         break;
 223                 case KP_SPEED:
 224                         conn_cmd(nb, skb, code, parse_speed);
 225                         ack = 1;
 226                         break;
 227                 case KP_CONNECT:
 228                         parse_connect(nb, skb);
 229                         ack = 1;
 230                         break;
 231                 case KP_CONNECT_SUCCESS:
 232                         conn_cmd(nb, skb, code, parse_conn_success);
 233                         ack = 1;
 234                         break;
 235                 case KP_CONN_DATA:
 236                         parse_conndata(nb, skb);
 237                         ack = 1;
 238                         break;
 239                 case KP_RESET_CONN:
 240                         conn_cmd(nb, skb, code, parse_reset);
 241                         ack = 1;
 242                         break;
 243                 default:
 244                         BUG();
 245                 }
 246         }
 247
 248         if (ack)
 249                 send_ack(cm, nb, 0, seqno);
 250         else
 251                 free_control_msg(cm);
 252 }
 253
 254 void kernel_packet(struct neighbor *nb, struct sk_buff *skb, __u32 seqno)
 255 {
 256         struct sk_buff *skb2 = skb_clone(skb, __GFP_DMA | GFP_KERNEL);
 257
 258         while (1) {
 259                 __u8 *codeptr = cor_pull_skb(skb2, 1);
 260                 __u8 code;
 261
 262                 char *lengthptr;
 263                 __u32 length;
 264
 265                 if (codeptr == 0)
 266                         break;
 267                 code = *codeptr;
 268
 269                 switch (code) {
 270                 case KP_PADDING:
 271                         break;
 272                 case KP_ACK:
 273                         if (cor_pull_skb(skb2, 8) == 0)
 274                                 goto discard;
 275                         break;
 276                 case KP_SPEED:
 277                         if (cor_pull_skb(skb2, 6) == 0)
 278                                 goto discard;
 279                         break;
 280                 case KP_CONNECT:
 281                         if (cor_pull_skb(skb2, 4) == 0)
 282                                 goto discard;
 283                         break;
 284                 case KP_CONNECT_SUCCESS:
 285                         if (cor_pull_skb(skb2, 8) == 0)
 286                                 goto discard;
 287                         break;
 288                 case KP_CONN_DATA:
 289                         if (cor_pull_skb(skb2, 8) == 0)
 290                                 goto discard;
 291                         lengthptr = cor_pull_skb(skb2, 2);
 292                         if (lengthptr == 0)
 293                                 goto discard;
 294                         length = ntohs(*((__u16 *)lengthptr));
 295                         if (cor_pull_skb(skb2, length) == 0)
 296                                 goto discard;
 297                         break;
 298                 case KP_RESET_CONN:
 299                         if (cor_pull_skb(skb2, 4) == 0)
 300                                 goto discard;
 301                         break;
 302                 default:
 303                         goto discard;
 304                 }
 305         }
 306         kfree_skb(skb2);
 307         kernel_packet2(nb, skb, seqno);
 308         kfree_skb(skb);
 309         return;
 310 discard:
 311         kfree_skb(skb2);
 312         kfree_skb(skb);
 313 }