OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [Common/] [ethernet/] [lwIP/] [api/] [api_msg.c] - Blame information for rev 606

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 606 jeremybenn 
/*
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 u8_t
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->recvmbox = sys_mbox_new();
232 
  if (newconn->recvmbox == SYS_MBOX_NULL) {
233 
    memp_free(MEMP_NETCONN, newconn);
234 
    return ERR_MEM;
235 
  }
236 
  newconn->mbox = sys_mbox_new();
237 
  if (newconn->mbox == SYS_MBOX_NULL) {
238 
    sys_mbox_free(newconn->recvmbox);
239 
    memp_free(MEMP_NETCONN, newconn);
240 
    return ERR_MEM;
241 
  }
242 
  newconn->sem = sys_sem_new(0);
243 
  if (newconn->sem == SYS_SEM_NULL) {
244 
    sys_mbox_free(newconn->recvmbox);
245 
    sys_mbox_free(newconn->mbox);
246 
    memp_free(MEMP_NETCONN, newconn);
247 
    return ERR_MEM;
248 
  }
249 
  /* Allocations were OK, setup the PCB etc */
250 
  newconn->type = NETCONN_TCP;
251 
  newconn->pcb.tcp = newpcb;
252 
  setup_tcp(newconn);
253 
  newconn->acceptmbox = SYS_MBOX_NULL;
254 
  newconn->err = err;
255 
  /* Register event with callback */
256 
  if (conn->callback)
257 
  {
258 
    (*conn->callback)(conn, NETCONN_EVT_RCVPLUS, 0);
259 
  }
260 
  /* We have to set the callback here even though
261 
   * the new socket is unknown. Mark the socket as -1. */
262 
  newconn->callback = conn->callback;
263 
  newconn->socket = -1;
264 
  newconn->recv_avail = 0;
265 
 
266 
  sys_mbox_post(mbox, newconn);
267 
  return ERR_OK;
268 
}
269 
#endif /* LWIP_TCP */
270 
 
271 
static void
272 
do_newconn(struct api_msg_msg *msg)
273 
{
274 
   if(msg->conn->pcb.tcp != NULL) {
275 
   /* This "new" connection already has a PCB allocated. */
276 
   /* Is this an error condition? Should it be deleted?
277 
      We currently just are happy and return. */
278 
     sys_mbox_post(msg->conn->mbox, NULL);
279 
     return;
280 
   }
281 
 
282 
   msg->conn->err = ERR_OK;
283 
 
284 
   /* Allocate a PCB for this connection */
285 
   switch(msg->conn->type) {
286 
#if LWIP_RAW
287 
   case NETCONN_RAW:
288 
      msg->conn->pcb.raw = raw_new(msg->msg.bc.port); /* misusing the port field */
289 
      raw_recv(msg->conn->pcb.raw, recv_raw, msg->conn);
290 
     break;
291 
#endif
292 
#if LWIP_UDP
293 
   case NETCONN_UDPLITE:
294 
      msg->conn->pcb.udp = udp_new();
295 
      if(msg->conn->pcb.udp == NULL) {
296 
         msg->conn->err = ERR_MEM;
297 
         break;
298 
      }
299 
      udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_UDPLITE);
300 
      udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
301 
      break;
302 
   case NETCONN_UDPNOCHKSUM:
303 
      msg->conn->pcb.udp = udp_new();
304 
      if(msg->conn->pcb.udp == NULL) {
305 
         msg->conn->err = ERR_MEM;
306 
         break;
307 
      }
308 
      udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_NOCHKSUM);
309 
      udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
310 
      break;
311 
   case NETCONN_UDP:
312 
      msg->conn->pcb.udp = udp_new();
313 
      if(msg->conn->pcb.udp == NULL) {
314 
         msg->conn->err = ERR_MEM;
315 
         break;
316 
      }
317 
      udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
318 
      break;
319 
#endif /* LWIP_UDP */
320 
#if LWIP_TCP
321 
   case NETCONN_TCP:
322 
      msg->conn->pcb.tcp = tcp_new();
323 
      if(msg->conn->pcb.tcp == NULL) {
324 
         msg->conn->err = ERR_MEM;
325 
         break;
326 
      }
327 
      setup_tcp(msg->conn);
328 
      break;
329 
#endif
330 
   }
331 
 
332 
 
333 
  sys_mbox_post(msg->conn->mbox, NULL);
334 
}
335 
 
336 
 
337 
static void
338 
do_delconn(struct api_msg_msg *msg)
339 
{
340 
  if (msg->conn->pcb.tcp != NULL) {
341 
    switch (msg->conn->type) {
342 
#if LWIP_RAW
343 
    case NETCONN_RAW:
344 
      raw_remove(msg->conn->pcb.raw);
345 
      break;
346 
#endif
347 
#if LWIP_UDP
348 
    case NETCONN_UDPLITE:
349 
      /* FALLTHROUGH */
350 
    case NETCONN_UDPNOCHKSUM:
351 
      /* FALLTHROUGH */
352 
    case NETCONN_UDP:
353 
      msg->conn->pcb.udp->recv_arg = NULL;
354 
      udp_remove(msg->conn->pcb.udp);
355 
      break;
356 
#endif /* LWIP_UDP */
357 
#if LWIP_TCP
358 
    case NETCONN_TCP:
359 
      if (msg->conn->pcb.tcp->state == LISTEN) {
360 
  tcp_arg(msg->conn->pcb.tcp, NULL);
361 
  tcp_accept(msg->conn->pcb.tcp, NULL);
362 
  tcp_close(msg->conn->pcb.tcp);
363 
      } else {
364 
  tcp_arg(msg->conn->pcb.tcp, NULL);
365 
  tcp_sent(msg->conn->pcb.tcp, NULL);
366 
  tcp_recv(msg->conn->pcb.tcp, NULL);
367 
  tcp_poll(msg->conn->pcb.tcp, NULL, 0);
368 
  tcp_err(msg->conn->pcb.tcp, NULL);
369 
  if (tcp_close(msg->conn->pcb.tcp) != ERR_OK) {
370 
    tcp_abort(msg->conn->pcb.tcp);
371 
  }
372 
      }
373 
#endif
374 
    default:
375 
    break;
376 
    }
377 
  }
378 
  /* Trigger select() in socket layer */
379 
  if (msg->conn->callback)
380 
  {
381 
      (*msg->conn->callback)(msg->conn, NETCONN_EVT_RCVPLUS, 0);
382 
      (*msg->conn->callback)(msg->conn, NETCONN_EVT_SENDPLUS, 0);
383 
  }
384 
 
385 
  if (msg->conn->mbox != SYS_MBOX_NULL) {
386 
    sys_mbox_post(msg->conn->mbox, NULL);
387 
  }
388 
}
389 
 
390 
static void
391 
do_bind(struct api_msg_msg *msg)
392 
{
393 
  if (msg->conn->pcb.tcp == NULL) {
394 
    switch (msg->conn->type) {
395 
#if LWIP_RAW
396 
    case NETCONN_RAW:
397 
      msg->conn->pcb.raw = raw_new(msg->msg.bc.port); /* misusing the port field as protocol */
398 
      raw_recv(msg->conn->pcb.raw, recv_raw, msg->conn);
399 
      break;
400 
#endif
401 
#if LWIP_UDP
402 
    case NETCONN_UDPLITE:
403 
      msg->conn->pcb.udp = udp_new();
404 
      udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_UDPLITE);
405 
      udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
406 
      break;
407 
    case NETCONN_UDPNOCHKSUM:
408 
      msg->conn->pcb.udp = udp_new();
409 
      udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_NOCHKSUM);
410 
      udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
411 
      break;
412 
    case NETCONN_UDP:
413 
      msg->conn->pcb.udp = udp_new();
414 
      udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
415 
      break;
416 
#endif /* LWIP_UDP */
417 
#if LWIP_TCP
418 
    case NETCONN_TCP:
419 
      msg->conn->pcb.tcp = tcp_new();
420 
      setup_tcp(msg->conn);
421 
#endif /* LWIP_TCP */
422 
    default:
423 
    break;
424 
    }
425 
  }
426 
  switch (msg->conn->type) {
427 
#if LWIP_RAW
428 
  case NETCONN_RAW:
429 
    msg->conn->err = raw_bind(msg->conn->pcb.raw,msg->msg.bc.ipaddr);
430 
    break;
431 
#endif
432 
#if LWIP_UDP
433 
  case NETCONN_UDPLITE:
434 
    /* FALLTHROUGH */
435 
  case NETCONN_UDPNOCHKSUM:
436 
    /* FALLTHROUGH */
437 
  case NETCONN_UDP:
438 
    msg->conn->err = udp_bind(msg->conn->pcb.udp, msg->msg.bc.ipaddr, msg->msg.bc.port);
439 
    break;
440 
#endif /* LWIP_UDP */
441 
#if LWIP_TCP
442 
  case NETCONN_TCP:
443 
    msg->conn->err = tcp_bind(msg->conn->pcb.tcp,
444 
            msg->msg.bc.ipaddr, msg->msg.bc.port);
445 
#endif /* LWIP_TCP */
446 
  default:
447 
    break;
448 
  }
449 
  sys_mbox_post(msg->conn->mbox, NULL);
450 
}
451 
#if LWIP_TCP
452 
 
453 
static err_t
454 
do_connected(void *arg, struct tcp_pcb *pcb, err_t err)
455 
{
456 
  struct netconn *conn;
457 
 
458 
  conn = arg;
459 
 
460 
  if (conn == NULL) {
461 
    return ERR_VAL;
462 
  }
463 
 
464 
  conn->err = err;
465 
  if (conn->type == NETCONN_TCP && err == ERR_OK) {
466 
    setup_tcp(conn);
467 
  }
468 
  sys_mbox_post(conn->mbox, NULL);
469 
  return ERR_OK;
470 
}
471 
#endif
472 
 
473 
static void
474 
do_connect(struct api_msg_msg *msg)
475 
{
476 
  if (msg->conn->pcb.tcp == NULL) {
477 
    switch (msg->conn->type) {
478 
#if LWIP_RAW
479 
    case NETCONN_RAW:
480 
      msg->conn->pcb.raw = raw_new(msg->msg.bc.port); /* misusing the port field as protocol */
481 
      raw_recv(msg->conn->pcb.raw, recv_raw, msg->conn);
482 
      break;
483 
#endif
484 
#if LWIP_UDP
485 
    case NETCONN_UDPLITE:
486 
      msg->conn->pcb.udp = udp_new();
487 
      if (msg->conn->pcb.udp == NULL) {
488 
  msg->conn->err = ERR_MEM;
489 
  sys_mbox_post(msg->conn->mbox, NULL);
490 
  return;
491 
      }
492 
      udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_UDPLITE);
493 
      udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
494 
      break;
495 
    case NETCONN_UDPNOCHKSUM:
496 
      msg->conn->pcb.udp = udp_new();
497 
      if (msg->conn->pcb.udp == NULL) {
498 
  msg->conn->err = ERR_MEM;
499 
  sys_mbox_post(msg->conn->mbox, NULL);
500 
  return;
501 
      }
502 
      udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_NOCHKSUM);
503 
      udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
504 
      break;
505 
    case NETCONN_UDP:
506 
      msg->conn->pcb.udp = udp_new();
507 
      if (msg->conn->pcb.udp == NULL) {
508 
  msg->conn->err = ERR_MEM;
509 
  sys_mbox_post(msg->conn->mbox, NULL);
510 
  return;
511 
      }
512 
      udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
513 
      break;
514 
#endif /* LWIP_UDP */
515 
#if LWIP_TCP
516 
    case NETCONN_TCP:
517 
      msg->conn->pcb.tcp = tcp_new();
518 
      if (msg->conn->pcb.tcp == NULL) {
519 
  msg->conn->err = ERR_MEM;
520 
  sys_mbox_post(msg->conn->mbox, NULL);
521 
  return;
522 
      }
523 
#endif
524 
    default:
525 
      break;
526 
    }
527 
  }
528 
  switch (msg->conn->type) {
529 
#if LWIP_RAW
530 
  case NETCONN_RAW:
531 
    raw_connect(msg->conn->pcb.raw, msg->msg.bc.ipaddr);
532 
    sys_mbox_post(msg->conn->mbox, NULL);
533 
    break;
534 
#endif
535 
#if LWIP_UDP
536 
  case NETCONN_UDPLITE:
537 
    /* FALLTHROUGH */
538 
  case NETCONN_UDPNOCHKSUM:
539 
    /* FALLTHROUGH */
540 
  case NETCONN_UDP:
541 
    udp_connect(msg->conn->pcb.udp, msg->msg.bc.ipaddr, msg->msg.bc.port);
542 
    sys_mbox_post(msg->conn->mbox, NULL);
543 
    break;
544 
#endif
545 
#if LWIP_TCP
546 
  case NETCONN_TCP:
547 
    /*    tcp_arg(msg->conn->pcb.tcp, msg->conn);*/
548 
    setup_tcp(msg->conn);
549 
    tcp_connect(msg->conn->pcb.tcp, msg->msg.bc.ipaddr, msg->msg.bc.port,
550 
    do_connected);
551 
    /*tcp_output(msg->conn->pcb.tcp);*/
552 
#endif
553 
 
554 
  default:
555 
    break;
556 
  }
557 
}
558 
 
559 
static void
560 
do_disconnect(struct api_msg_msg *msg)
561 
{
562 
 
563 
  switch (msg->conn->type) {
564 
#if LWIP_RAW
565 
  case NETCONN_RAW:
566 
    /* Do nothing as connecting is only a helper for upper lwip layers */
567 
    break;
568 
#endif
569 
#if LWIP_UDP
570 
  case NETCONN_UDPLITE:
571 
    /* FALLTHROUGH */
572 
  case NETCONN_UDPNOCHKSUM:
573 
    /* FALLTHROUGH */
574 
  case NETCONN_UDP:
575 
    udp_disconnect(msg->conn->pcb.udp);
576 
    break;
577 
#endif
578 
  case NETCONN_TCP:
579 
    break;
580 
  }
581 
  sys_mbox_post(msg->conn->mbox, NULL);
582 
}
583 
 
584 
 
585 
static void
586 
do_listen(struct api_msg_msg *msg)
587 
{
588 
  if (msg->conn->pcb.tcp != NULL) {
589 
    switch (msg->conn->type) {
590 
#if LWIP_RAW
591 
    case NETCONN_RAW:
592 
      LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: listen RAW: cannot listen for RAW.\n"));
593 
      break;
594 
#endif
595 
#if LWIP_UDP
596 
    case NETCONN_UDPLITE:
597 
      /* FALLTHROUGH */
598 
    case NETCONN_UDPNOCHKSUM:
599 
      /* FALLTHROUGH */
600 
    case NETCONN_UDP:
601 
      LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: listen UDP: cannot listen for UDP.\n"));
602 
      break;
603 
#endif /* LWIP_UDP */
604 
#if LWIP_TCP
605 
    case NETCONN_TCP:
606 
      msg->conn->pcb.tcp = tcp_listen(msg->conn->pcb.tcp);
607 
      if (msg->conn->pcb.tcp == NULL) {
608 
  msg->conn->err = ERR_MEM;
609 
      } else {
610 
  if (msg->conn->acceptmbox == SYS_MBOX_NULL) {
611 
    msg->conn->acceptmbox = sys_mbox_new();
612 
    if (msg->conn->acceptmbox == SYS_MBOX_NULL) {
613 
      msg->conn->err = ERR_MEM;
614 
      break;
615 
    }
616 
  }
617 
  tcp_arg(msg->conn->pcb.tcp, msg->conn);
618 
  tcp_accept(msg->conn->pcb.tcp, accept_function);
619 
      }
620 
#endif
621 
    default:
622 
      break;
623 
    }
624 
  }
625 
  sys_mbox_post(msg->conn->mbox, NULL);
626 
}
627 
 
628 
static void
629 
do_accept(struct api_msg_msg *msg)
630 
{
631 
  if (msg->conn->pcb.tcp != NULL) {
632 
    switch (msg->conn->type) {
633 
#if LWIP_RAW
634 
    case NETCONN_RAW:
635 
      LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: accept RAW: cannot accept for RAW.\n"));
636 
      break;
637 
#endif
638 
#if LWIP_UDP
639 
    case NETCONN_UDPLITE:
640 
      /* FALLTHROUGH */
641 
    case NETCONN_UDPNOCHKSUM:
642 
      /* FALLTHROUGH */
643 
    case NETCONN_UDP:
644 
      LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: accept UDP: cannot accept for UDP.\n"));
645 
      break;
646 
#endif /* LWIP_UDP */
647 
    case NETCONN_TCP:
648 
      break;
649 
    }
650 
  }
651 
}
652 
 
653 
static void
654 
do_send(struct api_msg_msg *msg)
655 
{
656 
  if (msg->conn->pcb.tcp != NULL) {
657 
    switch (msg->conn->type) {
658 
#if LWIP_RAW
659 
    case NETCONN_RAW:
660 
      raw_send(msg->conn->pcb.raw, msg->msg.p);
661 
      break;
662 
#endif
663 
#if LWIP_UDP
664 
    case NETCONN_UDPLITE:
665 
      /* FALLTHROUGH */
666 
    case NETCONN_UDPNOCHKSUM:
667 
      /* FALLTHROUGH */
668 
    case NETCONN_UDP:
669 
      udp_send(msg->conn->pcb.udp, msg->msg.p);
670 
      break;
671 
#endif /* LWIP_UDP */
672 
    case NETCONN_TCP:
673 
      break;
674 
    }
675 
  }
676 
  sys_mbox_post(msg->conn->mbox, NULL);
677 
}
678 
 
679 
static void
680 
do_recv(struct api_msg_msg *msg)
681 
{
682 
#if LWIP_TCP
683 
  if (msg->conn->pcb.tcp != NULL) {
684 
    if (msg->conn->type == NETCONN_TCP) {
685 
      tcp_recved(msg->conn->pcb.tcp, msg->msg.len);
686 
    }
687 
  }
688 
#endif
689 
  sys_mbox_post(msg->conn->mbox, NULL);
690 
}
691 
 
692 
static void
693 
do_write(struct api_msg_msg *msg)
694 
{
695 
#if LWIP_TCP
696 
  err_t err;
697 
#endif
698 
  if (msg->conn->pcb.tcp != NULL) {
699 
    switch (msg->conn->type) {
700 
#if LWIP_RAW
701 
    case NETCONN_RAW:
702 
      msg->conn->err = ERR_VAL;
703 
      break;
704 
#endif
705 
#if LWIP_UDP
706 
    case NETCONN_UDPLITE:
707 
      /* FALLTHROUGH */
708 
    case NETCONN_UDPNOCHKSUM:
709 
      /* FALLTHROUGH */
710 
    case NETCONN_UDP:
711 
      msg->conn->err = ERR_VAL;
712 
      break;
713 
#endif /* LWIP_UDP */
714 
#if LWIP_TCP
715 
    case NETCONN_TCP:
716 
      err = tcp_write(msg->conn->pcb.tcp, msg->msg.w.dataptr,
717 
                      msg->msg.w.len, msg->msg.w.copy);
718 
      /* This is the Nagle algorithm: inhibit the sending of new TCP
719 
   segments when new outgoing data arrives from the user if any
720 
   previously transmitted data on the connection remains
721 
   unacknowledged. */
722 
      if(err == ERR_OK && (msg->conn->pcb.tcp->unacked == NULL ||
723 
        (msg->conn->pcb.tcp->flags & TF_NODELAY) ||
724 
        (msg->conn->pcb.tcp->snd_queuelen) > 1)) {
725 
          tcp_output(msg->conn->pcb.tcp);
726 
      }
727 
      msg->conn->err = err;
728 
      if (msg->conn->callback)
729 
          if (err == ERR_OK)
730 
          {
731 
              if (tcp_sndbuf(msg->conn->pcb.tcp) <= TCP_SNDLOWAT)
732 
                  (*msg->conn->callback)(msg->conn, NETCONN_EVT_SENDMINUS, msg->msg.w.len);
733 
          }
734 
#endif
735 
    default:
736 
      break;
737 
    }
738 
  }
739 
  sys_mbox_post(msg->conn->mbox, NULL);
740 
}
741 
 
742 
static void
743 
do_close(struct api_msg_msg *msg)
744 
{
745 
  err_t err;
746 
 
747 
  err = ERR_OK;
748 
 
749 
  if (msg->conn->pcb.tcp != NULL) {
750 
    switch (msg->conn->type) {
751 
#if LWIP_RAW
752 
    case NETCONN_RAW:
753 
      break;
754 
#endif
755 
#if LWIP_UDP
756 
    case NETCONN_UDPLITE:
757 
      /* FALLTHROUGH */
758 
    case NETCONN_UDPNOCHKSUM:
759 
      /* FALLTHROUGH */
760 
    case NETCONN_UDP:
761 
      break;
762 
#endif /* LWIP_UDP */
763 
#if LWIP_TCP
764 
    case NETCONN_TCP:
765 
      if (msg->conn->pcb.tcp->state == LISTEN) {
766 
        err = tcp_close(msg->conn->pcb.tcp);
767 
      }
768 
      else if (msg->conn->pcb.tcp->state == CLOSE_WAIT) {
769 
        err = tcp_output(msg->conn->pcb.tcp);
770 
      }
771 
      msg->conn->err = err;
772 
#endif
773 
    default:
774 
      break;
775 
    }
776 
  }
777 
  sys_mbox_post(msg->conn->mbox, NULL);
778 
}
779 
 
780 
typedef void (* api_msg_decode)(struct api_msg_msg *msg);
781 
static api_msg_decode decode[API_MSG_MAX] = {
782 
  do_newconn,
783 
  do_delconn,
784 
  do_bind,
785 
  do_connect,
786 
  do_disconnect,
787 
  do_listen,
788 
  do_accept,
789 
  do_send,
790 
  do_recv,
791 
  do_write,
792 
  do_close
793 
  };
794 
void
795 
api_msg_input(struct api_msg *msg)
796 
{
797 
  decode[msg->type](&(msg->msg));
798 
}
799 
 
800 
void
801 
api_msg_post(struct api_msg *msg)
802 
{
803 
  tcpip_apimsg(msg);
804 
}
805 
 
806 
 
807 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.