kernel/core/net/icmp.c

   1 /*
   2  *  ZeX/OS
   3  *  Copyright (C) 2008  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   4  *  Copyright (C) 2010  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   5  *
   6  *  This program is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20
  21 #include <system.h>
  22 #include <string.h>
  23 #include <dev.h>
  24 #include <net/eth.h>
  25 #include <net/net.h>
  26 #include <net/if.h>
  27 #include <net/packet.h>
  28 #include <net/ip.h>
  29 #include <net/icmp.h>
  30 #include <net/checksum.h>
  31
  32 extern unsigned long timer_ticks;
  33
  34 static unsigned net_icmp_ping = 0;
  35
  36 static proto_ip_t proto_ip_prealloc;
  37 static char proto_icmp_prealloc[sizeof (proto_icmp_t)+57];
  38 static packet_t packet_prealloc;
  39 static char buf_icmp_prealloc[NET_PACKET_MTU + sizeof (proto_icmp_t) + 1];
  40
  41 /* prototype */
  42 unsigned net_proto_icmp_reply (netif_t *netif, packet_t *packet, proto_ip_t *ip, proto_icmp_t *icmp, char *buf, unsigned len);
  43 unsigned net_proto_icmp_request (netif_t *netif, net_ipv4 dest);
  44
  45 unsigned net_proto_icmp_ping (netif_t *netif, net_ipv4 ip)
  46 {
  47         if (!netif)
  48                 return 2;
  49
  50         unsigned ret = net_proto_icmp_request (netif, ip);
  51
  52         if (!ret)
  53                 return 0;
  54
  55         unsigned long time = timer_ticks;
  56
  57         while (!net_icmp_ping) {
  58                 /* timeout 1s - 1000ms */
  59                 if ((timer_ticks-time) > 1000)
  60                         return 0;
  61
  62                 schedule ();
  63         }
  64
  65         net_icmp_ping = 0;
  66
  67         return 1;
  68 }
  69
  70 unsigned net_proto_icmp_handler (packet_t *packet, proto_ip_t *ip, char *buf, unsigned len)
  71 {
  72         proto_icmp_t *icmp = (proto_icmp_t *) buf;
  73
  74         if (icmp->type == NET_ICMP_TYPE_PING_REQUEST) {
  75                 //kprintf ("ICMP->Request !\n");
  76
  77                 /* TODO: melo by to projit vsechny rozhrani */
  78                 netif_t *netif = netif_findbyname ("eth0");
  79
  80                 if (ip->ip_dest == netif->ip) {
  81                         //printf ("ICMP->Request from ");
  82                         //net_proto_ip_print (ip->ip_source);
  83                         //printf (" !\n");
  84
  85                         return net_proto_icmp_reply (netif, packet, ip, icmp, buf+8, len-12);
  86                 }
  87
  88                 return 0;
  89         }
  90
  91         if (icmp->type == NET_ICMP_TYPE_PING_REPLY) {
  92                 /* TODO: make it better :) */
  93                 net_icmp_ping = 1;
  94                 return 1;
  95         }
  96
  97         return 0;
  98 }
  99
 100 unsigned net_proto_icmp_request (netif_t *netif, net_ipv4 dest)
 101 {
 102         //printf ("ICMP request: (%d) %s\n", len, buf);
 103
 104         mac_addr_t mac_dest;
 105         unsigned get = arp_cache_get (dest, &mac_dest);
 106
 107         if (!get) {
 108                 arp_send_request (netif, dest);
 109
 110                 unsigned i = 0;
 111                 /* 100ms for waiting on ARP reply */
 112                 while (i < 100) {
 113                         get = arp_cache_get (dest, &mac_dest);
 114
 115                         if (get)
 116                                 break;
 117
 118                         /* TODO: make better waiting for ARP reply */
 119                         timer_wait (1);
 120
 121                         schedule ();
 122
 123                         i ++;
 124                 }
 125
 126                 if (!get)
 127                         return 0;
 128         }
 129
 130         /* packet header */
 131         packet_t *packet = (packet_t *) &packet_prealloc;
 132
 133         if (!packet)
 134                 return 0;
 135
 136         memcpy (&packet->mac_source, netif->dev->dev_addr, 6);
 137         memcpy (&packet->mac_dest, mac_dest, 6);
 138         packet->type = NET_PACKET_TYPE_IPV4;
 139
 140         /* ip layer */
 141         proto_ip_t *ip = (proto_ip_t *) &proto_ip_prealloc;
 142
 143         if (!ip)
 144                 return 0;
 145
 146         /* there are some fixed values - yeah it is horrible */
 147         ip->ver = 4;
 148         ip->head_len = 5;
 149         ip->total_len = swap16 (84);
 150         ip->flags = 0;
 151         ip->frag = 0;
 152         ip->ttl = 64;
 153         ip->checksum = 0;
 154         ip->proto = NET_PROTO_IP_TYPE_ICMP;
 155         ip->ip_source = netif->ip;
 156         ip->ip_dest = dest;
 157
 158         /* icmp layer */
 159         proto_icmp_t *icmp = (proto_icmp_t *) &proto_icmp_prealloc;
 160
 161         if (!icmp)
 162                 return 0;
 163
 164         memset ((char *) icmp+8, 0, 56);
 165
 166         icmp->type = NET_ICMP_TYPE_PING_REQUEST;
 167         icmp->code = 0;
 168         icmp->seq = 0;
 169         icmp->checksum = 0;
 170
 171         icmp->checksum = checksum16 (icmp, sizeof (proto_icmp_t)+56);
 172
 173         return net_proto_ip_send (netif, packet, ip, (char *) icmp, sizeof (proto_icmp_t)+56);
 174 }
 175
 176 unsigned net_proto_icmp_reply (netif_t *netif, packet_t *packet, proto_ip_t *ip, proto_icmp_t *icmp, char *buf, unsigned len)
 177 {
 178         //printf ("ICMP reply: (%d) %s\n", len, buf);
 179
 180         mac_addr_t mac_dest;
 181         mac_addr_t mac_source;
 182
 183         /* cross mac and ip address, because this packet have to go back */
 184         memcpy (&mac_dest, packet->mac_source, 6);
 185         memcpy (&mac_source, packet->mac_dest, 6);
 186
 187         net_ipv4 ip_dest = ip->ip_source;
 188         net_ipv4 ip_source = ip->ip_dest;
 189
 190         /* assign new values to old structures */
 191         memcpy (&packet->mac_source, mac_source, 6);
 192         memcpy (&packet->mac_dest, mac_dest, 6);
 193
 194         /* TODO: identification, flags, etc */
 195
 196         ip->ip_dest = ip_dest;
 197         ip->ip_source = ip_source;
 198         ip->checksum = 0;
 199
 200         icmp->type = NET_ICMP_TYPE_PING_REPLY;
 201         icmp->checksum = 0;
 202
 203         char *buf_icmp = (char *) &buf_icmp_prealloc;
 204
 205         if (!buf_icmp)
 206                 return 0;
 207
 208         unsigned l = sizeof (proto_icmp_t);
 209
 210         memcpy (buf_icmp, (char *) icmp, l);
 211         memcpy (buf_icmp+l, buf, len);
 212
 213         buf_icmp[l+len] = '\0';
 214
 215         /* calculate checksum and put it to icmp header */
 216         proto_icmp_t *icmp_ = (proto_icmp_t *) buf_icmp;
 217         icmp_->checksum = checksum16 (buf_icmp, len+l);
 218
 219         return net_proto_ip_send (netif, packet, ip, buf_icmp, len+l);
 220 }
 221