net/inet/icmp.c

/* */
This source file includes following definitions.
print_icmp
icmp_send
icmp_unreach
icmp_redirect
icmp_echo
icmp_info
icmp_address
icmp_rcv
icmp_ioctl
   1 /*
   2  * INET         An implementation of the TCP/IP protocol suite for the LINUX
   3  *              operating system.  INET is implemented using the  BSD Socket
   4  *              interface as the means of communication with the user level.
   5  *
   6  *              Internet Control Message Protocol (ICMP)
   7  *
   8  * Version:     @(#)icmp.c      1.0.11  06/02/93
   9  *
  10  * Authors:     Ross Biro, <bir7@leland.Stanford.Edu>
  11  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12  *              Mark Evans, <evansmp@uhura.aston.ac.uk>
  13  *
  14  * Fixes:       
  15  *              Alan Cox        :       Generic queue usage.
  16  *              Gerhard Koerting:       ICMP addressing corrected
  17  *              Alan Cox        :       Use tos/ttl settings
  18  *
  19  *
  20  *              This program is free software; you can redistribute it and/or
  21  *              modify it under the terms of the GNU General Public License
  22  *              as published by the Free Software Foundation; either version
  23  *              2 of the License, or (at your option) any later version.
  24  */
  25 #include <linux/types.h>
  26 #include <linux/sched.h>
  27 #include <linux/kernel.h>
  28 #include <linux/fcntl.h>
  29 #include <linux/socket.h>
  30 #include <linux/in.h>
  31 #include "inet.h"
  32 #include "dev.h"
  33 #include "ip.h"
  34 #include "route.h"
  35 #include "protocol.h"
  36 #include "icmp.h"
  37 #include "tcp.h"
  38 #include "skbuff.h"
  39 #include "sock.h"
  40 #include <linux/errno.h>
  41 #include <linux/timer.h>
  42 #include <asm/system.h>
  43 #include <asm/segment.h>
  44 
  45 
  46 #define min(a,b)        ((a)<(b)?(a):(b))
  47 
  48 
  49 /* An array of errno for error messages from dest unreach. */
  50 struct icmp_err icmp_err_convert[] = {
  51   { ENETUNREACH,        1 },    /*      ICMP_NET_UNREACH        */
  52   { EHOSTUNREACH,       1 },    /*      ICMP_HOST_UNREACH       */
  53   { ENOPROTOOPT,        1 },    /*      ICMP_PROT_UNREACH       */
  54   { ECONNREFUSED,       1 },    /*      ICMP_PORT_UNREACH       */
  55   { EOPNOTSUPP,         0 },    /*      ICMP_FRAG_NEEDED        */
  56   { EOPNOTSUPP,         0 },    /*      ICMP_SR_FAILED          */
  57   { ENETUNREACH,        1 },    /*      ICMP_NET_UNKNOWN        */
  58   { EHOSTDOWN,          1 },    /*      ICMP_HOST_UNKNOWN       */
  59   { ENONET,             1 },    /*      ICMP_HOST_ISOLATED      */
  60   { ENETUNREACH,        1 },    /*      ICMP_NET_ANO            */
  61   { EHOSTUNREACH,       1 },    /*      ICMP_HOST_ANO           */
  62   { EOPNOTSUPP,         0 },    /*      ICMP_NET_UNR_TOS        */
  63   { EOPNOTSUPP,         0 }     /*      ICMP_HOST_UNR_TOS       */
  64 };
  65 
  66 
  67 /* Display the contents of an ICMP header. */
  68 static void
  69 print_icmp(struct icmphdr *icmph)
     /*  */
  70 {
  71   if (inet_debug != DBG_ICMP) return;
  72 
  73   printk("ICMP: type = %d, code = %d, checksum = %X\n",
  74                         icmph->type, icmph->code, icmph->checksum);
  75   printk("      gateway = %s\n", in_ntoa(icmph->un.gateway));
  76 }
  77 
  78 
  79 /* Send an ICMP message. */
  80 void
  81 icmp_send(struct sk_buff *skb_in, int type, int code, struct device *dev)
     /*  */
  82 {
  83   struct sk_buff *skb;
  84   struct iphdr *iph;
  85   int offset;
  86   struct icmphdr *icmph;
  87   int len;
  88 
  89   DPRINTF((DBG_ICMP, "icmp_send(skb_in = %X, type = %d, code = %d, dev=%X)\n",
  90                                                 skb_in, type, code, dev));
  91 
  92   /* Get some memory for the reply. */
  93   len = sizeof(struct sk_buff) + dev->hard_header_len +
  94         sizeof(struct iphdr) + sizeof(struct icmphdr) +
  95         sizeof(struct iphdr) + 8;       /* amount of header to return */
  96            
  97   skb = (struct sk_buff *) alloc_skb(len, GFP_ATOMIC);
  98   if (skb == NULL) 
  99         return;
 100 
 101   skb->sk = NULL;
 102   skb->mem_addr = skb;
 103   skb->mem_len = len;
 104   len -= sizeof(struct sk_buff);
 105 
 106   /* Find the IP header. */
 107   iph = (struct iphdr *) (skb_in->data + dev->hard_header_len);
 108 
 109   /* Build Layer 2-3 headers for message back to source. */
 110   offset = ip_build_header(skb, dev->pa_addr, iph->saddr,
 111                            &dev, IPPROTO_ICMP, NULL, len, skb_in->ip_hdr->tos,255);
 112   if (offset < 0) {
 113         skb->sk = NULL;
 114         kfree_skb(skb, FREE_READ);
 115         return;
 116   }
 117 
 118   /* Re-adjust length according to actual IP header size. */
 119   skb->len = offset + sizeof(struct icmphdr) + sizeof(struct iphdr) + 8;
 120   icmph = (struct icmphdr *) (skb->data + offset);
 121   icmph->type = type;
 122   icmph->code = code;
 123   icmph->checksum = 0;
 124   icmph->un.gateway = 0;
 125   memcpy(icmph + 1, iph, sizeof(struct iphdr) + 8);
 126 
 127   icmph->checksum = ip_compute_csum((unsigned char *)icmph,
 128                          sizeof(struct icmphdr) + sizeof(struct iphdr) + 8);
 129 
 130   DPRINTF((DBG_ICMP, ">>\n"));
 131   print_icmp(icmph);
 132 
 133   /* Send it and free it. */
 134   ip_queue_xmit(NULL, dev, skb, 1);
 135 }
 136 
 137 
 138 /* Handle ICMP_UNREACH and ICMP_QUENCH. */
 139 static void
 140 icmp_unreach(struct icmphdr *icmph, struct sk_buff *skb)
     /*  */
 141 {
 142   struct inet_protocol *ipprot;
 143   struct iphdr *iph;
 144   unsigned char hash;
 145   int err;
 146 
 147   err = (icmph->type << 8) | icmph->code;
 148   iph = (struct iphdr *) (icmph + 1);
 149   switch(icmph->code & 7) {
 150         case ICMP_NET_UNREACH:
 151                 DPRINTF((DBG_ICMP, "ICMP: %s: network unreachable.\n",
 152                                                         in_ntoa(iph->daddr)));
 153                 break;
 154         case ICMP_HOST_UNREACH:
 155                 DPRINTF((DBG_ICMP, "ICMP: %s: host unreachable.\n",
 156                                                 in_ntoa(iph->daddr)));
 157                 break;
 158         case ICMP_PROT_UNREACH:
 159                 printk("ICMP: %s:%d: protocol unreachable.\n",
 160                         in_ntoa(iph->daddr), ntohs(iph->protocol));
 161                 break;
 162         case ICMP_PORT_UNREACH:
 163                 DPRINTF((DBG_ICMP, "ICMP: %s:%d: port unreachable.\n",
 164                         in_ntoa(iph->daddr), -1 /* FIXME: ntohs(iph->port) */));
 165                 break;
 166         case ICMP_FRAG_NEEDED:
 167                 printk("ICMP: %s: fragmentation needed and DF set.\n",
 168                                                         in_ntoa(iph->daddr));
 169                 break;
 170         case ICMP_SR_FAILED:
 171                 printk("ICMP: %s: Source Route Failed.\n", in_ntoa(iph->daddr));
 172                 break;
 173         default:
 174                 DPRINTF((DBG_ICMP, "ICMP: Unreachable: CODE=%d from %s\n",
 175                                 (icmph->code & 7), in_ntoa(iph->daddr)));
 176                 break;
 177   }
 178 
 179   /* Get the protocol(s). */
 180   hash = iph->protocol & (MAX_INET_PROTOS -1);
 181 
 182   /* This can change while we are doing it. */
 183   ipprot = (struct inet_protocol *) inet_protos[hash];
 184   while(ipprot != NULL) {
 185         struct inet_protocol *nextip;
 186 
 187         nextip = (struct inet_protocol *) ipprot->next;
 188 
 189         /* Pass it off to everyone who wants it. */
 190         if (iph->protocol == ipprot->protocol && ipprot->err_handler) {
 191                 ipprot->err_handler(err, (unsigned char *)(icmph + 1),
 192                                     iph->daddr, iph->saddr, ipprot);
 193         }
 194 
 195         ipprot = nextip;
 196   }
 197   skb->sk = NULL;
 198   kfree_skb(skb, FREE_READ);
 199 }
 200 
 201 
 202 /* Handle ICMP_REDIRECT. */
 203 static void
 204 icmp_redirect(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev)
     /*  */
 205 {
 206   struct iphdr *iph;
 207   unsigned long ip;
 208 
 209   iph = (struct iphdr *) (icmph + 1);
 210   ip = iph->daddr;
 211   switch(icmph->code & 7) {
 212         case ICMP_REDIR_NET:
 213 #ifdef not_a_good_idea
 214                 rt_add((RTF_DYNAMIC | RTF_MODIFIED | RTF_GATEWAY),
 215                         ip, 0, icmph->un.gateway, dev);
 216                 break;
 217 #endif
 218         case ICMP_REDIR_HOST:
 219                 rt_add((RTF_DYNAMIC | RTF_MODIFIED | RTF_HOST | RTF_GATEWAY),
 220                         ip, 0, icmph->un.gateway, dev);
 221                 break;
 222         case ICMP_REDIR_NETTOS:
 223         case ICMP_REDIR_HOSTTOS:
 224                 printk("ICMP: cannot handle TOS redirects yet!\n");
 225                 break;
 226         default:
 227                 DPRINTF((DBG_ICMP, "ICMP: Unreach: CODE=%d\n",
 228                                                 (icmph->code & 7)));
 229                 break;
 230   }
 231   skb->sk = NULL;
 232   kfree_skb(skb, FREE_READ);
 233 }
 234 
 235 
 236 /* Handle ICMP_ECHO ("ping") requests. */
 237 static void
 238 icmp_echo(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
     /*  */
 239           unsigned long saddr, unsigned long daddr, int len,
 240           struct options *opt)
 241 {
 242   struct icmphdr *icmphr;
 243   struct sk_buff *skb2;
 244   int size, offset;
 245 
 246   size = sizeof(struct sk_buff) + dev->hard_header_len + 64 + len;
 247   skb2 = alloc_skb(size, GFP_ATOMIC);
 248   if (skb2 == NULL) {
 249         skb->sk = NULL;
 250         kfree_skb(skb, FREE_READ);
 251         return;
 252   }
 253   skb2->sk = NULL;
 254   skb2->mem_addr = skb2;
 255   skb2->mem_len = size;
 256   skb2->free = 1;
 257 
 258   /* Build Layer 2-3 headers for message back to source */
 259   offset = ip_build_header(skb2, daddr, saddr, &dev,
 260                                 IPPROTO_ICMP, opt, len, skb->ip_hdr->tos,255);
 261   if (offset < 0) {
 262         printk("ICMP: Could not build IP Header for ICMP ECHO Response\n");
 263         kfree_skb(skb2,FREE_WRITE);
 264         skb->sk = NULL;
 265         kfree_skb(skb, FREE_READ);
 266         return;
 267   }
 268 
 269   /* Re-adjust length according to actual IP header size. */
 270   skb2->len = offset + len;
 271 
 272   /* Build ICMP_ECHO Response message. */
 273   icmphr = (struct icmphdr *) (skb2->data + offset);
 274   memcpy((char *) icmphr, (char *) icmph, len);
 275   icmphr->type = ICMP_ECHOREPLY;
 276   icmphr->code = 0;
 277   icmphr->checksum = 0;
 278   icmphr->checksum = ip_compute_csum((unsigned char *)icmphr, len);
 279 
 280   /* Ship it out - free it when done */
 281   ip_queue_xmit((struct sock *)NULL, dev, skb2, 1);
 282 
 283   skb->sk = NULL;
 284   kfree_skb(skb, FREE_READ);
 285 }
 286 
 287 
 288 /* Handle the ICMP INFORMATION REQUEST. */
 289 static void
 290 icmp_info(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
     /*  */
 291           unsigned long saddr, unsigned long daddr, int len,
 292           struct options *opt)
 293 {
 294   /* NOT YET */
 295   skb->sk = NULL;
 296   kfree_skb(skb, FREE_READ);
 297 }
 298 
 299 
 300 /* Handle ICMP_ADRESS_MASK requests. */
 301 static void
 302 icmp_address(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
     /*  */
 303           unsigned long saddr, unsigned long daddr, int len,
 304           struct options *opt)
 305 {
 306   struct icmphdr *icmphr;
 307   struct sk_buff *skb2;
 308   int size, offset;
 309 
 310   size = sizeof(struct sk_buff) + dev->hard_header_len + 64 + len;
 311   skb2 = alloc_skb(size, GFP_ATOMIC);
 312   if (skb2 == NULL) {
 313         skb->sk = NULL;
 314         kfree_skb(skb, FREE_READ);
 315         return;
 316   }
 317   skb2->sk = NULL;
 318   skb2->mem_addr = skb2;
 319   skb2->mem_len = size;
 320   skb2->free = 1;
 321 
 322   /* Build Layer 2-3 headers for message back to source */
 323   offset = ip_build_header(skb2, daddr, saddr, &dev,
 324                                 IPPROTO_ICMP, opt, len, skb->ip_hdr->tos,255);
 325   if (offset < 0) {
 326         printk("ICMP: Could not build IP Header for ICMP ADDRESS Response\n");
 327         kfree_skb(skb2,FREE_WRITE);
 328         skb->sk = NULL;
 329         kfree_skb(skb, FREE_READ);
 330         return;
 331   }
 332 
 333   /* Re-adjust length according to actual IP header size. */
 334   skb2->len = offset + len;
 335 
 336   /* Build ICMP ADDRESS MASK Response message. */
 337   icmphr = (struct icmphdr *) (skb2->data + offset);
 338   icmphr->type = ICMP_ADDRESSREPLY;
 339   icmphr->code = 0;
 340   icmphr->checksum = 0;
 341   icmphr->un.echo.id = icmph->un.echo.id;
 342   icmphr->un.echo.sequence = icmph->un.echo.sequence;
 343   memcpy((char *) (icmphr + 1), (char *) &dev->pa_mask, sizeof(dev->pa_mask));
 344 
 345   icmphr->checksum = ip_compute_csum((unsigned char *)icmphr, len);
 346 
 347   /* Ship it out - free it when done */
 348   ip_queue_xmit((struct sock *)NULL, dev, skb2, 1);
 349 
 350   skb->sk = NULL;
 351   kfree_skb(skb, FREE_READ);
 352 }
 353 
 354 
 355 /* Deal with incoming ICMP packets. */
 356 int
 357 icmp_rcv(struct sk_buff *skb1, struct device *dev, struct options *opt,
     /*  */
 358          unsigned long daddr, unsigned short len,
 359          unsigned long saddr, int redo, struct inet_protocol *protocol)
 360 {
 361   struct icmphdr *icmph;
 362   unsigned char *buff;
 363 
 364   /* Drop broadcast packets. */
 365   if (chk_addr(daddr) == IS_BROADCAST) {
 366         DPRINTF((DBG_ICMP, "ICMP: Discarded broadcast from %s\n",
 367                                                         in_ntoa(saddr)));
 368         skb1->sk = NULL;
 369         kfree_skb(skb1, FREE_READ);
 370         return(0);
 371   }
 372 
 373   buff = skb1->h.raw;
 374   icmph = (struct icmphdr *) buff;
 375 
 376   /* Validate the packet first */
 377   if (ip_compute_csum((unsigned char *) icmph, len)) {
 378         /* Failed checksum! */
 379         printk("ICMP: failed checksum from %s!\n", in_ntoa(saddr));
 380         skb1->sk = NULL;
 381         kfree_skb(skb1, FREE_READ);
 382         return(0);
 383   }
 384   print_icmp(icmph);
 385 
 386   /* Parse the ICMP message */
 387   switch(icmph->type) {
 388         case ICMP_TIME_EXCEEDED:
 389         case ICMP_DEST_UNREACH:
 390         case ICMP_SOURCE_QUENCH:
 391                 icmp_unreach(icmph, skb1);
 392                 return(0);
 393         case ICMP_REDIRECT:
 394                 icmp_redirect(icmph, skb1, dev);
 395                 return(0);
 396         case ICMP_ECHO: 
 397                 icmp_echo(icmph, skb1, dev, saddr, daddr, len, opt);
 398                 return 0;
 399         case ICMP_ECHOREPLY:
 400                 skb1->sk = NULL;
 401                 kfree_skb(skb1, FREE_READ);
 402                 return(0);
 403         case ICMP_INFO_REQUEST:
 404                 icmp_info(icmph, skb1, dev, saddr, daddr, len, opt);
 405                 return 0;
 406         case ICMP_INFO_REPLY:
 407                 skb1->sk = NULL;
 408                 kfree_skb(skb1, FREE_READ);
 409                 return(0);
 410         case ICMP_ADDRESS:
 411                 icmp_address(icmph, skb1, dev, saddr, daddr, len, opt);
 412                 return 0;
 413         case ICMP_ADDRESSREPLY:
 414                 skb1->sk = NULL;
 415                 kfree_skb(skb1, FREE_READ);
 416                 return(0);
 417         default:
 418                 DPRINTF((DBG_ICMP,
 419                         "ICMP: Unsupported ICMP from %s, type = 0x%X\n",
 420                                                 in_ntoa(saddr), icmph->type));
 421                 skb1->sk = NULL;
 422                 kfree_skb(skb1, FREE_READ);
 423                 return(0);
 424   }
 425   /*NOTREACHED*/
 426   skb1->sk = NULL;
 427   kfree_skb(skb1, FREE_READ);
 428   return(-1);
 429 }
 430 
 431 
 432 /* Perform any ICMP-related I/O control requests. */
 433 int
 434 icmp_ioctl(struct sock *sk, int cmd, unsigned long arg)
     /*  */
 435 {
 436   switch(cmd) {
 437         case DDIOCSDBG:
 438                 return(dbg_ioctl((void *) arg, DBG_ICMP));
 439         default:
 440                 return(-EINVAL);
 441   }
 442   return(0);
 443 }
/* */
root/net/inet/icmp.c

DEFINITIONS
