URL
https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk
Subversion Repositories openrisc_2011-10-31
[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [Common/] [ethernet/] [lwIP/] [api/] [api_msg.c] - Rev 637
Go to most recent revision | Compare with Previous | Blame | View Log
/* * Copyright (c) 2001-2004 Swedish Institute of Computer Science. * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, * are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY * OF SUCH DAMAGE. * * This file is part of the lwIP TCP/IP stack. * * Author: Adam Dunkels <adam@sics.se> * */ #include "lwip/opt.h" #include "lwip/arch.h" #include "lwip/api_msg.h" #include "lwip/memp.h" #include "lwip/sys.h" #include "lwip/tcpip.h" #if LWIP_RAW static u8_t recv_raw(void *arg, struct raw_pcb *pcb, struct pbuf *p, struct ip_addr *addr) { struct netbuf *buf; struct netconn *conn; conn = arg; if (!conn) return 0; if (conn->recvmbox != SYS_MBOX_NULL) { if (!(buf = memp_malloc(MEMP_NETBUF))) { return 0; } pbuf_ref(p); buf->p = p; buf->ptr = p; buf->fromaddr = addr; buf->fromport = pcb->protocol; conn->recv_avail += p->tot_len; /* Register event with callback */ if (conn->callback) (*conn->callback)(conn, NETCONN_EVT_RCVPLUS, p->tot_len); sys_mbox_post(conn->recvmbox, buf); } return 0; /* do not eat the packet */ } #endif #if LWIP_UDP static void recv_udp(void *arg, struct udp_pcb *pcb, struct pbuf *p, struct ip_addr *addr, u16_t port) { struct netbuf *buf; struct netconn *conn; conn = arg; if (conn == NULL) { pbuf_free(p); return; } if (conn->recvmbox != SYS_MBOX_NULL) { buf = memp_malloc(MEMP_NETBUF); if (buf == NULL) { pbuf_free(p); return; } else { buf->p = p; buf->ptr = p; buf->fromaddr = addr; buf->fromport = port; } conn->recv_avail += p->tot_len; /* Register event with callback */ if (conn->callback) (*conn->callback)(conn, NETCONN_EVT_RCVPLUS, p->tot_len); sys_mbox_post(conn->recvmbox, buf); } } #endif /* LWIP_UDP */ #if LWIP_TCP static err_t recv_tcp(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err) { struct netconn *conn; u16_t len; conn = arg; if (conn == NULL) { pbuf_free(p); return ERR_VAL; } if (conn->recvmbox != SYS_MBOX_NULL) { conn->err = err; if (p != NULL) { len = p->tot_len; conn->recv_avail += len; } else len = 0; /* Register event with callback */ if (conn->callback) (*conn->callback)(conn, NETCONN_EVT_RCVPLUS, len); sys_mbox_post(conn->recvmbox, p); } return ERR_OK; } static err_t poll_tcp(void *arg, struct tcp_pcb *pcb) { struct netconn *conn; conn = arg; if (conn != NULL && (conn->state == NETCONN_WRITE || conn->state == NETCONN_CLOSE) && conn->sem != SYS_SEM_NULL) { sys_sem_signal(conn->sem); } return ERR_OK; } static err_t sent_tcp(void *arg, struct tcp_pcb *pcb, u16_t len) { struct netconn *conn; conn = arg; if (conn != NULL && conn->sem != SYS_SEM_NULL) { sys_sem_signal(conn->sem); } if (conn && conn->callback) if (tcp_sndbuf(conn->pcb.tcp) > TCP_SNDLOWAT) (*conn->callback)(conn, NETCONN_EVT_SENDPLUS, len); return ERR_OK; } static void err_tcp(void *arg, err_t err) { struct netconn *conn; conn = arg; conn->pcb.tcp = NULL; conn->err = err; if (conn->recvmbox != SYS_MBOX_NULL) { /* Register event with callback */ if (conn->callback) (*conn->callback)(conn, NETCONN_EVT_RCVPLUS, 0); sys_mbox_post(conn->recvmbox, NULL); } if (conn->mbox != SYS_MBOX_NULL) { sys_mbox_post(conn->mbox, NULL); } if (conn->acceptmbox != SYS_MBOX_NULL) { /* Register event with callback */ if (conn->callback) (*conn->callback)(conn, NETCONN_EVT_RCVPLUS, 0); sys_mbox_post(conn->acceptmbox, NULL); } if (conn->sem != SYS_SEM_NULL) { sys_sem_signal(conn->sem); } } static void setup_tcp(struct netconn *conn) { struct tcp_pcb *pcb; pcb = conn->pcb.tcp; tcp_arg(pcb, conn); tcp_recv(pcb, recv_tcp); tcp_sent(pcb, sent_tcp); tcp_poll(pcb, poll_tcp, 4); tcp_err(pcb, err_tcp); } static err_t accept_function(void *arg, struct tcp_pcb *newpcb, err_t err) { sys_mbox_t mbox; struct netconn *newconn; struct netconn *conn; #if API_MSG_DEBUG #if TCP_DEBUG tcp_debug_print_state(newpcb->state); #endif /* TCP_DEBUG */ #endif /* API_MSG_DEBUG */ conn = (struct netconn *)arg; mbox = conn->acceptmbox; newconn = memp_malloc(MEMP_NETCONN); if (newconn == NULL) { return ERR_MEM; } newconn->recvmbox = sys_mbox_new(); if (newconn->recvmbox == SYS_MBOX_NULL) { memp_free(MEMP_NETCONN, newconn); return ERR_MEM; } newconn->mbox = sys_mbox_new(); if (newconn->mbox == SYS_MBOX_NULL) { sys_mbox_free(newconn->recvmbox); memp_free(MEMP_NETCONN, newconn); return ERR_MEM; } newconn->sem = sys_sem_new(0); if (newconn->sem == SYS_SEM_NULL) { sys_mbox_free(newconn->recvmbox); sys_mbox_free(newconn->mbox); memp_free(MEMP_NETCONN, newconn); return ERR_MEM; } /* Allocations were OK, setup the PCB etc */ newconn->type = NETCONN_TCP; newconn->pcb.tcp = newpcb; setup_tcp(newconn); newconn->acceptmbox = SYS_MBOX_NULL; newconn->err = err; /* Register event with callback */ if (conn->callback) { (*conn->callback)(conn, NETCONN_EVT_RCVPLUS, 0); } /* We have to set the callback here even though * the new socket is unknown. Mark the socket as -1. */ newconn->callback = conn->callback; newconn->socket = -1; newconn->recv_avail = 0; sys_mbox_post(mbox, newconn); return ERR_OK; } #endif /* LWIP_TCP */ static void do_newconn(struct api_msg_msg *msg) { if(msg->conn->pcb.tcp != NULL) { /* This "new" connection already has a PCB allocated. */ /* Is this an error condition? Should it be deleted? We currently just are happy and return. */ sys_mbox_post(msg->conn->mbox, NULL); return; } msg->conn->err = ERR_OK; /* Allocate a PCB for this connection */ switch(msg->conn->type) { #if LWIP_RAW case NETCONN_RAW: msg->conn->pcb.raw = raw_new(msg->msg.bc.port); /* misusing the port field */ raw_recv(msg->conn->pcb.raw, recv_raw, msg->conn); break; #endif #if LWIP_UDP case NETCONN_UDPLITE: msg->conn->pcb.udp = udp_new(); if(msg->conn->pcb.udp == NULL) { msg->conn->err = ERR_MEM; break; } udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_UDPLITE); udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn); break; case NETCONN_UDPNOCHKSUM: msg->conn->pcb.udp = udp_new(); if(msg->conn->pcb.udp == NULL) { msg->conn->err = ERR_MEM; break; } udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_NOCHKSUM); udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn); break; case NETCONN_UDP: msg->conn->pcb.udp = udp_new(); if(msg->conn->pcb.udp == NULL) { msg->conn->err = ERR_MEM; break; } udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn); break; #endif /* LWIP_UDP */ #if LWIP_TCP case NETCONN_TCP: msg->conn->pcb.tcp = tcp_new(); if(msg->conn->pcb.tcp == NULL) { msg->conn->err = ERR_MEM; break; } setup_tcp(msg->conn); break; #endif } sys_mbox_post(msg->conn->mbox, NULL); } static void do_delconn(struct api_msg_msg *msg) { if (msg->conn->pcb.tcp != NULL) { switch (msg->conn->type) { #if LWIP_RAW case NETCONN_RAW: raw_remove(msg->conn->pcb.raw); break; #endif #if LWIP_UDP case NETCONN_UDPLITE: /* FALLTHROUGH */ case NETCONN_UDPNOCHKSUM: /* FALLTHROUGH */ case NETCONN_UDP: msg->conn->pcb.udp->recv_arg = NULL; udp_remove(msg->conn->pcb.udp); break; #endif /* LWIP_UDP */ #if LWIP_TCP case NETCONN_TCP: if (msg->conn->pcb.tcp->state == LISTEN) { tcp_arg(msg->conn->pcb.tcp, NULL); tcp_accept(msg->conn->pcb.tcp, NULL); tcp_close(msg->conn->pcb.tcp); } else { tcp_arg(msg->conn->pcb.tcp, NULL); tcp_sent(msg->conn->pcb.tcp, NULL); tcp_recv(msg->conn->pcb.tcp, NULL); tcp_poll(msg->conn->pcb.tcp, NULL, 0); tcp_err(msg->conn->pcb.tcp, NULL); if (tcp_close(msg->conn->pcb.tcp) != ERR_OK) { tcp_abort(msg->conn->pcb.tcp); } } #endif default: break; } } /* Trigger select() in socket layer */ if (msg->conn->callback) { (*msg->conn->callback)(msg->conn, NETCONN_EVT_RCVPLUS, 0); (*msg->conn->callback)(msg->conn, NETCONN_EVT_SENDPLUS, 0); } if (msg->conn->mbox != SYS_MBOX_NULL) { sys_mbox_post(msg->conn->mbox, NULL); } } static void do_bind(struct api_msg_msg *msg) { if (msg->conn->pcb.tcp == NULL) { switch (msg->conn->type) { #if LWIP_RAW case NETCONN_RAW: msg->conn->pcb.raw = raw_new(msg->msg.bc.port); /* misusing the port field as protocol */ raw_recv(msg->conn->pcb.raw, recv_raw, msg->conn); break; #endif #if LWIP_UDP case NETCONN_UDPLITE: msg->conn->pcb.udp = udp_new(); udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_UDPLITE); udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn); break; case NETCONN_UDPNOCHKSUM: msg->conn->pcb.udp = udp_new(); udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_NOCHKSUM); udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn); break; case NETCONN_UDP: msg->conn->pcb.udp = udp_new(); udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn); break; #endif /* LWIP_UDP */ #if LWIP_TCP case NETCONN_TCP: msg->conn->pcb.tcp = tcp_new(); setup_tcp(msg->conn); #endif /* LWIP_TCP */ default: break; } } switch (msg->conn->type) { #if LWIP_RAW case NETCONN_RAW: msg->conn->err = raw_bind(msg->conn->pcb.raw,msg->msg.bc.ipaddr); break; #endif #if LWIP_UDP case NETCONN_UDPLITE: /* FALLTHROUGH */ case NETCONN_UDPNOCHKSUM: /* FALLTHROUGH */ case NETCONN_UDP: msg->conn->err = udp_bind(msg->conn->pcb.udp, msg->msg.bc.ipaddr, msg->msg.bc.port); break; #endif /* LWIP_UDP */ #if LWIP_TCP case NETCONN_TCP: msg->conn->err = tcp_bind(msg->conn->pcb.tcp, msg->msg.bc.ipaddr, msg->msg.bc.port); #endif /* LWIP_TCP */ default: break; } sys_mbox_post(msg->conn->mbox, NULL); } #if LWIP_TCP static err_t do_connected(void *arg, struct tcp_pcb *pcb, err_t err) { struct netconn *conn; conn = arg; if (conn == NULL) { return ERR_VAL; } conn->err = err; if (conn->type == NETCONN_TCP && err == ERR_OK) { setup_tcp(conn); } sys_mbox_post(conn->mbox, NULL); return ERR_OK; } #endif static void do_connect(struct api_msg_msg *msg) { if (msg->conn->pcb.tcp == NULL) { switch (msg->conn->type) { #if LWIP_RAW case NETCONN_RAW: msg->conn->pcb.raw = raw_new(msg->msg.bc.port); /* misusing the port field as protocol */ raw_recv(msg->conn->pcb.raw, recv_raw, msg->conn); break; #endif #if LWIP_UDP case NETCONN_UDPLITE: msg->conn->pcb.udp = udp_new(); if (msg->conn->pcb.udp == NULL) { msg->conn->err = ERR_MEM; sys_mbox_post(msg->conn->mbox, NULL); return; } udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_UDPLITE); udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn); break; case NETCONN_UDPNOCHKSUM: msg->conn->pcb.udp = udp_new(); if (msg->conn->pcb.udp == NULL) { msg->conn->err = ERR_MEM; sys_mbox_post(msg->conn->mbox, NULL); return; } udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_NOCHKSUM); udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn); break; case NETCONN_UDP: msg->conn->pcb.udp = udp_new(); if (msg->conn->pcb.udp == NULL) { msg->conn->err = ERR_MEM; sys_mbox_post(msg->conn->mbox, NULL); return; } udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn); break; #endif /* LWIP_UDP */ #if LWIP_TCP case NETCONN_TCP: msg->conn->pcb.tcp = tcp_new(); if (msg->conn->pcb.tcp == NULL) { msg->conn->err = ERR_MEM; sys_mbox_post(msg->conn->mbox, NULL); return; } #endif default: break; } } switch (msg->conn->type) { #if LWIP_RAW case NETCONN_RAW: raw_connect(msg->conn->pcb.raw, msg->msg.bc.ipaddr); sys_mbox_post(msg->conn->mbox, NULL); break; #endif #if LWIP_UDP case NETCONN_UDPLITE: /* FALLTHROUGH */ case NETCONN_UDPNOCHKSUM: /* FALLTHROUGH */ case NETCONN_UDP: udp_connect(msg->conn->pcb.udp, msg->msg.bc.ipaddr, msg->msg.bc.port); sys_mbox_post(msg->conn->mbox, NULL); break; #endif #if LWIP_TCP case NETCONN_TCP: /* tcp_arg(msg->conn->pcb.tcp, msg->conn);*/ setup_tcp(msg->conn); tcp_connect(msg->conn->pcb.tcp, msg->msg.bc.ipaddr, msg->msg.bc.port, do_connected); /*tcp_output(msg->conn->pcb.tcp);*/ #endif default: break; } } static void do_disconnect(struct api_msg_msg *msg) { switch (msg->conn->type) { #if LWIP_RAW case NETCONN_RAW: /* Do nothing as connecting is only a helper for upper lwip layers */ break; #endif #if LWIP_UDP case NETCONN_UDPLITE: /* FALLTHROUGH */ case NETCONN_UDPNOCHKSUM: /* FALLTHROUGH */ case NETCONN_UDP: udp_disconnect(msg->conn->pcb.udp); break; #endif case NETCONN_TCP: break; } sys_mbox_post(msg->conn->mbox, NULL); } static void do_listen(struct api_msg_msg *msg) { if (msg->conn->pcb.tcp != NULL) { switch (msg->conn->type) { #if LWIP_RAW case NETCONN_RAW: LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: listen RAW: cannot listen for RAW.\n")); break; #endif #if LWIP_UDP case NETCONN_UDPLITE: /* FALLTHROUGH */ case NETCONN_UDPNOCHKSUM: /* FALLTHROUGH */ case NETCONN_UDP: LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: listen UDP: cannot listen for UDP.\n")); break; #endif /* LWIP_UDP */ #if LWIP_TCP case NETCONN_TCP: msg->conn->pcb.tcp = tcp_listen(msg->conn->pcb.tcp); if (msg->conn->pcb.tcp == NULL) { msg->conn->err = ERR_MEM; } else { if (msg->conn->acceptmbox == SYS_MBOX_NULL) { msg->conn->acceptmbox = sys_mbox_new(); if (msg->conn->acceptmbox == SYS_MBOX_NULL) { msg->conn->err = ERR_MEM; break; } } tcp_arg(msg->conn->pcb.tcp, msg->conn); tcp_accept(msg->conn->pcb.tcp, accept_function); } #endif default: break; } } sys_mbox_post(msg->conn->mbox, NULL); } static void do_accept(struct api_msg_msg *msg) { if (msg->conn->pcb.tcp != NULL) { switch (msg->conn->type) { #if LWIP_RAW case NETCONN_RAW: LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: accept RAW: cannot accept for RAW.\n")); break; #endif #if LWIP_UDP case NETCONN_UDPLITE: /* FALLTHROUGH */ case NETCONN_UDPNOCHKSUM: /* FALLTHROUGH */ case NETCONN_UDP: LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: accept UDP: cannot accept for UDP.\n")); break; #endif /* LWIP_UDP */ case NETCONN_TCP: break; } } } static void do_send(struct api_msg_msg *msg) { if (msg->conn->pcb.tcp != NULL) { switch (msg->conn->type) { #if LWIP_RAW case NETCONN_RAW: raw_send(msg->conn->pcb.raw, msg->msg.p); break; #endif #if LWIP_UDP case NETCONN_UDPLITE: /* FALLTHROUGH */ case NETCONN_UDPNOCHKSUM: /* FALLTHROUGH */ case NETCONN_UDP: udp_send(msg->conn->pcb.udp, msg->msg.p); break; #endif /* LWIP_UDP */ case NETCONN_TCP: break; } } sys_mbox_post(msg->conn->mbox, NULL); } static void do_recv(struct api_msg_msg *msg) { #if LWIP_TCP if (msg->conn->pcb.tcp != NULL) { if (msg->conn->type == NETCONN_TCP) { tcp_recved(msg->conn->pcb.tcp, msg->msg.len); } } #endif sys_mbox_post(msg->conn->mbox, NULL); } static void do_write(struct api_msg_msg *msg) { #if LWIP_TCP err_t err; #endif if (msg->conn->pcb.tcp != NULL) { switch (msg->conn->type) { #if LWIP_RAW case NETCONN_RAW: msg->conn->err = ERR_VAL; break; #endif #if LWIP_UDP case NETCONN_UDPLITE: /* FALLTHROUGH */ case NETCONN_UDPNOCHKSUM: /* FALLTHROUGH */ case NETCONN_UDP: msg->conn->err = ERR_VAL; break; #endif /* LWIP_UDP */ #if LWIP_TCP case NETCONN_TCP: err = tcp_write(msg->conn->pcb.tcp, msg->msg.w.dataptr, msg->msg.w.len, msg->msg.w.copy); /* This is the Nagle algorithm: inhibit the sending of new TCP segments when new outgoing data arrives from the user if any previously transmitted data on the connection remains unacknowledged. */ if(err == ERR_OK && (msg->conn->pcb.tcp->unacked == NULL || (msg->conn->pcb.tcp->flags & TF_NODELAY) || (msg->conn->pcb.tcp->snd_queuelen) > 1)) { tcp_output(msg->conn->pcb.tcp); } msg->conn->err = err; if (msg->conn->callback) if (err == ERR_OK) { if (tcp_sndbuf(msg->conn->pcb.tcp) <= TCP_SNDLOWAT) (*msg->conn->callback)(msg->conn, NETCONN_EVT_SENDMINUS, msg->msg.w.len); } #endif default: break; } } sys_mbox_post(msg->conn->mbox, NULL); } static void do_close(struct api_msg_msg *msg) { err_t err; err = ERR_OK; if (msg->conn->pcb.tcp != NULL) { switch (msg->conn->type) { #if LWIP_RAW case NETCONN_RAW: break; #endif #if LWIP_UDP case NETCONN_UDPLITE: /* FALLTHROUGH */ case NETCONN_UDPNOCHKSUM: /* FALLTHROUGH */ case NETCONN_UDP: break; #endif /* LWIP_UDP */ #if LWIP_TCP case NETCONN_TCP: if (msg->conn->pcb.tcp->state == LISTEN) { err = tcp_close(msg->conn->pcb.tcp); } else if (msg->conn->pcb.tcp->state == CLOSE_WAIT) { err = tcp_output(msg->conn->pcb.tcp); } msg->conn->err = err; #endif default: break; } } sys_mbox_post(msg->conn->mbox, NULL); } typedef void (* api_msg_decode)(struct api_msg_msg *msg); static api_msg_decode decode[API_MSG_MAX] = { do_newconn, do_delconn, do_bind, do_connect, do_disconnect, do_listen, do_accept, do_send, do_recv, do_write, do_close }; void api_msg_input(struct api_msg *msg) { decode[msg->type](&(msg->msg)); } void api_msg_post(struct api_msg *msg) { tcpip_apimsg(msg); }
Go to most recent revision | Compare with Previous | Blame | View Log