/* This source file is part of the ATMEL AVR-UC3-SoftwareFramework-1.7.0 Release */
/*
* 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 derived from a part of the lwIP TCP/IP stack.
*
*/
#ifdef PING_CMD
#include "lwip/opt.h"
#include "lwip/mem.h"
#include "lwip/raw.h"
#include "lwip/icmp.h"
#include "lwip/netif.h"
#include "lwip/sys.h"
#include "lwip/sockets.h"
#include "lwip/inet.h"
#include "lwip/inet_chksum.h"
#include "ping.h"
#include "timer.h"
#include "util.h"
#include "getopt.h"
#define PING_ID 0xAFAF
struct ping_info_t {
struct ip_addr destination;
uint32_t deadline; /* -w (in seconds) */
uint32_t interval; /* -i (in ms) */
uint32_t timeout; /* ms */
uint32_t data_size; /* -s */
uint32_t count; /* -c, 0 means continous ping */
uint32_t size;
uint32_t first_tx_tm;
uint32_t last_tx_tm;
uint32_t last_rx_tm;
uint32_t num_tx;
uint32_t num_rx;
uint32_t flags;
uint16_t seq_num;
Bool quiet; /* -q */
ping_complete_cb_t complete_cb;
void *ctx;
#define PING_REPLY (1 << 0)
};
static struct ping_info_t INFO;
/** Prepare a echo ICMP request */
static void ping_prepare_echo(struct icmp_echo_hdr *iecho,
struct ping_info_t* ping_info)
{
int i;
ICMPH_TYPE_SET(iecho,ICMP_ECHO);
ICMPH_CODE_SET(iecho, 0);
iecho->chksum = 0;
iecho->id = PING_ID;
iecho->seqno = htons(++ping_info->seq_num);
iecho->chksum = 0;
/* fill the additional data buffer with some data */
for(i = 0; i < ping_info->data_size; i++) {
((char*)iecho)[sizeof(struct icmp_echo_hdr) + i] = i;
}
iecho->chksum = inet_chksum(iecho, ping_info->size);
}
/* Ping using the raw ip */
static u8_t ping_recv(void *arg, struct raw_pcb *pcb, struct pbuf *p,
struct ip_addr *addr)
{
struct icmp_echo_hdr *iecho;
struct ip_hdr *ip = p->payload;
struct ping_info_t* ping_info = (struct ping_info_t*) arg;
uint32_t us;
if (pbuf_header( p, -PBUF_IP_HLEN)==0) {
iecho = p->payload;
if ((iecho->id == PING_ID) &&
(iecho->seqno == htons(ping_info->seq_num))) {
ping_info->last_rx_tm = timer_get_ms();
ping_info->num_rx++;
us = 1000 *
(ping_info->last_rx_tm - ping_info->last_tx_tm);
if (!ping_info->quiet)
printk("%d bytes from %s: icmp_seq=%d ttl=%d " \
"time=%d.%03d ms\n",
p->tot_len, ip2str(ip->src),
iecho->seqno,
IPH_TTL(ip),
us / 1000, us % 1000);
/* do some ping result processing */
ping_info->flags |= PING_REPLY;
}
}
pbuf_free(p);
return 1; /* eat the event */
}
static void ping_send(struct raw_pcb *raw, struct ping_info_t* ping_info)
{
struct pbuf *p;
struct icmp_echo_hdr *iecho;
if (!(p = pbuf_alloc(PBUF_IP, ping_info->size, PBUF_RAM))) {
return;
}
if ((p->len == p->tot_len) && (p->next == NULL)) {
iecho = p->payload;
ping_prepare_echo(iecho, ping_info);
raw_sendto(raw, p, &ping_info->destination);
if (!ping_info->first_tx_tm)
ping_info->first_tx_tm = timer_get_ms();
ping_info->last_tx_tm = timer_get_ms();
ping_info->num_tx++;
}
pbuf_free(p);
}
void ping_set_callback(ping_complete_cb_t cb, void *ctx) {
INFO.complete_cb = cb;
INFO.ctx = ctx;
}
void ping_stop(uint32_t *tx_cnt, uint32_t *rx_cnt) {
struct ping_info_t *ping_info = &INFO;
*tx_cnt = ping_info->num_tx;
*rx_cnt = ping_info->num_rx;
ping_info->count = ping_info->num_tx;
if ( 0 == ping_info->count ) {
ping_info->count = 1;
}
}
static int init_ping_info(int argc, char* argv[], struct ping_info_t* ping_info)
{
int c;
ping_complete_cb_t cb;
void *ctx;
cb = ping_info->complete_cb;
ctx = ping_info->ctx;
memset(ping_info, 0, sizeof(struct ping_info_t));
ping_info->complete_cb = cb;
ping_info->ctx = ctx;
ping_info->deadline = 0;
ping_info->interval = 1000;
ping_info->timeout = 3000;
ping_info->data_size = 32;
ping_info->count = 3;
ping_info->destination =
netif_default ? netif_default->gw : ip_addr_any;
optind = 1;
while ((c = getopt(argc, argv, "c:i:s:w:q")) != -1) {
switch (c) {
case 'c':
ping_info->count = atoi(optarg);
break;
case 'i':
ping_info->interval = atoi(optarg);
break;
case 's':
ping_info->data_size = atoi(optarg);
break;
case 'q':
ping_info->quiet = TRUE;
break;
case 'w':
ping_info->deadline = atoi(optarg);
break;
}
}
ping_info->size = sizeof(struct icmp_echo_hdr) + ping_info->data_size;
if (optind >= argc)
return -1;
ping_info->destination = str2ip(argv[optind]);
if (!ping_info->destination.addr)
return -1;
ping_info->last_rx_tm = timer_get_ms();
return 0;
}
static void print_stats(struct ping_info_t* ping_info)
{
printk("\n--- %s ping statistics ---\n",
ip2str(ping_info->destination));
printk("%d packets transmitted, %d received, %d%% packet loss, "\
"time %dms\n\n",
ping_info->num_tx, ping_info->num_rx,
100 * (ping_info->num_tx - ping_info->num_rx) /
ping_info->num_tx,
timer_get_ms() - ping_info->first_tx_tm);
}
static void ping_finalize(struct ping_info_t* ping_info) {
print_stats(ping_info);
if (ping_info->complete_cb) {
ping_info->complete_cb(ping_info->num_tx, ping_info->num_rx, ping_info->ctx);
}
}
cmd_state_t cmd_ping(int argc, char* argv[], void* ctx)
{
static enum {
INIT,
PING,
WAIT_REPLY
} state = INIT;
struct ping_info_t *ping_info = &INFO;
static struct raw_pcb *pcb;
switch (state) {
case INIT:
if (init_ping_info(argc, argv, ping_info) != 0) {
printk("Usage: ping [-c count] [-i interval] " \
"[-s packetsize]\n " \
"[-w deadline] [-q] destination\n");
return CMD_DONE;
}
if (!(pcb = raw_new(IP_PROTO_ICMP))) {
printk("could not allocate pcb\n");
state = INIT;
return CMD_DONE;
}
raw_recv(pcb, ping_recv, ping_info);
raw_bind(pcb, IP_ADDR_ANY);
printk("PING %s %d(%d) bytes of data\n",
ip2str(ping_info->destination),
ping_info->data_size,
ping_info->size);
state = PING;
/* fall through */
case PING:
if (!netif_is_up(netif_default)) {
printk("netif is down\n");
raw_remove(pcb);
state = INIT;
return CMD_DONE;
}
if (ping_info->count && ping_info->num_tx == ping_info->count) {
ping_finalize(ping_info);
raw_remove(pcb);
state = INIT;
return CMD_DONE;
}
if (timer_get_ms() < ping_info->last_rx_tm + ping_info->interval) {
return CMD_INPROGRESS;
}
ping_send(pcb, ping_info);
state = WAIT_REPLY;
return CMD_INPROGRESS;
case WAIT_REPLY:
if (ping_info->flags & PING_REPLY) {
ping_info->flags &= (~PING_REPLY);
state = PING;
return CMD_INPROGRESS;
}
if (timer_get_ms() >
ping_info->last_tx_tm + ping_info->timeout) {
if (!ping_info->quiet)
printk("timeout from %s\n",
ip2str(ping_info->destination));
state = PING;
return CMD_INPROGRESS;
}
if (ping_info->deadline &&
timer_get_ms() >
ping_info->first_tx_tm + ping_info->deadline * 1000) {
ping_finalize(ping_info);
raw_remove(pcb);
state = INIT;
return CMD_DONE;
}
return CMD_INPROGRESS;
}
/* unreachable */
Assert(0);
return CMD_DONE;
}
#endif