net/cor/cpacket_parse.c

   1 /**
   2  *      Connection oriented routing
   3  *      Copyright (C) 2007-2011 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 struct work_struct cpacket_resume_work;
  24 static int cpacket_resume_running;
  25 DEFINE_SPINLOCK(cpacket_bufferlimits_lock);
  26 static __u64 cpacket_bufferusage;
  27 static int cpacket_kmallocfailed;
  28 LIST_HEAD(cpacket_bufferwaiting);
  29
  30 static int reserve_cpacket_buffer(struct conn *trtg_unconn_l, int fromresume)
  31 {
  32         unsigned long iflags;
  33         int putconn = 0;
  34
  35         __u32 paramlen = trtg_unconn_l->target.unconnected.paramlen;
  36         __u32 resplen = 128;
  37
  38         if (trtg_unconn_l->target.unconnected.cmd == CD_LIST_NEIGH)
  39                 resplen = LISTNEIGH_RESP_MAXSIZE + 128;
  40
  41         if (trtg_unconn_l->target.unconnected.in_buffer_wait_list &&
  42                         fromresume == 0)
  43                 return 1;
  44
  45         if (trtg_unconn_l->data_buf.cpacket_buffer + paramlen + resplen >
  46                         BUFFERLIMIT_CONNDATA_PERCONN)
  47                 return 1;
  48
  49         spin_lock_irqsave(&cpacket_bufferlimits_lock, iflags);
  50
  51         if (list_empty(&cpacket_bufferwaiting) == 0 || paramlen + resplen +
  52                         cpacket_bufferusage > BUFFERLIMIT_CONNDATA_GLOBAL) {
  53                 /* out of bufferspace */
  54                 if (trtg_unconn_l->target.unconnected.in_buffer_wait_list == 0){
  55                         trtg_unconn_l->target.unconnected.in_buffer_wait_list=1;
  56                         list_add_tail(&(trtg_unconn_l->target.unconnected.buffer_wait_list),
  57                                         &cpacket_bufferwaiting);
  58                         kref_get(&(trtg_unconn_l->ref));
  59
  60                         if (cpacket_resume_running == 0) {
  61                                 schedule_work(&cpacket_resume_work);
  62                                 cpacket_resume_running = 1;
  63                         }
  64                 }
  65                 spin_unlock_irqrestore(&cpacket_bufferlimits_lock,
  66                                         iflags);
  67                 return 1;
  68         }
  69
  70         cpacket_bufferusage += paramlen + resplen;
  71
  72         if (trtg_unconn_l->target.unconnected.in_buffer_wait_list) {
  73                 trtg_unconn_l->target.unconnected.in_buffer_wait_list = 0;
  74                 list_del(&(trtg_unconn_l->target.unconnected.buffer_wait_list));
  75                 putconn = 1;
  76         }
  77
  78         spin_unlock_irqrestore(&cpacket_bufferlimits_lock, iflags);
  79
  80         trtg_unconn_l->target.unconnected.cmdparams = kmalloc(paramlen,
  81                         GFP_KERNEL);
  82         if (unlikely(trtg_unconn_l->target.unconnected.cmdparams == 0)) {
  83                 spin_lock_irqsave(&cpacket_bufferlimits_lock, iflags);
  84                 cpacket_kmallocfailed = 1;
  85                 trtg_unconn_l->target.unconnected.in_buffer_wait_list = 1;
  86                 list_add(&(trtg_unconn_l->target.unconnected.buffer_wait_list),
  87                                 &cpacket_bufferwaiting);
  88                 if (cpacket_resume_running == 0) {
  89                         schedule_work(&cpacket_resume_work);
  90                         cpacket_resume_running = 1;
  91                 }
  92                 if (putconn == 0)
  93                         kref_get(&(trtg_unconn_l->ref));
  94                 cpacket_bufferusage -= paramlen + resplen;
  95                 spin_unlock_irqrestore(&cpacket_bufferlimits_lock, iflags);
  96                 return 1;
  97         }
  98
  99         mutex_lock(&(trtg_unconn_l->reversedir->rcv_lock));
 100         trtg_unconn_l->reversedir->data_buf.cpacket_buffer += resplen;
 101         mutex_unlock(&(trtg_unconn_l->reversedir->rcv_lock));
 102
 103         if (putconn)
 104                 kref_put(&(trtg_unconn_l->ref), free_conn);
 105
 106         return 0;
 107 }
 108
 109 static void cpacket_buffer_resume(struct work_struct *work)
 110 {
 111         unsigned long iflags;
 112         int i;
 113
 114         spin_lock_irqsave(&cpacket_bufferlimits_lock, iflags);
 115
 116         cpacket_kmallocfailed = 0;
 117
 118         for (i=0;i<100;i++) {
 119                 struct conn *trtg_unconn;
 120
 121                 if (list_empty(&cpacket_bufferwaiting))
 122                         goto finish;
 123
 124                 if (cpacket_kmallocfailed)
 125                         break;
 126
 127                 trtg_unconn = container_of(cpacket_bufferwaiting.next,
 128                                 struct conn,
 129                                 target.unconnected.buffer_wait_list);
 130
 131                 kref_get(&(trtg_unconn->ref));
 132
 133                 spin_unlock_irqrestore(&cpacket_bufferlimits_lock, iflags);
 134
 135                 mutex_lock(&(trtg_unconn->rcv_lock));
 136
 137                 if (unlikely(trtg_unconn->targettype != TARGET_UNCONNECTED))
 138                         goto cont;
 139
 140                 spin_lock_irqsave(&cpacket_bufferlimits_lock, iflags);
 141
 142                 BUG_ON(trtg_unconn->target.unconnected.in_buffer_wait_list ==
 143                                 0);
 144
 145                 if (unlikely(atomic_read(&(trtg_unconn->isreset)) != 0)) {
 146                         trtg_unconn->target.unconnected.in_buffer_wait_list = 0;
 147                         list_del(&(trtg_unconn->target.unconnected.buffer_wait_list));
 148                         goto cont;
 149                 }
 150
 151
 152                 spin_unlock_irqrestore(&cpacket_bufferlimits_lock, iflags);
 153                 mutex_unlock(&(trtg_unconn->rcv_lock));
 154
 155                 parse(trtg_unconn, 1);
 156
 157 cont:
 158                 kref_put(&(trtg_unconn->ref), free_conn);
 159                 spin_lock_irqsave(&cpacket_bufferlimits_lock, iflags);
 160         }
 161
 162         schedule_work(&cpacket_resume_work);
 163
 164         if (0) {
 165 finish:
 166                 cpacket_resume_running = 0;
 167         }
 168
 169         spin_unlock_irqrestore(&cpacket_bufferlimits_lock, iflags);
 170 }
 171
 172 void free_cpacket_buffer(__s32 amount)
 173 {
 174         unsigned long iflags;
 175         spin_lock_irqsave(&cpacket_bufferlimits_lock, iflags);
 176         BUG_ON(amount > 0 && amount > cpacket_bufferusage);
 177         cpacket_bufferusage -= amount;
 178
 179         if (amount > 0 && list_empty(&cpacket_bufferwaiting) == 0 &&
 180                         cpacket_resume_running == 0) {
 181                 schedule_work(&cpacket_resume_work);
 182                 cpacket_resume_running = 1;
 183         }
 184         spin_unlock_irqrestore(&cpacket_bufferlimits_lock, iflags);
 185 }
 186
 187 void connreset_cpacket_buffer(struct conn *trtg_unconn_l)
 188 {
 189         if (trtg_unconn_l->target.unconnected.in_buffer_wait_list) {
 190                 unsigned long iflags;
 191                 spin_lock_irqsave(&cpacket_bufferlimits_lock, iflags);
 192                 trtg_unconn_l->target.unconnected.in_buffer_wait_list = 0;
 193                 list_del(&(trtg_unconn_l->target.unconnected.buffer_wait_list));
 194                 spin_unlock_irqrestore(&cpacket_bufferlimits_lock, iflags);
 195         }
 196
 197         if (trtg_unconn_l->target.unconnected.cmdparams != 0) {
 198                 BUG_ON(trtg_unconn_l->target.unconnected.paramlen <= 0);
 199                 kfree(trtg_unconn_l->target.unconnected.cmdparams);
 200                 trtg_unconn_l->target.unconnected.cmdparams = 0;
 201                 free_cpacket_buffer(trtg_unconn_l->target.unconnected.paramlen);
 202         }
 203 }
 204
 205 int encode_len(char *buf, int buflen, __u32 len)
 206 {
 207         BUG_ON(buf == 0);
 208         BUG_ON(buflen < 4);
 209
 210         if (len <= 127) {
 211                 buf[0] = (__u8) len;
 212                 return 1;
 213         }
 214
 215         if (len <= 16511) {
 216                 buf[0] = (__u8) ((len - 128) /256 + 128);
 217                 buf[1] = (__u8) ((len- 128) & 255);
 218                 return 2;
 219         }
 220
 221         if (len < 1073741951) {
 222                 __u32 len_be = cpu_to_be32(len - 16511);
 223                 char *len_p = (char *) &len_be;
 224
 225                 buf[0] = len_p[0] + 192;
 226                 buf[1] = len_p[1];
 227                 buf[2] = len_p[2];
 228                 buf[3] = len_p[3];
 229                 return 4;
 230         }
 231
 232         return -1;
 233 }
 234
 235 int decode_len(char *buf, int buflen, __u32 *len)
 236 {
 237         if (buflen < 1)
 238                 return 0;
 239
 240         if ((__u8) buf[0] <= 127) {
 241                 *len = (__u8) buf[0];
 242                 return 1;
 243         }
 244
 245         if (buflen < 2)
 246                 return 0;
 247
 248         if ((__u8) buf[0] <= 191) {
 249                 *len = 128 + ((__u32) ((__u8) buf[0]) - 128) * 256 +
 250                                 ((__u8) buf[1]);
 251                 return 2;
 252         }
 253
 254         if (buflen < 4)
 255                 return 0;
 256
 257         ((char *) len)[0] = buf[0] - 192;
 258         ((char *) len)[1] = buf[1];
 259         ((char *) len)[2] = buf[2];
 260         ((char *) len)[3] = buf[3];
 261
 262         *len = be32_to_cpu(*len) + 16511;
 263         return 4;
 264 }
 265
 266 static void send_resp_ok(struct conn *trtg_unconn_l)
 267 {
 268         __u8 respcode = CDR_EXECOK;
 269
 270         mutex_lock(&(trtg_unconn_l->reversedir->rcv_lock));
 271         receive_cpacketresp(trtg_unconn_l->reversedir, (char *) &respcode, 1);
 272         mutex_unlock(&(trtg_unconn_l->reversedir->rcv_lock));
 273 }
 274
 275 static char *get_error_reason_text(__u16 reasoncode)
 276 {
 277         if (reasoncode == CDR_EXECFAILED_UNKNOWN_COMMAND)
 278                 return "Unknown command";
 279         else if (reasoncode == CDR_EXECFAILED_PERMISSION_DENIED)
 280                 return "Permission denied";
 281         else if (reasoncode == CDR_EXECFAILED_TEMPORARILY_OUT_OF_RESSOURCES)
 282                 return "Temporarily out of ressources";
 283         else if (reasoncode == CDR_EXECFAILED_CMD_TOO_SHORT)
 284                 return "The length of the command is too short for all params";
 285         else if (reasoncode == CDR_EXECFAILED_CMD_TOO_LONG)
 286                 return "command param is too long";
 287         else if (reasoncode == CDR_EXECFAILED_TARGETADDRTYPE_UNKNOWN)
 288                 return "targettype unknown";
 289         else if (reasoncode == CDR_EXECFAILED_TARGETADDR_DOESNTEXIST)
 290                 return "targetaddr does not exist";
 291         else if (reasoncode == CDR_EXECFAILED_TARGETADDR_PORTCLOSED)
 292                 return "Port is on open";
 293         else if (reasoncode == CDR_EXECFAILED_LISTENERQUEUE_FULL)
 294                 return "Listener queue full";
 295         else
 296                 return 0;
 297 }
 298
 299 static void send_resp_failed(struct conn *trtg_unconn_l, __u16 reasoncode)
 300 {
 301         char hdr[7];
 302
 303         char *reasontext;
 304         int reasonlen = 0;
 305         int reasonlen_len;
 306
 307         hdr[0] = CDR_EXECFAILED;
 308
 309         reasoncode = cpu_to_be16(reasoncode);
 310         hdr[1] = ((char *) &reasoncode)[0];
 311         hdr[2] = ((char *) &reasoncode)[1];
 312
 313         reasontext = get_error_reason_text(reasoncode);
 314         if (reasontext)
 315                 reasonlen = strnlen(reasontext, 1024);
 316         reasonlen_len = encode_len(hdr + 3, 4, reasonlen);
 317         BUG_ON(reasonlen_len <= 0);
 318
 319         mutex_lock(&(trtg_unconn_l->reversedir->rcv_lock));
 320         receive_cpacketresp(trtg_unconn_l->reversedir, hdr, 3 + reasonlen_len);
 321         receive_cpacketresp(trtg_unconn_l->reversedir, reasontext, reasonlen);
 322         mutex_unlock(&(trtg_unconn_l->reversedir->rcv_lock));
 323 }
 324
 325 static void send_resp_bin(struct conn *trtg_unconn_l, char *buf, __u32 len)
 326 {
 327         char hdr[5];
 328         int len_len;
 329
 330         hdr[0] = CDR_BINDATA;
 331         len_len = encode_len(hdr + 1, 4, len);
 332
 333         BUG_ON(len_len <= 0);
 334
 335         mutex_lock(&(trtg_unconn_l->reversedir->rcv_lock));
 336         receive_cpacketresp(trtg_unconn_l->reversedir, hdr, len_len + 1);
 337         receive_cpacketresp(trtg_unconn_l->reversedir, buf, len);
 338         mutex_unlock(&(trtg_unconn_l->reversedir->rcv_lock));
 339 }
 340
 341 static void parse_set_tos(struct conn *trtg_unconn_l)
 342 {
 343         if (unlikely(trtg_unconn_l->target.unconnected.paramlen < 2)) {
 344                 send_resp_failed(trtg_unconn_l, CDR_EXECFAILED_CMD_TOO_SHORT);
 345                 return;
 346         }
 347
 348         trtg_unconn_l->tos =
 349                         (trtg_unconn_l->target.unconnected.cmdparams[0]) & 3;
 350         trtg_unconn_l->reversedir->tos =
 351                         (trtg_unconn_l->target.unconnected.cmdparams[1]) & 3;
 352 }
 353
 354 static void parse_list_neigh(struct conn *trtg_unconn_l)
 355 {
 356         __u32 limit;
 357         __u32 offset;
 358         __u32 len;
 359
 360         __u32 read = 0;
 361         int rc;
 362
 363         char *buf;
 364
 365         BUG_ON(read > trtg_unconn_l->target.unconnected.paramlen);
 366         rc = decode_len(trtg_unconn_l->target.unconnected.cmdparams + read,
 367                         trtg_unconn_l->target.unconnected.paramlen - read,
 368                         &limit);
 369
 370         if (unlikely(rc <= 0)) {
 371                 send_resp_failed(trtg_unconn_l, CDR_EXECFAILED_CMD_TOO_SHORT);
 372                 return;
 373         }
 374
 375         read += rc;
 376
 377         BUG_ON(read > trtg_unconn_l->target.unconnected.paramlen);
 378         rc = decode_len(trtg_unconn_l->target.unconnected.cmdparams + read,
 379                         trtg_unconn_l->target.unconnected.paramlen - read,
 380                         &offset);
 381
 382         if (unlikely(rc <= 0)) {
 383                 send_resp_failed(trtg_unconn_l, CDR_EXECFAILED_CMD_TOO_SHORT);
 384                 return;
 385         }
 386
 387         read += rc;
 388
 389         buf = kmalloc(LISTNEIGH_RESP_MAXSIZE, GFP_KERNEL);
 390
 391         if (unlikely(buf == 0)) {
 392                 send_resp_failed(trtg_unconn_l,
 393                                 CDR_EXECFAILED_TEMPORARILY_OUT_OF_RESSOURCES);
 394                 return;
 395         }
 396
 397         send_resp_ok(trtg_unconn_l);
 398
 399         len = generate_neigh_list(buf, 2048, limit, offset);
 400         send_resp_bin(trtg_unconn_l, buf, len);
 401 }
 402
 403 static void parse_connect_port(struct conn *trtg_unconn_l)
 404 {
 405         __be64 addr;
 406         int rc;
 407
 408         if (unlikely(trtg_unconn_l->target.unconnected.paramlen < 8)) {
 409                 send_resp_failed(trtg_unconn_l, CDR_EXECFAILED_CMD_TOO_SHORT);
 410                 return;
 411         }
 412
 413         memcpy((char *) &addr, trtg_unconn_l->target.unconnected.cmdparams, 8);
 414
 415         rc = connect_port(trtg_unconn_l, addr);
 416
 417         if (rc == 0) {
 418                 send_resp_ok(trtg_unconn_l);
 419         } else if (rc == 2) {
 420                 send_resp_failed(trtg_unconn_l,
 421                                 CDR_EXECFAILED_TARGETADDR_DOESNTEXIST);
 422         } else if (rc == 3) {
 423                 send_resp_failed(trtg_unconn_l,
 424                                 CDR_EXECFAILED_LISTENERQUEUE_FULL);
 425         } else {
 426                 BUG();
 427         }
 428 }
 429
 430 static void parse_connect_nb(struct conn *trtg_unconn_l)
 431 {
 432         __u32 addrtypelen;
 433         __u32 addrlen;
 434         __u8 *addrtype;
 435         __u8 *addr;
 436
 437         __u32 read = 0;
 438         int rc;
 439
 440         BUG_ON(read > trtg_unconn_l->target.unconnected.paramlen);
 441         rc = decode_len(trtg_unconn_l->target.unconnected.cmdparams + read,
 442                         trtg_unconn_l->target.unconnected.paramlen - read,
 443                         &addrtypelen);
 444
 445         if (unlikely(rc <= 0)) {
 446                 send_resp_failed(trtg_unconn_l, CDR_EXECFAILED_CMD_TOO_SHORT);
 447                 return;
 448         }
 449
 450         read += rc;
 451
 452         BUG_ON(read > trtg_unconn_l->target.unconnected.paramlen);
 453         rc = decode_len(trtg_unconn_l->target.unconnected.cmdparams + read,
 454                         trtg_unconn_l->target.unconnected.paramlen - read,
 455                         &addrlen);
 456
 457         if (unlikely(rc <= 0)) {
 458                 send_resp_failed(trtg_unconn_l, CDR_EXECFAILED_CMD_TOO_SHORT);
 459                 return;
 460         }
 461
 462         read += rc;
 463
 464         if (unlikely(addrtypelen > 65535 || addrtypelen > 65535)) {
 465                 send_resp_failed(trtg_unconn_l,
 466                                 CDR_EXECFAILED_TARGETADDR_DOESNTEXIST);
 467                 return;
 468         }
 469
 470         if (unlikely((read + addrtypelen + addrlen) >
 471                         trtg_unconn_l->target.unconnected.paramlen)) {
 472                 send_resp_failed(trtg_unconn_l, CDR_EXECFAILED_CMD_TOO_SHORT);
 473                 return;
 474         }
 475
 476         addrtype = trtg_unconn_l->target.unconnected.cmdparams + read;
 477         addr = addrtype + addrtypelen;
 478
 479         rc = connect_neigh(trtg_unconn_l, (__u16) addrtypelen, addrtype,
 480                         (__u16) addrlen, addr);
 481
 482         if (rc == 0) {
 483                 send_resp_ok(trtg_unconn_l);
 484         } else if (rc == 2) {
 485                 send_resp_failed(trtg_unconn_l,
 486                                 CDR_EXECFAILED_TARGETADDRTYPE_UNKNOWN);
 487         } else if (rc == 3) {
 488                 send_resp_failed(trtg_unconn_l,
 489                                 CDR_EXECFAILED_TARGETADDR_DOESNTEXIST);
 490         } else if (rc == 4) {
 491                 send_resp_failed(trtg_unconn_l,
 492                                 CDR_EXECFAILED_TEMPORARILY_OUT_OF_RESSOURCES);
 493         } else {
 494                 BUG();
 495         }
 496 }
 497
 498 static void parse_cmd(struct conn *trtg_unconn_l)
 499 {
 500         __u16 code = trtg_unconn_l->target.unconnected.cmd;
 501
 502         BUG_ON(trtg_unconn_l->target.unconnected.cmdparams == 0);
 503
 504         if (code == CD_CONNECT_NB) {
 505                 parse_connect_nb(trtg_unconn_l);
 506         } else if (code == CD_CONNECT_PORT) {
 507                 parse_connect_port(trtg_unconn_l);
 508         } else if (code == CD_LIST_NEIGH) {
 509                 parse_list_neigh(trtg_unconn_l);
 510         } else if (code == CD_SET_TOS) {
 511                 parse_set_tos(trtg_unconn_l);
 512         } else {
 513                 send_resp_failed(trtg_unconn_l, CDR_EXECFAILED_UNKNOWN_COMMAND);
 514         }
 515 }
 516
 517 static void read_cmd(struct conn *trtg_unconn_l)
 518 {
 519         int pull;
 520
 521         pull = min(trtg_unconn_l->target.unconnected.paramlen -
 522                         trtg_unconn_l->target.unconnected.cmdread,
 523                         trtg_unconn_l->data_buf.read_remaining);
 524
 525         BUG_ON(pull < 0);
 526         BUG_ON(trtg_unconn_l->target.unconnected.cmdparams == 0);
 527
 528         if (pull == 0)
 529                 return;
 530
 531         databuf_pull(trtg_unconn_l,
 532                         trtg_unconn_l->target.unconnected.cmdparams +
 533                         trtg_unconn_l->target.unconnected.cmdread, pull);
 534         databuf_ackread(trtg_unconn_l);
 535
 536         trtg_unconn_l->target.unconnected.cmdread += pull;
 537 }
 538
 539 static void read_discard(struct conn *trtg_unconn_l)
 540 {
 541         BUG_ON(trtg_unconn_l->target.unconnected.paramlen_read == 0);
 542
 543         while (trtg_unconn_l->target.unconnected.paramlen <
 544                         trtg_unconn_l->target.unconnected.cmdread &&
 545                         trtg_unconn_l->data_buf.read_remaining > 0) {
 546                 char buf[1];
 547                 databuf_pull(trtg_unconn_l, buf, 1);
 548                 databuf_ackread(trtg_unconn_l);
 549
 550                 trtg_unconn_l->target.unconnected.cmdread++;
 551         }
 552 }
 553
 554 static void read_hdr(struct conn *trtg_unconn_l)
 555 {
 556         BUG_ON(trtg_unconn_l->target.unconnected.cmdparams != 0);
 557
 558         while (trtg_unconn_l->target.unconnected.paramlen_read == 0 &&
 559                         trtg_unconn_l->data_buf.read_remaining > 0) {
 560                 int rc;
 561
 562                 BUG_ON(trtg_unconn_l->target.unconnected.cmdread >= 6);
 563
 564                 if (trtg_unconn_l->target.unconnected.cmdread < 2) {
 565                         char buf[1];
 566                         databuf_pull(trtg_unconn_l, buf, 1);
 567                         trtg_unconn_l->target.unconnected.cmd <<= 8;
 568                         trtg_unconn_l->target.unconnected.cmd += buf[0];
 569                         trtg_unconn_l->target.unconnected.cmdread += 1;
 570                         continue;
 571                 }
 572
 573                 databuf_pull(trtg_unconn_l,
 574                                 trtg_unconn_l->target.unconnected.paramlen_buf +
 575                                 trtg_unconn_l->target.unconnected.cmdread - 2,
 576                                 1);
 577                 trtg_unconn_l->target.unconnected.cmdread += 1;
 578
 579                 rc = decode_len(trtg_unconn_l->target.unconnected.paramlen_buf,
 580                                 trtg_unconn_l->target.unconnected.cmdread - 2,
 581                                 &(trtg_unconn_l->target.unconnected.paramlen));
 582
 583                 if (rc > 0) {
 584                         trtg_unconn_l->target.unconnected.paramlen_read = 1;
 585                         trtg_unconn_l->target.unconnected.cmdread = 0;
 586                         break;
 587                 }
 588         }
 589 }
 590
 591 void parse(struct conn *trtg_unconn, int fromresume)
 592 {
 593 start:
 594         mutex_lock(&(trtg_unconn->rcv_lock));
 595
 596         if (unlikely(atomic_read(&(trtg_unconn->isreset)) != 0))
 597                 goto out;
 598
 599         if (unlikely(trtg_unconn->targettype != TARGET_UNCONNECTED))
 600                 goto out;
 601
 602         BUG_ON(trtg_unconn->data_buf.cpacket_buffer != 0);
 603
 604         if (trtg_unconn->target.unconnected.paramlen_read == 0) {
 605                 read_hdr(trtg_unconn);
 606                 if (trtg_unconn->target.unconnected.paramlen_read == 0)
 607                         goto out;
 608
 609                 if (trtg_unconn->target.unconnected.paramlen >
 610                                 MAX_CONN_CMD_LEN) {
 611                         send_resp_failed(trtg_unconn,
 612                                         CDR_EXECFAILED_CMD_TOO_LONG);
 613                 }
 614         }
 615
 616         if (trtg_unconn->target.unconnected.paramlen > MAX_CONN_CMD_LEN) {
 617                 read_discard(trtg_unconn);
 618                 goto out;
 619         }
 620
 621         if (trtg_unconn->target.unconnected.cmdparams == 0) {
 622                 if (reserve_cpacket_buffer(trtg_unconn, fromresume))
 623                         goto out;
 624         }
 625
 626         if (trtg_unconn->target.unconnected.paramlen >
 627                         trtg_unconn->target.unconnected.cmdread) {
 628                 read_cmd(trtg_unconn);
 629         }
 630
 631         if (trtg_unconn->target.unconnected.paramlen ==
 632                         trtg_unconn->target.unconnected.cmdread) {
 633                 char *cmd = trtg_unconn->target.unconnected.cmdparams;
 634                 __s32 cpacket_buffer;
 635                 __u32 paramlen = trtg_unconn->target.unconnected.paramlen;
 636                 int flush = 0;
 637
 638                 BUG_ON(trtg_unconn->is_client == 0);
 639                 mutex_lock(&(trtg_unconn->reversedir->rcv_lock));
 640                 cpacket_buffer = trtg_unconn->reversedir->data_buf.cpacket_buffer;
 641                 mutex_unlock(&(trtg_unconn->reversedir->rcv_lock));
 642                 parse_cmd(trtg_unconn);
 643                 kfree(cmd);
 644                 mutex_lock(&(trtg_unconn->reversedir->rcv_lock));
 645                 trtg_unconn->reversedir->data_buf.cpacket_buffer =
 646                                 trtg_unconn->reversedir->data_buf.totalsize +
 647                                 trtg_unconn->reversedir->data_buf.overhead;
 648                 cpacket_buffer -= trtg_unconn->reversedir->data_buf.cpacket_buffer;
 649                 mutex_unlock(&(trtg_unconn->reversedir->rcv_lock));
 650                 free_cpacket_buffer(paramlen + cpacket_buffer);
 651
 652                 if (trtg_unconn->targettype != TARGET_UNCONNECTED) {
 653                         flush = 1;
 654                 } else {
 655                         trtg_unconn->target.unconnected.cmdparams = 0;
 656                         trtg_unconn->target.unconnected.cmdread = 0;
 657                         trtg_unconn->target.unconnected.paramlen_read = 0;
 658                         trtg_unconn->target.unconnected.cmd = 0;
 659                         trtg_unconn->target.unconnected.paramlen = 0;
 660                 }
 661
 662                 mutex_unlock(&(trtg_unconn->rcv_lock));
 663                 if (flush)
 664                         flush_buf(trtg_unconn);
 665                 flush_buf(trtg_unconn->reversedir);
 666                 if (flush == 0)
 667                         goto start;
 668                 return;
 669         }
 670
 671 out:
 672         mutex_unlock(&(trtg_unconn->rcv_lock));
 673 }
 674
 675 int __init cor_cpacket_init(void)
 676 {
 677         INIT_WORK(&cpacket_resume_work, cpacket_buffer_resume);
 678         cpacket_resume_running = 0;
 679         cpacket_bufferusage = 0;
 680         cpacket_kmallocfailed = 0;
 681         return 0;
 682 }
 683
 684 MODULE_LICENSE("GPL");