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