/*
* Copyright (c) 2001-2003 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
*
*/
#include
#include
#include
#include "lwip/opt.h"
#include "lwip/mem.h"
#include "lwip/memp.h"
#include "lwip/sys.h"
#include "lwip/stats.h"
#include "lwip/tcpip.h"
#include "netif/tapif.h"
#include "netif/tunif.h"
#include "netif/unixif.h"
#include "netif/dropif.h"
#include "netif/pcapif.h"
#include "netif/loopif.h"
#include "netif/tcpdump.h"
#if PPP_SUPPORT
#include "netif/ppp/ppp.h"
#define PPP_PTY_TEST 1
#include
#endif
#include "lwip/ip_addr.h"
#include "arch/perf.h"
#include "httpd.h"
#include "udpecho.h"
#include "tcpecho.h"
#include "shell.h"
#if LWIP_RAW
#include "lwip/icmp.h"
#include "lwip/raw.h"
#include "lwip/sockets.h"
#endif
/* (manual) host IP configuration */
static struct ip_addr ipaddr, netmask, gw;
/* ping out destination cmd option */
static unsigned char ping_flag;
static struct ip_addr ping_addr;
/* nonstatic debug cmd option, exported in lwipopts.h */
unsigned char debug_flags;
/** @todo add options for selecting netif, starting DHCP client etc */
static struct option longopts[] = {
/* turn on debugging output (if build with LWIP_DEBUG) */
{"debug", no_argument, NULL, 'd'},
/* help */
{"help", no_argument, NULL, 'h'},
/* gateway address */
{"gateway", required_argument, NULL, 'g'},
/* ip address */
{"ipaddr", required_argument, NULL, 'i'},
/* netmask */
{"netmask", required_argument, NULL, 'm'},
/* ping destination */
{"ping", required_argument, NULL, 'p'},
/* new command line options go here! */
{NULL, 0, NULL, 0}
};
#define NUM_OPTS ((sizeof(longopts) / sizeof(struct option)) - 1)
void
usage(void)
{
unsigned char i;
printf("options:\n");
for (i = 0; i < NUM_OPTS; i++) {
printf("-%c --%s\n", longopts[i].val, longopts[i].name);
}
}
static void
tcp_debug_timeout(void *data)
{
#if TCP_DEBUG
tcp_debug_print_pcbs();
#endif /* TCP_DEBUG */
sys_timeout(5000, tcp_debug_timeout, NULL);
}
static void
tcpip_init_done(void *arg)
{
sys_sem_t *sem;
sem = arg;
sys_sem_signal(*sem);
}
#if PPP_SUPPORT
void
pppLinkStatusCallback(void *ctx, int errCode, void *arg)
{
switch (errCode) {
case PPPERR_NONE: /* No error. */
{
struct ppp_addrs *ppp_addrs = arg;
printf("pppLinkStatusCallback: PPPERR_NONE");
printf(" our_ipaddr=%s", _inet_ntoa(ppp_addrs->our_ipaddr.addr));
printf(" his_ipaddr=%s", _inet_ntoa(ppp_addrs->his_ipaddr.addr));
printf(" netmask=%s", _inet_ntoa(ppp_addrs->netmask.addr));
printf(" dns1=%s", _inet_ntoa(ppp_addrs->dns1.addr));
printf(" dns2=%s\n", _inet_ntoa(ppp_addrs->dns2.addr));
}
break;
case PPPERR_PARAM: /* Invalid parameter. */
printf("pppLinkStatusCallback: PPPERR_PARAM\n");
break;
case PPPERR_OPEN: /* Unable to open PPP session. */
printf("pppLinkStatusCallback: PPPERR_OPEN\n");
break;
case PPPERR_DEVICE: /* Invalid I/O device for PPP. */
printf("pppLinkStatusCallback: PPPERR_DEVICE\n");
break;
case PPPERR_ALLOC: /* Unable to allocate resources. */
printf("pppLinkStatusCallback: PPPERR_ALLOC\n");
break;
case PPPERR_USER: /* User interrupt. */
printf("pppLinkStatusCallback: PPPERR_USER\n");
break;
case PPPERR_CONNECT: /* Connection lost. */
printf("pppLinkStatusCallback: PPPERR_CONNECT\n");
break;
case PPPERR_AUTHFAIL: /* Failed authentication challenge. */
printf("pppLinkStatusCallback: PPPERR_AUTHFAIL\n");
break;
case PPPERR_PROTOCOL: /* Failed to meet protocol. */
printf("pppLinkStatusCallback: PPPERR_PROTOCOL\n");
break;
default:
printf("pppLinkStatusCallback: unknown errCode %d\n", errCode);
break;
}
}
#endif
/*-----------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------*/
#if LWIP_RAW
static int seq_num;
#if 0
/* Ping using the raw ip */
static int
ping_recv(void *arg, struct raw_pcb *pcb, struct pbuf *p, struct ip_addr *addr)
{
printf("ping recv\n");
return 1; /* eat the event */
}
static void
ping_send(struct raw_pcb *raw, struct ip_addr *addr)
{
struct pbuf *p;
struct icmp_echo_hdr *iecho;
p = pbuf_alloc(PBUF_IP, sizeof(struct icmp_echo_hdr), PBUF_RAM);
if (!p)
return;
iecho = p->payload;
ICMPH_TYPE_SET(iecho, ICMP_ECHO);
iecho->chksum = 0;
iecho->seqno = htons(seq_num);
iecho->chksum = inet_chksum(iecho, p->len);
raw_send_to(raw, p, addr);
pbuf_free(p);
seq_num++;
}
static void
ping_thread(void *arg)
{
struct raw_pcb *raw;
if (!(raw = raw_new(IP_PROTO_ICMP)))
return;
raw_recv(raw, ping_recv, NULL);
while (1) {
printf("ping send\n");
ping_send(raw, &ping_addr);
sleep(1);
}
/* Never reaches this */
raw_remove(raw);
}
#else
/* Ping using the socket ip */
static void
ping_send(int s, struct ip_addr *addr)
{
struct icmp_echo_hdr *iecho;
struct sockaddr_in to;
if (!(iecho = malloc(sizeof(struct icmp_echo_hdr))))
return;
ICMPH_TYPE_SET(iecho, ICMP_ECHO);
iecho->chksum = 0;
iecho->seqno = htons(seq_num);
iecho->chksum = inet_chksum(iecho, sizeof(*iecho));
to.sin_len = sizeof(to);
to.sin_family = AF_INET;
to.sin_addr.s_addr = addr->addr;
lwip_sendto(s, iecho, sizeof(*iecho), 0, (struct sockaddr *)&to, sizeof(to));
free(iecho);
seq_num++;
}
static void
ping_recv(int s, struct ip_addr *addr)
{
char buf [200];
int fromlen , len;
struct sockaddr_in from;
len = lwip_recvfrom(s, buf, sizeof(buf), 0, (struct sockaddr *)&from, &fromlen);
printf("Received %d bytes from %lx\n", len, ntohl(from.sin_addr.s_addr));
}
static void
ping_thread(void *arg)
{
int s;
if ((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) {
return;
}
while (1) {
printf("sending ping\n");
ping_send(s, &ping_addr);
ping_recv(s, &ping_addr);
sleep(1);
}
}
#endif
#endif
static void
cli_thread(void *arg)
{
struct netconn *cliConn;
struct ip_addr srvAddr;
static char pageBuf[] = "GET /index.html HTTP/1.0\r\n\r\n";
size_t len = sizeof(pageBuf);
struct netbuf *nb;
char *data;
int xlen;
int err;
printf("cli thread activated\n");
for (;;) {
printf("cli (re)creating connection...\n");
if ((cliConn = netconn_new(NETCONN_TCP)) == NULL) {
printf("netconn_new failed\n");
return; /* should not happen */
}
IP4_ADDR(&srvAddr, 127, 0, 0, 2);
printf("cli connecting...\n");
while ((err = netconn_connect(cliConn, &srvAddr, 80)) != 0) {
printf("connection error %d\n", err);
}
printf("cli writing HTTP request....\n");
if (netconn_write(cliConn, pageBuf, len, NETCONN_NOCOPY) != ERR_OK) {
printf("netconn_write FAILED!\n");
netconn_close(cliConn);
break;
}
#if 0
if ((nb = netconn_recv(cliConn)) != NULL) {
netbuf_data(nb, (void *)&data, (u16_t *) &xlen);
printf("got respond %s\n", data);
netbuf_delete(nb);
}
#endif
// sleep(1);
netconn_delete(cliConn);
}
printf("client thread terminated\n");
}
static void
srv_thread(void *arg)
{
struct netconn *srvConn, *nc;
struct netbuf *nb;
struct ip_addr myAddr;
char *data;
size_t len;
int err;
printf("srv thread activated\n");
if ((srvConn = netconn_new(NETCONN_TCP)) == NULL)
return; /* should not happen */
if ((err = netconn_bind(srvConn, NULL, 80)) != 0)
printf("bind failed, err = %d\n", err);
if ((err = netconn_listen(srvConn)) != 0)
printf("listen failed, err = %d\n", err);
for (;;) {
printf("srv listening return, proceed to accept\n");
nc = netconn_accept(srvConn);
if (nc == NULL) {
printf("srv accept failed!\n");
continue;
}
printf("srv receiving HTTP request ....\n");
if ((nb = netconn_recv(nc)) != NULL) {
netbuf_data(nb, (void *)&data, (u16_t *) & len);
if (data[0] == 'G' && data[1] == 'E' && data[2] == 'T') {
printf("srv: it's a GET method %s\n", data);
#if 0
if (netconn_write(nc, "test", 5, NETCONN_NOCOPY) != ERR_OK) {
printf("netconn_write FAILED!\n");
netconn_close(nc);
}
#endif
}
netbuf_delete(nb);
}
printf("srv delete server connection\n");
while (netconn_delete(nc) != ERR_OK) {
printf("srv netconn_delete failed!\n");
sleep(3);
}
}
printf("server thread terminated\n");
}
struct netif netif;
#if LWIP_HAVE_LOOPIF
struct netif loopif;
#endif
/*-----------------------------------------------------------------------------------*/
static void
main_thread(void *arg)
{
sys_sem_t sem;
#if PPP_SUPPORT
sio_fd_t ppp_sio;
#endif
netif_init();
sem = sys_sem_new(0);
tcpip_init(tcpip_init_done, &sem);
sys_sem_wait(sem);
sys_sem_free(sem);
printf("TCP/IP initialized.\n");
#if PPP_SUPPORT
pppInit();
#if PPP_PTY_TEST
ppp_sio = sio_open(2);
#else
ppp_sio = sio_open(0);
#endif
if (!ppp_sio) {
perror("Error opening device: ");
exit(1);
}
#ifdef LWIP_PPP_CHAP_TEST
pppSetAuth(PPPAUTHTYPE_CHAP, "lwip", "mysecret");
#endif
pppOpen(ppp_sio, pppLinkStatusCallback, NULL);
#endif /* PPP_SUPPORT */
#if LWIP_DHCP
{
IP4_ADDR(&gw, 0, 0, 0, 0);
IP4_ADDR(&ipaddr, 0, 0, 0, 0);
IP4_ADDR(&netmask, 0, 0, 0, 0);
netif_add(&netif, &ipaddr, &netmask, &gw, NULL, tapif_init,
tcpip_input);
netif_set_default(&netif);
dhcp_start(&netif);
}
#else
#if LWIP_HAVE_LOOPIF == 0
netif_set_default(netif_add(&netif, &ipaddr, &netmask, &gw, NULL, tapif_init,
tcpip_input));
netif_set_up(&netif);
#endif
#endif
#if 0
/* Only used for testing purposes: */
netif_add(&ipaddr, &netmask, &gw, NULL, pcapif_init, tcpip_input);
#endif
#if LWIP_HAVE_LOOPIF
IP4_ADDR(&gw, 127, 0, 0, 1);
IP4_ADDR(&ipaddr, 127, 0, 0, 2);
IP4_ADDR(&netmask, 255, 0, 0, 0);
netif_set_default(netif_add(&loopif, &ipaddr, &netmask, &gw, NULL, loopif_init,
tcpip_input));
netif_set_up(&loopif);
#endif
#if LWIP_TCP
//tcpecho_init();
//shell_init();
//httpd_init();
#endif
#if LWIP_UDP
//udpecho_init();
#endif
#if LWIP_RAW
/** @todo remove dependency on RAW PCB support */
if (ping_flag) {
sys_thread_new(ping_thread, NULL, DEFAULT_THREAD_PRIO);
}
#endif
sys_thread_new(srv_thread, NULL, DEFAULT_THREAD_PRIO);
sys_thread_new(cli_thread, NULL, DEFAULT_THREAD_PRIO);
printf("Applications started.\n");
/* sys_timeout(5000, tcp_debug_timeout, NULL); */
#ifdef MEM_PERF
mem_perf_init("/tmp/memstats.client");
#endif /* MEM_PERF */
#if 0
stats_display();
#endif
/* Block for ever. */
sem = sys_sem_new(0);
sys_sem_wait(sem);
}
/*-----------------------------------------------------------------------------------*/
int
main(int argc, char **argv)
{
struct in_addr inaddr;
int ch;
char ip_str [16] = {0}, nm_str[16] = {0}, gw_str[16] = {0};
/* startup defaults (may be overridden by one or more opts) */
IP4_ADDR(&gw, 127, 0, 0, 1);
IP4_ADDR(&netmask, 255, 0, 0, 0);
IP4_ADDR(&ipaddr, 127, 0, 0, 2);
ping_flag = 0;
/* use debug flags defined by debug.h */
debug_flags = DBG_OFF;
while ((ch = getopt_long(argc, argv, "dhg:i:m:p:", longopts, NULL)) != -1) {
switch (ch) {
case 'd':
debug_flags |= (DBG_ON | DBG_TRACE | DBG_STATE | DBG_FRESH | DBG_HALT);
break;
case 'h':
usage();
exit(0);
break;
case 'g':
inet_aton(optarg, &inaddr);
gw.addr = inaddr.s_addr;
break;
case 'i':
inet_aton(optarg, &inaddr);
ipaddr.addr = inaddr.s_addr;
break;
case 'm':
inet_aton(optarg, &inaddr);
netmask.addr = inaddr.s_addr;
break;
case 'p':
ping_flag = !0;
inet_aton(optarg, &inaddr);
/* lwip inet.h oddity workaround */
ping_addr.addr = inaddr.s_addr;
strncpy(ip_str, inet_ntoa(inaddr), sizeof(ip_str));
printf("Using %s to ping\n", ip_str);
break;
default:
usage();
break;
}
}
argc -= optind;
argv += optind;
inaddr.s_addr = ipaddr.addr;
strncpy(ip_str, inet_ntoa(inaddr), sizeof(ip_str));
inaddr.s_addr = netmask.addr;
strncpy(nm_str, inet_ntoa(inaddr), sizeof(nm_str));
inaddr.s_addr = gw.addr;
strncpy(gw_str, inet_ntoa(inaddr), sizeof(gw_str));
printf("Host at %s mask %s gateway %s\n", ip_str, nm_str, gw_str);
#ifdef PERF
perf_init("/tmp/simhost.perf");
#endif /* PERF */
#if LWIP_STATS
stats_init();
#endif /* STATS */
mem_init();
memp_init();
pbuf_init();
sys_init();
#ifdef LWIP_TCPDUMP
tcpdump_init();
#endif
printf("System initialized.\n");
sys_thread_new(main_thread, NULL, DEFAULT_THREAD_PRIO);
pause();
return 0;
}
/*-----------------------------------------------------------------------------------*/