kernel/core/net/icmp6.c

   1 /*
   2  *  ZeX/OS
   3  *  Copyright (C) 2008  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   4  *  Copyright (C) 2009  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   5  *  Copyright (C) 2010  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   6  *
   7  *  This program is free software: you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation, either version 3 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21
  22 #include <system.h>
  23 #include <string.h>
  24 #include <dev.h>
  25 #include <net/eth.h>
  26 #include <net/net.h>
  27 #include <net/if.h>
  28 #include <net/packet.h>
  29 #include <net/ip.h>
  30 #include <net/icmp.h>
  31 #include <net/ndp.h>
  32 #include <net/tun.h>
  33 #include <net/checksum.h>
  34
  35 extern unsigned long timer_ticks;
  36
  37 static unsigned net_icmp6_ping = 0;
  38
  39 static proto_ipv6_t proto_ipv6_prealloc;
  40 static char proto_icmp_prealloc[sizeof (proto_icmp_t)+65];
  41 static packet_t packet_prealloc;
  42 static char buf_icmp_prealloc[NET_PACKET_MTU + sizeof (proto_icmp_t) + 1];
  43
  44 /* prototype */
  45 unsigned net_proto_icmp6_reply (netif_t *netif, packet_t *packet, proto_ipv6_t *ip, proto_icmp_t *icmp, char *buf, unsigned len);
  46 unsigned net_proto_icmp6_request (netif_t *netif, net_ipv6 dest);
  47
  48 unsigned net_proto_icmp6_ping (netif_t *netif, net_ipv6 ip)
  49 {
  50         if (!netif)
  51                 return 2;
  52
  53         unsigned ret = net_proto_icmp6_request (netif, ip);
  54
  55         if (!ret)
  56                 return 0;
  57
  58         unsigned long time = timer_ticks;
  59
  60         while (!net_icmp6_ping) {
  61                 /* timeout 1s - 1000ms */
  62                 if ((timer_ticks-time) > 1000)
  63                         return 0;
  64
  65                 schedule ();
  66         }
  67
  68         net_icmp6_ping = 0;
  69
  70         return 1;
  71 }
  72
  73 unsigned net_proto_icmp6_handler (packet_t *packet, proto_ipv6_t *ip, char *buf, unsigned len)
  74 {
  75         proto_icmp_t *icmp = (proto_icmp_t *) buf;
  76
  77         if (icmp->type == NET_ICMP6_TYPE_PING_REQUEST) {
  78                 //kprintf ("ICMP->Request !\n");
  79
  80                 /* TODO: melo by to projit vsechny rozhrani */
  81                 netif_t *netif = netif_findbyname ("eth0");
  82
  83                 if (net_proto_ipv6_cmp (ip->ip_dest, netif->ipv6))
  84                         return net_proto_icmp6_reply (netif, packet, ip, icmp, buf+8, len-8);
  85
  86                 return 0;
  87         }
  88
  89         if (icmp->type == NET_ICMP6_TYPE_PING_REPLY) {
  90                 /* TODO: make it better :) */
  91                 net_icmp6_ping = 1;
  92                 return 1;
  93         }
  94
  95         /* ICMPv6 - NDP protocol handler */
  96         if (icmp->type == NET_NDP_TYPE_NBADVERT) {
  97                 netif_t *netif = netif_findbyname ("eth0");
  98
  99                 proto_ndp_t *ndp = (proto_ndp_t *) buf;
 100
 101                 if (net_proto_ipv6_cmp (ip->ip_dest, netif->ipv6))
 102                         return ndp_cache_add (ndp->ll_mac, ndp->target);
 103
 104                 return 0;
 105         }
 106
 107         if (icmp->type == NET_NDP_TYPE_NBSOL) {
 108                 netif_t *netif = netif_findbyname ("eth0");
 109
 110                 proto_ndp_t *ndp = (proto_ndp_t *) buf;
 111
 112                 /* send NDP reply */
 113                 if (net_proto_ipv6_cmp (ndp->target, netif->ipv6)) {
 114                         ndp_cache_add (ndp->ll_mac, ip->ip_source);
 115                         return ndp_send_nbreply (netif, ndp->ll_mac, ip->ip_source);
 116                 }
 117         }
 118
 119         if (icmp->type == NET_NDP_TYPE_RADVERT) {
 120                 netif_t *netif = netif_findbyname ("eth0");
 121
 122                 proto_icmp_ndp2_t *ndp = (proto_icmp_ndp2_t *) buf;
 123
 124                 /* send NDP reply */
 125                 return ndp_send_rreply (netif, ndp, ip->ip_source, ip->ip_dest);
 126
 127         }
 128
 129         return 0;
 130 }
 131
 132 unsigned net_proto_icmp6_request (netif_t *netif, net_ipv6 dest)
 133 {
 134         mac_addr_t mac_dest;
 135
 136         if (!tun6_addr_get ()) {
 137                 unsigned get = ndp_cache_get (dest, &mac_dest);
 138
 139                 if (!get) {
 140                         ndp_send_nbrequest (netif, dest);
 141
 142                         unsigned i = 0;
 143                         /* 200ms for waiting on NDP reply */
 144                         while (i < 200) {
 145                                 get = ndp_cache_get (dest, &mac_dest);
 146
 147                                 if (get)
 148                                         break;
 149
 150                                 /* TODO: make better waiting for ARP reply */
 151                                 timer_wait (1);
 152
 153                                 schedule ();
 154
 155                                 i ++;
 156                         }
 157
 158                         if (!get)
 159                                 return 0;
 160                 }
 161         } else {
 162                 /* IPv6 tunnel stuff */
 163                 net_ipv4 tunnel = tun6_addr_get ();
 164                 unsigned get = arp_cache_get (tunnel, &mac_dest);
 165
 166                 if (!get) {
 167                         arp_send_request (netif, tunnel);
 168
 169                         unsigned i = 0;
 170                         /* 100ms for waiting on ARP reply */
 171                         while (i < 100) {
 172                                 get = arp_cache_get (tunnel, &mac_dest);
 173
 174                                 if (get)
 175                                         break;
 176
 177                                 /* TODO: make better waiting for ARP reply */
 178                                 timer_wait (1);
 179
 180                                 schedule ();
 181
 182                                 i ++;
 183                         }
 184
 185                         if (!get)
 186                                 return 0;
 187                 }
 188         }
 189
 190         /* packet header */
 191         packet_t *packet = (packet_t *) &packet_prealloc;
 192
 193         if (!packet)
 194                 return 0;
 195
 196         memcpy (&packet->mac_source, netif->dev->dev_addr, 6);
 197         memcpy (&packet->mac_dest, mac_dest, 6);
 198         packet->type = NET_PACKET_TYPE_IPV6;
 199
 200         /* ip layer */
 201         proto_ipv6_t *ip = (proto_ipv6_t *) &proto_ipv6_prealloc;
 202
 203         if (!ip)
 204                 return 0;
 205
 206         /* there are some fixed values - yeah it is horrible */
 207         ip->ver = 0x60;
 208         ip->tclass = 0x0;
 209         ip->flabel = 0x0;
 210         ip->pl_len = swap16 (64);
 211         ip->nhead = NET_PROTO_IP_TYPE_ICMP6;
 212         ip->hop = 0xff;
 213         memcpy (ip->ip_source, (void *) netif->ipv6, sizeof (net_ipv6));
 214         memcpy (ip->ip_dest, (void *) dest, sizeof (net_ipv6));
 215
 216         /* icmp layer */
 217         proto_icmp_t *icmp = (proto_icmp_t *) &proto_icmp_prealloc;
 218
 219         if (!icmp)
 220                 return 0;
 221
 222         memset ((char *) icmp, 0, 64);
 223
 224         icmp->type = NET_ICMP6_TYPE_PING_REQUEST;
 225         icmp->code = 0;
 226         icmp->seq = 0x3ff3;
 227
 228         unsigned ret = 0;
 229
 230         icmp->checksum = checksum16_ipv6 (ip->ip_source, ip->ip_dest, icmp, sizeof (proto_icmp_t)+56, NET_PROTO_IP_TYPE_ICMP6);
 231
 232         if (!tun6_addr_get ())
 233                 ret = net_proto_ipv6_send (netif, packet, ip, (char *) icmp, sizeof (proto_icmp_t)+56);
 234         else    /* tunnel mode */
 235                 ret = net_proto_tun6_send (netif, packet, ip, (char *) icmp, sizeof (proto_icmp_t)+56);
 236
 237         return ret;
 238 }
 239
 240 unsigned net_proto_icmp6_reply (netif_t *netif, packet_t *packet, proto_ipv6_t *ip, proto_icmp_t *icmp, char *buf, unsigned len)
 241 {
 242         mac_addr_t mac_dest;
 243         mac_addr_t mac_source;
 244
 245         /* cross mac and ip address, because this packet have to go back */
 246         memcpy (&mac_dest, packet->mac_source, 6);
 247         memcpy (&mac_source, packet->mac_dest, 6);
 248
 249         /* assign new values to old structures */
 250         memcpy (&packet->mac_source, mac_source, 6);
 251         memcpy (&packet->mac_dest, mac_dest, 6);
 252
 253         /* TODO: identification, flags, etc */
 254
 255         /* ip layer */
 256         net_ipv6 tmp;
 257         memcpy (tmp, (void *) ip->ip_dest, sizeof (net_ipv6));
 258
 259         memcpy (ip->ip_dest, (void *) ip->ip_source, sizeof (net_ipv6));
 260         memcpy (ip->ip_source, (void *) tmp, sizeof (net_ipv6));
 261
 262         icmp->type = NET_ICMP6_TYPE_PING_REPLY;
 263         icmp->checksum = 0;
 264
 265         char *buf_icmp = (char *) &buf_icmp_prealloc;
 266
 267         if (!buf_icmp)
 268                 return 0;
 269
 270         unsigned l = sizeof (proto_icmp_t);
 271
 272         memcpy (buf_icmp, (char *) icmp, l);
 273         memcpy (buf_icmp+l, buf, len);
 274
 275         buf_icmp[l+len] = '\0';
 276
 277         unsigned ret = 0;
 278
 279         /* calculate checksum and put it to icmp header */
 280         proto_icmp_t *icmp_ = (proto_icmp_t *) buf_icmp;
 281
 282         icmp_->checksum = checksum16_ipv6 (ip->ip_source, ip->ip_dest, buf_icmp, len+l, NET_PROTO_IP_TYPE_ICMP6);
 283
 284         if (!tun6_addr_get ())
 285                 ret = net_proto_ipv6_send (netif, packet, ip, buf_icmp, len+l);
 286         else
 287                 ret = net_proto_tun6_send (netif, packet, ip, buf_icmp, len+l);
 288
 289         return ret;
 290 }
 291