void echo_application_thread()
{
int sock, new_sd;
struct sockaddr_in address, remote;
int size;
if ((sock = lwip_socket(AF_INET, SOCK_STREAM, 0)) < 0)
return;
address.sin_family = AF_INET;
address.sin_port = htons(echo_port);
address.sin_addr.s_addr = INADDR_ANY;
if (lwip_bind(sock, (struct sockaddr *)&address, sizeof (address)) < 0)
return;
lwip_listen(sock, 0);
size = sizeof(remote);
while (1) {
if ((new_sd = lwip_accept(sock, (struct sockaddr *)&remote, (socklen_t *)&size)) > 0) {
sys_thread_new("echos", process_echo_request,
(void*)new_sd,
THREAD_STACKSIZE,
DEFAULT_THREAD_PRIO);
}
}
}
/*
* Function: CreateUdpSocket
* Description: Create a socket to an UDP port
* Return: Handle to the socket
*/
int CreateUdpSocket(uint16_t port, UdpCbkFunc cbkFunc)
{
int udpSocket;
struct sockaddr_in sLocalAddr;
imask_t val;
/* Init socket */
udpSocket = lwip_socket(AF_INET, SOCK_DGRAM, 0);
Irq_Save(val);
for(int i=0;i<MAX_NUM_OF_SOCKETS;i++){
if(sockList[i] == (-1)){
sockList[i] = udpSocket;
cbkFuncList[i] = cbkFunc;
break;
}
}
Irq_Restore(val);
memset((char *)&sLocalAddr, 0, sizeof(sLocalAddr));
/*Source*/
sLocalAddr.sin_family = AF_INET;
sLocalAddr.sin_len = sizeof(sLocalAddr);
sLocalAddr.sin_addr.s_addr = htonl(INADDR_ANY);
sLocalAddr.sin_port = htons(port);
if(lwip_bind(udpSocket, (struct sockaddr *)&sLocalAddr, sizeof(sLocalAddr)) < 0)
{
KillUdpSocket(udpSocket);
}
return udpSocket;
}
void telnet_init(int vdefd)
{
int sockfd;
struct sockaddr_in serv_addr;
vdehist_termread=lwip_read;
vdehist_termwrite=lwip_write;
vdehist_logincmd=telnet_logincmd;
sockfd=lwip_socket(AF_INET, SOCK_STREAM, 0);
if (!sockfd) {
printlog(LOG_ERR,"telnet socket err: %s",strerror(errno));
}
bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(TELNET_TCP_PORT);
if (lwip_bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
printlog(LOG_ERR,"telnet bind err: %s",strerror(errno));
}
lwip_listen(sockfd, 5);
addpfd(sockfd,telnetaccept);
}
int
main(int argc, char **argv)
{
int sock, length;
struct sockaddr_in server;
int msgsock;
int i;
// intalization
lwip_tcpip_init();
/* DHCP */
//enum { BUF_SIZE = Nic::Packet_allocator::DEFAULT_PACKET_SIZE * 128 };
int BUF_SIZE= 200000;
if (lwip_nic_init(0, 0, 0, BUF_SIZE, BUF_SIZE)) {
printf("ERROR: We got no IP address!\n");
return 1;
}
/* Create socket */
sock = lwip_socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0) {
perror("opening stream socket");
exit(1);
}
/* Name socket using wildcards */
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = htons(SRV_PORT);
if (lwip_bind(sock, (struct sockaddr *)&server, sizeof(server))) {
perror("binding stream socket");
exit(1);
}
/* Find out assigned port number and print it out */
//length = sizeof(server);
//if (getsockname(sock, (struct sockaddr *)&server, &length)) {
// perror("getting socket name");
// exit(1);
// }
// printf("Socket has port #%d\n", ntohs(server.sin_port));
printf("Socket has port #%d\n",3333);
/* Start accepting connections */
lwip_listen(sock, 5);
do {
msgsock = lwip_accept(sock, 0, 0);
if (msgsock == -1)
perror("accept");
printf("process message on msgsock %d \n ",msgsock);
process_client(msgsock);
close(msgsock);
} while (TRUE);
/*
* Since this program has an infinite loop, the socket "sock" is
* never explicitly closed. However, all sockets will be closed
* automatically when a process is killed or terminates normally.
*/
}
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
{
int sock = socket_for_fd(sockfd);
int ret = lwip_bind(sock, addr, addrlen);
if (ret == 0)
mark_connected(sockfd, 1);
return ret;
}
int
mc_event_main(xsMachine *the, mc_event_shutdown_callback_t *cb)
{
struct timeval tv;
fd_set rs, ws;
int n = -1, i;
unsigned int flags;
uint64_t timeInterval;
struct sockaddr_in sin;
int localevent_sock;
mc_shutdown_callback = cb;
g_status = -1; /* not ready yet */
if ((localevent_sock = lwip_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
return -1;
sin.sin_family = AF_INET;
sin.sin_port = htons(MC_LOCAL_EVENT_PORT);
sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
lwip_bind(localevent_sock, (struct sockaddr *)&sin, sizeof(sin));
mc_event_register(localevent_sock, MC_SOCK_READ, mc_event_local_callback, the);
mc_event_delegation_init();
g_status = 0; /* running */
while (!g_status) {
timeInterval = mc_event_process_timeout(the);
if (timeInterval != 0) {
tv.tv_sec = timeInterval / 1000;
tv.tv_usec = (timeInterval % 1000) * 1000;
}
if (maxfd < 0) { /* @@ what if only timer is running?? */
mc_log_debug("event: no one is waiting!\n");
break; /* no one is waiting for anything! will be blocked forever unless break */
}
rs = reads;
ws = writes;
n = lwip_select(maxfd + 1, &rs, &ws, NULL, timeInterval > 0 ? &tv : NULL);
if (mc_event_callback_any.callback != NULL)
(*mc_event_callback_any.callback)(mc_event_callback_any.fd, (unsigned int)n, mc_event_callback_any.closure);
if (n > 0) {
for (i = 0; i <= maxfd; i++) {
flags = 0;
if (FD_ISSET(i, &rs))
flags |= MC_SOCK_READ;
if (FD_ISSET(i, &ws))
flags |= MC_SOCK_WRITE;
if (flags) {
if (mc_event_callbacks[i].callback == NULL) {
mc_log_error("event: %s ready for closed socket(%d)!?\n", flags & MC_SOCK_WRITE ? "write" : "read", i);
continue;
}
(*mc_event_callbacks[i].callback)(i, flags, mc_event_callbacks[i].closure);
}
}
}
}
mc_event_delegation_fin();
lwip_close(localevent_sock);
return g_exit_status;
}
/**
Bind to a port to listen for incoming data.
Before you can receive UDP data, you need to bind to a port. If you're only
going to be writing, you don't need to bother binding.
@param socket The socket obtained from udpOpen()
@param port An integer specifying the port to bind to.
@return True on success, false on failure.
\b Example
\code
int sock = udpOpen(); // create a new socket
if (udpBind(sock, 10000) == true) { // then bind to port 10000
// we're successfully bound, and ready to read
}
\endcode
*/
bool udpBind(int socket, int port)
{
struct sockaddr_in sa = {
.sin_family = AF_INET,
.sin_addr.s_addr = INADDR_ANY,
.sin_port = htons(port)
};
return lwip_bind(socket, (const struct sockaddr *)&sa, sizeof(sa)) == 0;
}
int LWIP_SOCKETS_Driver::Bind(SOCK_SOCKET socket, const SOCK_sockaddr* address, int addressLen)
{
NATIVE_PROFILE_PAL_NETWORK();
sockaddr_in addr;
SOCK_SOCKADDR_TO_SOCKADDR(address, addr, &addressLen);
return lwip_bind(socket, (sockaddr*)&addr, addressLen);
}
int zts_bind(int fd, const struct sockaddr *addr, socklen_t addrlen)
{
if (!addr) {
return ZTS_ERR_INVALID_ARG;
}
if (addrlen > (int)sizeof(struct sockaddr_storage) || addrlen < (int)sizeof(struct sockaddr_in)) {
return ZTS_ERR_INVALID_ARG;
}
return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_bind(fd, addr, addrlen);
}
void MTD_FLASHMEM UDPClient::init(IPAddress remoteAddress, uint16_t remotePort) {
m_socket = lwip_socket(AF_INET, SOCK_DGRAM, 0);
sockaddr_in localAddress = {0};
localAddress.sin_family = AF_INET;
localAddress.sin_len = sizeof(sockaddr_in);
localAddress.sin_addr.s_addr = htonl(INADDR_ANY);
localAddress.sin_port = htons(getUDPPort());
lwip_bind(m_socket.getSocket(), (sockaddr *)&localAddress, sizeof(sockaddr_in));
m_socket.setRemoteAddress(remoteAddress, remotePort);
}
void udpsend_thread(void *p)
{
int sd;
struct sockaddr_in server;
struct sockaddr_in to;
int BUFSIZE = 8192;
char buf[BUFSIZE];
struct ip_addr to_ipaddr;
int n, i;
/* create a new socket to send responses to this client */
sd = socket(AF_INET, SOCK_DGRAM, 0);
if (sd < 0) {
xil_printf("%s: error creating socket, return value = %d\r\n", __FUNCTION__, sd);
return ;
}
memset(&server, 0, sizeof server);
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = 9130;
if (lwip_bind(sd, (struct sockaddr *)&server, sizeof server) < 0) {
printf("error binding");
return ;
}
IP4_ADDR(&to_ipaddr, 192, 168, 1, 100);
memset(&to, 0, sizeof to);
to.sin_family = AF_INET;
to.sin_addr.s_addr = to_ipaddr.addr;
to.sin_port = 9123;
memset(buf, 0, sizeof buf);
buf[0] = '0'; buf[1] = '0';
buf[1400] = '1'; buf[1401] = '1';
buf[1500] = '2'; buf[1501] = '2';
buf[2000] = '3'; buf[2001] = '3';
/* send one packet to create ARP entry */
lwip_sendto(sd, buf, 1024, 0, (struct sockaddr *)&to, sizeof to);
/* wait until receive'd arp entry updates ARP cache */
sleep(20);
#if 1
/* now send real packets */
for (i = 0; i < 10; i++) {
n = lwip_sendto(sd, buf, sizeof buf, 0, (struct sockaddr *)&to, sizeof to);
xil_printf("sent bytes = %d\r\n", n);
}
#endif
}
static void socketCreate(uint16 sockNr)
{
int sockFd;
int sockType;
struct sockaddr_in sLocalAddr;
if (SocketAdminList[sockNr].SocketProtocolIsTcp) {
sockType = SOCK_STREAM;
} else {
sockType = SOCK_DGRAM;
}
sockFd = lwip_socket(AF_INET, sockType, 0);
if (sockFd >= 0) {
memset((char *)&sLocalAddr, 0, sizeof(sLocalAddr));
int on = 1;
lwip_ioctl(sockFd, FIONBIO, &on);
// lwip_setsockopt( sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(int) ); // shuzhou add
lwip_setsockopt(sockFd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(int)); // Set socket to no delay
/*Source*/
sLocalAddr.sin_family = AF_INET;
sLocalAddr.sin_len = sizeof(sLocalAddr);
sLocalAddr.sin_addr.s_addr = htonl(INADDR_ANY); // TODO: Use IP from configuration instead
sLocalAddr.sin_port = htons(SocketAdminList[sockNr].SocketConnectionRef->SocketLocalPort);
if(lwip_bind(sockFd, (struct sockaddr *)&sLocalAddr, sizeof(sLocalAddr)) >= 0) {
if (!SocketAdminList[sockNr].SocketProtocolIsTcp) {
// Now the UDP socket is ready for receive/transmit
SocketAdminList[sockNr].SocketHandle = sockFd;
SocketAdminList[sockNr].SocketState = SOCKET_UDP_READY;
} else {
if ( lwip_listen(sockFd, 20) == 0 ){ // TODO: What number of the backlog?
// Now the TCP socket is ready for receive/transmit
SocketAdminList[sockNr].SocketHandle = sockFd;
SocketAdminList[sockNr].SocketState = SOCKET_TCP_LISTENING;
} else {
lwip_close(sockFd);
}
}
} else {
lwip_close(sockFd);
}
} else {
// Socket creation failed
// Do nothing, try again later
}
}
BST_IP_ERR_T BST_IP_BsdBind( BST_FD_T fd, BST_UINT16 usPort )
{
struct sockaddr_in stLocalAddr;
if( !BST_IP_IsBsdFdValid(fd) )
{
return BST_IP_ERR_MEM;
}
stLocalAddr.sin_len = BST_OS_SIZEOF(stLocalAddr);
stLocalAddr.sin_family = AF_INET;
stLocalAddr.sin_port = PP_HTONS( usPort );
stLocalAddr.sin_addr.s_addr = BST_IP_ADDRESS_ANY;
return (BST_IP_ERR_T)lwip_bind( fd.lFd, ( struct sockaddr *)&stLocalAddr, BST_OS_SIZEOF(stLocalAddr) );
}
void rx_application_thread()
{
int sock, new_sd;
struct sockaddr_in address, remote;
int size;
if ((sock = lwip_socket(AF_INET, SOCK_STREAM, 0)) < 0)
return;
address.sin_family = AF_INET;
address.sin_port = htons(rxperf_port);
address.sin_addr.s_addr = INADDR_ANY;
if (lwip_bind(sock, (struct sockaddr *)&address, sizeof (address)) < 0) {
#ifdef OS_IS_FREERTOS
vTaskDelete(NULL);
#endif
return;
}
lwip_listen(sock, 0);
size = sizeof(remote);
new_sd = lwip_accept(sock, (struct sockaddr *)&remote, (socklen_t*)&size);
while (1) {
#if (USE_JUMBO_FRAMES==1)
char recv_buf[9700];
/* keep reading data */
if (lwip_read(new_sd, recv_buf, 8000) <= 0)
break;
#else
char recv_buf[1500];
/* keep reading data */
if (lwip_read(new_sd, recv_buf, 1460) <= 0)
break;
#endif
}
print("Connection closed. RXPERF exiting.\r\n");
lwip_close(new_sd);
#ifdef OS_IS_FREERTOS
xil_printf("Rx IPERF Thread is being DELETED\r\n");
vTaskDelete(NULL);
#endif
}
static void receive_udp(void *pvParameters) {
int lSocket;
struct sockaddr_in sLocalAddr, sDestAddr;
int nbytes;
int i;
lSocket = lwip_socket(AF_INET, SOCK_DGRAM, 0);
if(lSocket != 0) {
printf("ERROR \r\n");
}
memset((char *)&sLocalAddr, 0, sizeof(sLocalAddr));
memset((char *)&sDestAddr, 0, sizeof(sDestAddr));
/*Destination*/
sDestAddr.sin_family = AF_INET;
sDestAddr.sin_len = sizeof(sDestAddr);
sDestAddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
sDestAddr.sin_port = htons(8080);
/*Source*/
sLocalAddr.sin_family = AF_INET;
sLocalAddr.sin_len = sizeof(sLocalAddr);
sLocalAddr.sin_addr.s_addr = htonl(INADDR_ANY); //inet_addr("192.168.4.1");
sLocalAddr.sin_port = htons(8080);
int err = lwip_bind(lSocket, (struct sockaddr *)&sLocalAddr, sizeof(sLocalAddr));
if(err != 0) {
printf("ERROR \r\n");
}
while (1) {
nbytes=lwip_recv(lSocket, buffer, sizeof(buffer),8);
if (nbytes>0) {
//lwip_sendto(lSocket, buffer, nbytes, 0, (struct sockaddr *)&sDestAddr, sizeof(sDestAddr));
char * dat = malloc(nbytes);
memcpy(dat, buffer, nbytes);
dat[nbytes] = 0;
my_event_t ev;
ev.event_type = EVT_DATA;
ev.data = dat;
ev.len = nbytes;
xQueueSend(mainqueue, &ev, 0);
}
}
lwip_close(lSocket);
}
/* ------------------------------------------------------------------------------------------------------
* sockex_nonblocking_connect()
*
* Description : Handing socket receive data.
*
* Argument(s) : none.
*
*/
void sockex_testrecv(void *arg)
{
// int ret;
struct sockaddr_in servaddr, cliaddr;
// struct timeval tv;
unsigned long cliaddr_len;
LWIP_UNUSED_ARG(arg);
memset(&servaddr, 0, sizeof(servaddr)); /* set up address to connect to */
servaddr.sin_len = sizeof(servaddr);
servaddr.sin_family = AF_INET;
servaddr.sin_port = PP_HTONS(SOCK_HOSR_PORT);
servaddr.sin_addr.s_addr = lwIPLocalIPAddrGet(); /* Set local IP address.*/
listenfd = lwip_socket(AF_INET, SOCK_STREAM, 0);
lwip_bind(listenfd, (struct sockaddr *)&servaddr, sizeof(struct sockaddr));
lwip_listen(listenfd, SOCK_HOSR_PORT);
RS232printf("Accepting connections ...\n");
cliaddr_len = sizeof(cliaddr);
for(;;)
{
connfd = lwip_accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
if(connfd <= 0)
{
OSTimeDly(2);
continue;
}
else
{
connfd = connfd;
RS232printf("cli is ok!");
}
// lwip_select();
OSTimeDly(2);
}
}
int32_t OsNetworkBind(THandle aHandle, TIpAddress aAddress, uint32_t aPort)
{
if ( OsNetworkHandle_IsInterrupted(aHandle) )
return -1;
LOGFUNCIN();
struct sockaddr_in s;
s.sin_family = AF_INET;
s.sin_port = htons(aPort);
s.sin_addr.s_addr = aAddress; // this is already stored in network order
int err = lwip_bind ( HANDLE_TO_SOCKET(aHandle), (struct sockaddr*) &s, sizeof(s) );
if ( err == EADDRINUSE )
return -2;
LOGFUNCOUT();
return err;
}
/* http server */
int
web_application_thread()
{
int sock, new_sd;
struct sockaddr_in address, remote;
socklen_t size;
/* create a TCP socket */
if ((sock = lwip_socket(AF_INET, SOCK_STREAM, 0)) < 0)
return 0;
/* bind to port 80 at any interface */
address.sin_family = AF_INET;
address.sin_port = htons(http_port);
address.sin_addr.s_addr = INADDR_ANY;
if (lwip_bind(sock, (struct sockaddr *) &address, sizeof(address)) < 0)
return 0;
/* listen for incoming connections */
lwip_listen(sock, 5);
size = sizeof(remote);
while (1) {
sys_thread_t new_thread;
new_sd =
lwip_accept(sock, (struct sockaddr *) &remote,
&size);
/* spawn a separate handler for each request */
new_thread = sys_thread_new("httpd", (void (*)(void *)) process_http_request,
(void *) new_sd, THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);
/* close connection if no new threads available */
if (new_thread == 0) {
close(new_sd);
}
}
return 0;
}
/* http server */
int
web_application_thread()
{
int sock, new_sd;
struct sockaddr_in address, remote;
int size;
/* create a TCP socket */
if ((sock = lwip_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
#ifdef OS_IS_FREERTOS
vTaskDelete(NULL);
#endif
return -1;
}
/* bind to port 80 at any interface */
address.sin_family = AF_INET;
address.sin_port = htons(http_port);
address.sin_addr.s_addr = INADDR_ANY;
if (lwip_bind(sock, (struct sockaddr *)&address, sizeof (address)) < 0) {
#ifdef OS_IS_FREERTOS
vTaskDelete(NULL);
#endif
return -1;
}
/* listen for incoming connections */
lwip_listen(sock, 0);
size = sizeof(remote);
while (1) {
new_sd = lwip_accept(sock, (struct sockaddr *)&remote, (socklen_t *)&size);
/* spawn a separate handler for each request */
process_http_request((void*)new_sd);
//sys_thread_new("httpd", (void(*)(void*))process_http_request, (void*)new_sd,
// THREAD_STACKSIZE,
// DEFAULT_THREAD_PRIO);
}
return 0;
}
static int OsNetworkHandle_Initialise(OsNetworkHandle* aHandle, int aSocket)
{
LOGFUNC();
aHandle->iSocket = aSocket;
#if INT_ENABLED
int ih = lwip_socket(AF_INET, SOCK_DGRAM, 0);
if ( ih < 0 )
{
LOG("%s failed with %d\n", __FUNCTION__, errno);
return -1;
}
struct sockaddr_in s;
s.sin_family = AF_INET;
s.sin_port = htons( 10000 + (short) aSocket ); // relate port to fd
s.sin_addr.s_addr = IPADDR_LOOPBACK; // localhost
int err = lwip_bind ( ih, (struct sockaddr*) &s, sizeof(s) );
if ( err < 0 )
{
lwip_close(ih);
return -1;
}
aHandle->iIntSocket = ih;
#endif
LOG("Created OsNetworkHandle %d:%d\n", aHandle->iSocket, aHandle->iIntSocket);
return 0;
}
void Test_lwIP()
{
int server;
int client;
int acceptSock;
int nonblock;
int recvd;
struct sockaddr_in addr, acceptAddr;
socklen_t len;
// tcp interface variables
struct ip_addr IpAddrLB;
IP4_ADDR( &IpAddrLB, 127,0,0,1); //Loopback
addr.sin_family = AF_INET;
addr.sin_port = 8080;
addr.sin_addr.s_addr = *(u32_t*)&IpAddrLB;
addr.sin_len = sizeof(struct sockaddr_in);
server = lwip_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
client = lwip_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
nonblock = 1;
if(server == -1 || client == -1) lcd_printf("Sockets were not created!\n");
if(-1 == lwip_ioctl(server, FIONBIO, (void*)&nonblock)) lcd_printf("Error ioctl 1\n");
if(-1 == lwip_ioctl(client, FIONBIO, (void*)&nonblock)) lcd_printf("Error ioctl 2\n");
len = sizeof(addr);
if(-1 == lwip_bind( server, (const struct sockaddr*)&addr, len ))lcd_printf("Error bind\n");
if(-1 == lwip_listen( server, 2 )) lcd_printf("Error listen\n");
/ / Set up a tcp connection for client: Bind, Connect
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
{
struct fdtab_entry *e = fdtab_get(sockfd);
switch(e->type) {
case FDTAB_TYPE_UNIX_SOCKET:
assert(addrlen >= sizeof(struct sockaddr_un));
assert(addr->sa_family == AF_UNIX);
struct _unix_socket *us = e->handle;
memcpy(&us->sockaddr, addr, sizeof(struct sockaddr_un));
POSIXCOMPAT_DEBUG("bind(%d, %p (%s), %u)\n", sockfd, addr,
us->sockaddr.sun_path, addrlen);
// XXX: Should fail if file already exists
// Create socket file
errval_t err = vfs_create(us->sockaddr.sun_path, &us->vfs_handle);
if(err_is_fail(err)) {
DEBUG_ERR(err, "vfs_create");
return -1;
}
break;
case FDTAB_TYPE_LWIP_SOCKET:
lwip_mutex_lock();
int ret = lwip_bind(e->fd, addr, addrlen);
lwip_mutex_unlock();
return ret;
default:
return -1;
}
return 0;
}
int Socket::BindToAddr(const std::string& addr, const std::string& port)
{
struct sockaddr_in my_addr;
memset(&my_addr, 0, sizeof(struct sockaddr_in));
my_addr.sin_family = AF_INET;
my_addr.sin_addr.s_addr = INADDR_ANY;
my_addr.sin_port = htons(atoi(port.c_str()));
if (addr != "ANY" && inet_addr(addr.c_str()) != INADDR_NONE)
{
my_addr.sin_addr.s_addr = inet_addr(addr.c_str());
}
log(LOG_NOTICE) << "binding to " << addr << " -> " << inet_ntoa(my_addr.sin_addr) << " port " << port;
if (lwip_bind(socket_->fd, (struct sockaddr *) &my_addr, sizeof(my_addr)) < 0)
{
log(LOG_EMERG) << "Error on bind!";
return -1;
}
return 0;
}
//--------------------------------------------------------------
void serverThread(void *args) // Server thread: Handle Client & packets
{
int tcp_socket;
struct sockaddr_in peer;
int peerlen, r, err;
conn_retry:
peer.sin_family = AF_INET;
peer.sin_port = htons(SERVER_TCP_PORT);
peer.sin_addr.s_addr = htonl(INADDR_ANY);
#ifdef _NETLOG
netlog_send("%s: server init starting...\n", MODNAME);
#endif
// create the socket
tcp_socket = lwip_socket(AF_INET, SOCK_STREAM, 0);
if (tcp_socket < 0) {
err = -1;
goto error;
}
#ifdef _NETLOG
netlog_send("%s: server socket created.\n", MODNAME);
#endif
r = lwip_bind(tcp_socket,(struct sockaddr *)&peer,sizeof(peer));
if (r < 0) {
err = -2;
goto error;
}
#ifdef _NETLOG
netlog_send("%s: bind OK.\n", MODNAME);
#endif
r = lwip_listen(tcp_socket, 3);
if (r < 0) {
err = -3;
goto error;
}
#ifdef _NETLOG
netlog_send("%s: server ready!\n", MODNAME);
#endif
while(1) {
peerlen = sizeof(peer);
r = lwip_accept(tcp_socket,(struct sockaddr *)&peer, &peerlen);
if (r < 0) {
err = -4;
goto error;
}
client_socket = r;
r = handleClient(client_socket);
if (r < 0) {
lwip_close(client_socket);
#ifdef _NETLOG
netlog_send("%s: Client Connection closed - error %d\n", MODNAME, r);
#endif
}
}
error:
lwip_close(client_socket);
#ifdef _NETLOG
netlog_send("%s: Client Connection closed - error %d\n", MODNAME, err);
#endif
goto conn_retry;
}
static void
serve_thread(uint32_t a) {
struct st_args *args = (struct st_args *)a;
union Nsipc *req = args->req;
int r;
switch (args->reqno) {
case NSREQ_ACCEPT:
{
struct Nsret_accept ret;
r = lwip_accept(req->accept.req_s, &ret.ret_addr,
&ret.ret_addrlen);
memmove(req, &ret, sizeof ret);
break;
}
case NSREQ_BIND:
r = lwip_bind(req->bind.req_s, &req->bind.req_name,
req->bind.req_namelen);
break;
case NSREQ_SHUTDOWN:
r = lwip_shutdown(req->shutdown.req_s, req->shutdown.req_how);
break;
case NSREQ_CLOSE:
r = lwip_close(req->close.req_s);
break;
case NSREQ_CONNECT:
r = lwip_connect(req->connect.req_s, &req->connect.req_name,
req->connect.req_namelen);
break;
case NSREQ_LISTEN:
r = lwip_listen(req->listen.req_s, req->listen.req_backlog);
break;
case NSREQ_RECV:
// Note that we read the request fields before we
// overwrite it with the response data.
r = lwip_recv(req->recv.req_s, req->recvRet.ret_buf,
req->recv.req_len, req->recv.req_flags);
break;
case NSREQ_SEND:
r = lwip_send(req->send.req_s, &req->send.req_buf,
req->send.req_size, req->send.req_flags);
break;
case NSREQ_SOCKET:
r = lwip_socket(req->socket.req_domain, req->socket.req_type,
req->socket.req_protocol);
break;
case NSREQ_INPUT:
jif_input(&nif, (void *)&req->pkt);
r = 0;
break;
default:
cprintf("Invalid request code %d from %08x\n", args->whom, args->req);
r = -E_INVAL;
break;
}
if (r == -1) {
char buf[100];
snprintf(buf, sizeof buf, "ns req type %d", args->reqno);
perror(buf);
}
if (args->reqno != NSREQ_INPUT)
ipc_send(args->whom, r, 0, 0);
put_buffer(args->req);
sys_page_unmap(0, (void*) args->req);
free(args);
}
int OTAClass::beginLocal(uint16_t port, bool reboot_when_success) {
int ret = -1;
// variables for image processing
flash_t flash;
uint32_t img2_addr, img2_len, img3_addr, img3_len;
uint32_t img_upper_bound;
uint32_t checksum = 0;
uint32_t signature1, signature2;
// variables for network processing
int server_socket = -1;
int client_socket = -1;
struct sockaddr_in localHost;
struct sockaddr_in client_addr;
int socket_error, socket_timeout;
socklen_t optlen;
// variables for OTA
unsigned char *buf = NULL;
int read_bytes = 0, processed_len;
uint32_t file_info[3];
uint32_t ota_len;
uint32_t ota_blk_size = 0;
int i, n;
do {
sync_ota_addr();
get_image_info(&img2_addr, &img2_len, &img3_addr, &img3_len);
img_upper_bound = img2_addr + 0x10 + img2_len; // image2 base + header + len
if (img3_len > 0) {
img_upper_bound += 0x10 + img3_len; // image 3 header + len
}
if ((ota_addr & 0xfff != 0) || (ota_addr == ~0x0) || (ota_addr < img_upper_bound)) {
OTA_PRINTF("Invalid OTA address: %08X\r\n", ota_addr);
break;
}
buf = (unsigned char *) malloc (BUFSIZE);
if (buf == NULL) {
OTA_PRINTF("Fail to allocate memory\r\n");
break;
}
server_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (server_socket < 0) {
OTA_PRINTF("Fail to create socket\r\n");
break;
}
memset(&localHost, 0, sizeof(localHost));
localHost.sin_family = AF_INET;
localHost.sin_port = htons(port);
localHost.sin_addr.s_addr = INADDR_ANY;
if (lwip_bind(server_socket, (struct sockaddr *)&localHost, sizeof(localHost)) < 0) {
OTA_PRINTF("Bind fail\r\n");
break;
}
if (lwip_listen(server_socket , 1) < 0) {
OTA_PRINTF("Listen fail\r\n");
break;
}
OTA_PRINTF("Wait for client\r\n");
n = (int) sizeof( client_addr );
memset(&client_addr, 0, sizeof(client_addr));
client_socket = lwip_accept(server_socket, (struct sockaddr *) &client_addr, (socklen_t *)&n);
OTA_PRINTF("Client connected. IP:%s port:%d\r\n\r\n", inet_ntoa(client_addr.sin_addr.s_addr), ntohs(client_addr.sin_port));
socket_timeout = DEFAULT_IMAGE_DOWNLOAD_TIMEOUT;
lwip_setsockopt(client_socket, SOL_SOCKET, SO_RCVTIMEO, &socket_timeout, sizeof(socket_timeout));
OTA_PRINTF("Read OTA info...\r\n");
read_bytes = read(client_socket, file_info, sizeof(file_info));
if (read_bytes < 0) {
OTA_PRINTF("Fail to read OTA info\r\n");
break;
}
if (file_info[2] == 0) {
OTA_PRINTF("OTA image len is 0\r\n");
break;
}
ota_len = file_info[2];
ota_blk_size = ((ota_len - 1) / 4096) + 1;
for (i = 0; i < ota_blk_size; i++) {
flash_erase_sector(&flash, ota_addr + i * 4096);
}
OTA_PRINTF("Start download\r\n");
// Now download OTA image
processed_len = 0;
while( processed_len < ota_len ) {
memset(buf, 0, BUFSIZE);
read_bytes = read(client_socket, buf, BUFSIZE);
if (read_bytes < 0) {
optlen = sizeof(socket_error);
getsockopt(client_socket, SOL_SOCKET, SO_ERROR, &socket_error, &optlen);
if (socket_error == EAGAIN) {
// socket timeout
}
break;
}
if (flash_stream_write(&flash, ota_addr + processed_len, read_bytes, buf) < 0) {
OTA_PRINTF("Write sector fail\r\n");
break;
}
processed_len += read_bytes;
}
if (processed_len != ota_len) {
OTA_PRINTF("Download fail\r\n");
break;
}
// Read OTA image from flash and calculate checksum
checksum = processed_len = 0;
while ( processed_len < ota_len ) {
n = (processed_len + BUFSIZE < ota_len) ? BUFSIZE : (ota_len - processed_len);
flash_stream_read(&flash, ota_addr + processed_len, n, buf);
for (i=0; i<n; i++) checksum += (buf[i] & 0xFF);
processed_len += n;
}
if (checksum != file_info[0]) {
OTA_PRINTF("Bad checksum:%d expected:%d\r\n", checksum, file_info[0]);
break;
}
// Put signature for OTA image
flash_write_word(&flash, ota_addr + 8, 0x35393138);
flash_write_word(&flash, ota_addr + 12, 0x31313738);
flash_read_word(&flash, ota_addr + 8, &signature1);
flash_read_word(&flash, ota_addr + 12, &signature2);
if (signature1 != 0x35393138 || signature2 != 0x31313738) {
OTA_PRINTF("Put signature fail\r\n");
break;
}
// Mark image 2 as old image
flash_write_word(&flash, img2_addr + 8, 0x35393130);
ret = 0;
OTA_PRINTF("OTA success\r\n");
} while (0);
if (buf != NULL) {
free(buf);
}
if (server_socket >= 0) {
close(server_socket);
}
if (client_socket >= 0) {
close(client_socket);
}
if (ret < 0) {
OTA_PRINTF("OTA fail\r\n");
} else {
if (reboot_when_success) {
sys_reset();
}
}
return ret;
}
/**
* Send an SNTP request via sockets.
* This is a very minimal implementation that does not fully conform
* to the SNTPv4 RFC, especially regarding server load and error procesing.
*/
void
sntp_request(void *arg)
{
int sock;
struct sockaddr_in local;
struct sockaddr_in to;
int tolen;
int size;
int timeout;
struct sntp_msg sntpmsg;
ip_addr_t sntp_server_address;
LWIP_UNUSED_ARG(arg);
/* if we got a valid SNTP server address... */
if (ipaddr_aton(SNTP_SERVER_ADDRESS, &sntp_server_address)) {
/* create new socket */
sock = lwip_socket(AF_INET, SOCK_DGRAM, 0);
if (sock >= 0) {
/* prepare local address */
memset(&local, 0, sizeof(local));
local.sin_family = AF_INET;
local.sin_port = PP_HTONS(INADDR_ANY);
local.sin_addr.s_addr = PP_HTONL(INADDR_ANY);
/* bind to local address */
if (lwip_bind(sock, (struct sockaddr *)&local, sizeof(local)) == 0) {
/* set recv timeout */
timeout = SNTP_RECV_TIMEOUT;
lwip_setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
/* prepare SNTP request */
sntp_initialize_request(&sntpmsg);
/* prepare SNTP server address */
memset(&to, 0, sizeof(to));
to.sin_family = AF_INET;
to.sin_port = PP_HTONS(SNTP_PORT);
inet_addr_from_ipaddr(&to.sin_addr, &sntp_server_address);
/* send SNTP request to server */
if (lwip_sendto(sock, &sntpmsg, SNTP_MSG_LEN, 0, (struct sockaddr *)&to, sizeof(to)) >= 0) {
/* receive SNTP server response */
tolen = sizeof(to);
size = lwip_recvfrom(sock, &sntpmsg, SNTP_MSG_LEN, 0, (struct sockaddr *)&to, (socklen_t *)&tolen);
/* if the response size is good */
if (size == SNTP_MSG_LEN) {
/* if this is a SNTP response... */
if (((sntpmsg.li_vn_mode & SNTP_MODE_MASK) == SNTP_MODE_SERVER) ||
((sntpmsg.li_vn_mode & SNTP_MODE_MASK) == SNTP_MODE_BROADCAST)) {
/* do time processing */
sntp_process(sntpmsg.receive_timestamp);
} else {
LWIP_DEBUGF( SNTP_DEBUG_WARN, ("sntp_request: not response frame code\n"));
}
}
} else {
LWIP_DEBUGF( SNTP_DEBUG_WARN, ("sntp_request: not sendto==%i\n", errno));
}
}
/* close the socket */
closesocket(sock);
}
}
}
void vBasicSocketsCommandInterpreterTask( void *pvParameters )
{
long lSocket, lClientFd, lBytes, lAddrLen = sizeof( struct sockaddr_in ), lInputIndex;
struct sockaddr_in sLocalAddr;
struct sockaddr_in client_addr;
const char *pcWelcomeMessage = "FreeRTOS command server - connection accepted.\r\nType Help to view a list of registered commands.\r\n\r\n>";
char cInChar;
static char cInputString[ cmdMAX_INPUT_SIZE ], cOutputString[ cmdMAX_OUTPUT_SIZE ];
portBASE_TYPE xReturned;
extern void vRegisterSampleCLICommands( void );
( void ) pvParameters;
/* Register the standard CLI commands. */
vRegisterSampleCLICommands();
lSocket = lwip_socket(AF_INET, SOCK_STREAM, 0);
if( lSocket >= 0 )
{
memset((char *)&sLocalAddr, 0, sizeof(sLocalAddr));
sLocalAddr.sin_family = AF_INET;
sLocalAddr.sin_len = sizeof(sLocalAddr);
sLocalAddr.sin_addr.s_addr = htonl(INADDR_ANY);
sLocalAddr.sin_port = ntohs( ( ( unsigned short ) 23 ) );
if( lwip_bind( lSocket, ( struct sockaddr *) &sLocalAddr, sizeof( sLocalAddr ) ) < 0 )
{
lwip_close( lSocket );
vTaskDelete( NULL );
}
if( lwip_listen( lSocket, 20 ) != 0 )
{
lwip_close( lSocket );
vTaskDelete( NULL );
}
for( ;; )
{
lClientFd = lwip_accept(lSocket, ( struct sockaddr * ) &client_addr, ( u32_t * ) &lAddrLen );
if( lClientFd > 0L )
{
lwip_send( lClientFd, pcWelcomeMessage, strlen( ( const char * ) pcWelcomeMessage ), 0 );
lInputIndex = 0;
memset( cInputString, 0x00, cmdMAX_INPUT_SIZE );
do
{
lBytes = lwip_recv( lClientFd, &cInChar, sizeof( cInChar ), 0 );
if( lBytes > 0L )
{
if( cInChar == '\n' )
{
/* The input string has been terminated. Was the
input a quit command? */
if( strcmp( "quit", ( const char * ) cInputString ) == 0 )
{
/* Set lBytes to 0 to close the connection. */
lBytes = 0L;
}
else
{
/* The input string was not a quit command.
Pass the string to the command interpreter. */
do
{
/* Get the next output string from the command interpreter. */
xReturned = FreeRTOS_CLIProcessCommand( cInputString, cOutputString, cmdMAX_INPUT_SIZE );
lwip_send( lClientFd, cOutputString, strlen( ( const char * ) cOutputString ), 0 );
} while( xReturned != pdFALSE );
/* All the strings generated by the input
command have been sent. Clear the input
string ready to receive the next command. */
lInputIndex = 0;
memset( cInputString, 0x00, cmdMAX_INPUT_SIZE );
lwip_send( lClientFd, "\r\n>", strlen( "\r\n>" ), 0 );
}
}
else
{
if( cInChar == '\r' )
{
/* Ignore the character. */
}
else if( cInChar == '\b' )
{
/* Backspace was pressed. Erase the last
character in the string - if any. */
if( lInputIndex > 0 )
{
lInputIndex--;
cInputString[ lInputIndex ] = '\0';
}
}
else
{
/* A character was entered. Add it to the string
entered so far. When a \n is entered the complete
string will be passed to the command interpreter. */
if( lInputIndex < cmdMAX_INPUT_SIZE )
{
cInputString[ lInputIndex ] = cInChar;
lInputIndex++;
}
}
}
}
} while( lBytes > 0L );
lwip_close( lClientFd );
}
}
}
/* Will only get here if a listening socket could not be created. */
vTaskDelete( NULL );
}
/**************************************************************
* void chargen_thread(void *arg)
*
* chargen task. This server will wait for connections on well
* known TCP port number: 19. For every connection, the server will
* write as much data as possible to the tcp port.
**************************************************************/
static void chargen_thread(void *arg)
{
int listenfd;
struct sockaddr_in chargen_saddr;
fd_set readset;
fd_set writeset;
int i, maxfdp1;
struct charcb *p_charcb;
/* First acquire our socket for listening for connections */
listenfd = lwip_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
LWIP_ASSERT("chargen_thread(): Socket create failed.", listenfd >= 0);
memset(&chargen_saddr, 0, sizeof(chargen_saddr));
chargen_saddr.sin_family = AF_INET;
chargen_saddr.sin_addr.s_addr = htonl(INADDR_ANY);
chargen_saddr.sin_port = htons(19); // Chargen server port
if (lwip_bind(listenfd, (struct sockaddr *) &chargen_saddr, sizeof(chargen_saddr)) == -1)
LWIP_ASSERT("chargen_thread(): Socket bind failed.", 0);
/* Put socket into listening mode */
if (lwip_listen(listenfd, MAX_SERV) == -1)
LWIP_ASSERT("chargen_thread(): Listen failed.", 0);
/* Wait forever for network input: This could be connections or data */
for (;;) {
maxfdp1 = listenfd+1;
/* Determine what sockets need to be in readset */
FD_ZERO(&readset);
FD_ZERO(&writeset);
FD_SET(listenfd, &readset);
for (p_charcb = charcb_list; p_charcb; p_charcb = p_charcb->next) {
if (maxfdp1 < p_charcb->socket + 1)
maxfdp1 = p_charcb->socket + 1;
FD_SET(p_charcb->socket, &readset);
FD_SET(p_charcb->socket, &writeset);
}
/* Wait for data or a new connection */
i = lwip_select(maxfdp1, &readset, &writeset, 0, 0);
if (i == 0) continue;
/* At least one descriptor is ready */
if (FD_ISSET(listenfd, &readset)) {
/* We have a new connection request!!! */
/* Lets create a new control block */
p_charcb = (struct charcb *)rt_calloc(1, sizeof(struct charcb));
if (p_charcb) {
p_charcb->socket = lwip_accept(listenfd,
(struct sockaddr *) &p_charcb->cliaddr,
&p_charcb->clilen);
if (p_charcb->socket < 0)
rt_free(p_charcb);
else {
/* Keep this tecb in our list */
p_charcb->next = charcb_list;
charcb_list = p_charcb;
p_charcb->nextchar = 0x21;
}
} else {
/* No memory to accept connection. Just accept and then close */
int sock;
struct sockaddr cliaddr;
socklen_t clilen;
sock = lwip_accept(listenfd, &cliaddr, &clilen);
if (sock >= 0)
lwip_close(sock);
}
}
/* Go through list of connected clients and process data */
for (p_charcb = charcb_list; p_charcb; p_charcb = p_charcb->next) {
if (FD_ISSET(p_charcb->socket, &readset)) {
/* This socket is ready for reading. This could be because someone typed
* some characters or it could be because the socket is now closed. Try reading
* some data to see. */
if (do_read(p_charcb) < 0)
break;
}
if (FD_ISSET(p_charcb->socket, &writeset)) {
char line[80];
char setchar = p_charcb->nextchar;
for( i = 0; i < 59; i++) {
line[i] = setchar;
if (++setchar == 0x7f)
setchar = 0x21;
}
line[i] = 0;
strcat(line, "\n\r");
if (lwip_write(p_charcb->socket, line, strlen(line)) < 0) {
close_chargen(p_charcb);
break;
}
if (++p_charcb->nextchar == 0x7f)
p_charcb->nextchar = 0x21;
}
}
}
}
/* ------------------------------------------------------------------------------------------------------
* sockex_selects()
*
* Description : socket selects test.
*
* Argument(s) : none.
*
*/
void sockex_selects(void *arg)
{
int sock_fd, new_fd;
struct sockaddr_in server_addr;
struct sockaddr_in client_addr;
socklen_t sin_size;
int yes;
INT8U buf[BUF_SIZE];
int ret;
int i;
fd_set fdsr; /* Create file descriptor.*/
int maxsock;
struct timeval tv;
conn_amount = 0;
LWIP_UNUSED_ARG(arg);
sock_fd = lwip_socket(AF_INET, SOCK_STREAM, 0);
yes = 1;
ret = lwip_setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
if(ret == -1)
{
return;
}
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_len = sizeof(server_addr);
server_addr.sin_port = PP_HTONS(SOCK_HOSR_PORT);
server_addr.sin_addr.s_addr = lwIPLocalIPAddrGet(); /* IP_ADDR_ANY is '0.0.0.0'.*/
lwip_bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr));
lwip_listen(sock_fd, BACKLOG + 1); /* MAX TCP client is BACKLOG.*/
sin_size = sizeof(client_addr);
maxsock = sock_fd;
while(1)
{
FD_ZERO(&fdsr); /* Initialize file descriptor set.*/
FD_SET(sock_fd, &fdsr);
tv.tv_sec = 10; /* Timeout setting.*/
tv.tv_usec = 0;
for (i = 0; i < BACKLOG; i++) /* Add active connection to fd set.*/
{
if (fd_A[i] != 0) {
FD_SET(fd_A[i], &fdsr);
}
}
ret = lwip_select(maxsock + 1, &fdsr, NULL, NULL, &tv);
if(ret < 0)
{
break;
}
else if(ret == 0)
{
continue;
}
for (i = 0; i < conn_amount; i++) /* Check every fd in the set.*/
{
if (FD_ISSET(fd_A[i], &fdsr))
{
int opt = 100; /* set recv timeout (100 ms) */
lwip_setsockopt(fd_A[i], SOL_SOCKET, SO_RCVTIMEO, &opt, sizeof(int));
ret = lwip_read(fd_A[i], buf, 8);
if (ret <= 0)
{
// lwip_close(fd_A[i]);
// FD_CLR(fd_A[i], &fdsr);
// fd_A[i] = 0;
}
else /* receive data.*/
{
if((buf[0] == 'C')&&(buf[1] == 'o'))
{
// address_t addr;
// INT8U mac[8] = {0x00, 0x12, 0x4B, 0x00, 0x01, 0xC0, 0xB7, 0xE0};
// addr.mode = LONG_ADDR;
// utilReverseBuf(mac, 8);
// memcpy(addr.long_addr, mac, 8);
// mac_tx_handle(&addr, &buf[7], 1, MAC_DATA);
}
if (ret < BUF_SIZE)
memset(&buf[ret], '\0', 1);
}
}
}
if(FD_ISSET(sock_fd, &fdsr)) /* Check whether a new connection comes.*/
{
new_fd = lwip_accept(sock_fd, (struct sockaddr *)&client_addr, &sin_size);
if(new_fd <= 0)
{
continue;
}
// lwip_send(new_fd, "con", 4, 0);
if(conn_amount < BACKLOG) /* Add to fd queue.*/
{
fd_A[conn_amount++] = new_fd;
if(new_fd > maxsock)
maxsock = new_fd;
}
else
{
// conn_amount = 0;
lwip_close(fd_A[conn_amount-1]);
fd_A[conn_amount-1] = new_fd;
if(new_fd > maxsock)
maxsock = new_fd;
// lwip_send(new_fd, "bye", 4, 0);
// lwip_close(new_fd); /* Close larger than 5 socket.*/
}
}
// for (i = 0; i < BACKLOG; i++) /* Close other connections.*/
// {
// if (fd_A[i] != 0) {
// lwip_close(fd_A[i]);
// }
// }
}
}
