packages/net/lwip_tcpip/v2_0/src/api/api_msg.c

   1 /*
   2  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without modification,
   6  * are permitted provided that the following conditions are met:
   7  *
   8  * 1. Redistributions of source code must retain the above copyright notice,
   9  *    this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright notice,
  11  *    this list of conditions and the following disclaimer in the documentation
  12  *    and/or other materials provided with the distribution.
  13  * 3. The name of the author may not be used to endorse or promote products
  14  *    derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
  19  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
  21  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  22  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  23  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  24  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  25  * OF SUCH DAMAGE.
  26  *
  27  * This file is part of the lwIP TCP/IP stack.
  28  *
  29  * Author: Adam Dunkels <adam@sics.se>
  30  *
  31  */
  32
  33 #include "lwip/opt.h"
  34 #include "lwip/arch.h"
  35 #include "lwip/api_msg.h"
  36 #include "lwip/memp.h"
  37 #include "lwip/sys.h"
  38 #include "lwip/tcpip.h"
  39
  40 #if LWIP_RAW
  41 static int
  42 recv_raw(void *arg, struct raw_pcb *pcb, struct pbuf *p,
  43     struct ip_addr *addr)
  44 {
  45   struct netbuf *buf;
  46   struct netconn *conn;
  47
  48   conn = arg;
  49   if (!conn) return 0;
  50
  51   if (conn->recvmbox != SYS_MBOX_NULL) {
  52     if (!(buf = memp_malloc(MEMP_NETBUF))) {
  53       return 0;
  54     }
  55     pbuf_ref(p);
  56     buf->p = p;
  57     buf->ptr = p;
  58     buf->fromaddr = addr;
  59     buf->fromport = pcb->protocol;
  60
  61     conn->recv_avail += p->tot_len;
  62     /* Register event with callback */
  63     if (conn->callback)
  64         (*conn->callback)(conn, NETCONN_EVT_RCVPLUS, p->tot_len);
  65     sys_mbox_post(conn->recvmbox, buf);
  66   }
  67
  68   return 0; /* do not eat the packet */
  69 }
  70 #endif
  71 #if LWIP_UDP
  72 static void
  73 recv_udp(void *arg, struct udp_pcb *pcb, struct pbuf *p,
  74    struct ip_addr *addr, u16_t port)
  75 {
  76   struct netbuf *buf;
  77   struct netconn *conn;
  78
  79   conn = arg;
  80
  81   if (conn == NULL) {
  82     pbuf_free(p);
  83     return;
  84   }
  85   if (conn->recvmbox != SYS_MBOX_NULL) {
  86     buf = memp_malloc(MEMP_NETBUF);
  87     if (buf == NULL) {
  88       pbuf_free(p);
  89       return;
  90     } else {
  91       buf->p = p;
  92       buf->ptr = p;
  93       buf->fromaddr = addr;
  94       buf->fromport = port;
  95     }
  96
  97   conn->recv_avail += p->tot_len;
  98     /* Register event with callback */
  99     if (conn->callback)
 100         (*conn->callback)(conn, NETCONN_EVT_RCVPLUS, p->tot_len);
 101     sys_mbox_post(conn->recvmbox, buf);
 102   }
 103 }
 104 #endif /* LWIP_UDP */
 105 #if LWIP_TCP
 106
 107 static err_t
 108 recv_tcp(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err)
 109 {
 110   struct netconn *conn;
 111   u16_t len;
 112
 113   conn = arg;
 114
 115   if (conn == NULL) {
 116     pbuf_free(p);
 117     return ERR_VAL;
 118   }
 119
 120   if (conn->recvmbox != SYS_MBOX_NULL) {
 121
 122     conn->err = err;
 123     if (p != NULL) {
 124         len = p->tot_len;
 125         conn->recv_avail += len;
 126     }
 127     else
 128         len = 0;
 129     /* Register event with callback */
 130     if (conn->callback)
 131         (*conn->callback)(conn, NETCONN_EVT_RCVPLUS, len);
 132     sys_mbox_post(conn->recvmbox, p);
 133   }
 134   return ERR_OK;
 135 }
 136
 137
 138 static err_t
 139 poll_tcp(void *arg, struct tcp_pcb *pcb)
 140 {
 141   struct netconn *conn;
 142
 143   conn = arg;
 144   if (conn != NULL &&
 145      (conn->state == NETCONN_WRITE || conn->state == NETCONN_CLOSE) &&
 146      conn->sem != SYS_SEM_NULL) {
 147     sys_sem_signal(conn->sem);
 148   }
 149   return ERR_OK;
 150 }
 151
 152 static err_t
 153 sent_tcp(void *arg, struct tcp_pcb *pcb, u16_t len)
 154 {
 155   struct netconn *conn;
 156
 157   conn = arg;
 158   if (conn != NULL && conn->sem != SYS_SEM_NULL) {
 159     sys_sem_signal(conn->sem);
 160   }
 161
 162   if (conn && conn->callback)
 163       if (tcp_sndbuf(conn->pcb.tcp) > TCP_SNDLOWAT)
 164           (*conn->callback)(conn, NETCONN_EVT_SENDPLUS, len);
 165
 166   return ERR_OK;
 167 }
 168
 169 static void
 170 err_tcp(void *arg, err_t err)
 171 {
 172   struct netconn *conn;
 173
 174   conn = arg;
 175
 176   conn->pcb.tcp = NULL;
 177
 178
 179   conn->err = err;
 180   if (conn->recvmbox != SYS_MBOX_NULL) {
 181     /* Register event with callback */
 182     if (conn->callback)
 183       (*conn->callback)(conn, NETCONN_EVT_RCVPLUS, 0);
 184     sys_mbox_post(conn->recvmbox, NULL);
 185   }
 186   if (conn->mbox != SYS_MBOX_NULL) {
 187     sys_mbox_post(conn->mbox, NULL);
 188   }
 189   if (conn->acceptmbox != SYS_MBOX_NULL) {
 190      /* Register event with callback */
 191     if (conn->callback)
 192       (*conn->callback)(conn, NETCONN_EVT_RCVPLUS, 0);
 193     sys_mbox_post(conn->acceptmbox, NULL);
 194   }
 195   if (conn->sem != SYS_SEM_NULL) {
 196     sys_sem_signal(conn->sem);
 197   }
 198 }
 199
 200 static void
 201 setup_tcp(struct netconn *conn)
 202 {
 203   struct tcp_pcb *pcb;
 204
 205   pcb = conn->pcb.tcp;
 206   tcp_arg(pcb, conn);
 207   tcp_recv(pcb, recv_tcp);
 208   tcp_sent(pcb, sent_tcp);
 209   tcp_poll(pcb, poll_tcp, 4);
 210   tcp_err(pcb, err_tcp);
 211 }
 212
 213 static err_t
 214 accept_function(void *arg, struct tcp_pcb *newpcb, err_t err)
 215 {
 216   sys_mbox_t mbox;
 217   struct netconn *newconn;
 218   struct netconn *conn;
 219
 220 #if API_MSG_DEBUG
 221 #if TCP_DEBUG
 222   tcp_debug_print_state(newpcb->state);
 223 #endif /* TCP_DEBUG */
 224 #endif /* API_MSG_DEBUG */
 225   conn = (struct netconn *)arg;
 226   mbox = conn->acceptmbox;
 227   newconn = memp_malloc(MEMP_NETCONN);
 228   if (newconn == NULL) {
 229     return ERR_MEM;
 230   }
 231   newconn->type = NETCONN_TCP;
 232   newconn->pcb.tcp = newpcb;
 233   setup_tcp(newconn);
 234   newconn->recvmbox = sys_mbox_new();
 235   if (newconn->recvmbox == SYS_MBOX_NULL) {
 236     memp_free(MEMP_NETCONN, newconn);
 237     return ERR_MEM;
 238   }
 239   newconn->mbox = sys_mbox_new();
 240   if (newconn->mbox == SYS_MBOX_NULL) {
 241     sys_mbox_free(newconn->recvmbox);
 242     memp_free(MEMP_NETCONN, newconn);
 243     return ERR_MEM;
 244   }
 245   newconn->sem = sys_sem_new(0);
 246   if (newconn->sem == SYS_SEM_NULL) {
 247     sys_mbox_free(newconn->recvmbox);
 248     sys_mbox_free(newconn->mbox);
 249     memp_free(MEMP_NETCONN, newconn);
 250     return ERR_MEM;
 251   }
 252   newconn->acceptmbox = SYS_MBOX_NULL;
 253   newconn->err = err;
 254   /* Register event with callback */
 255   if (conn->callback)
 256   {
 257     (*conn->callback)(conn, NETCONN_EVT_RCVPLUS, 0);
 258     /* We have to set the callback here even though
 259      * the new socket is unknown. Mark the socket as -1. */
 260     newconn->callback = conn->callback;
 261     newconn->socket = -1;
 262   }
 263
 264   sys_mbox_post(mbox, newconn);
 265   return ERR_OK;
 266 }
 267 #endif /* LWIP_TCP */
 268
 269 static void
 270 do_newconn(struct api_msg_msg *msg)
 271 {
 272    if(msg->conn->pcb.tcp != NULL) {
 273    /* This "new" connection already has a PCB allocated. */
 274    /* Is this an error condition? Should it be deleted?
 275       We currently just are happy and return. */
 276      sys_mbox_post(msg->conn->mbox, NULL);
 277      return;
 278    }
 279
 280    msg->conn->err = ERR_OK;
 281
 282    /* Allocate a PCB for this connection */
 283    switch(msg->conn->type) {
 284 #if LWIP_RAW
 285    case NETCONN_RAW:
 286       msg->conn->pcb.raw = raw_new(msg->msg.bc.port); /* misusing the port field */
 287       raw_recv(msg->conn->pcb.raw, recv_raw, msg->conn);
 288      break;
 289 #endif
 290 #if LWIP_UDP
 291    case NETCONN_UDPLITE:
 292       msg->conn->pcb.udp = udp_new();
 293       if(msg->conn->pcb.udp == NULL) {
 294          msg->conn->err = ERR_MEM;
 295          break;
 296       }
 297       udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_UDPLITE);
 298       udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
 299       break;
 300    case NETCONN_UDPNOCHKSUM:
 301       msg->conn->pcb.udp = udp_new();
 302       if(msg->conn->pcb.udp == NULL) {
 303          msg->conn->err = ERR_MEM;
 304          break;
 305       }
 306       udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_NOCHKSUM);
 307       udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
 308       break;
 309    case NETCONN_UDP:
 310       msg->conn->pcb.udp = udp_new();
 311       if(msg->conn->pcb.udp == NULL) {
 312          msg->conn->err = ERR_MEM;
 313          break;
 314       }
 315       udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
 316       break;
 317 #endif /* LWIP_UDP */
 318 #if LWIP_TCP
 319    case NETCONN_TCP:
 320       msg->conn->pcb.tcp = tcp_new();
 321       if(msg->conn->pcb.tcp == NULL) {
 322          msg->conn->err = ERR_MEM;
 323          break;
 324       }
 325       setup_tcp(msg->conn);
 326       break;
 327 #endif
 328    }
 329
 330
 331   sys_mbox_post(msg->conn->mbox, NULL);
 332 }
 333
 334
 335 static void
 336 do_delconn(struct api_msg_msg *msg)
 337 {
 338   if (msg->conn->pcb.tcp != NULL) {
 339     switch (msg->conn->type) {
 340 #if LWIP_RAW
 341     case NETCONN_RAW:
 342       raw_remove(msg->conn->pcb.raw);
 343       break;
 344 #endif
 345 #if LWIP_UDP
 346     case NETCONN_UDPLITE:
 347       /* FALLTHROUGH */
 348     case NETCONN_UDPNOCHKSUM:
 349       /* FALLTHROUGH */
 350     case NETCONN_UDP:
 351       msg->conn->pcb.udp->recv_arg = NULL;
 352       udp_remove(msg->conn->pcb.udp);
 353       break;
 354 #endif /* LWIP_UDP */
 355 #if LWIP_TCP
 356     case NETCONN_TCP:
 357       if (msg->conn->pcb.tcp->state == LISTEN) {
 358   tcp_arg(msg->conn->pcb.tcp, NULL);
 359   tcp_accept(msg->conn->pcb.tcp, NULL);
 360   tcp_close(msg->conn->pcb.tcp);
 361       } else {
 362   tcp_arg(msg->conn->pcb.tcp, NULL);
 363   tcp_sent(msg->conn->pcb.tcp, NULL);
 364   tcp_recv(msg->conn->pcb.tcp, NULL);
 365   tcp_poll(msg->conn->pcb.tcp, NULL, 0);
 366   tcp_err(msg->conn->pcb.tcp, NULL);
 367   if (tcp_close(msg->conn->pcb.tcp) != ERR_OK) {
 368     tcp_abort(msg->conn->pcb.tcp);
 369   }
 370       }
 371 #endif
 372     default:
 373     break;
 374     }
 375   }
 376   /* Trigger select() in socket layer */
 377   if (msg->conn->callback)
 378   {
 379       (*msg->conn->callback)(msg->conn, NETCONN_EVT_RCVPLUS, 0);
 380       (*msg->conn->callback)(msg->conn, NETCONN_EVT_SENDPLUS, 0);
 381   }
 382
 383   if (msg->conn->mbox != SYS_MBOX_NULL) {
 384     sys_mbox_post(msg->conn->mbox, NULL);
 385   }
 386 }
 387
 388 static void
 389 do_bind(struct api_msg_msg *msg)
 390 {
 391   if (msg->conn->pcb.tcp == NULL) {
 392     switch (msg->conn->type) {
 393 #if LWIP_RAW
 394     case NETCONN_RAW:
 395       msg->conn->pcb.raw = raw_new(msg->msg.bc.port); /* misusing the port field as protocol */
 396       raw_recv(msg->conn->pcb.raw, recv_raw, msg->conn);
 397       break;
 398 #endif
 399 #if LWIP_UDP
 400     case NETCONN_UDPLITE:
 401       msg->conn->pcb.udp = udp_new();
 402       udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_UDPLITE);
 403       udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
 404       break;
 405     case NETCONN_UDPNOCHKSUM:
 406       msg->conn->pcb.udp = udp_new();
 407       udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_NOCHKSUM);
 408       udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
 409       break;
 410     case NETCONN_UDP:
 411       msg->conn->pcb.udp = udp_new();
 412       udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
 413       break;
 414 #endif /* LWIP_UDP */
 415 #if LWIP_TCP
 416     case NETCONN_TCP:
 417       msg->conn->pcb.tcp = tcp_new();
 418       setup_tcp(msg->conn);
 419 #endif /* LWIP_TCP */
 420     default:
 421     break;
 422     }
 423   }
 424   switch (msg->conn->type) {
 425 #if LWIP_RAW
 426   case NETCONN_RAW:
 427     msg->conn->err = raw_bind(msg->conn->pcb.raw,msg->msg.bc.ipaddr);
 428     break;
 429 #endif
 430 #if LWIP_UDP
 431   case NETCONN_UDPLITE:
 432     /* FALLTHROUGH */
 433   case NETCONN_UDPNOCHKSUM:
 434     /* FALLTHROUGH */
 435   case NETCONN_UDP:
 436     msg->conn->err = udp_bind(msg->conn->pcb.udp, msg->msg.bc.ipaddr, msg->msg.bc.port);
 437     break;
 438 #endif /* LWIP_UDP */
 439 #if LWIP_TCP
 440   case NETCONN_TCP:
 441     msg->conn->err = tcp_bind(msg->conn->pcb.tcp,
 442             msg->msg.bc.ipaddr, msg->msg.bc.port);
 443 #endif /* LWIP_TCP */
 444   default:
 445     break;
 446   }
 447   sys_mbox_post(msg->conn->mbox, NULL);
 448 }
 449 #if LWIP_TCP
 450
 451 static err_t
 452 do_connected(void *arg, struct tcp_pcb *pcb, err_t err)
 453 {
 454   struct netconn *conn;
 455
 456   conn = arg;
 457
 458   if (conn == NULL) {
 459     return ERR_VAL;
 460   }
 461
 462   conn->err = err;
 463   if (conn->type == NETCONN_TCP && err == ERR_OK) {
 464     setup_tcp(conn);
 465   }
 466   sys_mbox_post(conn->mbox, NULL);
 467   return ERR_OK;
 468 }
 469 #endif
 470
 471 static void
 472 do_connect(struct api_msg_msg *msg)
 473 {
 474   if (msg->conn->pcb.tcp == NULL) {
 475     switch (msg->conn->type) {
 476 #if LWIP_RAW
 477     case NETCONN_RAW:
 478       msg->conn->pcb.raw = raw_new(msg->msg.bc.port); /* misusing the port field as protocol */
 479       raw_recv(msg->conn->pcb.raw, recv_raw, msg->conn);
 480       break;
 481 #endif
 482 #if LWIP_UDP
 483     case NETCONN_UDPLITE:
 484       msg->conn->pcb.udp = udp_new();
 485       if (msg->conn->pcb.udp == NULL) {
 486   msg->conn->err = ERR_MEM;
 487   sys_mbox_post(msg->conn->mbox, NULL);
 488   return;
 489       }
 490       udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_UDPLITE);
 491       udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
 492       break;
 493     case NETCONN_UDPNOCHKSUM:
 494       msg->conn->pcb.udp = udp_new();
 495       if (msg->conn->pcb.udp == NULL) {
 496   msg->conn->err = ERR_MEM;
 497   sys_mbox_post(msg->conn->mbox, NULL);
 498   return;
 499       }
 500       udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_NOCHKSUM);
 501       udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
 502       break;
 503     case NETCONN_UDP:
 504       msg->conn->pcb.udp = udp_new();
 505       if (msg->conn->pcb.udp == NULL) {
 506   msg->conn->err = ERR_MEM;
 507   sys_mbox_post(msg->conn->mbox, NULL);
 508   return;
 509       }
 510       udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
 511       break;
 512 #endif /* LWIP_UDP */
 513 #if LWIP_TCP
 514     case NETCONN_TCP:
 515       msg->conn->pcb.tcp = tcp_new();
 516       if (msg->conn->pcb.tcp == NULL) {
 517   msg->conn->err = ERR_MEM;
 518   sys_mbox_post(msg->conn->mbox, NULL);
 519   return;
 520       }
 521 #endif
 522     default:
 523       break;
 524     }
 525   }
 526   switch (msg->conn->type) {
 527 #if LWIP_RAW
 528   case NETCONN_RAW:
 529     raw_connect(msg->conn->pcb.raw, msg->msg.bc.ipaddr);
 530     sys_mbox_post(msg->conn->mbox, NULL);
 531     break;
 532 #endif
 533 #if LWIP_UDP
 534   case NETCONN_UDPLITE:
 535     /* FALLTHROUGH */
 536   case NETCONN_UDPNOCHKSUM:
 537     /* FALLTHROUGH */
 538   case NETCONN_UDP:
 539     udp_connect(msg->conn->pcb.udp, msg->msg.bc.ipaddr, msg->msg.bc.port);
 540     sys_mbox_post(msg->conn->mbox, NULL);
 541     break;
 542 #endif
 543 #if LWIP_TCP
 544   case NETCONN_TCP:
 545     /*    tcp_arg(msg->conn->pcb.tcp, msg->conn);*/
 546     setup_tcp(msg->conn);
 547     tcp_connect(msg->conn->pcb.tcp, msg->msg.bc.ipaddr, msg->msg.bc.port,
 548     do_connected);
 549     /*tcp_output(msg->conn->pcb.tcp);*/
 550 #endif
 551
 552   default:
 553     break;
 554   }
 555 }
 556
 557 static void
 558 do_disconnect(struct api_msg_msg *msg)
 559 {
 560
 561   switch (msg->conn->type) {
 562 #if LWIP_RAW
 563   case NETCONN_RAW:
 564     /* Do nothing as connecting is only a helper for upper lwip layers */
 565     break;
 566 #endif
 567 #if LWIP_UDP
 568   case NETCONN_UDPLITE:
 569     /* FALLTHROUGH */
 570   case NETCONN_UDPNOCHKSUM:
 571     /* FALLTHROUGH */
 572   case NETCONN_UDP:
 573     udp_disconnect(msg->conn->pcb.udp);
 574     break;
 575 #endif
 576   case NETCONN_TCP:
 577     break;
 578   }
 579   sys_mbox_post(msg->conn->mbox, NULL);
 580 }
 581
 582
 583 static void
 584 do_listen(struct api_msg_msg *msg)
 585 {
 586   if (msg->conn->pcb.tcp != NULL) {
 587     switch (msg->conn->type) {
 588 #if LWIP_RAW
 589     case NETCONN_RAW:
 590       LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: listen RAW: cannot listen for RAW.\n"));
 591       break;
 592 #endif
 593 #if LWIP_UDP
 594     case NETCONN_UDPLITE:
 595       /* FALLTHROUGH */
 596     case NETCONN_UDPNOCHKSUM:
 597       /* FALLTHROUGH */
 598     case NETCONN_UDP:
 599       LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: listen UDP: cannot listen for UDP.\n"));
 600       break;
 601 #endif /* LWIP_UDP */
 602 #if LWIP_TCP
 603     case NETCONN_TCP:
 604       msg->conn->pcb.tcp = tcp_listen(msg->conn->pcb.tcp);
 605       if (msg->conn->pcb.tcp == NULL) {
 606   msg->conn->err = ERR_MEM;
 607       } else {
 608   if (msg->conn->acceptmbox == SYS_MBOX_NULL) {
 609     msg->conn->acceptmbox = sys_mbox_new();
 610     if (msg->conn->acceptmbox == SYS_MBOX_NULL) {
 611       msg->conn->err = ERR_MEM;
 612       break;
 613     }
 614   }
 615   tcp_arg(msg->conn->pcb.tcp, msg->conn);
 616   tcp_accept(msg->conn->pcb.tcp, accept_function);
 617       }
 618 #endif
 619     default:
 620       break;
 621     }
 622   }
 623   sys_mbox_post(msg->conn->mbox, NULL);
 624 }
 625
 626 static void
 627 do_accept(struct api_msg_msg *msg)
 628 {
 629   if (msg->conn->pcb.tcp != NULL) {
 630     switch (msg->conn->type) {
 631 #if LWIP_RAW
 632     case NETCONN_RAW:
 633       LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: accept RAW: cannot accept for RAW.\n"));
 634       break;
 635 #endif
 636 #if LWIP_UDP
 637     case NETCONN_UDPLITE:
 638       /* FALLTHROUGH */
 639     case NETCONN_UDPNOCHKSUM:
 640       /* FALLTHROUGH */
 641     case NETCONN_UDP:
 642       LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: accept UDP: cannot accept for UDP.\n"));
 643       break;
 644 #endif /* LWIP_UDP */
 645     case NETCONN_TCP:
 646       break;
 647     }
 648   }
 649 }
 650
 651 static void
 652 do_send(struct api_msg_msg *msg)
 653 {
 654   if (msg->conn->pcb.tcp != NULL) {
 655     switch (msg->conn->type) {
 656 #if LWIP_RAW
 657     case NETCONN_RAW:
 658       raw_send(msg->conn->pcb.raw, msg->msg.p);
 659       break;
 660 #endif
 661 #if LWIP_UDP
 662     case NETCONN_UDPLITE:
 663       /* FALLTHROUGH */
 664     case NETCONN_UDPNOCHKSUM:
 665       /* FALLTHROUGH */
 666     case NETCONN_UDP:
 667       udp_send(msg->conn->pcb.udp, msg->msg.p);
 668       break;
 669 #endif /* LWIP_UDP */
 670     case NETCONN_TCP:
 671       break;
 672     }
 673   }
 674   sys_mbox_post(msg->conn->mbox, NULL);
 675 }
 676
 677 static void
 678 do_recv(struct api_msg_msg *msg)
 679 {
 680 #if LWIP_TCP
 681   if (msg->conn->pcb.tcp != NULL) {
 682     if (msg->conn->type == NETCONN_TCP) {
 683       tcp_recved(msg->conn->pcb.tcp, msg->msg.len);
 684     }
 685   }
 686 #endif
 687   sys_mbox_post(msg->conn->mbox, NULL);
 688 }
 689
 690 static void
 691 do_write(struct api_msg_msg *msg)
 692 {
 693 #if LWIP_TCP
 694   err_t err;
 695 #endif
 696   if (msg->conn->pcb.tcp != NULL) {
 697     switch (msg->conn->type) {
 698 #if LWIP_RAW
 699     case NETCONN_RAW:
 700       msg->conn->err = ERR_VAL;
 701       break;
 702 #endif
 703 #if LWIP_UDP
 704     case NETCONN_UDPLITE:
 705       /* FALLTHROUGH */
 706     case NETCONN_UDPNOCHKSUM:
 707       /* FALLTHROUGH */
 708     case NETCONN_UDP:
 709       msg->conn->err = ERR_VAL;
 710       break;
 711 #endif /* LWIP_UDP */
 712 #if LWIP_TCP
 713     case NETCONN_TCP:
 714       err = tcp_write(msg->conn->pcb.tcp, msg->msg.w.dataptr,
 715                       msg->msg.w.len, msg->msg.w.copy);
 716       /* This is the Nagle algorithm: inhibit the sending of new TCP
 717    segments when new outgoing data arrives from the user if any
 718    previously transmitted data on the connection remains
 719    unacknowledged. */
 720       if(err == ERR_OK && (msg->conn->pcb.tcp->unacked == NULL || (msg->conn->pcb.tcp->flags & TF_NODELAY)) ) {
 721   tcp_output(msg->conn->pcb.tcp);
 722       }
 723       msg->conn->err = err;
 724       if (msg->conn->callback)
 725           if (err == ERR_OK)
 726           {
 727               if (tcp_sndbuf(msg->conn->pcb.tcp) <= TCP_SNDLOWAT)
 728                   (*msg->conn->callback)(msg->conn, NETCONN_EVT_SENDMINUS, msg->msg.w.len);
 729           }
 730 #endif
 731     default:
 732       break;
 733     }
 734   }
 735   sys_mbox_post(msg->conn->mbox, NULL);
 736 }
 737
 738 static void
 739 do_close(struct api_msg_msg *msg)
 740 {
 741   err_t err;
 742
 743   err = ERR_OK;
 744
 745   if (msg->conn->pcb.tcp != NULL) {
 746     switch (msg->conn->type) {
 747 #if LWIP_RAW
 748     case NETCONN_RAW:
 749       break;
 750 #endif
 751 #if LWIP_UDP
 752     case NETCONN_UDPLITE:
 753       /* FALLTHROUGH */
 754     case NETCONN_UDPNOCHKSUM:
 755       /* FALLTHROUGH */
 756     case NETCONN_UDP:
 757       break;
 758 #endif /* LWIP_UDP */
 759 #if LWIP_TCP
 760     case NETCONN_TCP:
 761       if (msg->conn->pcb.tcp->state == LISTEN) {
 762   err = tcp_close(msg->conn->pcb.tcp);
 763       }
 764       msg->conn->err = err;
 765 #endif
 766     default:
 767       break;
 768     }
 769   }
 770   sys_mbox_post(msg->conn->mbox, NULL);
 771 }
 772
 773 typedef void (* api_msg_decode)(struct api_msg_msg *msg);
 774 static api_msg_decode decode[API_MSG_MAX] = {
 775   do_newconn,
 776   do_delconn,
 777   do_bind,
 778   do_connect,
 779   do_disconnect,
 780   do_listen,
 781   do_accept,
 782   do_send,
 783   do_recv,
 784   do_write,
 785   do_close
 786   };
 787 void
 788 api_msg_input(struct api_msg *msg)
 789 {
 790   decode[msg->type](&(msg->msg));
 791 }
 792
 793 void
 794 api_msg_post(struct api_msg *msg)
 795 {
 796   tcpip_apimsg(msg);
 797 }
 798
 799
 800