Statistics
| Branch: | Revision:

root / slirp / ip_icmp.c @ 5fafdf24

History | View | Annotate | Download (10.5 kB)

1
/*
2
 * Copyright (c) 1982, 1986, 1988, 1993
3
 *        The Regents of the University of California.  All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 * 1. Redistributions of source code must retain the above copyright
9
 *    notice, this list of conditions and the following disclaimer.
10
 * 2. Redistributions in binary form must reproduce the above copyright
11
 *    notice, this list of conditions and the following disclaimer in the
12
 *    documentation and/or other materials provided with the distribution.
13
 * 3. All advertising materials mentioning features or use of this software
14
 *    must display the following acknowledgement:
15
 *        This product includes software developed by the University of
16
 *        California, Berkeley and its contributors.
17
 * 4. Neither the name of the University nor the names of its contributors
18
 *    may be used to endorse or promote products derived from this software
19
 *    without specific prior written permission.
20
 *
21
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31
 * SUCH DAMAGE.
32
 *
33
 *        @(#)ip_icmp.c        8.2 (Berkeley) 1/4/94
34
 * ip_icmp.c,v 1.7 1995/05/30 08:09:42 rgrimes Exp
35
 */
36

    
37
#include "slirp.h"
38
#include "ip_icmp.h"
39

    
40
struct icmpstat icmpstat;
41

    
42
/* The message sent when emulating PING */
43
/* Be nice and tell them it's just a psuedo-ping packet */
44
char icmp_ping_msg[] = "This is a psuedo-PING packet used by Slirp to emulate ICMP ECHO-REQUEST packets.\n";
45

    
46
/* list of actions for icmp_error() on RX of an icmp message */
47
static int icmp_flush[19] = {
48
/*  ECHO REPLY (0)  */   0,
49
                         1,
50
                         1,
51
/* DEST UNREACH (3) */   1,
52
/* SOURCE QUENCH (4)*/   1,
53
/* REDIRECT (5) */       1,
54
                         1,
55
                         1,
56
/* ECHO (8) */           0,
57
/* ROUTERADVERT (9) */   1,
58
/* ROUTERSOLICIT (10) */ 1,
59
/* TIME EXCEEDED (11) */ 1,
60
/* PARAMETER PROBLEM (12) */ 1,
61
/* TIMESTAMP (13) */     0,
62
/* TIMESTAMP REPLY (14) */ 0,
63
/* INFO (15) */          0,
64
/* INFO REPLY (16) */    0,
65
/* ADDR MASK (17) */     0,
66
/* ADDR MASK REPLY (18) */ 0
67
};
68

    
69
/*
70
 * Process a received ICMP message.
71
 */
72
void
73
icmp_input(m, hlen)
74
     struct mbuf *m;
75
     int hlen;
76
{
77
  register struct icmp *icp;
78
  register struct ip *ip=mtod(m, struct ip *);
79
  int icmplen=ip->ip_len;
80
  /* int code; */
81

    
82
  DEBUG_CALL("icmp_input");
83
  DEBUG_ARG("m = %lx", (long )m);
84
  DEBUG_ARG("m_len = %d", m->m_len);
85

    
86
  icmpstat.icps_received++;
87

    
88
  /*
89
   * Locate icmp structure in mbuf, and check
90
   * that its not corrupted and of at least minimum length.
91
   */
92
  if (icmplen < ICMP_MINLEN) {          /* min 8 bytes payload */
93
    icmpstat.icps_tooshort++;
94
  freeit:
95
    m_freem(m);
96
    goto end_error;
97
  }
98

    
99
  m->m_len -= hlen;
100
  m->m_data += hlen;
101
  icp = mtod(m, struct icmp *);
102
  if (cksum(m, icmplen)) {
103
    icmpstat.icps_checksum++;
104
    goto freeit;
105
  }
106
  m->m_len += hlen;
107
  m->m_data -= hlen;
108
 
109
  /*        icmpstat.icps_inhist[icp->icmp_type]++; */
110
  /* code = icp->icmp_code; */
111

    
112
  DEBUG_ARG("icmp_type = %d", icp->icmp_type);
113
  switch (icp->icmp_type) {
114
  case ICMP_ECHO:
115
    icp->icmp_type = ICMP_ECHOREPLY;
116
    ip->ip_len += hlen;                     /* since ip_input subtracts this */
117
    if (ip->ip_dst.s_addr == alias_addr.s_addr) {
118
      icmp_reflect(m);
119
    } else {
120
      struct socket *so;
121
      struct sockaddr_in addr;
122
      if ((so = socreate()) == NULL) goto freeit;
123
      if(udp_attach(so) == -1) {
124
        DEBUG_MISC((dfd,"icmp_input udp_attach errno = %d-%s\n",
125
                    errno,strerror(errno)));
126
        sofree(so);
127
        m_free(m);
128
        goto end_error;
129
      }
130
      so->so_m = m;
131
      so->so_faddr = ip->ip_dst;
132
      so->so_fport = htons(7);
133
      so->so_laddr = ip->ip_src;
134
      so->so_lport = htons(9);
135
      so->so_iptos = ip->ip_tos;
136
      so->so_type = IPPROTO_ICMP;
137
      so->so_state = SS_ISFCONNECTED;
138
     
139
      /* Send the packet */
140
      addr.sin_family = AF_INET;
141
      if ((so->so_faddr.s_addr & htonl(0xffffff00)) == special_addr.s_addr) {
142
        /* It's an alias */
143
        switch(ntohl(so->so_faddr.s_addr) & 0xff) {
144
        case CTL_DNS:
145
          addr.sin_addr = dns_addr;
146
          break;
147
        case CTL_ALIAS:
148
        default:
149
          addr.sin_addr = loopback_addr;
150
          break;
151
        }
152
      } else {
153
        addr.sin_addr = so->so_faddr;
154
      }
155
      addr.sin_port = so->so_fport;
156
      if(sendto(so->s, icmp_ping_msg, strlen(icmp_ping_msg), 0,
157
                (struct sockaddr *)&addr, sizeof(addr)) == -1) {
158
        DEBUG_MISC((dfd,"icmp_input udp sendto tx errno = %d-%s\n",
159
                    errno,strerror(errno)));
160
        icmp_error(m, ICMP_UNREACH,ICMP_UNREACH_NET, 0,strerror(errno));
161
        udp_detach(so);
162
      }
163
    } /* if ip->ip_dst.s_addr == alias_addr.s_addr */
164
    break;
165
  case ICMP_UNREACH:
166
    /* XXX? report error? close socket? */
167
  case ICMP_TIMXCEED:
168
  case ICMP_PARAMPROB:
169
  case ICMP_SOURCEQUENCH:
170
  case ICMP_TSTAMP:
171
  case ICMP_MASKREQ:
172
  case ICMP_REDIRECT:
173
    icmpstat.icps_notsupp++;
174
    m_freem(m);
175
    break;
176
   
177
  default:
178
    icmpstat.icps_badtype++;
179
    m_freem(m);
180
  } /* swith */
181

    
182
end_error:
183
  /* m is m_free()'d xor put in a socket xor or given to ip_send */
184
  return;
185
}
186

    
187

    
188
/*
189
 *        Send an ICMP message in response to a situation
190
 *
191
 *        RFC 1122: 3.2.2        MUST send at least the IP header and 8 bytes of header. MAY send more (we do).
192
 *                        MUST NOT change this header information.
193
 *                        MUST NOT reply to a multicast/broadcast IP address.
194
 *                        MUST NOT reply to a multicast/broadcast MAC address.
195
 *                        MUST reply to only the first fragment.
196
 */
197
/*
198
 * Send ICMP_UNREACH back to the source regarding msrc.
199
 * mbuf *msrc is used as a template, but is NOT m_free()'d.
200
 * It is reported as the bad ip packet.  The header should
201
 * be fully correct and in host byte order.
202
 * ICMP fragmentation is illegal.  All machines must accept 576 bytes in one
203
 * packet.  The maximum payload is 576-20(ip hdr)-8(icmp hdr)=548
204
 */
205

    
206
#define ICMP_MAXDATALEN (IP_MSS-28)
207
void
208
icmp_error(msrc, type, code, minsize, message)
209
     struct mbuf *msrc;
210
     u_char type;
211
     u_char code;
212
     int minsize;
213
     char *message;
214
{
215
  unsigned hlen, shlen, s_ip_len;
216
  register struct ip *ip;
217
  register struct icmp *icp;
218
  register struct mbuf *m;
219

    
220
  DEBUG_CALL("icmp_error");
221
  DEBUG_ARG("msrc = %lx", (long )msrc);
222
  DEBUG_ARG("msrc_len = %d", msrc->m_len);
223

    
224
  if(type!=ICMP_UNREACH && type!=ICMP_TIMXCEED) goto end_error;
225

    
226
  /* check msrc */
227
  if(!msrc) goto end_error;
228
  ip = mtod(msrc, struct ip *);
229
#if DEBUG 
230
  { char bufa[20], bufb[20];
231
    strcpy(bufa, inet_ntoa(ip->ip_src));
232
    strcpy(bufb, inet_ntoa(ip->ip_dst));
233
    DEBUG_MISC((dfd, " %.16s to %.16s\n", bufa, bufb));
234
  }
235
#endif
236
  if(ip->ip_off & IP_OFFMASK) goto end_error;    /* Only reply to fragment 0 */
237

    
238
  shlen=ip->ip_hl << 2;
239
  s_ip_len=ip->ip_len;
240
  if(ip->ip_p == IPPROTO_ICMP) {
241
    icp = (struct icmp *)((char *)ip + shlen);
242
    /*
243
     *        Assume any unknown ICMP type is an error. This isn't
244
     *        specified by the RFC, but think about it..
245
     */
246
    if(icp->icmp_type>18 || icmp_flush[icp->icmp_type]) goto end_error;
247
  }
248

    
249
  /* make a copy */
250
  if(!(m=m_get())) goto end_error;               /* get mbuf */
251
  { int new_m_size;
252
    new_m_size=sizeof(struct ip )+ICMP_MINLEN+msrc->m_len+ICMP_MAXDATALEN;
253
    if(new_m_size>m->m_size) m_inc(m, new_m_size);
254
  }
255
  memcpy(m->m_data, msrc->m_data, msrc->m_len);
256
  m->m_len = msrc->m_len;                        /* copy msrc to m */
257

    
258
  /* make the header of the reply packet */
259
  ip  = mtod(m, struct ip *);
260
  hlen= sizeof(struct ip );     /* no options in reply */
261
 
262
  /* fill in icmp */
263
  m->m_data += hlen;                 
264
  m->m_len -= hlen;
265

    
266
  icp = mtod(m, struct icmp *);
267

    
268
  if(minsize) s_ip_len=shlen+ICMP_MINLEN;   /* return header+8b only */
269
  else if(s_ip_len>ICMP_MAXDATALEN)         /* maximum size */
270
    s_ip_len=ICMP_MAXDATALEN;
271

    
272
  m->m_len=ICMP_MINLEN+s_ip_len;        /* 8 bytes ICMP header */ 
273

    
274
  /* min. size = 8+sizeof(struct ip)+8 */
275

    
276
  icp->icmp_type = type;
277
  icp->icmp_code = code;
278
  icp->icmp_id = 0;
279
  icp->icmp_seq = 0;
280

    
281
  memcpy(&icp->icmp_ip, msrc->m_data, s_ip_len);   /* report the ip packet */
282
  HTONS(icp->icmp_ip.ip_len);
283
  HTONS(icp->icmp_ip.ip_id);
284
  HTONS(icp->icmp_ip.ip_off);
285

    
286
#if DEBUG
287
  if(message) {           /* DEBUG : append message to ICMP packet */
288
    int message_len;
289
    char *cpnt;
290
    message_len=strlen(message);
291
    if(message_len>ICMP_MAXDATALEN) message_len=ICMP_MAXDATALEN;
292
    cpnt=(char *)m->m_data+m->m_len;
293
    memcpy(cpnt, message, message_len);
294
    m->m_len+=message_len;
295
  }
296
#endif
297

    
298
  icp->icmp_cksum = 0;
299
  icp->icmp_cksum = cksum(m, m->m_len);
300

    
301
  m->m_data -= hlen;
302
  m->m_len += hlen;
303

    
304
  /* fill in ip */
305
  ip->ip_hl = hlen >> 2;
306
  ip->ip_len = m->m_len;
307
 
308
  ip->ip_tos=((ip->ip_tos & 0x1E) | 0xC0);  /* high priority for errors */
309

    
310
  ip->ip_ttl = MAXTTL;
311
  ip->ip_p = IPPROTO_ICMP;
312
  ip->ip_dst = ip->ip_src;    /* ip adresses */
313
  ip->ip_src = alias_addr;
314

    
315
  (void ) ip_output((struct socket *)NULL, m);
316
 
317
  icmpstat.icps_reflect++;
318

    
319
end_error:
320
  return;
321
}
322
#undef ICMP_MAXDATALEN
323

    
324
/*
325
 * Reflect the ip packet back to the source
326
 */
327
void
328
icmp_reflect(m)
329
     struct mbuf *m;
330
{
331
  register struct ip *ip = mtod(m, struct ip *);
332
  int hlen = ip->ip_hl << 2;
333
  int optlen = hlen - sizeof(struct ip );
334
  register struct icmp *icp;
335

    
336
  /*
337
   * Send an icmp packet back to the ip level,
338
   * after supplying a checksum.
339
   */
340
  m->m_data += hlen;
341
  m->m_len -= hlen;
342
  icp = mtod(m, struct icmp *);
343

    
344
  icp->icmp_cksum = 0;
345
  icp->icmp_cksum = cksum(m, ip->ip_len - hlen);
346

    
347
  m->m_data -= hlen;
348
  m->m_len += hlen;
349

    
350
  /* fill in ip */
351
  if (optlen > 0) {
352
    /*
353
     * Strip out original options by copying rest of first
354
     * mbuf's data back, and adjust the IP length.
355
     */
356
    memmove((caddr_t)(ip + 1), (caddr_t)ip + hlen,
357
            (unsigned )(m->m_len - hlen));
358
    hlen -= optlen;
359
    ip->ip_hl = hlen >> 2;
360
    ip->ip_len -= optlen;
361
    m->m_len -= optlen;
362
  }
363

    
364
  ip->ip_ttl = MAXTTL;
365
  { /* swap */
366
    struct in_addr icmp_dst;
367
    icmp_dst = ip->ip_dst;
368
    ip->ip_dst = ip->ip_src;
369
    ip->ip_src = icmp_dst;
370
  }
371

    
372
  (void ) ip_output((struct socket *)NULL, m);
373

    
374
  icmpstat.icps_reflect++;
375
}