Find file
Fetching contributors…
Cannot retrieve contributors at this time
2267 lines (1933 sloc) 52.2 KB
#include <time.h>
#include <errno.h>
#include <unistd.h>
#include <ogcsys.h>
#include <lwp.h>
#include <video.h>
#include <message.h>
#include <mutex.h>
#include <cond.h>
#include <semaphore.h>
#include <processor.h>
#include <lwp_threads.h>
#include <lwp_watchdog.h>
#include <lwip/debug.h>
#include <lwip/opt.h>
#include <lwip/mem.h>
#include <lwip/memp.h>
#include <lwip/sys.h>
#include <lwip/stats.h>
#include <lwip/ip.h>
#include <lwip/raw.h>
#include <lwip/udp.h>
#include <lwip/tcp.h>
#include <lwip/dhcp.h>
#include <lwip/api.h>
#include <lwip/api_msg.h>
#include <lwip/tcpip.h>
#include <netif/etharp.h>
#include <netif/loopif.h>
#include <netif/gcif/gcif.h>
#include <sys/iosupport.h>
#include "network.h"
//#define _NET_DEBUG
#define ARP_TIMER_ID 0x00010000
#define TCP_TIMER_ID 0x00020000
#define DHCPCOARSE_TIMER_ID 0x00030000
#define DHCPFINE_TIMER_ID 0x00040000
#define STACKSIZE 32768
#define MQBOX_SIZE 256
#define NUM_SOCKETS MEMP_NUM_NETCONN
struct netsocket {
struct netconn *conn;
struct netbuf *lastdata;
u16 lastoffset,rcvevt,sendevt,flags;
s32 err;
};
struct netselect_cb {
struct netselect_cb *next;
fd_set *readset;
fd_set *writeset;
fd_set *exceptset;
u32 signaled;
mutex_t cond_lck;
cond_t cond;
};
typedef void (*apimsg_decode)(struct apimsg_msg *);
static u32 g_netinitiated = 0;
static u32 tcpiplayer_inited = 0;
static u64 net_tcp_ticks = 0;
static u64 net_dhcpcoarse_ticks = 0;
static u64 net_dhcpfine_ticks = 0;
static u64 net_arp_ticks = 0;
static wd_cntrl arp_time_cntrl;
static wd_cntrl tcp_timer_cntrl;
static wd_cntrl dhcp_coarsetimer_cntrl;
static wd_cntrl dhcp_finetimer_cntrl;
static struct netif g_hNetIF;
static struct netif g_hLoopIF;
static struct netsocket sockets[NUM_SOCKETS];
static struct netselect_cb *selectcb_list = NULL;
static sys_sem netsocket_sem;
static sys_sem sockselect_sem;
static sys_mbox netthread_mbox;
static sys_thread hnet_thread;
static u8 netthread_stack[STACKSIZE];
static u32 tcp_timer_active = 0;
static struct netbuf* netbuf_new();
static void netbuf_delete(struct netbuf *);
static void* netbuf_alloc(struct netbuf *,u32);
static void netbuf_free(struct netbuf *);
static void netbuf_copypartial(struct netbuf *,void *,u32,u32);
static void netbuf_ref(struct netbuf *,const void *,u32);
static struct netconn* netconn_new_with_callback(enum netconn_type,void (*)(struct netconn *,enum netconn_evt,u32));
static struct netconn* netconn_new_with_proto_and_callback(enum netconn_type,u16,void (*)(struct netconn *,enum netconn_evt,u32));
static err_t netconn_delete(struct netconn *);
static struct netconn* netconn_accept(struct netconn* );
static err_t netconn_peer(struct netconn *,struct ip_addr *,u16 *);
static err_t netconn_bind(struct netconn *,struct ip_addr *,u16);
static err_t netconn_listen(struct netconn *);
static struct netbuf* netconn_recv(struct netconn *);
static err_t netconn_send(struct netconn *,struct netbuf *);
static err_t netconn_write(struct netconn *,const void *,u32,u8);
static err_t netconn_connect(struct netconn *,struct ip_addr *,u16);
static err_t netconn_disconnect(struct netconn *);
static void do_newconn(struct apimsg_msg *);
static void do_delconn(struct apimsg_msg *);
static void do_bind(struct apimsg_msg *);
static void do_listen(struct apimsg_msg *);
static void do_connect(struct apimsg_msg *);
static void do_disconnect(struct apimsg_msg *);
static void do_accept(struct apimsg_msg *);
static void do_send(struct apimsg_msg *);
static void do_recv(struct apimsg_msg *);
static void do_write(struct apimsg_msg *);
static void do_close(struct apimsg_msg *);
static apimsg_decode decode[APIMSG_MAX] = {
do_newconn,
do_delconn,
do_bind,
do_connect,
do_disconnect,
do_listen,
do_accept,
do_send,
do_recv,
do_write,
do_close
};
static void apimsg_post(struct api_msg *);
static err_t net_input(struct pbuf *,struct netif *);
static void net_apimsg(struct api_msg *);
static err_t net_callback(void (*)(void *),void *);
static void* net_thread(void *);
static void tmr_callback(void *arg)
{
void (*functor)() = (void(*)())arg;
if(functor) functor();
}
/* low level stuff */
static void __dhcpcoarse_timer(void *arg)
{
__lwp_thread_dispatchdisable();
net_callback(tmr_callback,(void*)dhcp_coarse_tmr);
__lwp_wd_insert_ticks(&dhcp_coarsetimer_cntrl,net_dhcpcoarse_ticks);
__lwp_thread_dispatchunnest();
}
static void __dhcpfine_timer(void *arg)
{
__lwp_thread_dispatchdisable();
net_callback(tmr_callback,(void*)dhcp_fine_tmr);
__lwp_wd_insert_ticks(&dhcp_finetimer_cntrl,net_dhcpfine_ticks);
__lwp_thread_dispatchunnest();
}
static void __tcp_timer(void *arg)
{
#ifdef _NET_DEBUG
printf("__tcp_timer(%d,%p,%p)\n",tcp_timer_active,tcp_active_pcbs,tcp_tw_pcbs);
#endif
__lwp_thread_dispatchdisable();
net_callback(tmr_callback,(void*)tcp_tmr);
if (tcp_active_pcbs || tcp_tw_pcbs) {
__lwp_wd_insert_ticks(&tcp_timer_cntrl,net_tcp_ticks);
} else
tcp_timer_active = 0;
__lwp_thread_dispatchunnest();
}
static void __arp_timer(void *arg)
{
__lwp_thread_dispatchdisable();
net_callback(tmr_callback,(void*)etharp_tmr);
__lwp_wd_insert_ticks(&arp_time_cntrl,net_arp_ticks);
__lwp_thread_dispatchunnest();
}
void tcp_timer_needed(void)
{
#ifdef _NET_DEBUG
printf("tcp_timer_needed()\n");
#endif
if(!tcp_timer_active && (tcp_active_pcbs || tcp_tw_pcbs)) {
tcp_timer_active = 1;
__lwp_wd_insert_ticks(&tcp_timer_cntrl,net_tcp_ticks);
}
}
/* netbuf part */
static __inline__ u16 netbuf_len(struct netbuf *buf)
{
return ((buf && buf->p)?buf->p->tot_len:0);
}
static __inline__ struct ip_addr* netbuf_fromaddr(struct netbuf *buf)
{
return (buf?buf->fromaddr:NULL);
}
static __inline__ u16 netbuf_fromport(struct netbuf *buf)
{
return (buf?buf->fromport:0);
}
static void netbuf_copypartial(struct netbuf *buf,void *dataptr,u32 len,u32 offset)
{
struct pbuf *p;
u16 i,left;
left = 0;
if(buf==NULL || dataptr==NULL) return;
for(p=buf->p;left<len && p!=NULL;p=p->next) {
if(offset!=0 && offset>=p->len)
offset -= p->len;
else {
for(i=offset;i<p->len;i++) {
((u8*)dataptr)[left] = ((u8*)p->payload)[i];
if(++left>=len) return;
}
offset = 0;
}
}
}
static struct netbuf* netbuf_new()
{
struct netbuf *buf = NULL;
buf = memp_malloc(MEMP_NETBUF);
if(buf) {
buf->p = NULL;
buf->ptr = NULL;
}
return buf;
}
static void netbuf_delete(struct netbuf *buf)
{
if(buf!=NULL) {
if(buf->p!=NULL) pbuf_free(buf->p);
memp_free(MEMP_NETBUF,buf);
}
}
static void* netbuf_alloc(struct netbuf *buf,u32 size)
{
if(buf->p!=NULL) pbuf_free(buf->p);
buf->p = pbuf_alloc(PBUF_TRANSPORT,size,PBUF_RAM);
if(buf->p==NULL) return NULL;
buf->ptr = buf->p;
return buf->p->payload;
}
static void netbuf_free(struct netbuf *buf)
{
if(buf->p!=NULL) pbuf_free(buf->p);
buf->p = buf->ptr = NULL;
}
static void netbuf_ref(struct netbuf *buf, const void *dataptr,u32 size)
{
if(buf->p!=NULL) pbuf_free(buf->p);
buf->p = pbuf_alloc(PBUF_TRANSPORT,0,PBUF_REF);
buf->p->payload = (void*)dataptr;
buf->p->len = buf->p->tot_len = size;
buf->ptr = buf->p;
}
/* netconn part */
static inline enum netconn_type netconn_type(struct netconn *conn)
{
return conn->type;
}
static struct netconn* netconn_new_with_callback(enum netconn_type t,void (*cb)(struct netconn*,enum netconn_evt,u32))
{
return netconn_new_with_proto_and_callback(t,0,cb);
}
static struct netconn* netconn_new_with_proto_and_callback(enum netconn_type t,u16 proto,void (*cb)(struct netconn *,enum netconn_evt,u32))
{
u32 dummy = 0;
struct netconn *conn;
struct api_msg *msg;
conn = memp_malloc(MEMP_NETCONN);
if(!conn) return NULL;
conn->err = ERR_OK;
conn->type = t;
conn->pcb.tcp = NULL;
if(MQ_Init(&conn->mbox,MQBOX_SIZE)!=MQ_ERROR_SUCCESSFUL) {
memp_free(MEMP_NETCONN,conn);
return NULL;
}
if(LWP_SemInit(&conn->sem,0,1)==-1) {
MQ_Close(conn->mbox);
memp_free(MEMP_NETCONN,conn);
return NULL;
}
conn->acceptmbox = SYS_MBOX_NULL;
conn->recvmbox = SYS_MBOX_NULL;
conn->state = NETCONN_NONE;
conn->socket = 0;
conn->callback = cb;
conn->recvavail = 0;
msg = memp_malloc(MEMP_API_MSG);
if(!msg) {
MQ_Close(conn->mbox);
memp_free(MEMP_NETCONN,conn);
return NULL;
}
msg->type = APIMSG_NEWCONN;
msg->msg.msg.bc.port = proto;
msg->msg.conn = conn;
apimsg_post(msg);
MQ_Receive(conn->mbox,(mqmsg_t)&dummy,MQ_MSG_BLOCK);
memp_free(MEMP_API_MSG,msg);
if(conn->err!=ERR_OK) {
MQ_Close(conn->mbox);
memp_free(MEMP_NETCONN,conn);
return NULL;
}
return conn;
}
static err_t netconn_delete(struct netconn *conn)
{
u32 dummy = 0;
struct api_msg *msg;
sys_mbox mbox;
void *mem;
LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_delete(%p)\n", conn));
if(!conn) return ERR_OK;
msg = memp_malloc(MEMP_API_MSG);
if(!msg) return ERR_MEM;
msg->type = APIMSG_DELCONN;
msg->msg.conn = conn;
apimsg_post(msg);
MQ_Receive(conn->mbox,(mqmsg_t)&dummy,MQ_MSG_BLOCK);
memp_free(MEMP_API_MSG,msg);
mbox = conn->recvmbox;
conn->recvmbox = SYS_MBOX_NULL;
if(mbox!=SYS_MBOX_NULL) {
while(MQ_Receive(mbox,(mqmsg_t)&mem,MQ_MSG_NOBLOCK)==TRUE) {
if(mem!=NULL) {
if(conn->type==NETCONN_TCP)
pbuf_free((struct pbuf*)mem);
else
netbuf_delete((struct netbuf*)mem);
}
}
MQ_Close(mbox);
}
mbox = conn->acceptmbox;
conn->acceptmbox = SYS_MBOX_NULL;
if(mbox!=SYS_MBOX_NULL) {
while(MQ_Receive(mbox,(mqmsg_t)&mem,MQ_MSG_NOBLOCK)==TRUE) {
if(mem!=NULL) netconn_delete((struct netconn*)mem);
}
MQ_Close(mbox);
}
MQ_Close(conn->mbox);
conn->mbox = SYS_MBOX_NULL;
LWP_SemDestroy(conn->sem);
conn->sem = SYS_SEM_NULL;
memp_free(MEMP_NETCONN,conn);
return ERR_OK;
}
static struct netconn* netconn_accept(struct netconn* conn)
{
struct netconn *newconn;
if(conn==NULL) return NULL;
LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_accept(%p)\n", conn));
MQ_Receive(conn->acceptmbox,(mqmsg_t)&newconn,MQ_MSG_BLOCK);
if(conn->callback)
(*conn->callback)(conn,NETCONN_EVTRCVMINUS,0);
return newconn;
}
static err_t netconn_peer(struct netconn *conn,struct ip_addr *addr,u16 *port)
{
switch(conn->type) {
case NETCONN_RAW:
return ERR_CONN;
case NETCONN_UDPLITE:
case NETCONN_UDPNOCHKSUM:
case NETCONN_UDP:
if(conn->pcb.udp==NULL || ((conn->pcb.udp->flags&UDP_FLAGS_CONNECTED)==0))
return ERR_CONN;
*addr = conn->pcb.udp->remote_ip;
*port = conn->pcb.udp->remote_port;
break;
case NETCONN_TCP:
if(conn->pcb.tcp==NULL)
return ERR_CONN;
*addr = conn->pcb.tcp->remote_ip;
*port = conn->pcb.tcp->remote_port;
break;
}
return (conn->err = ERR_OK);
}
static err_t netconn_bind(struct netconn *conn,struct ip_addr *addr,u16 port)
{
u32 dummy = 0;
struct api_msg *msg;
LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_bind(%p)\n", conn));
if(conn==NULL) return ERR_VAL;
if(conn->type!=NETCONN_TCP && conn->recvmbox==SYS_MBOX_NULL) {
if(MQ_Init(&conn->recvmbox,MQBOX_SIZE)!=MQ_ERROR_SUCCESSFUL) return ERR_MEM;
}
if((msg=memp_malloc(MEMP_API_MSG))==NULL)
return (conn->err = ERR_MEM);
msg->type = APIMSG_BIND;
msg->msg.conn = conn;
msg->msg.msg.bc.ipaddr = addr;
msg->msg.msg.bc.port = port;
apimsg_post(msg);
MQ_Receive(conn->mbox,(mqmsg_t)&dummy,MQ_MSG_BLOCK);
memp_free(MEMP_API_MSG,msg);
return conn->err;
}
static err_t netconn_listen(struct netconn *conn)
{
u32 dummy = 0;
struct api_msg *msg;
LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_listen(%p)\n", conn));
if(conn==NULL) return -1;
if(conn->acceptmbox==SYS_MBOX_NULL) {
if(MQ_Init(&conn->acceptmbox,MQBOX_SIZE)!=MQ_ERROR_SUCCESSFUL) return ERR_MEM;
}
if((msg=memp_malloc(MEMP_API_MSG))==NULL) return (conn->err = ERR_MEM);
msg->type = APIMSG_LISTEN;
msg->msg.conn = conn;
apimsg_post(msg);
MQ_Receive(conn->mbox,(mqmsg_t)&dummy,MQ_MSG_BLOCK);
memp_free(MEMP_API_MSG,msg);
return conn->err;
}
static struct netbuf* netconn_recv(struct netconn *conn)
{
u32 dummy = 0;
struct api_msg *msg;
struct netbuf *buf;
struct pbuf *p;
u16 len;
if(conn==NULL) return NULL;
if(conn->recvmbox==SYS_MBOX_NULL) {
conn->err = ERR_CONN;
return NULL;
}
if(conn->err!=ERR_OK) return NULL;
if(conn->type==NETCONN_TCP) {
if(conn->pcb.tcp->state==LISTEN) {
conn->err = ERR_CONN;
return NULL;
}
buf = memp_malloc(MEMP_NETBUF);
if(buf==NULL) {
conn->err = ERR_MEM;
return NULL;
}
MQ_Receive(conn->recvmbox,(mqmsg_t)&p,MQ_MSG_BLOCK);
if(p!=NULL) {
len = p->tot_len;
conn->recvavail -= len;
} else
len = 0;
if(conn->callback)
(*conn->callback)(conn,NETCONN_EVTRCVMINUS,len);
if(p==NULL) {
memp_free(MEMP_NETBUF,buf);
MQ_Close(conn->recvmbox);
conn->recvmbox = SYS_MBOX_NULL;
return NULL;
}
buf->p = p;
buf->ptr = p;
buf->fromport = 0;
buf->fromaddr = NULL;
if((msg=memp_malloc(MEMP_API_MSG))==NULL) {
conn->err = ERR_MEM;
return buf;
}
msg->type = APIMSG_RECV;
msg->msg.conn = conn;
if(buf!=NULL)
msg->msg.msg.len = len;
else
msg->msg.msg.len = 1;
apimsg_post(msg);
MQ_Receive(conn->mbox,(mqmsg_t)&dummy,MQ_MSG_BLOCK);
memp_free(MEMP_API_MSG,msg);
} else {
MQ_Receive(conn->recvmbox,(mqmsg_t)&buf,MQ_MSG_BLOCK);
conn->recvavail -= buf->p->tot_len;
if(conn->callback)
(*conn->callback)(conn,NETCONN_EVTRCVMINUS,buf->p->tot_len);
}
LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_recv: received %p (err %d)\n", (void *)buf, conn->err));
return buf;
}
static err_t netconn_send(struct netconn *conn,struct netbuf *buf)
{
u32 dummy = 0;
struct api_msg *msg;
if(conn==NULL) return ERR_VAL;
if(conn->err!=ERR_OK) return conn->err;
if((msg=memp_malloc(MEMP_API_MSG))==NULL) return (conn->err = ERR_MEM);
LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_send: sending %d bytes\n", buf->p->tot_len));
msg->type = APIMSG_SEND;
msg->msg.conn = conn;
msg->msg.msg.p = buf->p;
apimsg_post(msg);
MQ_Receive(conn->mbox,(mqmsg_t)&dummy,MQ_MSG_BLOCK);
memp_free(MEMP_API_MSG,msg);
return conn->err;
}
static err_t netconn_write(struct netconn *conn,const void *dataptr,u32 size,u8 copy)
{
u32 dummy = 0;
struct api_msg *msg;
u16 len,snd_buf;
LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_write(%d)\n",conn->err));
if(conn==NULL) return ERR_VAL;
if(conn->err!=ERR_OK) return conn->err;
if((msg=memp_malloc(MEMP_API_MSG))==NULL) return (conn->err = ERR_MEM);
msg->type = APIMSG_WRITE;
msg->msg.conn = conn;
conn->state = NETCONN_WRITE;
while(conn->err==ERR_OK && size>0) {
msg->msg.msg.w.dataptr = (void*)dataptr;
msg->msg.msg.w.copy = copy;
if(conn->type==NETCONN_TCP) {
while((snd_buf=tcp_sndbuf(conn->pcb.tcp))==0) {
LWIP_DEBUGF(API_LIB_DEBUG,("netconn_write: tcp_sndbuf = 0,err = %d\n", conn->err));
LWP_SemWait(conn->sem);
if(conn->err!=ERR_OK) goto ret;
}
if(size>snd_buf)
len = snd_buf;
else
len = size;
} else
len = size;
LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_write: writing %d bytes (%d)\n", len, copy));
msg->msg.msg.w.len = len;
apimsg_post(msg);
MQ_Receive(conn->mbox,(mqmsg_t)&dummy,MQ_MSG_BLOCK);
if(conn->err==ERR_OK) {
LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_write: %d bytes written\n",len));
dataptr = (void*)((char*)dataptr+len);
size -= len;
} else if(conn->err==ERR_MEM) {
LWIP_DEBUGF(API_LIB_DEBUG,("netconn_write: mem err\n"));
conn->err = ERR_OK;
LWP_SemWait(conn->sem);
} else {
LWIP_DEBUGF(API_LIB_DEBUG,("netconn_write: err = %d\n", conn->err));
break;
}
}
ret:
memp_free(MEMP_API_MSG,msg);
conn->state = NETCONN_NONE;
return conn->err;
}
static err_t netconn_connect(struct netconn *conn,struct ip_addr *addr,u16 port)
{
u32 dummy = 0;
struct api_msg *msg;
if(conn==NULL) return -1;
if(conn->recvmbox==SYS_MBOX_NULL) {
if(MQ_Init(&conn->recvmbox,MQBOX_SIZE)!=MQ_ERROR_SUCCESSFUL) return ERR_MEM;
}
if((msg=memp_malloc(MEMP_API_MSG))==NULL) return ERR_MEM;
msg->type = APIMSG_CONNECT;
msg->msg.conn = conn;
msg->msg.msg.bc.ipaddr = addr;
msg->msg.msg.bc.port = port;
apimsg_post(msg);
MQ_Receive(conn->mbox,(mqmsg_t)&dummy,MQ_MSG_BLOCK);
memp_free(MEMP_API_MSG,msg);
return conn->err;
}
static err_t netconn_disconnect(struct netconn *conn)
{
u32 dummy = 0;
struct api_msg *msg;
if(conn==NULL) return ERR_VAL;
if((msg=memp_malloc(MEMP_API_MSG))==NULL) return ERR_MEM;
msg->type = APIMSG_DISCONNECT;
msg->msg.conn = conn;
apimsg_post(msg);
MQ_Receive(conn->mbox,(mqmsg_t)&dummy,MQ_MSG_BLOCK);
memp_free(MEMP_API_MSG,msg);
return conn->err;
}
/* api msg part */
static u8_t recv_raw(void *arg,struct raw_pcb *pcb,struct pbuf *p,struct ip_addr *addr)
{
struct netbuf *buf;
struct netconn *conn = (struct netconn*)arg;
if(!conn) return 0;
if(conn->recvmbox!=SYS_MBOX_NULL) {
if((buf=memp_malloc(MEMP_NETBUF))==NULL) return 0;
pbuf_ref(p);
buf->p = p;
buf->ptr = p;
buf->fromaddr = addr;
buf->fromport = pcb->protocol;
conn->recvavail += p->tot_len;
if(conn->callback)
(*conn->callback)(conn,NETCONN_EVTRCVPLUS,p->tot_len);
MQ_Send(conn->recvmbox,&buf,MQ_MSG_BLOCK);
}
return 0;
}
static void recv_udp(void *arg,struct udp_pcb *pcb,struct pbuf *p,struct ip_addr *addr,u16 port)
{
struct netbuf *buf;
struct netconn *conn = (struct netconn*)arg;
if(!conn) {
pbuf_free(p);
return;
}
if(conn->recvmbox!=SYS_MBOX_NULL) {
buf = memp_malloc(MEMP_NETBUF);
if(!buf) {
pbuf_free(p);
return;
}
buf->p = p;
buf->ptr = p;
buf->fromaddr = addr;
buf->fromport = port;
conn->recvavail += p->tot_len;
if(conn->callback)
(*conn->callback)(conn,NETCONN_EVTRCVPLUS,p->tot_len);
MQ_Send(conn->recvmbox,&buf,MQ_MSG_BLOCK);
}
}
static err_t recv_tcp(void *arg,struct tcp_pcb *pcb,struct pbuf *p,err_t err)
{
u16 len;
struct netconn *conn = (struct netconn*)arg;
LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: recv_tcp(%p,%p,%p,%d)\n",arg,pcb,p,err));
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->recvavail += len;
} else len = 0;
if(conn->callback)
(*conn->callback)(conn,NETCONN_EVTRCVPLUS,len);
MQ_Send(conn->recvmbox,&p,MQ_MSG_BLOCK);
}
return ERR_OK;
}
static void err_tcp(void *arg,err_t err)
{
u32 dummy = 0;
struct netconn *conn = (struct netconn*)arg;
LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: err_tcp: %d\n",err));
if(conn) {
conn->err = err;
conn->pcb.tcp = NULL;
if(conn->recvmbox!=SYS_MBOX_NULL) {
if(conn->callback) (*conn->callback)(conn,NETCONN_EVTRCVPLUS,0);
MQ_Send(conn->recvmbox,&dummy,MQ_MSG_BLOCK);
}
if(conn->mbox!=SYS_MBOX_NULL) {
MQ_Send(conn->mbox,&dummy,MQ_MSG_BLOCK);
}
if(conn->acceptmbox!=SYS_MBOX_NULL) {
if(conn->callback) (*conn->callback)(conn,NETCONN_EVTRCVPLUS,0);
MQ_Send(conn->acceptmbox,&dummy,MQ_MSG_BLOCK);
}
if(conn->sem!=SYS_SEM_NULL) {
LWP_SemPost(conn->sem);
}
}
}
static err_t poll_tcp(void *arg,struct tcp_pcb *pcb)
{
struct netconn *conn = (struct netconn*)arg;
LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: poll_tcp\n"));
if(conn && conn->sem!=SYS_SEM_NULL && (conn->state==NETCONN_WRITE || conn->state==NETCONN_CLOSE))
LWP_SemPost(conn->sem);
return ERR_OK;
}
static err_t sent_tcp(void *arg,struct tcp_pcb *pcb,u16 len)
{
struct netconn *conn = (struct netconn*)arg;
LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: sent_tcp: sent %d bytes\n",len));
if(conn && conn->sem!=SYS_SEM_NULL)
LWP_SemPost(conn->sem);
if(conn && conn->callback) {
if(tcp_sndbuf(conn->pcb.tcp)>TCP_SNDLOWAT)
(*conn->callback)(conn,NETCONN_EVTSENDPLUS,len);
}
return ERR_OK;
}
static void setuptcp(struct netconn *conn)
{
struct tcp_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_func(void *arg,struct tcp_pcb *newpcb,err_t err)
{
sys_mbox mbox;
struct netconn *newconn,*conn = (struct netconn*)arg;
LWIP_DEBUGF(API_LIB_DEBUG, ("accept_func: %p %p %d\n",arg,newpcb,err));
mbox = conn->acceptmbox;
newconn = memp_malloc(MEMP_NETCONN);
if(newconn==NULL) return ERR_MEM;
if(MQ_Init(&newconn->recvmbox,MQBOX_SIZE)!=MQ_ERROR_SUCCESSFUL) {
memp_free(MEMP_NETCONN,newconn);
return ERR_MEM;
}
if(MQ_Init(&newconn->mbox,MQBOX_SIZE)!=MQ_ERROR_SUCCESSFUL) {
MQ_Close(newconn->recvmbox);
memp_free(MEMP_NETCONN,newconn);
return ERR_MEM;
}
if(LWP_SemInit(&newconn->sem,0,1)==-1) {
MQ_Close(newconn->recvmbox);
MQ_Close(newconn->mbox);
memp_free(MEMP_NETCONN,newconn);
return ERR_MEM;
}
newconn->type = NETCONN_TCP;
newconn->pcb.tcp = newpcb;
setuptcp(newconn);
newconn->acceptmbox = SYS_MBOX_NULL;
newconn->err = err;
if(conn->callback) {
(*conn->callback)(conn,NETCONN_EVTRCVPLUS,0);
}
newconn->callback = conn->callback;
newconn->socket = -1;
newconn->recvavail = 0;
MQ_Send(mbox,&newconn,MQ_MSG_BLOCK);
return ERR_OK;
}
static void do_newconn(struct apimsg_msg *msg)
{
u32 dummy = 0;
if(msg->conn->pcb.tcp) {
MQ_Send(msg->conn->mbox,&dummy,MQ_MSG_BLOCK);
return;
}
msg->conn->err = ERR_OK;
switch(msg->conn->type) {
case NETCONN_RAW:
msg->conn->pcb.raw = raw_new(msg->msg.bc.port);
raw_recv(msg->conn->pcb.raw,recv_raw,msg->conn);
break;
case NETCONN_UDPLITE:
msg->conn->pcb.udp = udp_new();
if(!msg->conn->pcb.udp) {
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) {
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) {
msg->conn->err = ERR_MEM;
break;
}
udp_recv(msg->conn->pcb.udp,recv_udp,msg->conn);
break;
case NETCONN_TCP:
msg->conn->pcb.tcp = tcp_new();
if(!msg->conn->pcb.tcp) {
msg->conn->err = ERR_MEM;
break;
}
setuptcp(msg->conn);
break;
default:
break;
}
MQ_Send(msg->conn->mbox,&dummy,MQ_MSG_BLOCK);
}
static void do_delconn(struct apimsg_msg *msg)
{
u32 dummy = 0;
if(msg->conn->pcb.tcp) {
switch(msg->conn->type) {
case NETCONN_RAW:
raw_remove(msg->conn->pcb.raw);
break;
case NETCONN_UDPLITE:
case NETCONN_UDPNOCHKSUM:
case NETCONN_UDP:
msg->conn->pcb.udp->recv_arg = NULL;
udp_remove(msg->conn->pcb.udp);
break;
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);
}
break;
default:
break;
}
}
if(msg->conn->callback) {
(*msg->conn->callback)(msg->conn,NETCONN_EVTRCVPLUS,0);
(*msg->conn->callback)(msg->conn,NETCONN_EVTSENDPLUS,0);
}
if(msg->conn->mbox!=SYS_MBOX_NULL)
MQ_Send(msg->conn->mbox,&dummy,MQ_MSG_BLOCK);
}
static void do_bind(struct apimsg_msg *msg)
{
u32 dummy = 0;
if(msg->conn->pcb.tcp==NULL) {
switch(msg->conn->type) {
case NETCONN_RAW:
msg->conn->pcb.raw = raw_new(msg->msg.bc.port);
raw_recv(msg->conn->pcb.raw,recv_raw,msg->conn);
break;
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;
case NETCONN_TCP:
msg->conn->pcb.tcp = tcp_new();
setuptcp(msg->conn);
break;
default:
break;
}
}
switch(msg->conn->type) {
case NETCONN_RAW:
msg->conn->err = raw_bind(msg->conn->pcb.raw,msg->msg.bc.ipaddr);
break;
case NETCONN_UDPLITE:
case NETCONN_UDPNOCHKSUM:
case NETCONN_UDP:
msg->conn->err = udp_bind(msg->conn->pcb.udp,msg->msg.bc.ipaddr,msg->msg.bc.port);
break;
case NETCONN_TCP:
msg->conn->err = tcp_bind(msg->conn->pcb.tcp,msg->msg.bc.ipaddr,msg->msg.bc.port);
break;
default:
break;
}
MQ_Send(msg->conn->mbox,&dummy,MQ_MSG_BLOCK);
}
static err_t do_connected(void *arg,struct tcp_pcb *pcb,err_t err)
{
u32 dummy = 0;
struct netconn *conn = (struct netconn*)arg;
if(!conn) return ERR_VAL;
conn->err = err;
if(conn->type==NETCONN_TCP && err==ERR_OK) setuptcp(conn);
MQ_Send(conn->mbox,&dummy,MQ_MSG_BLOCK);
return ERR_OK;
}
static void do_connect(struct apimsg_msg *msg)
{
u32 dummy = 0;
if(!msg->conn->pcb.tcp) {
switch(msg->conn->type) {
case NETCONN_RAW:
msg->conn->pcb.raw = raw_new(msg->msg.bc.port);
raw_recv(msg->conn->pcb.raw,recv_raw,msg->conn);
break;
case NETCONN_UDPLITE:
msg->conn->pcb.udp = udp_new();
if(!msg->conn->pcb.udp) {
msg->conn->err = ERR_MEM;
MQ_Send(msg->conn->mbox,&dummy,MQ_MSG_BLOCK);
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) {
msg->conn->err = ERR_MEM;
MQ_Send(msg->conn->mbox,&dummy,MQ_MSG_BLOCK);
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) {
msg->conn->err = ERR_MEM;
MQ_Send(msg->conn->mbox,&dummy,MQ_MSG_BLOCK);
return;
}
udp_recv(msg->conn->pcb.udp,recv_udp,msg->conn);
break;
case NETCONN_TCP:
msg->conn->pcb.tcp = tcp_new();
if(!msg->conn->pcb.tcp) {
msg->conn->err = ERR_MEM;
MQ_Send(msg->conn->mbox,&dummy,MQ_MSG_BLOCK);
return;
}
break;
default:
break;
}
}
switch(msg->conn->type) {
case NETCONN_RAW:
raw_connect(msg->conn->pcb.raw,msg->msg.bc.ipaddr);
MQ_Send(msg->conn->mbox,&dummy,MQ_MSG_BLOCK);
break;
case NETCONN_UDPLITE:
case NETCONN_UDPNOCHKSUM:
case NETCONN_UDP:
udp_connect(msg->conn->pcb.udp,msg->msg.bc.ipaddr,msg->msg.bc.port);
MQ_Send(msg->conn->mbox,&dummy,MQ_MSG_BLOCK);
break;
case NETCONN_TCP:
setuptcp(msg->conn);
tcp_connect(msg->conn->pcb.tcp,msg->msg.bc.ipaddr,msg->msg.bc.port,do_connected);
break;
default:
break;
}
}
static void do_disconnect(struct apimsg_msg *msg)
{
u32 dummy = 0;
switch(msg->conn->type) {
case NETCONN_RAW:
break;
case NETCONN_UDPLITE:
case NETCONN_UDPNOCHKSUM:
case NETCONN_UDP:
udp_disconnect(msg->conn->pcb.udp);
break;
case NETCONN_TCP:
break;
}
MQ_Send(msg->conn->mbox,&dummy,MQ_MSG_BLOCK);
}
static void do_listen(struct apimsg_msg *msg)
{
u32 dummy = 0;
if(msg->conn->pcb.tcp!=NULL) {
switch(msg->conn->type) {
case NETCONN_RAW:
LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: listen RAW: cannot listen for RAW.\n"));
break;
case NETCONN_UDPLITE:
case NETCONN_UDPNOCHKSUM:
case NETCONN_UDP:
LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: listen UDP: cannot listen for UDP.\n"));
break;
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) {
if(MQ_Init(&msg->conn->acceptmbox,MQBOX_SIZE)!=MQ_ERROR_SUCCESSFUL) {
msg->conn->err = ERR_MEM;
break;
}
}
tcp_arg(msg->conn->pcb.tcp,msg->conn);
tcp_accept(msg->conn->pcb.tcp,accept_func);
}
break;
default:
break;
}
}
MQ_Send(msg->conn->mbox,&dummy,MQ_MSG_BLOCK);
}
static void do_accept(struct apimsg_msg *msg)
{
if(msg->conn->pcb.tcp) {
switch(msg->conn->type) {
case NETCONN_RAW:
LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: accept RAW: cannot accept for RAW.\n"));
break;
case NETCONN_UDPLITE:
case NETCONN_UDPNOCHKSUM:
case NETCONN_UDP:
LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: accept UDP: cannot accept for UDP.\n"));
break;
case NETCONN_TCP:
break;
}
}
}
static void do_send(struct apimsg_msg *msg)
{
u32 dummy = 0;
if(msg->conn->pcb.tcp) {
switch(msg->conn->type) {
case NETCONN_RAW:
raw_send(msg->conn->pcb.raw,msg->msg.p);
break;
case NETCONN_UDPLITE:
case NETCONN_UDPNOCHKSUM:
case NETCONN_UDP:
udp_send(msg->conn->pcb.udp,msg->msg.p);
break;
case NETCONN_TCP:
break;
}
}
MQ_Send(msg->conn->mbox,&dummy,MQ_MSG_BLOCK);
}
static void do_recv(struct apimsg_msg *msg)
{
u32 dummy = 0;
if(msg->conn->pcb.tcp && msg->conn->type==NETCONN_TCP) {
tcp_recved(msg->conn->pcb.tcp,msg->msg.len);
}
MQ_Send(msg->conn->mbox,&dummy,MQ_MSG_BLOCK);
}
static void do_write(struct apimsg_msg *msg)
{
err_t err;
u32 dummy = 0;
if(msg->conn->pcb.tcp) {
switch(msg->conn->type) {
case NETCONN_RAW:
case NETCONN_UDPLITE:
case NETCONN_UDPNOCHKSUM:
case NETCONN_UDP:
msg->conn->err = ERR_VAL;
break;
case NETCONN_TCP:
err = tcp_write(msg->conn->pcb.tcp,msg->msg.w.dataptr,msg->msg.w.len,msg->msg.w.copy);
if(err==ERR_OK && (!msg->conn->pcb.tcp->unacked || (msg->conn->pcb.tcp->flags&TF_NODELAY)
|| msg->conn->pcb.tcp->snd_queuelen>1)) {
LWIP_DEBUGF(API_MSG_DEBUG, ("api_msg: TCP write: tcp_output.\n"));
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_EVTSENDMINUS,msg->msg.w.len);
}
}
break;
default:
break;
}
}
MQ_Send(msg->conn->mbox,&dummy,MQ_MSG_BLOCK);
}
static void do_close(struct apimsg_msg *msg)
{
u32 dummy = 0;
err_t err = ERR_OK;
if(msg->conn->pcb.tcp) {
switch(msg->conn->type) {
case NETCONN_RAW:
case NETCONN_UDPLITE:
case NETCONN_UDPNOCHKSUM:
case NETCONN_UDP:
break;
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;
break;
default:
break;
}
}
MQ_Send(msg->conn->mbox,&dummy,MQ_MSG_BLOCK);
}
static void apimsg_input(struct api_msg *msg)
{
decode[msg->type](&(msg->msg));
}
static void apimsg_post(struct api_msg *msg)
{
net_apimsg(msg);
}
/* tcpip thread part */
static err_t net_input(struct pbuf *p,struct netif *inp)
{
struct net_msg *msg = memp_malloc(MEMP_TCPIP_MSG);
LWIP_DEBUGF(TCPIP_DEBUG, ("net_input: %p %p\n", p,inp));
if(msg==NULL) {
LWIP_ERROR(("net_input: msg out of memory.\n"));
pbuf_free(p);
return ERR_MEM;
}
msg->type = NETMSG_INPUT;
msg->msg.inp.p = p;
msg->msg.inp.net = inp;
MQ_Send(netthread_mbox,&msg,MQ_MSG_BLOCK);
return ERR_OK;
}
static void net_apimsg(struct api_msg *apimsg)
{
struct net_msg *msg = memp_malloc(MEMP_TCPIP_MSG);
LWIP_DEBUGF(TCPIP_DEBUG, ("net_apimsg: %p\n",apimsg));
if(msg==NULL) {
LWIP_ERROR(("net_apimsg: msg out of memory.\n"));
memp_free(MEMP_API_MSG,apimsg);
return;
}
msg->type = NETMSG_API;
msg->msg.apimsg = apimsg;
MQ_Send(netthread_mbox,&msg,MQ_MSG_BLOCK);
}
static err_t net_callback(void (*f)(void *),void *ctx)
{
struct net_msg *msg = memp_malloc(MEMP_TCPIP_MSG);
LWIP_DEBUGF(TCPIP_DEBUG, ("net_callback: %p(%p)\n", f,ctx));
if(msg==NULL) {
LWIP_ERROR(("net_apimsg: msg out of memory.\n"));
return ERR_MEM;
}
msg->type = NETMSG_CALLBACK;
msg->msg.cb.f = f;
msg->msg.cb.ctx = ctx;
MQ_Send(netthread_mbox,&msg,MQ_MSG_BLOCK);
return ERR_OK;
}
static void* net_thread(void *arg)
{
struct net_msg *msg;
struct timespec tb;
sys_sem sem = (sys_sem)arg;
etharp_init();
ip_init();
udp_init();
tcp_init();
tb.tv_sec = ARP_TMR_INTERVAL/TB_MSPERSEC;
tb.tv_nsec = 0;
net_arp_ticks = __lwp_wd_calc_ticks(&tb);
__lwp_wd_initialize(&arp_time_cntrl,__arp_timer,ARP_TIMER_ID,NULL);
__lwp_wd_insert_ticks(&arp_time_cntrl,net_arp_ticks);
tb.tv_sec = 0;
tb.tv_nsec = TCP_TMR_INTERVAL*TB_NSPERMS;
net_tcp_ticks = __lwp_wd_calc_ticks(&tb);
__lwp_wd_initialize(&tcp_timer_cntrl,__tcp_timer,TCP_TIMER_ID,NULL);
LWP_SemPost(sem);
LWIP_DEBUGF(TCPIP_DEBUG, ("net_thread(%p)\n",arg));
while(1) {
MQ_Receive(netthread_mbox,(mqmsg_t)&msg,MQ_MSG_BLOCK);
switch(msg->type) {
case NETMSG_API:
LWIP_DEBUGF(TCPIP_DEBUG, ("net_thread: API message %p\n", (void *)msg));
apimsg_input(msg->msg.apimsg);
break;
case NETMSG_INPUT:
LWIP_DEBUGF(TCPIP_DEBUG, ("net_thread: IP packet %p\n", (void *)msg));
bba_process(msg->msg.inp.p,msg->msg.inp.net);
break;
case NETMSG_CALLBACK:
LWIP_DEBUGF(TCPIP_DEBUG, ("net_thread: CALLBACK %p\n", (void *)msg));
msg->msg.cb.f(msg->msg.cb.ctx);
break;
default:
break;
}
memp_free(MEMP_TCPIP_MSG,msg);
}
}
/* sockets part */
static s32 alloc_socket(struct netconn *conn)
{
s32 i;
LWP_SemWait(netsocket_sem);
for(i=0;i<NUM_SOCKETS;i++) {
if(!sockets[i].conn) {
sockets[i].conn = conn;
sockets[i].lastdata = NULL;
sockets[i].lastoffset = 0;
sockets[i].rcvevt = 0;
sockets[i].sendevt = 1;
sockets[i].flags = 0;
sockets[i].err = 0;
LWP_SemPost(netsocket_sem);
return i;
}
}
LWP_SemPost(netsocket_sem);
return -1;
}
static struct netsocket* get_socket(s32 s)
{
struct netsocket *sock;
if(s<0 || s>NUM_SOCKETS) {
LWIP_DEBUGF(SOCKETS_DEBUG, ("get_socket(%d): invalid\n", s));
return NULL;
}
sock = &sockets[s];
if(!sock->conn) {
LWIP_DEBUGF(SOCKETS_DEBUG, ("get_socket(%d): no active\n", s));
return NULL;
}
return sock;
}
static void evt_callback(struct netconn *conn,enum netconn_evt evt,u32 len)
{
s32 s;
struct netsocket *sock;
struct netselect_cb *scb;
if(conn) {
s = conn->socket;
if(s<0) {
if(evt==NETCONN_EVTRCVPLUS)
conn->socket--;
return;
}
sock = get_socket(s);
if(!sock) return;
} else
return;
LWP_SemWait(sockselect_sem);
switch(evt) {
case NETCONN_EVTRCVPLUS:
sock->rcvevt++;
break;
case NETCONN_EVTRCVMINUS:
sock->rcvevt--;
break;
case NETCONN_EVTSENDPLUS:
sock->sendevt = 1;
break;
case NETCONN_EVTSENDMINUS:
sock->sendevt = 0;
break;
}
LWP_SemPost(sockselect_sem);
while(1) {
LWP_SemWait(sockselect_sem);
for(scb = selectcb_list;scb;scb = scb->next) {
if(scb->signaled==0) {
if(scb->readset && FD_ISSET(s,scb->readset))
if(sock->rcvevt) break;
if(scb->writeset && FD_ISSET(s,scb->writeset))
if(sock->sendevt) break;
}
}
if(scb) {
scb->signaled = 1;
LWP_SemPost(sockselect_sem);
LWP_MutexLock(scb->cond_lck);
LWP_CondSignal(scb->cond);
LWP_MutexUnlock(scb->cond_lck);
} else {
LWP_SemPost(sockselect_sem);
break;
}
}
}
extern const devoptab_t dotab_stdnet;
s32 if_configex(struct in_addr *local_ip,struct in_addr *netmask,struct in_addr *gateway,boolean use_dhcp)
{
s32 ret = 0;
struct ip_addr loc_ip, mask, gw;
struct netif *pnet;
struct timespec tb;
dev_s hbba = NULL;
if(g_netinitiated) return 0;
g_netinitiated = 1;
AddDevice(&dotab_stdnet);
#ifdef STATS
stats_init();
#endif /* STATS */
sys_init();
mem_init();
memp_init();
pbuf_init();
netif_init();
// init tcpip thread message box
if(MQ_Init(&netthread_mbox,MQBOX_SIZE)!=MQ_ERROR_SUCCESSFUL) return -1;
// create & setup interface
loc_ip.addr = 0;
mask.addr = 0;
gw.addr = 0;
if(use_dhcp==FALSE) {
if( !gateway || gateway->s_addr==0
|| !local_ip || local_ip->s_addr==0
|| !netmask || netmask->s_addr==0 ) return -1;
loc_ip.addr = local_ip->s_addr;
mask.addr = netmask->s_addr;
gw.addr = gateway->s_addr;
}
hbba = bba_create(&g_hNetIF);
pnet = netif_add(&g_hNetIF,&loc_ip, &mask, &gw, hbba, bba_init, net_input);
if(pnet) {
netif_set_up(pnet);
netif_set_default(pnet);
#if (LWIP_DHCP)
if(use_dhcp==TRUE) {
//setup coarse timer
tb.tv_sec = DHCP_COARSE_TIMER_SECS;
tb.tv_nsec = 0;
net_dhcpcoarse_ticks = __lwp_wd_calc_ticks(&tb);
__lwp_wd_initialize(&dhcp_coarsetimer_cntrl,__dhcpcoarse_timer,DHCPCOARSE_TIMER_ID,NULL);
__lwp_wd_insert_ticks(&dhcp_coarsetimer_cntrl,net_dhcpcoarse_ticks);
//setup fine timer
tb.tv_sec = 0;
tb.tv_nsec = DHCP_FINE_TIMER_MSECS*TB_NSPERMS;
net_dhcpfine_ticks = __lwp_wd_calc_ticks(&tb);
__lwp_wd_initialize(&dhcp_finetimer_cntrl,__dhcpfine_timer,DHCPFINE_TIMER_ID,NULL);
__lwp_wd_insert_ticks(&dhcp_finetimer_cntrl,net_dhcpfine_ticks);
//now start dhcp client
dhcp_start(pnet);
}
#endif
} else
return -1;
// setup loopinterface
IP4_ADDR(&loc_ip, 127,0,0,1);
IP4_ADDR(&mask, 255,0,0,0);
IP4_ADDR(&gw, 127,0,0,1);
pnet = netif_add(&g_hLoopIF,&loc_ip,&mask,&gw,NULL,loopif_init,net_input);
//last and least start the tcpip layer
ret = net_init();
if ( ret == 0 && use_dhcp == TRUE ) {
int retries = 0;
// wait for dhcp to bind
while ( g_hNetIF.dhcp->state != DHCP_BOUND && retries < 20 ) {
retries++;
usleep(500000);
}
if ( retries < 20 ) {
//copy back network addresses
if ( local_ip != NULL ) local_ip->s_addr = g_hNetIF.ip_addr.addr;
if ( gateway != NULL ) gateway->s_addr = g_hNetIF.gw.addr;
if ( netmask != NULL ) netmask->s_addr = g_hNetIF.netmask.addr;
} else {
ret = -2;
}
}
return ret;
}
s32 if_config(char *local_ip, char *netmask, char *gateway,boolean use_dhcp)
{
s32 ret = 0;
struct in_addr loc_ip, mask, gw;
loc_ip.s_addr = 0;
mask.s_addr = 0;
gw.s_addr = 0;
if ( local_ip != NULL ) loc_ip.s_addr = inet_addr(local_ip);
if ( netmask != NULL ) mask.s_addr = inet_addr(netmask);
if ( gateway != NULL ) gw.s_addr = inet_addr(gateway);
ret = if_configex( &loc_ip, &mask, &gw, use_dhcp );
if (ret<0) return ret;
if ( use_dhcp == TRUE ) {
//copy back network addresses
if ( local_ip != NULL ) strcpy(local_ip, inet_ntoa( loc_ip ));
if ( netmask != NULL ) strcpy(netmask, inet_ntoa( mask));
if ( gateway != NULL ) strcpy(gateway, inet_ntoa( gw ));
}
return ret;
}
s32 net_init()
{
sys_sem sem;
if(tcpiplayer_inited) return 1;
if(LWP_SemInit(&netsocket_sem,1,1)==-1) return -1;
if(LWP_SemInit(&sockselect_sem,1,1)==-1) {
LWP_SemDestroy(netsocket_sem);
return -1;
}
if(LWP_SemInit(&sem,0,1)==-1) {
LWP_SemDestroy(netsocket_sem);
LWP_SemDestroy(sockselect_sem);
return -1;
}
if(LWP_CreateThread(&hnet_thread,net_thread,(void*)sem,netthread_stack,STACKSIZE,220)==-1) {
LWP_SemDestroy(netsocket_sem);
LWP_SemDestroy(sockselect_sem);
LWP_SemDestroy(sem);
return -1;
}
LWP_SemWait(sem);
LWP_SemDestroy(sem);
tcpiplayer_inited = 1;
return 0;
}
s32 net_shutdown(s32 s,u32 how)
{
return -1;
}
s32 net_fcntl(s32 s, u32 cmd, u32 flags)
{
return -1;
}
s32 net_socket(u32 domain,u32 type,u32 protocol)
{
s32 i;
struct netconn *conn;
switch(type) {
case SOCK_RAW:
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_socket(SOCK_RAW)\n"));
conn = netconn_new_with_proto_and_callback(NETCONN_RAW,protocol,evt_callback);
break;
case SOCK_DGRAM:
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_socket(SOCK_DGRAM)\n"));
conn = netconn_new_with_callback(NETCONN_UDP,evt_callback);
break;
case SOCK_STREAM:
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_socket(SOCK_STREAM)\n"));
conn = netconn_new_with_callback(NETCONN_TCP,evt_callback);
break;
default:
return -1;
}
if(!conn) return -1;
i = alloc_socket(conn);
if(i==-1) {
netconn_delete(conn);
return -1;
}
conn->socket = i;
return i;
}
s32 net_accept(s32 s,struct sockaddr *addr,socklen_t *addrlen)
{
struct netsocket *sock;
struct netconn *newconn;
struct ip_addr naddr = {0};
u16 port = 0;
s32 newsock;
struct sockaddr_in sin;
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_accept(%d)\n", s));
sock = get_socket(s);
if(!sock) return -1;
newconn = netconn_accept(sock->conn);
netconn_peer(newconn,&naddr,&port);
memset(&sin,0,sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
sin.sin_addr.s_addr = naddr.addr;
if(*addrlen>sizeof(sin))
*addrlen = sizeof(sin);
memcpy(addr,&sin,*addrlen);
newsock = alloc_socket(newconn);
if(newsock==-1) {
netconn_delete(newconn);
return -1;
}
newconn->callback = evt_callback;
sock = get_socket(newsock);
LWP_SemWait(netsocket_sem);
sock->rcvevt += -1 - newconn->socket;
newconn->socket = newsock;
LWP_SemPost(netsocket_sem);
return newsock;
}
s32 net_bind(s32 s,struct sockaddr *name,socklen_t namelen)
{
struct netsocket *sock;
struct ip_addr loc_addr;
u16 loc_port;
err_t err;
sock = get_socket(s);
if(!sock) return -1;
loc_addr.addr = ((struct sockaddr_in*)name)->sin_addr.s_addr;
loc_port = ((struct sockaddr_in*)name)->sin_port;
err = netconn_bind(sock->conn,&loc_addr,ntohs(loc_port));
if(err!=ERR_OK) return -1;
return 0;
}
s32 net_listen(s32 s,u32 backlog)
{
struct netsocket *sock;
err_t err;
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_listen(%d, backlog=%d)\n", s, backlog));
sock = get_socket(s);
if(!sock) return -1;
err = netconn_listen(sock->conn);
if(err!=ERR_OK) {
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_listen(%d) failed, err=%d\n", s, err));
return -1;
}
return 0;
}
s32 net_recvfrom(s32 s,void *mem,s32 len,u32 flags,struct sockaddr *from,socklen_t *fromlen)
{
struct netsocket *sock;
struct netbuf *buf;
u16 buflen,copylen;
struct ip_addr *addr;
u16 port;
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_recvfrom(%d, %p, %d, 0x%x, ..)\n", s, mem, len, flags));
if(mem==NULL || len<=0) return -1;
sock = get_socket(s);
if(!sock) return -1;
if(sock->lastdata)
buf = sock->lastdata;
else {
if(((flags&MSG_DONTWAIT) || (sock->flags&O_NONBLOCK)) && !sock->rcvevt) {
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_recvfrom(%d): returning EWOULDBLOCK\n", s));
return -1;
}
buf = netconn_recv(sock->conn);
if(!buf) {
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_recvfrom(%d): buf == NULL!\n", s));
return 0;
}
}
buflen = netbuf_len(buf);
buflen -= sock->lastoffset;
if(buflen<=0)
return 0;
if(len>buflen)
copylen = buflen;
else
copylen = len;
netbuf_copypartial(buf,mem,copylen,sock->lastoffset);
if(from && fromlen) {
struct sockaddr_in sin;
addr = netbuf_fromaddr(buf);
port = netbuf_fromport(buf);
memset(&sin,0,sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
sin.sin_addr.s_addr = addr->addr;
if(*fromlen>sizeof(sin))
*fromlen = sizeof(sin);
memcpy(from,&sin,*fromlen);
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_recvfrom(%d): addr=", s));
ip_addr_debug_print(SOCKETS_DEBUG, addr);
LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u len=%u\n", port, copylen));
}
if(netconn_type(sock->conn)==NETCONN_TCP && (buflen-copylen)>0) {
sock->lastdata = buf;
sock->lastoffset += copylen;
} else {
sock->lastdata = NULL;
sock->lastoffset = 0;
netbuf_delete(buf);
}
return copylen;
}
s32 net_read(s32 s,void *mem,s32 len)
{
return net_recvfrom(s,mem,len,0,NULL,NULL);
}
s32 net_recv(s32 s,void *mem,s32 len,u32 flags)
{
return net_recvfrom(s,mem,len,flags,NULL,NULL);
}
s32 net_sendto(s32 s,const void *data,s32 len,u32 flags,struct sockaddr *to,socklen_t tolen)
{
struct netsocket *sock;
struct ip_addr remote_addr, addr;
u16_t remote_port, port = 0;
s32 ret,connected;
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_sendto(%d, data=%p, size=%d, flags=0x%x)\n", s, data, len, flags));
if(data==NULL || len<=0) return -1;
sock = get_socket(s);
if (!sock) return -1;
/* get the peer if currently connected */
connected = (netconn_peer(sock->conn, &addr, &port) == ERR_OK);
remote_addr.addr = ((struct sockaddr_in *)to)->sin_addr.s_addr;
remote_port = ((struct sockaddr_in *)to)->sin_port;
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_sendto(%d, data=%p, size=%d, flags=0x%x to=", s, data, len, flags));
ip_addr_debug_print(SOCKETS_DEBUG, &remote_addr);
LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u\n", ntohs(remote_port)));
netconn_connect(sock->conn, &remote_addr, ntohs(remote_port));
ret = net_send(s, data, len, flags);
/* reset the remote address and port number
of the connection */
if (connected)
netconn_connect(sock->conn, &addr, port);
else
netconn_disconnect(sock->conn);
return ret;
}
s32 net_send(s32 s,const void *data,s32 len,u32 flags)
{
struct netsocket *sock;
struct netbuf *buf;
err_t err;
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_send(%d, data=%p, size=%d, flags=0x%x)\n", s, data, len, flags));
if(data==NULL || len<=0) return -1;
sock = get_socket(s);
if(!sock) return -1;
switch(netconn_type(sock->conn)) {
case NETCONN_RAW:
case NETCONN_UDP:
case NETCONN_UDPLITE:
case NETCONN_UDPNOCHKSUM:
buf = netbuf_new();
if(!buf) {
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_send(%d) ENOBUFS\n", s));
return -1;
}
netbuf_ref(buf,data,len);
err = netconn_send(sock->conn,buf);
netbuf_delete(buf);
break;
case NETCONN_TCP:
err = netconn_write(sock->conn,data,len,NETCONN_COPY);
break;
default:
err = ERR_ARG;
break;
}
if(err!=ERR_OK) {
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_send(%d) err=%d\n", s, err));
return -1;
}
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_send(%d) ok size=%d\n", s, len));
return len;
}
s32 net_write(s32 s,const void *data,s32 size)
{
return net_send(s,data,size,0);
}
s32 net_connect(s32 s,struct sockaddr *name,socklen_t namelen)
{
struct netsocket *sock;
err_t err;
sock = get_socket(s);
if(!sock) return -1;
if(((struct sockaddr_in*)name)->sin_family==AF_UNSPEC) {
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_connect(%d, AF_UNSPEC)\n", s));
err = netconn_disconnect(sock->conn);
} else {
struct ip_addr remote_addr;
u16 remote_port;
remote_addr.addr = ((struct sockaddr_in*)name)->sin_addr.s_addr;
remote_port = ((struct sockaddr_in*)name)->sin_port;
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_connect(%d, addr=", s));
ip_addr_debug_print(SOCKETS_DEBUG, &remote_addr);
LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u)\n", ntohs(remote_port)));
err = netconn_connect(sock->conn,&remote_addr,ntohs(remote_port));
}
if(err!=ERR_OK) {
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_connect(%d) failed, err=%d\n", s, err));
return -1;
}
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_connect(%d) succeeded\n", s));
return 0;
}
s32 net_close(s32 s)
{
struct netsocket *sock;
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_close(%d)\n", s));
LWP_SemWait(netsocket_sem);
sock = get_socket(s);
if(!sock) {
LWP_SemPost(netsocket_sem);
return -1;
}
netconn_delete(sock->conn);
if(sock->lastdata) netbuf_delete(sock->lastdata);
sock->lastdata = NULL;
sock->lastoffset = 0;
sock->conn = NULL;
LWP_SemPost(netsocket_sem);
return 0;
}
static s32 net_selscan(s32 maxfdp1,fd_set *readset,fd_set *writeset,fd_set *exceptset)
{
s32 i,nready = 0;
fd_set lreadset,lwriteset,lexceptset;
struct netsocket *sock;
FD_ZERO(&lreadset);
FD_ZERO(&lwriteset);
FD_ZERO(&lexceptset);
for(i=0;i<maxfdp1;i++) {
if(FD_ISSET(i,readset)) {
sock = get_socket(i);
if(sock && (sock->lastdata || sock->rcvevt)) {
FD_SET(i,&lreadset);
nready++;
}
}
if(FD_ISSET(i,writeset)) {
sock = get_socket(i);
if(sock && sock->sendevt) {
FD_SET(i,&lwriteset);
nready++;
}
}
}
*readset = lreadset;
*writeset = lwriteset;
FD_ZERO(exceptset);
return nready;
}
s32 net_select(s32 maxfdp1,fd_set *readset,fd_set *writeset,fd_set *exceptset,struct timeval *timeout)
{
s32 i,nready;
fd_set lreadset,lwriteset,lexceptset;
struct timespec tb,*p_tb;
struct netselect_cb sel_cb;
struct netselect_cb *psel_cb;
sel_cb.next = NULL;
sel_cb.readset = readset;
sel_cb.writeset = writeset;
sel_cb.exceptset = exceptset;
sel_cb.signaled = 0;
LWP_SemWait(sockselect_sem);
if(readset)
lreadset = *readset;
else
FD_ZERO(&lreadset);
if(writeset)
lwriteset = *writeset;
else
FD_ZERO(&lwriteset);
if(exceptset)
lexceptset = *exceptset;
else
FD_ZERO(&lexceptset);
nready = net_selscan(maxfdp1,&lreadset,&lwriteset,&lexceptset);
if(!nready) {
if(timeout && timeout->tv_sec==0 && timeout->tv_usec==0) {
LWP_SemPost(sockselect_sem);
if(readset)
FD_ZERO(readset);
if(writeset)
FD_ZERO(writeset);
if(exceptset)
FD_ZERO(exceptset);
return 0;
}
LWP_MutexInit(&sel_cb.cond_lck,FALSE);
LWP_CondInit(&sel_cb.cond);
sel_cb.next = selectcb_list;
selectcb_list = &sel_cb;
LWP_SemPost(sockselect_sem);
if(timeout==NULL)
p_tb = NULL;
else {
tb.tv_sec = timeout->tv_sec;
tb.tv_nsec = (timeout->tv_usec+500)*TB_NSPERUS;
p_tb = &tb;
}
LWP_MutexLock(sel_cb.cond_lck);
i = LWP_CondTimedWait(sel_cb.cond,sel_cb.cond_lck,p_tb);
LWP_MutexUnlock(sel_cb.cond_lck);
LWP_SemWait(sockselect_sem);
if(selectcb_list==&sel_cb)
selectcb_list = sel_cb.next;
else {
for(psel_cb = selectcb_list;psel_cb;psel_cb = psel_cb->next) {
if(psel_cb->next==&sel_cb) {
psel_cb->next = sel_cb.next;
break;
}
}
}
LWP_CondDestroy(sel_cb.cond);
LWP_MutexDestroy(sel_cb.cond_lck);
LWP_SemPost(sockselect_sem);
if(i==ETIMEDOUT) {
if(readset)
FD_ZERO(readset);
if(writeset)
FD_ZERO(writeset);
if(exceptset)
FD_ZERO(exceptset);
return 0;
}
if(readset)
lreadset = *readset;
else
FD_ZERO(&lreadset);
if(writeset)
lwriteset = *writeset;
else
FD_ZERO(&lwriteset);
if(exceptset)
lexceptset = *exceptset;
else
FD_ZERO(&lexceptset);
nready = net_selscan(maxfdp1,&lreadset,&lwriteset,&lexceptset);
} else
LWP_SemPost(sockselect_sem);
if(readset)
*readset = lreadset;
if(writeset)
*writeset = lwriteset;
if(exceptset)
*exceptset = lexceptset;
return nready;
}
s32 net_setsockopt(s32 s,u32 level,u32 optname,const void *optval,socklen_t optlen)
{
s32 err = 0;
struct netsocket *sock;
sock = get_socket(s);
if(sock==NULL) return -1;
if(optval==NULL) return -1;
switch(level) {
case SOL_SOCKET:
{
switch(optname) {
case SO_BROADCAST:
case SO_KEEPALIVE:
case SO_REUSEADDR:
case SO_REUSEPORT:
if(optlen<sizeof(u32)) err = EINVAL;
break;
default:
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_setsockopt(%d, SOL_SOCKET, UNIMPL: optname=0x%x, ..)\n", s, optname));
err = ENOPROTOOPT;
}
}
break;
case IPPROTO_IP:
{
switch(optname) {
case IP_TTL:
case IP_TOS:
if(optlen<sizeof(u32)) err = EINVAL;
break;
default:
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_setsockopt(%d, IPPROTO_IP, UNIMPL: optname=0x%x, ..)\n", s, optname));
err = ENOPROTOOPT;
}
}
break;
case IPPROTO_TCP:
{
if(optlen<sizeof(u32)) {
err = EINVAL;
break;
}
if(sock->conn->type!=NETCONN_TCP) return 0;
switch(optname) {
case TCP_NODELAY:
case TCP_KEEPALIVE:
break;
default:
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_setsockopt(%d, IPPROTO_TCP, UNIMPL: optname=0x%x, ..)\n", s, optname));
err = ENOPROTOOPT;
}
}
break;
default:
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_setsockopt(%d, level=0x%x, UNIMPL: optname=0x%x, ..)\n", s, level, optname));
err = ENOPROTOOPT;
}
if(err!=0) return -1;
switch(level) {
case SOL_SOCKET:
{
switch(optname) {
case SO_BROADCAST:
case SO_KEEPALIVE:
case SO_REUSEADDR:
case SO_REUSEPORT:
if(*(u32*)optval)
sock->conn->pcb.tcp->so_options |= optname;
else
sock->conn->pcb.tcp->so_options &= ~optname;
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_setsockopt(%d, SOL_SOCKET, optname=0x%x, ..) -> %s\n", s, optname, (*(u32*)optval?"on":"off")));
break;
}
}
break;
case IPPROTO_IP:
{
switch(optname) {
case IP_TTL:
sock->conn->pcb.tcp->ttl = (u8)(*(u32*)optval);
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_setsockopt(%d, IPPROTO_IP, IP_TTL, ..) -> %u\n", s, sock->conn->pcb.tcp->ttl));
break;
case IP_TOS:
sock->conn->pcb.tcp->tos = (u8)(*(u32*)optval);
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_setsockopt(%d, IPPROTO_IP, IP_TOS, ..)-> %u\n", s, sock->conn->pcb.tcp->tos));
break;
}
}
break;
case IPPROTO_TCP:
{
switch(optname) {
case TCP_NODELAY:
if(*(u32*)optval)
sock->conn->pcb.tcp->flags |= TF_NODELAY;
else
sock->conn->pcb.tcp->flags &= ~TF_NODELAY;
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_setsockopt(%d, IPPROTO_TCP, TCP_NODELAY) -> %s\n", s, (*(u32*)optval)?"on":"off") );
break;
case TCP_KEEPALIVE:
sock->conn->pcb.tcp->keepalive = (u32)(*(u32*)optval);
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_setsockopt(%d, IPPROTO_TCP, TCP_KEEPALIVE) -> %u\n", s, sock->conn->pcb.tcp->keepalive));
break;
}
}
}
return err?-1:0;
}
s32 net_ioctl(s32 s, u32 cmd, void *argp)
{
struct netsocket *sock = get_socket(s);
if(!sock) return -1;
switch (cmd) {
case FIONREAD:
if(!argp) return -1;
*((u16_t*)argp) = sock->conn->recvavail;
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_ioctl(%d, FIONREAD, %p) = %u\n", s, argp, *((u16*)argp)));
return 0;
case FIONBIO:
if(argp && *(u32*)argp)
sock->flags |= O_NONBLOCK;
else
sock->flags &= ~O_NONBLOCK;
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_ioctl(%d, FIONBIO, %d)\n", s, !!(sock->flags&O_NONBLOCK)));
return 0;
default:
LWIP_DEBUGF(SOCKETS_DEBUG, ("net_ioctl(%d, UNIMPL: 0x%lx, %p)\n", s, cmd, argp));
return -1;
}
}