net/cor/cpacket_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 "cor.h"
  22
  23 static char *get_error_reason_text(__u16 reasoncode)
  24 {
  25         if (reasoncode == CDR_EXECFAILED_UNKNOWN_COMMAND)
  26                 return "Unknown command";
  27         else if (reasoncode == CDR_EXECFAILED_PERMISSION_DENIED)
  28                 return "Permission denied";
  29         else if (reasoncode == CDR_EXECFAILED_TEMPORARILY_OUT_OF_RESSOURCES)
  30                 return "Temporarily out of ressources";
  31         else if (reasoncode == CDR_EXECFAILED_CMD_TOO_SHORT)
  32                 return "The length of the command is too short for all params";
  33         else if (reasoncode == CDR_EXECFAILED_CMD_TOO_LONG)
  34                 return "command param is too long";
  35         else if (reasoncode == CDR_EXECFAILED_TARGETADDRTYPE_UNKNOWN)
  36                 return "targettype unknown";
  37         else if (reasoncode == CDR_EXECFAILED_TARGETADDR_DOESNTEXIST)
  38                 return "targetaddr does not exist";
  39         else if (reasoncode == CDR_EXECFAILED_TARGETADDR_PORTCLOSED)
  40                 return "Port is on open";
  41         else if (reasoncode == CDR_EXECFAILED_LISTENERQUEUE_FULL)
  42                 return "Listener queue full";
  43         else
  44                 return 0;
  45 }
  46
  47 static void send_resp(struct conn *conn, __u16 respcode,
  48                 __u16 reasoncode)
  49 {
  50         struct conn *rconn = conn->reversedir;
  51
  52         int reasonlen = 0;
  53         __u16 reasonlen_be;
  54
  55         char *reasontext = 0;
  56
  57         if (respcode == CDR_EXECFAILED)
  58                 get_error_reason_text(respcode);
  59
  60         if (reasontext)
  61                 reasonlen = strnlen(reasontext, 65535);
  62
  63         respcode = cpu_to_be16(respcode);
  64         reasoncode = cpu_to_be16(reasoncode);
  65         reasonlen_be = cpu_to_be16(reasonlen);
  66
  67         if (rconn->targettype == TARGET_SOCK) {
  68                 mutex_lock(&(rconn->target.sock.lock));
  69                 ringbuffer_put(&(rconn->target.sock.rbuf),
  70                                 (char *) &respcode, 2, 0);
  71                 ringbuffer_put(&(rconn->target.sock.rbuf),
  72                                 (char *) &reasoncode, 2, 0);
  73                 ringbuffer_put(&(rconn->target.sock.rbuf),
  74                                 (char *) &reasonlen_be, 2, 0);
  75                 ringbuffer_put(&(rconn->target.sock.rbuf), reasontext,
  76                                 reasonlen, 0);
  77                 mutex_unlock(&(rconn->target.sock.lock));
  78         } else if (rconn->targettype == TARGET_OUT) {
  79                 #warning todo
  80         } else {
  81                 BUG();
  82         }
  83 }
  84
  85 static void send_resp_bin(struct conn *rconn, char *buf, __u32 len)
  86 {
  87         struct conn *sconn = rconn->reversedir;
  88
  89         __u32 code = cpu_to_be16(CDR_BINDATA);
  90         __u32 len_be = cpu_to_be32(len);
  91
  92         if (sconn->targettype == TARGET_SOCK) {
  93                 mutex_lock(&(sconn->target.sock.lock));
  94                 ringbuffer_put(&(sconn->target.sock.rbuf),
  95                                 (char *) &code, 2, 0);
  96                 ringbuffer_put(&(sconn->target.sock.rbuf),
  97                                 (char *) &len_be, 4, 0);
  98                 ringbuffer_put(&(sconn->target.sock.rbuf), buf, len, 0);
  99                 mutex_unlock(&(sconn->target.sock.lock));
 100         } else if (sconn->targettype == TARGET_OUT) {
 101                 #warning todo
 102         } else {
 103                 BUG();
 104         }
 105 }
 106
 107 static void parse_list_neigh(struct conn *rconn)
 108 {
 109         __u32 limit;
 110         __u32 offset;
 111         __u32 len;
 112
 113         char *buf;
 114
 115         if (rconn->target.unconnected.paramlen < 8) {
 116                 send_resp(rconn, CDR_EXECFAILED, CDR_EXECFAILED_CMD_TOO_SHORT);
 117                 return;
 118         }
 119
 120         ((char *)&limit)[0] = rconn->target.unconnected.cmdparams[0];
 121         ((char *)&limit)[1] = rconn->target.unconnected.cmdparams[1];
 122         ((char *)&limit)[2] = rconn->target.unconnected.cmdparams[2];
 123         ((char *)&limit)[3] = rconn->target.unconnected.cmdparams[3];
 124
 125         ((char *)&offset)[0] = rconn->target.unconnected.cmdparams[4];
 126         ((char *)&offset)[1] = rconn->target.unconnected.cmdparams[5];
 127         ((char *)&offset)[2] = rconn->target.unconnected.cmdparams[6];
 128         ((char *)&offset)[3] = rconn->target.unconnected.cmdparams[7];
 129
 130         limit = be32_to_cpu(limit);
 131         offset = be32_to_cpu(offset);
 132
 133         buf = kmalloc(2048, GFP_KERNEL);
 134
 135         if (unlikely(buf == 0)) {
 136                 send_resp(rconn, CDR_EXECFAILED,
 137                                 CDR_EXECFAILED_TEMPORARILY_OUT_OF_RESSOURCES);
 138                 return;
 139         }
 140
 141         send_resp(rconn, CDR_EXECOK, CDR_EXECOK_OK);
 142
 143         len = generate_neigh_list(buf, 2048, limit, offset);
 144         send_resp_bin(rconn, buf, len);
 145 }
 146
 147 static void parse_connect_port(struct conn *rconn)
 148 {
 149         __be64 addr;
 150         int rc;
 151
 152         BUG_ON(0 == rconn->target.unconnected.cmdparams);
 153
 154         if (rconn->target.unconnected.paramlen < 8) {
 155                 send_resp(rconn, CDR_EXECFAILED, CDR_EXECFAILED_CMD_TOO_SHORT);
 156                 return;
 157         }
 158
 159         memcpy((char *) &addr, rconn->target.unconnected.cmdparams, 8);
 160
 161         rc = connect_port(rconn, addr);
 162
 163         if (rc == 2) {
 164                 send_resp(rconn, CDR_EXECFAILED,
 165                                 CDR_EXECFAILED_TARGETADDR_DOESNTEXIST);
 166         } else if (rc != 3) {
 167                 send_resp(rconn, CDR_EXECFAILED,
 168                                 CDR_EXECFAILED_LISTENERQUEUE_FULL);
 169         } else if (rc == 0) {
 170                 send_resp(rconn, CDR_EXECOK, CDR_EXECOK_OK);
 171         } else if (unlikely(rc != 0)) {
 172                 BUG();
 173         }
 174 }
 175
 176 static void parse_connect_nb(struct conn *rconn)
 177 {
 178         __u16 addrtypelen;
 179         __u16 addrlen;
 180         __u8 *addrtype;
 181         __u8 *addr;
 182         int rc;
 183
 184         BUG_ON(0 == rconn->target.unconnected.cmdparams);
 185
 186         if (rconn->target.unconnected.paramlen < 4) {
 187                 send_resp(rconn, CDR_EXECFAILED, CDR_EXECFAILED_CMD_TOO_SHORT);
 188                 return;
 189         }
 190
 191         ((char *)&addrtypelen)[0] = rconn->target.unconnected.cmdparams[0];
 192         ((char *)&addrtypelen)[1] = rconn->target.unconnected.cmdparams[1];
 193
 194         ((char *)&addrlen)[0] = rconn->target.unconnected.cmdparams[2];
 195         ((char *)&addrlen)[1] = rconn->target.unconnected.cmdparams[3];
 196
 197         addrtypelen = be16_to_cpu(addrtypelen);
 198         addrlen = be16_to_cpu(addrlen);
 199
 200         if ((4 + (__u32) addrtypelen + (__u32) addrlen) >
 201                         rconn->target.unconnected.paramlen) {
 202                 send_resp(rconn, CDR_EXECFAILED, CDR_EXECFAILED_CMD_TOO_SHORT);
 203                 return;
 204         }
 205
 206         addrtype = rconn->target.unconnected.cmdparams + 4;
 207         addr = addrtype + addrtypelen;
 208
 209         rc = connect_neigh(rconn, addrtypelen, addrtype, addrlen, addr);
 210
 211         if (rc == 2) {
 212                 send_resp(rconn, CDR_EXECFAILED,
 213                                 CDR_EXECFAILED_TARGETADDRTYPE_UNKNOWN);
 214         } else if (rc == 3) {
 215                 send_resp(rconn, CDR_EXECFAILED,
 216                                 CDR_EXECFAILED_TARGETADDR_DOESNTEXIST);
 217         } else if (rc == 4) {
 218                 send_resp(rconn, CDR_EXECFAILED,
 219                                 CDR_EXECFAILED_TEMPORARILY_OUT_OF_RESSOURCES);
 220         } else if (rc == 0) {
 221                 send_resp(rconn, CDR_EXECOK, CDR_EXECOK_OK);
 222         } else if (unlikely(rc != 0)) {
 223                 BUG();
 224         }
 225 }
 226
 227 static void parse_cmd(struct conn *rconn)
 228 {
 229         __u16 code = rconn->target.unconnected.cmd;
 230
 231         if (code == CD_CONNECT_NB) {
 232                 parse_connect_nb(rconn);
 233         } else if (code == CD_CONNECT_PORT) {
 234                 parse_connect_port(rconn);
 235         } else if (code == CD_LIST_NEIGH) {
 236                 parse_list_neigh(rconn);
 237         } else {
 238                 send_resp(rconn, CDR_EXECFAILED, CDR_EXECFAILED_UNKNOWN_COMMAND);
 239         }
 240 }
 241
 242 static void read_cmd(struct data *data, struct conn *rconn)
 243 {
 244         char *buf;
 245         int pull;
 246
 247         pull = min(rconn->target.unconnected.paramlen + 6 -
 248                         rconn->target.unconnected.cmdread, data_len(data));
 249
 250         BUG_ON(0 > pull);
 251         BUG_ON(0 == rconn->target.unconnected.cmdparams);
 252         BUG_ON(6 > rconn->target.unconnected.cmdread);
 253
 254         if (pull == 0)
 255                 return;
 256
 257         buf = data_pull(data, pull);
 258
 259         BUG_ON(0 == buf);
 260
 261         memcpy(rconn->target.unconnected.cmdparams +
 262                         rconn->target.unconnected.cmdread - 6, buf, pull);
 263         rconn->target.unconnected.cmdread += pull;
 264 }
 265
 266 static void read_discard(struct data *data, struct conn *rconn)
 267 {
 268         char *buf;
 269         int pull;
 270
 271         pull = min(rconn->target.unconnected.paramlen + 6 -
 272                         rconn->target.unconnected.cmdread, data_len(data));
 273
 274         BUG_ON(0 > pull);
 275         BUG_ON(6 > rconn->target.unconnected.cmdread);
 276
 277         if (pull == 0)
 278                 return;
 279
 280         buf = data_pull(data, pull);
 281
 282         BUG_ON(data == 0);
 283
 284         rconn->target.unconnected.cmdread += pull;
 285 }
 286
 287 static void read_hdr(struct data *data, struct conn *rconn)
 288 {
 289         char *buf;
 290         int readoffset;
 291         int pull;
 292
 293         pull = min(6 - rconn->target.unconnected.cmdread, data_len(data));
 294
 295         if (pull == 0)
 296                 return;
 297
 298         BUG_ON(pull < 0);
 299
 300         buf = data_pull(data, pull);
 301
 302         BUG_ON(rconn->target.unconnected.cmdparams == 0);
 303         BUG_ON(buf == 0);
 304
 305         for (readoffset=0;readoffset<pull;readoffset++) {
 306                 if (2 > rconn->target.unconnected.cmdread) {
 307                         rconn->target.unconnected.cmd <<= 8;
 308                         rconn->target.unconnected.cmd += buf[readoffset];
 309                 } else {
 310                         rconn->target.unconnected.paramlen <<= 8;
 311                         rconn->target.unconnected.paramlen +=
 312                                         buf[readoffset];
 313                 }
 314                 rconn->target.unconnected.cmdread++;
 315         }
 316 }
 317
 318 void parse(struct data *data, struct conn *rconn)
 319 {
 320         __u8 *cmd;
 321
 322         BUG_ON(TARGET_UNCONNECTED != rconn->targettype);
 323
 324         if (rconn->target.unconnected.cmdparams == 0)
 325                 rconn->target.unconnected.cmdparams = kmalloc(MAX_CONN_CMD_LEN,
 326                                 GFP_KERNEL);
 327
 328         cmd = rconn->target.unconnected.cmdparams;
 329
 330         if (rconn->target.unconnected.cmdread == 0) {
 331                 rconn->target.unconnected.cmd = 0;
 332                 rconn->target.unconnected.paramlen = 0;
 333         }
 334
 335         if (rconn->target.unconnected.cmdread < 6) {
 336                 read_hdr(data, rconn);
 337                 if (rconn->target.unconnected.cmdread < 6)
 338                         return;
 339
 340                 if (rconn->target.unconnected.paramlen > MAX_CONN_CMD_LEN) {
 341                         send_resp(rconn, CDR_EXECFAILED,
 342                                         CDR_EXECFAILED_CMD_TOO_LONG);
 343                 }
 344         }
 345
 346         if (rconn->target.unconnected.paramlen > MAX_CONN_CMD_LEN) {
 347                 read_discard(data, rconn);
 348                 return;
 349         }
 350
 351         if (rconn->target.unconnected.cmdread >= 6 &&
 352                         rconn->target.unconnected.paramlen >
 353                         rconn->target.unconnected.cmdread - 6) {
 354                 read_cmd(data, rconn);
 355         }
 356
 357         if (rconn->target.unconnected.paramlen ==
 358                         rconn->target.unconnected.cmdread - 6) {
 359                 rconn->target.unconnected.cmdread = 0;
 360                 parse_cmd(rconn);
 361         }
 362
 363         if (TARGET_UNCONNECTED != rconn->targettype)
 364                 kfree(cmd);
 365 }