Annotation of embedaddon/libnet/src/libnet_write.c, revision 1.1.1.1
1.1 misho 1: /*
2: * $Id: libnet_write.c,v 1.13 2004/02/20 18:53:50 mike Exp $
3: *
4: * libnet
5: * libnet_write.c - writes a prebuilt packet to the network
6: *
7: * Copyright (c) 1998 - 2004 Mike D. Schiffman <mike@infonexus.com>
8: * All rights reserved.
9: * win32 specific code
10: * Copyright (c) 2002 - 2003 Roberto Larcher <roberto.larcher@libero.it>
11: *
12: * Redistribution and use in source and binary forms, with or without
13: * modification, are permitted provided that the following conditions
14: * are met:
15: * 1. Redistributions of source code must retain the above copyright
16: * notice, this list of conditions and the following disclaimer.
17: * 2. Redistributions in binary form must reproduce the above copyright
18: * notice, this list of conditions and the following disclaimer in the
19: * documentation and/or other materials provided with the distribution.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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: */
34:
35: #if (HAVE_CONFIG_H)
36: #include "../include/config.h"
37: #endif
38: #if (!(_WIN32) || (__CYGWIN__))
39: #include "../include/libnet.h"
40: #else
41: #include "../include/win32/libnet.h"
42: #include "../include/win32/config.h"
43: #include "packet32.h"
44: #include "Ntddndis.h"
45: #endif
46:
47: int
48: libnet_write(libnet_t *l)
49: {
50: int c;
51: u_int32_t len;
52: u_int8_t *packet = NULL;
53:
54: if (l == NULL)
55: {
56: return (-1);
57: }
58:
59: c = libnet_pblock_coalesce(l, &packet, &len);
60: if (c == - 1)
61: {
62: /* err msg set in libnet_pblock_coalesce() */
63: return (-1);
64: }
65:
66: /* assume error */
67: c = -1;
68: switch (l->injection_type)
69: {
70: case LIBNET_RAW4:
71: case LIBNET_RAW4_ADV:
72: if (len > LIBNET_MAX_PACKET)
73: {
74: snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,
75: "%s(): packet is too large (%d bytes)\n",
76: __func__, len);
77: goto done;
78: }
79: c = libnet_write_raw_ipv4(l, packet, len);
80: break;
81: case LIBNET_RAW6:
82: case LIBNET_RAW6_ADV:
83: c = libnet_write_raw_ipv6(l, packet, len);
84: break;
85: case LIBNET_LINK:
86: case LIBNET_LINK_ADV:
87: c = libnet_write_link(l, packet, len);
88: break;
89: default:
90: snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,
91: "%s(): unsuported injection type\n", __func__);
92: goto done;
93: }
94:
95: /* do statistics */
96: if (c == len)
97: {
98: l->stats.packets_sent++;
99: l->stats.bytes_written += c;
100: }
101: else
102: {
103: l->stats.packet_errors++;
104: /*
105: * XXX - we probably should have a way to retrieve the number of
106: * bytes actually written (since we might have written something).
107: */
108: if (c > 0)
109: {
110: l->stats.bytes_written += c;
111: }
112: }
113: done:
114: /*
115: * Restore original pointer address so free won't complain about a
116: * modified chunk pointer.
117: */
118: if (l->aligner > 0)
119: {
120: packet = packet - l->aligner;
121: }
122: free(packet);
123: return (c);
124: }
125:
126: #if defined (__WIN32__)
127: libnet_ptag_t
128: libnet_win32_build_fake_ethernet(u_int8_t *dst, u_int8_t *src, u_int16_t type,
129: u_int8_t *payload, u_int32_t payload_s, u_int8_t *packet, libnet_t *l,
130: libnet_ptag_t ptag)
131: {
132: struct libnet_ethernet_hdr eth_hdr;
133:
134: if (!packet)
135: {
136: return (-1);
137: }
138:
139: memset(ð_hdr, 0, sizeof(eth_hdr));
140: eth_hdr.ether_type = htons(type);
141: memcpy(eth_hdr.ether_dhost, dst, ETHER_ADDR_LEN); /* destination address */
142: memcpy(eth_hdr.ether_shost, src, ETHER_ADDR_LEN); /* source address */
143:
144: if (payload && payload_s)
145: {
146: /*
147: * Unchecked runtime error for buf + ETH_H payload to be greater than
148: * the allocated heap memory.
149: */
150: memcpy(packet + LIBNET_ETH_H, payload, payload_s);
151: }
152: memcpy(packet, ð_hdr, sizeof(eth_hdr));
153: return (1);
154: }
155:
156: libnet_ptag_t
157: libnet_win32_build_fake_token(u_int8_t *dst, u_int8_t *src, u_int16_t type,
158: u_int8_t *payload, u_int32_t payload_s, u_int8_t *packet, libnet_t *l,
159: libnet_ptag_t ptag)
160: {
161: struct libnet_token_ring_hdr token_ring_hdr;
162:
163: if (!packet)
164: {
165: return (-1);
166: }
167:
168: memset(&token_ring_hdr, 0, sizeof(token_ring_hdr));
169: token_ring_hdr.token_ring_access_control = 0x10;
170: token_ring_hdr.token_ring_frame_control = 0x40;
171: token_ring_hdr.token_ring_llc_dsap = 0xaa;
172: token_ring_hdr.token_ring_llc_ssap = 0xaa;
173: token_ring_hdr.token_ring_llc_control_field = 0x03;
174: token_ring_hdr.token_ring_type = htons(type);
175: memcpy(token_ring_hdr.token_ring_dhost, dst, ETHER_ADDR_LEN);
176: memcpy(token_ring_hdr.token_ring_shost, libnet_get_hwaddr(l),
177: ETHER_ADDR_LEN);
178:
179: if (payload && payload_s)
180: {
181: /*
182: * Unchecked runtime error for buf + ETH_H payload to be greater than
183: * the allocated heap memory.
184: */
185: memcpy(packet + LIBNET_TOKEN_RING_H, payload, payload_s);
186: }
187: memcpy(packet, &token_ring_hdr, sizeof(token_ring_hdr));
188: return (1);
189: }
190:
191:
192: int
193: libnet_win32_write_raw_ipv4(libnet_t *l, u_int8_t *payload, u_int32_t payload_s)
194: {
195: static BYTE dst[ETHER_ADDR_LEN];
196: static BYTE src[ETHER_ADDR_LEN];
197:
198: u_int8_t *packet = NULL;
199: u_int32_t packet_s;
200:
201: LPPACKET lpPacket = NULL;
202: DWORD remoteip = 0;
203: DWORD BytesTransfered;
204: NetType type;
205: struct libnet_ipv4_hdr *ip_hdr = NULL;
206:
207: memset(dst, 0, sizeof(dst));
208: memset(src, 0, sizeof(src));
209:
210: packet_s = payload_s + l->link_offset;
211: packet = (u_int8_t *)malloc(packet_s);
212: if (packet == NULL)
213: {
214: snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,
215: "%s(): failed to allocate packet\n", __func__);
216: return (-1);
217: }
218:
219: /* we have to do the IP checksum */
220: if (libnet_do_checksum(l, payload, IPPROTO_IP, LIBNET_IPV4_H) == -1)
221: {
222: /* error msg set in libnet_do_checksum */
223: return (-1);
224: }
225:
226: /* MACs, IPs and other stuff... */
227: ip_hdr = (struct libnet_ipv4_hdr *)payload;
228: memcpy(src, libnet_get_hwaddr(l), sizeof(src));
229: remoteip = ip_hdr->ip_dst.S_un.S_addr;
230:
231: /* check if the remote station is the local station */
232: if (remoteip == libnet_get_ipaddr4(l))
233: {
234: memcpy(dst, src, sizeof(dst));
235: }
236: else
237: {
238: memcpy(dst, libnet_win32_get_remote_mac(l, remoteip), sizeof(dst));
239: }
240:
241: PacketGetNetType(l->lpAdapter, &type);
242:
243: switch(type.LinkType)
244: {
245: case NdisMedium802_3:
246: libnet_win32_build_fake_ethernet(dst, src, ETHERTYPE_IP, payload,
247: payload_s, packet, l , 0);
248: break;
249: case NdisMedium802_5:
250: libnet_win32_build_fake_token(dst, src, ETHERTYPE_IP, payload,
251: payload_s, packet, l, 0);
252: break;
253: case NdisMediumFddi:
254: break;
255: case NdisMediumWan:
256: case NdisMediumAtm:
257: case NdisMediumArcnet878_2:
258: default:
259: snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,
260: "%s(): network type (%d) is not supported\n", __func__,
261: type.LinkType);
262: return (-1);
263: break;
264: }
265:
266: BytesTransfered = -1;
267: if ((lpPacket = PacketAllocatePacket()) == NULL)
268: {
269: snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,
270: "%s(): failed to allocate the LPPACKET structure\n", __func__);
271: return (-1);
272: }
273:
274: PacketInitPacket(lpPacket, packet, packet_s);
275:
276: /* PacketSendPacket returns a BOOLEAN */
277: if (PacketSendPacket(l->lpAdapter, lpPacket, TRUE))
278: {
279: BytesTransfered = packet_s;
280: }
281:
282: PacketFreePacket(lpPacket);
283: free(packet);
284:
285: return (BytesTransfered);
286: }
287:
288: int
289: libnet_write_raw_ipv4(libnet_t *l, u_int8_t *packet, u_int32_t size)
290: {
291: return (libnet_win32_write_raw_ipv4(l, packet, size));
292: }
293:
294: int
295: libnet_write_raw_ipv6(libnet_t *l, u_int8_t *packet, u_int32_t size)
296: {
297: /* no difference in win32 */
298: return (libnet_write_raw_ipv4(l, packet, size));
299: }
300:
301: #else /* __WIN32__ */
302:
303: int
304: libnet_write_raw_ipv4(libnet_t *l, u_int8_t *packet, u_int32_t size)
305: {
306: int c;
307: struct sockaddr_in sin;
308: struct libnet_ipv4_hdr *ip_hdr;
309:
310: if (l == NULL)
311: {
312: return (-1);
313: }
314:
315: ip_hdr = (struct libnet_ipv4_hdr *)packet;
316:
317: #if (LIBNET_BSD_BYTE_SWAP)
318: /*
319: * For link access, we don't need to worry about the inconsistencies of
320: * certain BSD kernels. However, raw socket nuances abound. Certain
321: * BSD implmentations require the ip_len and ip_off fields to be in host
322: * byte order.
323: */
324: ip_hdr->ip_len = FIX(ip_hdr->ip_len);
325: ip_hdr->ip_off = FIX(ip_hdr->ip_off);
326: #endif /* LIBNET_BSD_BYTE_SWAP */
327:
328: memset(&sin, 0, sizeof(sin));
329: sin.sin_family = AF_INET;
330: sin.sin_addr.s_addr = ip_hdr->ip_dst.s_addr;
331: #if (__WIN32__)
332: /* set port for TCP */
333: /*
334: * XXX - should first check to see if there's a pblock for a TCP
335: * header, if not we can use a dummy value for the port.
336: */
337: if (ip_hdr->ip_p == 6)
338: {
339: struct libnet_tcp_hdr *tcph_p =
340: (struct libnet_tcp_hdr *)(packet + (ip_hdr->ip_hl << 2));
341: sin.sin_port = tcph_p->th_dport;
342: }
343: /* set port for UDP */
344: /*
345: * XXX - should first check to see if there's a pblock for a UDP
346: * header, if not we can use a dummy value for the port.
347: */
348: else if (ip_hdr->ip_p == 17)
349: {
350: struct libnet_udp_hdr *udph_p =
351: (struct libnet_udp_hdr *)(packet + (ip_hdr->ip_hl << 2));
352: sin.sin_port = udph_p->uh_dport;
353: }
354: #endif /* __WIN32__ */
355:
356: c = sendto(l->fd, packet, size, 0, (struct sockaddr *)&sin,
357: sizeof(struct sockaddr));
358:
359: #if (LIBNET_BSD_BYTE_SWAP)
360: ip_hdr->ip_len = UNFIX(ip_hdr->ip_len);
361: ip_hdr->ip_off = UNFIX(ip_hdr->ip_off);
362: #endif /* LIBNET_BSD_BYTE_SWAP */
363:
364: if (c != size)
365: {
366: #if !(__WIN32__)
367: snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,
368: "%s(): %d bytes written (%s)\n", __func__, c,
369: strerror(errno));
370: #else /* __WIN32__ */
371: snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,
372: "%s(): %d bytes written (%d)\n", __func__, c,
373: WSAGetLastError());
374: #endif /* !__WIN32__ */
375: }
376: return (c);
377: }
378:
379: int
380: libnet_write_raw_ipv6(libnet_t *l, u_int8_t *packet, u_int32_t size)
381: {
382: #if defined HAVE_SOLARIS && !defined HAVE_SOLARIS_IPV6
383: snprintf(l->err_buf, LIBNET_ERRBUF_SIZE, "%s(): no IPv6 support\n",
384: __func__, strerror(errno));
385: return (-1);
386: }
387: #else
388: int c;
389: struct sockaddr_in6 sin;
390: struct libnet_ipv6_hdr *ip_hdr;
391:
392: if (l == NULL)
393: {
394: return (-1);
395: }
396:
397: ip_hdr = (struct libnet_ipv6_hdr *)packet;
398:
399: memset(&sin, 0, sizeof(sin));
400: sin.sin6_family = AF_INET6;
401: memcpy(sin.sin6_addr.s6_addr, ip_hdr->ip_dst.libnet_s6_addr,
402: sizeof(ip_hdr->ip_dst.libnet_s6_addr));
403:
404: c = sendto(l->fd, packet, size, 0, (struct sockaddr *)&sin, sizeof(sin));
405: if (c != size)
406: {
407: #if !(__WIN32__)
408: snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,
409: "%s(): %d bytes written (%s)\n", __func__, c,
410: strerror(errno));
411: #else /* __WIN32__ */
412: snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,
413: "%s(): %d bytes written (%d)\n", __func__, c,
414: WSAGetLastError());
415: #endif /* !__WIN32__ */
416: }
417: return (c);
418: }
419: #endif
420: #endif
421: /* EOF */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to libnet_write.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libnet / src