1: /*
2: * net_functios.c
3: *
4: * Created on: 30.07.2009
5: * Copyright (C) 2009 by Chebotarev Roman <roma@ultranet.ru>
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 2 of the License.
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, write to the Free Software
18: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19: */
20:
21: #include "common_includes.h"
22: #include "dhcp.h"
23: #include "dhcdrop_types.h"
24: #include "net_functions.h"
25:
26: int is_timeout;
27:
28: uint16_t rs_crc(const unsigned short *buffer, int length)
29: {
30: uint32_t crc = 0;
31: /* Calculate CRC */
32: while (length > 1)
33: {
34: crc += *buffer++;
35: length -= sizeof (unsigned short);
36: }
37: if (length)
38: crc += *(unsigned char*) buffer;
39:
40: crc = (crc >> 16) + (crc & 0xFFFF);
41: crc += (crc >> 16);
42:
43: return (uint16_t)(~crc);
44: }
45:
46: void assemble_net_header_arp(struct arp_packet_net_header * net_header,
47: const uint8_t * ether_src,
48: uint16_t op_code)
49: {
50: /* Fill ethernet header */
51: memcpy(net_header->eth_head.ether_shost, ether_src, sizeof(net_header->eth_head.ether_shost));
52: memset(net_header->eth_head.ether_dhost, 0xFF, sizeof(net_header->eth_head.ether_dhost));
53: net_header->eth_head.ether_type = htons(ETHERTYPE_ARP);
54: /* Fill ARP header */
55: net_header->arp_head.arp_hwtype = htons(1); /* Ethernet */
56: net_header->arp_head.arp_proto = htons(ETHERTYPE_IP);
57: net_header->arp_head.arp_hwlen = ETH_ALEN;
58: net_header->arp_head.arp_palen = IPV4_ALEN;
59: net_header->arp_head.arp_oper = op_code;
60: }
61:
62: void assemble_net_header_dhcp
63: (
64: struct dhcp_packet_net_header * header,
65: const int data_len,
66: const struct config_params * params,
67: const uint8_t * ether_src,
68: const uint32_t dst_ip,
69: const uint32_t src_ip
70: )
71: {
72: /* Fill ethernet header */
73: memcpy(header->eth_head.ether_shost, ether_src, sizeof(header->eth_head.ether_shost));
74: memset(header->eth_head.ether_dhost, 0xFF, sizeof(header->eth_head.ether_dhost));
75: header->eth_head.ether_type = htons(ETHERTYPE_IP);
76: /* Fill IP header */
77: bzero(&header->ip_header, sizeof(struct iphdr));
78: header->ip_header.ihl = IP_HDR_LEN;
79: header->ip_header.version = 4;
80: header->ip_header.tos = 0x10;
81: header->ip_header.tot_len = htons(B_IP_HDR_LEN + sizeof(struct udphdr) + data_len);
82: header->ip_header.id = (uint16_t) rand();
83: header->ip_header.frag_off = 0;
84: header->ip_header.ttl = DEF_TTL;
85: header->ip_header.protocol = IPPROTO_UDP;
86: header->ip_header.check = 0;
87: header->ip_header.saddr = src_ip;
88: if(dst_ip)
89: header->ip_header.daddr = dst_ip;
90: else
91: memset(&header->ip_header.daddr, 0xFF, sizeof(uint32_t)); /*Set dst IP = 255.255.255.255*/
92:
93: header->ip_header.check = rs_crc((unsigned short*)&header->ip_header, sizeof(struct iphdr));
94: header->udp_header.source = htons(params->client_port);
95: header->udp_header.dest = htons(params->server_port);
96: header->udp_header.len = htons(sizeof(struct udphdr) + data_len);
97: header->udp_header.check = 0; /* Don't use because CRC for UDP - optional parametr */
98:
99: return;
100: }
101:
102: int send_packet(pcap_t* descr, enum packet_types packet_type, const uint8_t *snd_data, const int data_len,
103: const struct config_params * config,
104: const uint8_t * ether_src, const uint32_t dst_ip)
105: {
106: int header_size = 0;
107: static unsigned char pack_buf[DHCP_MTU_MAX];
108:
109: bzero(pack_buf, sizeof(pack_buf));
110:
111: /* Create net-header */
112: switch(packet_type)
113: {
114: case dhcp_packet:
115: if(!config)
116: return 0;
117: assemble_net_header_dhcp((struct dhcp_packet_net_header *)pack_buf,
118: data_len, config, ether_src, dst_ip, 0);//((struct dhcp_packet *) snd_data)->ciaddr.s_addr);
119: header_size = sizeof(struct dhcp_packet_net_header);
120: break;
121: case arp_packet:
122: assemble_net_header_arp((struct arp_packet_net_header *) pack_buf, ether_src, ARP_OP_REQ);
123: header_size = sizeof(struct arp_packet_net_header);
124: break;
125: default:
126: printf("send_packet(): unknown type of packet.\n");
127: return 0;
128: }
129:
130: /* Copy user data to send buffer */
131: memcpy(pack_buf + header_size, snd_data, data_len);
132:
133: if(pcap_inject(descr, pack_buf, header_size + data_len) == -1)
134: {
135: pcap_perror(descr, "pcap_inject");
136: return 0;
137: }
138:
139: return 1;
140: }
141:
142: void packet_handler(u_char *out_packet, const struct pcap_pkthdr *h,
143: const u_char *packet)
144: {
145: if(h->len > DHCP_MTU_MAX)
146: {
147: printf("Received too long packet: %d. Can't dispatch!\n", h->len);
148: return;
149: }
150:
151: memcpy(out_packet, (u_char*)packet, h->len);
152: return;
153: }
154:
155: int get_packet(pcap_t * descr, u_char * ether_packet, const int wait_seconds)
156: {
157: int ret = 0;
158: uint32_t t;
159:
160: if(wait_seconds > 0)
161: {
162: is_timeout = 0;
163: t = timer_start(wait_seconds, timeout);
164: }
165: else
166: is_timeout = 1;
167: while(1)
168: {
169: if(wait_seconds)
170: usleep(CAP_TIMEOUT); /* Waiting 100 microseconds for avoid CPU overload */
171:
172: ret = pcap_dispatch(descr, 1, packet_handler, (u_char*)ether_packet);
173: if(ret < 0)
174: {
175: perror("pcap_dispatch");
176: return -1;
177: }
178:
179: if(is_timeout || ret)
180: {
181: timer_stop(t);
182: break;
183: }
184: }
185: return ret;
186: }
187:
188:
189: #ifdef _WIN32
190: void CALLBACK timeout(UINT uTimerID, UINT uMsg, DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
191: #else
192: void timeout(int signal)
193: #endif
194: {
195: is_timeout = 1;
196: }
197:
198: /* Opening and testing device */
199: pcap_t * get_device(const struct config_params * params)
200: {
201: char errbuf[PCAP_ERRBUF_SIZE];
202: pcap_t * pcap_socket = pcap_open_live(params->if_name, DHCP_MTU_MAX, 1,
203: PCAP_OPEN_LIVE_TIMEOUT, errbuf);
204:
205: if(pcap_socket == NULL)
206: {
207: printf("Opening device error! %s\n",errbuf);
208: exit(ERR_OPENDEV);
209: }
210:
211: if(pcap_datalink(pcap_socket) != DLT_EN10MB)
212: {
213: printf("Can't work on this link layer type! Exit.\n");
214: exit(ERR_INVALID_DEV);
215: }
216:
217: #ifdef __linux__
218: /* Set nonblock mode for processing DHCP timeouts */
219: if(pcap_setnonblock(pcap_socket, 1, errbuf) == -1)
220: {
221: printf("pcap_setnoblock error: '%s'\n", errbuf);
222: pcap_close(pcap_socket);
223: exit(ERR_SETNOBLOCK);
224: }
225: #endif
226:
227: return pcap_socket;
228: }
229:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to net_functions.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dhcdrop / src