Commit 1ce1f0978d65727c6bbc7f9f745470eabccea0aa - reaver

New upstream version 1.6.4 Mati Aharoni (Kali Developer) 6 years ago

61 changed file(s) with 1788 addition(s) and 11947 deletion(s). Raw diff Collapse all Expand all

+15

-0

.gitignore less more

3	3	*.so
4	4	*.wpc
5	5	*.patch
	6	*.cap
	7	*.pcap
	8	*.pcapng
	9	*.log
	10	*.diff
	11	*.csv
	12	*.netxml
	13	*.tar
	14	*.tar.gz
	15	*.tar.bz2
	16	*.tar.xz
	17	*.pyc
	18	*.aes
	19	*.gpg
	20	src/version.h
6	21	src/wash
7	22	src/reaver
8	23	src/config.log

-6

README.md less more

67	67
68	68	# Reaver Usage
69	69
70		```Reaver v1.6.3 WiFi Protected Setup Attack Tool
	70	```Reaver v1.6.4 WiFi Protected Setup Attack Tool
71	71	Copyright (c) 2011, Tactical Network Solutions, Craig Heffner <[email protected]>
72	72
73	73	Required Arguments:

84	84	-D, --daemonize Daemonize reaver
85	85	-f, --fixed Disable channel hopping
86	86	-5, --5ghz Use 5GHz 802.11 channels
87		-v, --verbose Display non-critical warnings (-vv for more)
	87	-v, --verbose Display non-critical warnings (-vv or -vvv for more)
88	88	-q, --quiet Only display critical messages
89	89	-h, --help Show help
90	90

95	95	-g, --max-attempts=<num> Quit after num pin attempts
96	96	-x, --fail-wait=<seconds> Set the time to sleep after 10 unexpected failures [0]
97	97	-r, --recurring-delay=<x:y> Sleep for y seconds every x pin attempts
98		-t, --timeout=<seconds> Set the receive timeout period [5]
99		-T, --m57-timeout=<seconds> Set the M5/M7 timeout period [0.20]
	98	-t, --timeout=<seconds> Set the receive timeout period [10]
	99	-T, --m57-timeout=<seconds> Set the M5/M7 timeout period [0.40]
100	100	-A, --no-associate Do not associate with the AP (association must be done by another application)
101	101	-N, --no-nacks Do not send NACK messages when out of order packets are received
102	102	-S, --dh-small Use small DH keys to improve crack speed
103	103	-L, --ignore-locks Ignore locked state reported by the target AP
104	104	-E, --eap-terminate Terminate each WPS session with an EAP FAIL packet
105		-n, --nack Target AP always sends a NACK [Auto]
	105	-J, --timeout-is-nack Treat timeout as NACK (DIR-300/320)
106	106	-w, --win7 Mimic a Windows 7 registrar [False]
107	107	-K, --pixie-dust Run pixiedust attack
108	108	-Z Run pixiedust attack
109	109
110	110	Example:
111		reaver -i wlan0mon -b 00:90:4C:C1:AC:21 -vv
	111	./reaver -i wlan0mon -b 00:90:4C:C1:AC:21 -vv
112	112	```
113	113
114	114	Options description and examples of use can be found in the [Readme from Craig Heffner](https://github.com/t6x/reaver-wps-fork-t6x/blob/master/docs/README.REAVER). Here comes a description of the new options introduced since then:

+279

-295

src/80211.c less more

30	30	* files in the program, then also delete it here.
31	31	*/
32	32
	33	#include "iface.h"
33	34	#include "80211.h"
34	35	#include "send.h"
	36	#include "utils/radiotap.h"
	37	#include "crc.h"
	38	#include <libwps.h>
	39	#include <assert.h>
	40
	41	/* define NO_REPLAY_HTCAPS to 1 if you want to disable sending
	42	ht caps in association request for testing */
	43	#ifndef NO_REPLAY_HTCAPS
	44	#define NO_REPLAY_HTCAPS 0
	45	#endif
	46
	47	static void deauthenticate(void);
	48	static void authenticate(void);
	49	static void associate(void);
35	50
36	51	/Reads the next packet from pcap_next() and validates the FCS. /
37		u_char next_packet(struct pcap_pkthdr header)
38		{
39		u_char *packet = NULL;
	52	unsigned char next_packet(struct pcap_pkthdr header)
	53	{
	54	const unsigned char *packet = NULL;
	55	struct pcap_pkthdr *pkt_header;
	56	int status;
40	57
41	58	/* Loop until we get a valid packet, or until we run out of packets */
42		while((packet = (void*)pcap_next(get_handle(), header)) != NULL)
	59	while((status = pcap_next_ex(get_handle(), &pkt_header, &packet)) == 1 \|\| !status)
43	60	{
44		if(get_validate_fcs())
45		{
46		if(check_fcs(packet, header->len))
47		{
48		break;
49		}
50		else
51		{
52		cprintf(INFO, "[!] Found packet with bad FCS, skipping...\n");
53		}
54		}
55		else
56		{
57		break;
58		}
59		}
60
61		return packet;
	61	if(!status) continue; /* timeout */
	62
	63	memcpy(header, pkt_header, sizeof(*header));
	64
	65	if(get_validate_fcs() && !check_fcs(packet, header->len))
	66	continue;
	67
	68	break;
	69	}
	70
	71	return (void*)packet;
62	72	}
63	73
64	74	/*

68	78	void read_ap_beacon()
69	79	{
70	80	struct pcap_pkthdr header;
71		const u_char *packet = NULL;
	81	const unsigned char *packet = NULL;
72	82	struct radio_tap_header *rt_header = NULL;
73	83	struct dot11_frame_header *frame_header = NULL;
74	84	struct beacon_management_frame *beacon = NULL;

90	100	if(header.len >= MIN_BEACON_SIZE)
91	101	{
92	102	rt_header = (struct radio_tap_header *) radio_header(packet, header.len);
93		size_t rt_header_len = __le16_to_cpu(rt_header->len);
	103	size_t rt_header_len = end_le16toh(rt_header->len);
94	104	frame_header = (struct dot11_frame_header *) (packet + rt_header_len);
95	105
96	106	if(is_target(frame_header))
97	107	{
98		if((frame_header->fc & __cpu_to_le16(IEEE80211_FCTL_FTYPE \| IEEE80211_FCTL_STYPE)) ==
99		__cpu_to_le16(IEEE80211_FTYPE_MGMT \| IEEE80211_STYPE_BEACON))
	108	if((frame_header->fc & end_htole16(IEEE80211_FCTL_FTYPE \| IEEE80211_FCTL_STYPE)) ==
	109	end_htole16(IEEE80211_FTYPE_MGMT \| IEEE80211_STYPE_BEACON))
100	110	{
101	111	beacon = (struct beacon_management_frame *) (packet + rt_header_len + sizeof(struct dot11_frame_header));
102		set_ap_capability(__le16_to_cpu(beacon->capability));
	112	set_ap_capability(end_le16toh(beacon->capability));
103	113
104	114	/* Obtain the SSID and channel number from the beacon packet */
105	115	tag_offset = rt_header_len + sizeof(struct dot11_frame_header) + sizeof(struct beacon_management_frame);

126	136	}
127	137	}
128	138
	139	#include "radiotap_flags.h"
	140
129	141	/* Extracts the signal strength field (if any) from the packet's radio tap header */
130		int8_t signal_strength(const u_char *packet, size_t len)
131		{
132		int8_t ssi = 0;
133		int offset = sizeof(struct radio_tap_header);
134		struct radio_tap_header *header = NULL;
135		uint32_t flags, flags2;
136
137		if(has_rt_header() && (len > (sizeof(struct radio_tap_header) + TSFT_SIZE + FLAGS_SIZE + RATE_SIZE + CHANNEL_SIZE + FHSS_FLAG)))
	142	int8_t signal_strength(const unsigned char *packet, size_t len)
	143	{
	144	if(has_rt_header() && (len > (sizeof(struct radio_tap_header))))
138	145	{
139		header = (struct radio_tap_header *) packet;
140
141		flags = flags2 = __le32_to_cpu(header->flags);
142		while ((flags2 & (1u << 31)) && offset <= len - 4)
143		{
144		flags2 = __le32_to_cpu((uint32_t )(packet + offset));
145		offset += sizeof(flags2);
146		}
147
148		if((flags & SSI_FLAG) == SSI_FLAG)
149		{
150		if((flags & TSFT_FLAG) == TSFT_FLAG)
151		{
152		RADIOTAP_ALIGN(offset, TSFT_ALIGNMENT);
153		offset += TSFT_SIZE;
154		}
155
156		if((flags & FLAGS_FLAG) == FLAGS_FLAG)
157		{
158		offset += FLAGS_SIZE;
159		}
160
161		if((flags & RATE_FLAG) == RATE_FLAG)
162		{
163		offset += RATE_SIZE;
164		}
165
166		if((flags & CHANNEL_FLAG) == CHANNEL_FLAG)
167		{
168		RADIOTAP_ALIGN(offset, CHANNEL_ALIGNMENT);
169		offset += CHANNEL_SIZE;
170		}
171
172		if((flags & FHSS_FLAG) == FHSS_FLAG)
173		{
174		offset += FHSS_SIZE;
175		}
176
177		if(offset < len)
178		{
179		ssi = (int8_t) packet[offset];
180		}
181		}
182		}
183
184		return ssi;
	146	uint32_t offset, presentflags;
	147	if(!rt_get_presentflags(packet, len, &presentflags, &offset))
	148	return 0;
	149	if(!(presentflags & (1U << IEEE80211_RADIOTAP_DBM_ANTSIGNAL)))
	150	return 0;
	151	offset = rt_get_flag_offset(presentflags, IEEE80211_RADIOTAP_DBM_ANTSIGNAL, offset);
	152	if (offset < len)
	153	return (int8_t) packet[offset];
	154	}
	155
	156	return 0;
185	157	}
186	158
187	159	/*

193	165	int locked = 0;
194	166	struct libwps_data wps = { 0 };
195	167	struct pcap_pkthdr header;
196		const u_char *packet = NULL;
	168	const unsigned char *packet = NULL;
197	169	struct radio_tap_header *rt_header = NULL;
198	170	struct dot11_frame_header *frame_header = NULL;
199	171

208	180	if(header.len >= MIN_BEACON_SIZE)
209	181	{
210	182	rt_header = (struct radio_tap_header *) radio_header(packet, header.len);
211		size_t rt_header_len = __le16_to_cpu(rt_header->len);
	183	size_t rt_header_len = end_le16toh(rt_header->len);
212	184	frame_header = (struct dot11_frame_header *) (packet + rt_header_len);
213	185
214	186	if(memcmp(frame_header->addr3, get_bssid(), MAC_ADDR_LEN) == 0)
215	187	{
216		if((frame_header->fc & __cpu_to_le16(IEEE80211_FCTL_FTYPE \| IEEE80211_FCTL_STYPE)) ==
217		__cpu_to_le16(IEEE80211_FTYPE_MGMT \| IEEE80211_STYPE_BEACON))
	188	if((frame_header->fc & end_htole16(IEEE80211_FCTL_FTYPE \| IEEE80211_FCTL_STYPE)) ==
	189	end_htole16(IEEE80211_FTYPE_MGMT \| IEEE80211_STYPE_BEACON))
218	190	{
219	191	if(parse_wps_parameters(packet, header.len, &wps))
220	192	{

233	205	return locked;
234	206	}
235	207
236		/* Deauths and re-associates a MAC address with the AP. Returns 0 on failure, 1 for success. */
237		int reassociate()
238		{
239		int tries = 0, retval = 0;
240
241		/* Make sure we can still see beacons (also, read_ap_beaon will ensure we're on the right channel) */
242		read_ap_beacon();
243
244		if(!get_external_association())
245		{
246		/* Deauth to void any previous association with the AP */
247		deauthenticate();
248
249		/* Try MAX_AUTH_TRIES times to authenticate to the AP */
250		do
251		{
252		authenticate();
253		tries++;
254		}
255		while((associate_recv_loop() != AUTH_OK) && (tries < MAX_AUTH_TRIES));
256
257		/* If authentication was successful, try MAX_AUTH_TRIES to associate with the AP */
258		if(tries < MAX_AUTH_TRIES)
259		{
260		tries = 0;
261
262		do
263		{
264		associate();
265		tries++;
266		}
267		while((associate_recv_loop() != ASSOCIATE_OK) && (tries < MAX_AUTH_TRIES));
268		}
269
270		if(tries <= MAX_AUTH_TRIES)
271		{
272		retval = 1;
273		}
274		else
275		{
276		retval = 0;
277		}
278		}
279		else
280		{
281		retval = 1;
282		}
283
284		return retval;
285		}
286
287		/* Deauthenticate ourselves from the AP */
288		void deauthenticate()
289		{
290		const void radio_tap = NULL, dot11_frame = NULL, *packet = NULL;
291		size_t radio_tap_len = 0, dot11_frame_len = 0, packet_len = 0;
292
293		radio_tap = build_radio_tap_header(&radio_tap_len);
294		dot11_frame = build_dot11_frame_header(FC_DEAUTHENTICATE, &dot11_frame_len);
295		packet_len = radio_tap_len + dot11_frame_len + DEAUTH_REASON_CODE_SIZE;
296
297		if(radio_tap && dot11_frame)
298		{
299		packet = malloc(packet_len);
300		if(packet)
301		{
302		memset((void *) packet, 0, packet_len);
303
304		memcpy((void *) packet, radio_tap, radio_tap_len);
305		memcpy((void ) ((char ) packet+radio_tap_len), dot11_frame, dot11_frame_len);
306		memcpy((void ) ((char ) packet+radio_tap_len+dot11_frame_len), DEAUTH_REASON_CODE, DEAUTH_REASON_CODE_SIZE);
307
308		send_packet(packet, packet_len, 0);
309
310		free((void *) packet);
311		}
312		}
313
314		if(radio_tap) free((void *) radio_tap);
315		if(dot11_frame) free((void *) dot11_frame);
316
317		return;
318		}
319
320		/* Authenticate ourselves with the AP */
321		void authenticate()
322		{
323		const void radio_tap = NULL, dot11_frame = NULL, management_frame = NULL, packet = NULL;
324		size_t radio_tap_len = 0, dot11_frame_len = 0, management_frame_len = 0, packet_len = 0;
325
326		radio_tap = build_radio_tap_header(&radio_tap_len);
327		dot11_frame = build_dot11_frame_header(FC_AUTHENTICATE, &dot11_frame_len);
328		management_frame = build_authentication_management_frame(&management_frame_len);
329		packet_len = radio_tap_len + dot11_frame_len + management_frame_len;
330
331		if(radio_tap && dot11_frame && management_frame)
332		{
333		packet = malloc(packet_len);
334		if(packet)
335		{
336		memset((void *) packet, 0, packet_len);
337
338		memcpy((void *) packet, radio_tap, radio_tap_len);
339		memcpy((void ) ((char ) packet+radio_tap_len), dot11_frame, dot11_frame_len);
340		memcpy((void ) ((char ) packet+radio_tap_len+dot11_frame_len), management_frame, management_frame_len);
341
342		send_packet(packet, packet_len, 0);
343
344		free((void *) packet);
345		}
346		}
347
348		if(radio_tap) free((void *) radio_tap);
349		if(dot11_frame) free((void *) dot11_frame);
350		if(management_frame) free((void *) management_frame);
351
352		return;
353		}
354
355		/* Associate with the AP */
356		void associate()
357		{
358		const void radio_tap = NULL, dot11_frame = NULL, management_frame = NULL, ssid_tag = NULL, wps_tag = NULL, rates_tag = NULL, *packet = NULL;
359		size_t radio_tap_len = 0, dot11_frame_len = 0, management_frame_len = 0, ssid_tag_len = 0, wps_tag_len = 0, rates_tag_len = 0, packet_len = 0, offset = 0;
360
361		radio_tap = build_radio_tap_header(&radio_tap_len);
362		dot11_frame = build_dot11_frame_header(FC_ASSOCIATE, &dot11_frame_len);
363		management_frame = build_association_management_frame(&management_frame_len);
364		ssid_tag = build_ssid_tagged_parameter(&ssid_tag_len);
365		rates_tag = build_supported_rates_tagged_parameter(&rates_tag_len);
366		wps_tag = build_wps_tagged_parameter(&wps_tag_len);
367		packet_len = radio_tap_len + dot11_frame_len + management_frame_len + ssid_tag_len + wps_tag_len + rates_tag_len;
368
369		if(radio_tap && dot11_frame && management_frame && ssid_tag && wps_tag && rates_tag)
370		{
371		packet = malloc(packet_len);
372		if(packet)
373		{
374		memset((void *) packet, 0, packet_len);
375
376		memcpy((void *) packet, radio_tap, radio_tap_len);
377		offset += radio_tap_len;
378		memcpy((void ) ((char ) packet+offset), dot11_frame, dot11_frame_len);
379		offset += dot11_frame_len;
380		memcpy((void ) ((char ) packet+offset), management_frame, management_frame_len);
381		offset += management_frame_len;
382		memcpy((void ) ((char ) packet+offset), ssid_tag, ssid_tag_len);
383		offset += ssid_tag_len;
384		memcpy((void ) ((char ) packet+offset), rates_tag, rates_tag_len);
385		offset += rates_tag_len;
386		memcpy((void ) ((char ) packet+offset), wps_tag, wps_tag_len);
387
388		send_packet(packet, packet_len, 0);
389
390		free((void *) packet);
391		}
392		}
393
394		if(radio_tap) free((void *) radio_tap);
395		if(dot11_frame) free((void *) dot11_frame);
396		if(management_frame) free((void *) management_frame);
397		if(ssid_tag) free((void *) ssid_tag);
398		if(wps_tag) free((void *) wps_tag);
399		if(rates_tag) free((void *) rates_tag);
400
401		return;
402		}
403	208
404	209	/* Waits for authentication and association responses from the target AP */
405		int associate_recv_loop()
	210	static int process_authenticate_associate_resp(int want_assoc)
406	211	{
407	212	struct pcap_pkthdr header;
408		u_char *packet;
	213	unsigned char *packet;
409	214	struct radio_tap_header *rt_header;
410	215	struct dot11_frame_header *dot11_frame;
411	216	struct authentication_management_frame *auth_frame;
412	217	struct association_response_management_frame *assoc_frame;
413		int ret_val = 0, start_time = 0;
414
415		start_time = time(NULL);
416
417		while((time(NULL) - start_time) < ASSOCIATE_WAIT_TIME)
	218	int ret_val = 0;
	219
	220	start_timer();
	221
	222	while(!get_out_of_time())
418	223	{
419	224	if((packet = next_packet(&header)) == NULL) break;
420	225
421	226	if(header.len < MIN_AUTH_SIZE) continue;
422	227
423	228	rt_header = (void*) radio_header(packet, header.len);
424		size_t rt_header_len = __le16_to_cpu(rt_header->len);
	229	size_t rt_header_len = end_le16toh(rt_header->len);
425	230	dot11_frame = (void*)(packet + rt_header_len);
426	231
427	232	if((memcmp(dot11_frame->addr3, get_bssid(), MAC_ADDR_LEN) != 0) \|\|
428	233	(memcmp(dot11_frame->addr1, get_mac(), MAC_ADDR_LEN) != 0))
429	234	continue;
430	235
431		int isMgmtFrame = (dot11_frame->fc & __cpu_to_le16(IEEE80211_FCTL_FTYPE)) == __cpu_to_le16(IEEE80211_FTYPE_MGMT);
	236	int isMgmtFrame = (dot11_frame->fc & end_htole16(IEEE80211_FCTL_FTYPE)) == end_htole16(IEEE80211_FTYPE_MGMT);
432	237	if(!isMgmtFrame) continue;
433	238
434	239	void *ptr = (packet + sizeof(struct dot11_frame_header) + rt_header_len);
435	240	auth_frame = ptr;
436	241	assoc_frame = ptr;
437	242
438		int isAuthResp = (dot11_frame->fc & __cpu_to_le16(IEEE80211_FCTL_STYPE)) == __cpu_to_le16(IEEE80211_STYPE_AUTH);
439		int isAssocResp = (dot11_frame->fc & __cpu_to_le16(IEEE80211_FCTL_STYPE)) == __cpu_to_le16(IEEE80211_STYPE_ASSOC_RESP);
	243	int isAuthResp = (dot11_frame->fc & end_htole16(IEEE80211_FCTL_STYPE)) == end_htole16(IEEE80211_STYPE_AUTH);
	244	int isAssocResp = (dot11_frame->fc & end_htole16(IEEE80211_FCTL_STYPE)) == end_htole16(IEEE80211_STYPE_ASSOC_RESP);
440	245
441	246	if(!isAuthResp && !isAssocResp) continue;
442	247
	248	if(isAuthResp && want_assoc) continue;
	249
443	250	/* Did we get an authentication packet with a successful status? */
444		if(isAuthResp && (auth_frame->status == __cpu_to_le16(AUTHENTICATION_SUCCESS))) {
	251	if(isAuthResp && (auth_frame->status == end_htole16(AUTHENTICATION_SUCCESS))) {
445	252	ret_val = AUTH_OK;
446	253	break;
447	254	}
448	255	/* Did we get an association packet with a successful status? */
449		else if(isAssocResp && (assoc_frame->status == __cpu_to_le16(ASSOCIATION_SUCCESS))) {
	256	else if(isAssocResp && (assoc_frame->status == end_htole16(ASSOCIATION_SUCCESS))) {
450	257	ret_val = ASSOCIATE_OK;
451	258	break;
452	259	}

454	261
455	262	return ret_val;
456	263	}
	264
	265
	266
	267	/* Deauths and re-associates a MAC address with the AP. Returns 0 on failure, 1 for success. */
	268	int reassociate(void)
	269	{
	270	if (get_external_association()) return 1;
	271
	272	int state = 0, ret;
	273
	274	while(1) {
	275	switch(state) {
	276	case 0:
	277	deauthenticate();
	278	state++;
	279	break;
	280	case 1:
	281	authenticate();
	282	state++;
	283	break;
	284	case 2:
	285	ret = process_authenticate_associate_resp(0);
	286	if(ret) state++;
	287	else return 0;
	288	break;
	289	case 3:
	290	associate();
	291	state++;
	292	break;
	293	case 4:
	294	ret = process_authenticate_associate_resp(0);
	295	if(ret) state++;
	296	else return 0;
	297	break;
	298	case 5:
	299	return 1;
	300
	301	}
	302	}
	303	}
	304
	305	/* Deauthenticate ourselves from the AP */
	306	static void deauthenticate(void)
	307	{
	308	size_t radio_tap_len, dot11_frame_len, packet_len, offset = 0;
	309	struct radio_tap_header radio_tap;
	310	struct dot11_frame_header dot11_frame;
	311
	312	radio_tap_len = build_radio_tap_header(&radio_tap);
	313	dot11_frame_len = build_dot11_frame_header(&dot11_frame, FC_DEAUTHENTICATE);
	314	packet_len = radio_tap_len + dot11_frame_len + DEAUTH_REASON_CODE_SIZE;
	315
	316	unsigned char packet[sizeof radio_tap + sizeof dot11_frame + DEAUTH_REASON_CODE_SIZE];
	317	assert(sizeof packet == packet_len);
	318
	319	memcpy(packet, &radio_tap, radio_tap_len);
	320	offset += radio_tap_len;
	321	memcpy(packet + offset, &dot11_frame, dot11_frame_len);
	322	offset += dot11_frame_len;
	323	memcpy(packet + offset, DEAUTH_REASON_CODE, DEAUTH_REASON_CODE_SIZE);
	324
	325	send_packet(packet, packet_len, 1);
	326	}
	327
	328	/* Authenticate ourselves with the AP */
	329	static void authenticate(void)
	330	{
	331	size_t radio_tap_len, dot11_frame_len, management_frame_len, packet_len, offset;
	332	struct radio_tap_header radio_tap;
	333	struct dot11_frame_header dot11_frame;
	334	struct authentication_management_frame management_frame;
	335
	336	radio_tap_len = build_radio_tap_header(&radio_tap);
	337	dot11_frame_len = build_dot11_frame_header(&dot11_frame, FC_AUTHENTICATE);
	338	management_frame_len = build_authentication_management_frame(&management_frame);
	339
	340	packet_len = radio_tap_len + dot11_frame_len + management_frame_len;
	341
	342	unsigned char packet[ sizeof (struct radio_tap_header)
	343	+ sizeof (struct dot11_frame_header)
	344	+ sizeof (struct authentication_management_frame)];
	345
	346	assert(packet_len == sizeof packet);
	347
	348	offset = 0;
	349
	350	memcpy(packet + offset, &radio_tap, radio_tap_len);
	351	offset += radio_tap_len;
	352	memcpy(packet + offset, &dot11_frame, dot11_frame_len);
	353	offset += dot11_frame_len;
	354	memcpy(packet + offset, &management_frame, management_frame_len);
	355
	356	send_packet(packet, packet_len, 1);
	357	cprintf(VERBOSE, "[+] Sending authentication request\n");
	358	}
	359
	360	/* Associate with the AP */
	361	static void associate(void)
	362	{
	363	size_t radio_tap_len, dot11_frame_len, management_frame_len, ssid_tag_len,
	364	wps_tag_len, rates_tag_len, ht_tag_len, packet_len, offset = 0;
	365	struct radio_tap_header radio_tap;
	366	struct dot11_frame_header dot11_frame;
	367	struct association_request_management_frame management_frame;
	368	char *essid = get_ssid();
	369	if(!essid) essid = "";
	370	unsigned char ssid_tag[sizeof (struct tagged_parameter) + IW_ESSID_MAX_SIZE];
	371	unsigned char rates_tag[128];
	372	unsigned char wps_tag[sizeof (struct tagged_parameter) + WPS_TAG_SIZE];
	373	unsigned char ht_tag[128];
	374
	375
	376	radio_tap_len = build_radio_tap_header(&radio_tap);
	377	dot11_frame_len = build_dot11_frame_header(&dot11_frame, FC_ASSOCIATE);
	378	management_frame_len = build_association_management_frame(&management_frame);
	379	ssid_tag_len = build_ssid_tagged_parameter(ssid_tag, essid);
	380	rates_tag_len = build_supported_rates_tagged_parameter(rates_tag, sizeof rates_tag);
	381	wps_tag_len = build_wps_tagged_parameter(wps_tag);
	382
	383	if(!NO_REPLAY_HTCAPS) {
	384	ht_tag_len = build_htcaps_parameter(ht_tag, sizeof ht_tag);
	385	} else {
	386	ht_tag_len = 0;
	387	}
	388	packet_len = radio_tap_len + dot11_frame_len + management_frame_len + ssid_tag_len + wps_tag_len + rates_tag_len + ht_tag_len;
	389
	390	unsigned char packet[512];
	391	assert(packet_len < sizeof packet);
	392
	393	memcpy(packet, &radio_tap, radio_tap_len);
	394	offset += radio_tap_len;
	395	memcpy(packet+offset, &dot11_frame, dot11_frame_len);
	396	offset += dot11_frame_len;
	397	memcpy(packet+offset, &management_frame, management_frame_len);
	398	offset += management_frame_len;
	399	memcpy(packet+offset, ssid_tag, ssid_tag_len);
	400	offset += ssid_tag_len;
	401	memcpy(packet+offset, rates_tag, rates_tag_len);
	402	offset += rates_tag_len;
	403
	404	memcpy(packet+offset, ht_tag, ht_tag_len);
	405	offset += ht_tag_len;
	406
	407	memcpy(packet+offset, wps_tag, wps_tag_len);
	408
	409	send_packet(packet, packet_len, 1);
	410	cprintf(VERBOSE, "[+] Sending association request\n");
	411
	412	}
	413
457	414
458	415	/* Given a beacon / probe response packet, returns the reported encryption type (WPA, WEP, NONE)
459	416	THIS IS BROKE!!! DO NOT USE!!!
460	417	*/
461		enum encryption_type supported_encryption(const u_char *packet, size_t len)
	418	enum encryption_type supported_encryption(const unsigned char *packet, size_t len)
462	419	{
463	420	enum encryption_type enc = NONE;
464		const u_char *tag_data = NULL;
	421	const unsigned char *tag_data = NULL;
465	422	struct radio_tap_header *rt_header = NULL;
466	423	size_t vlen = 0, voff = 0, tag_offset = 0, tag_len = 0, offset = 0;
467	424	struct beacon_management_frame *beacon = NULL;

469	426	if(len > MIN_BEACON_SIZE)
470	427	{
471	428	rt_header = (struct radio_tap_header *) radio_header(packet, len);
472		size_t rt_header_len = __le16_to_cpu(rt_header->len);
	429	size_t rt_header_len = end_le16toh(rt_header->len);
473	430	beacon = (struct beacon_management_frame *) (packet + rt_header_len + sizeof(struct dot11_frame_header));
474	431	offset = tag_offset = rt_header_len + sizeof(struct dot11_frame_header) + sizeof(struct beacon_management_frame);
475	432
476	433	tag_len = len - tag_offset;
477		tag_data = (const u_char *) (packet + tag_offset);
478
479		if((__le16_to_cpu(beacon->capability) & CAPABILITY_WEP) == CAPABILITY_WEP)
	434	tag_data = (const unsigned char *) (packet + tag_offset);
	435
	436	if((end_le16toh(beacon->capability) & CAPABILITY_WEP) == CAPABILITY_WEP)
480	437	{
481	438	enc = WEP;
482	439

491	448	while(offset < len)
492	449	{
493	450	tag_len = len - offset;
494		tag_data = (const u_char *) (packet + offset);
	451	tag_data = (const unsigned char *) (packet + offset);
495	452
496	453	tag_data = parse_ie_data(tag_data, tag_len, (uint8_t) VENDOR_SPECIFIC_TAG, &vlen, &voff);
497	454	if(vlen > WPA_IE_ID_LEN)

513	470	return enc;
514	471	}
515	472
516		static int get_next_ie(const u_char data, size_t len, size_t currpos) {
	473	static int get_next_ie(const unsigned char data, size_t len, size_t currpos) {
517	474	if(*currpos + 2 >= len) return 0;
518	475	currpos = currpos + 2 + data[*currpos + 1];
	476	if(*currpos >= len) return 0;
519	477	return 1;
520	478	}
521	479
522	480	/* Given the tagged parameter sets from a beacon packet, locate the AP's SSID and return its current channel number */
523		int parse_beacon_tags(const u_char *packet, size_t len)
	481	int parse_beacon_tags(const unsigned char *packet, size_t len)
524	482	{
525	483	set_vendor(0, "\0\0\0");
526	484	char *ssid = NULL;
527		const u_char *tag_data = NULL;
	485	const unsigned char *tag_data = NULL;
528	486	unsigned char ie = NULL, channel_data = NULL;
529	487	size_t ie_len = 0, ie_offset = 0, tag_len = 0, tag_offset = 0;
530	488	int channel = 0;
531	489	struct radio_tap_header *rt_header = NULL;
532	490
533	491	rt_header = (struct radio_tap_header *) radio_header(packet, len);
534		tag_offset = __le16_to_cpu(rt_header->len) + sizeof(struct dot11_frame_header) + sizeof(struct beacon_management_frame);
	492	tag_offset = end_le16toh(rt_header->len) + sizeof(struct dot11_frame_header) + sizeof(struct beacon_management_frame);
535	493
536	494	if(tag_offset < len)
537	495	{
538	496	tag_len = (len - tag_offset); /* this actually denotes length of the entire tag data area */
539		tag_data = (const u_char *) (packet + tag_offset);
	497	tag_data = (const unsigned char *) (packet + tag_offset);
540	498
541	499	/* If no SSID was manually specified, parse and save the AP SSID */
542	500	if(get_ssid() == NULL)

558	516	}
559	517	}
560	518
	519	ie = parse_ie_data(tag_data, tag_len, HT_CAPS_TAG_NUMBER, &ie_len, &ie_offset);
	520	if(ie)
	521	{
	522	set_ap_htcaps(ie, ie_len);
	523	free(ie);
	524	}
	525
561	526	ie = parse_ie_data(tag_data, tag_len, (uint8_t) RATES_TAG_NUMBER, &ie_len, &ie_offset);
562	527	if(ie)
563	528	{

584	549
585	550	size_t ie_iterator = 0;
586	551	do {
587		const u_char *tag = tag_data + ie_iterator;
	552	const unsigned char *tag = tag_data + ie_iterator;
588	553	// check for the length of the tag, and that its not microsoft
589	554	if(tag[0] == VENDOR_SPECIFIC_TAG &&
590		tag[1] < 11 &&
591	555	ie_iterator+2+3 < tag_len &&
592		memcmp(tag+2, "\x00\x50\xf2", 3)) {
	556	((tag[1] < 11 && memcmp(tag+2, "\x00\x14\x6c", 3) && memcmp(tag+2, "\x00\x50\xf2", 3)) \|\|
	557	(tag[1] == 30 && !(memcmp(tag+2, "\x00\x26\x86", 3))))) {
593	558	set_vendor(1, tag + 2);
594	559	break;
595	560	}

601	566	}
602	567
603	568	/* Gets the data for a given IE inside a tagged parameter list */
604		unsigned char parse_ie_data(const u_char data, size_t len, uint8_t tag_number, size_t ie_len, size_t ie_offset)
	569	unsigned char parse_ie_data(const unsigned char data, size_t len, uint8_t tag_number, size_t ie_len, size_t ie_offset)
605	570	{
606	571	unsigned char *tag_data = NULL;
607	572	int offset = 0, tag_size = 0;

637	602	}
638	603
639	604	/* Validates a packet's reported FCS value */
640		int check_fcs(const u_char *packet, size_t len)
641		{
642		int offset = 0, match = 0;
	605	int check_fcs(const unsigned char *packet, size_t len)
	606	{
	607	uint32_t offset = 0, match = 0;
643	608	uint32_t fcs = 0, fcs_calc = 0;
644	609	struct radio_tap_header *rt_header = NULL;
645
	610
646	611	if(len > 4)
647	612	{
	613
	614	/* FCS is not calculated over the radio tap header */
	615	if(has_rt_header() && len >= sizeof(*rt_header))
	616	{
	617	uint32_t presentflags, flags;
	618	if(!rt_get_presentflags(packet, len, &presentflags, &offset))
	619	goto skip;
	620	if(!(presentflags & (1U << IEEE80211_RADIOTAP_FLAGS)))
	621	goto skip;
	622	offset = rt_get_flag_offset(presentflags, IEEE80211_RADIOTAP_FLAGS, offset);
	623	if(offset < len) {
	624	memcpy(&flags, packet + offset, 4);
	625	flags = end_le32toh(flags);
	626	if(flags & IEEE80211_RADIOTAP_F_BADFCS)
	627	return 0;
	628	if(!(flags & IEEE80211_RADIOTAP_F_FCS))
	629	return 1;
	630	}
	631
	632	skip:
	633	rt_header = (struct radio_tap_header *) packet;
	634	offset = end_le16toh(rt_header->len);
	635
	636	}
	637
648	638	/* Get the packet's reported FCS (last 4 bytes of the packet) */
649		fcs = __le32_to_cpu((uint32_t)(packet + (len-4)));
650
651		/* FCS is not calculated over the radio tap header */
652		if(has_rt_header())
653		{
654		rt_header = (struct radio_tap_header *) packet;
655		offset += __le16_to_cpu(rt_header->len);
656		}
	639	fcs = end_le32toh((uint32_t)(packet + (len-4)));
	640
657	641
658	642	if(len > offset)
659	643	{

668	652	}
669	653
670	654	return match;
671
	655
672	656	}
673	657
674	658	/* Checks a given BSSID to see if it's on our target list */

704	688	* Returns a pointer to the radio tap header. If there is no radio tap header,
705	689	* it returns a pointer to a dummy radio tap header.
706	690	*/
707		u_char radio_header(const u_char packet, size_t len)
	691	unsigned char radio_header(const unsigned char packet, size_t len)
708	692	{
709	693	if(has_rt_header())
710	694	{

+10

-21

src/80211.h less more

33	33	#ifndef DOT11_H
34	34	#define DOT11_H
35	35
	36	#include <stdint.h>
	37	#include <stddef.h>
36	38	#include "defs.h"
37		#include "globule.h"
38		#include <libwps.h>
39		#include "argsparser.h"
40		#include "builder.h"
41		#include "iface.h"
42		#include "crc.h"
43		#include "wps.h"
44	39
45	40	#define AUTH_OK 1
46	41	#define ASSOCIATE_OK 2

72	67	#define RADIO_TAP_VERSION 0x00
73	68	#define FAKE_RADIO_TAP_HEADER "\x00\x00\x00\x00\x00\x00\x00\x00"
74	69
75		#define MAX_AUTH_TRIES 5
76
77	70	#define MIN_AUTH_SIZE (sizeof(struct radio_tap_header) + sizeof(struct dot11_frame_header) + sizeof(struct authentication_management_frame))
78	71
79	72	#define SUBTYPE_AUTHENTICATION 0x0B
80	73	#define SUBTYPE_ASSOCIATION 0x01
81	74
82		u_char next_packet(struct pcap_pkthdr header);
	75	unsigned char next_packet(struct pcap_pkthdr header);
83	76	void read_ap_beacon();
84		int8_t signal_strength(const u_char *packet, size_t len);
	77	int8_t signal_strength(const unsigned char *packet, size_t len);
85	78	int is_wps_locked();
86		int reassociate();
87		void deauthenticate();
88		void authenticate();
89		void associate();
90		int associate_recv_loop();
91		enum encryption_type supported_encryption(const u_char *packet, size_t len);
92		int parse_beacon_tags(const u_char *data, size_t len);
93		unsigned char parse_ie_data(const u_char data, size_t len, uint8_t tag_number, size_t ie_len, size_t ie_offset);
	79	int reassociate(void);
	80	enum encryption_type supported_encryption(const unsigned char *packet, size_t len);
	81	int parse_beacon_tags(const unsigned char *data, size_t len);
	82	unsigned char parse_ie_data(const unsigned char data, size_t len, uint8_t tag_number, size_t ie_len, size_t ie_offset);
94	83	int is_target(struct dot11_frame_header *frame_header);
95		int check_fcs(const u_char *packet, size_t len);
	84	int check_fcs(const unsigned char *packet, size_t len);
96	85	int has_rt_header(void);
97		u_char radio_header(const u_char packet, size_t len);
	86	unsigned char radio_header(const unsigned char packet, size_t len);
98	87
99	88	#endif

+24

-22

src/Makefile less more

	0	srcdir = .
	1	INSTALL = ./install.sh
	2	MKDIRP = mkdir -p
	3
0	4	-include config.mak
1	5
2	6	LIBWPS_DIR=libwps

4	8
5	9	DISABLED_WARNINGS= \
6	10	-Wno-unused-variable \
7		-Wno-unused-but-set-variable \
8	11	-Wno-unused-function \
9	12	-Wno-pointer-sign
10	13

89	92	$(TLS_OBJS) $(CRYPTO_OBJS) $(LWE_OBJS)
90	93
91	94
92		WASH_OBJS=globule.o init.o misc.o 80211.o iface.o \
93		builder.o crc.o pixie.o send.o sigalrm.o wpsmon.o
94		REAVER_OBJS=argsparser.o globule.o init.o sigint.o iface.o sigalrm.o \
	95	PROG_OBJS=argsparser.o globule.o init.o sigint.o iface.o sigalrm.o \
95	96	misc.o cracker.o session.o send.o pins.o 80211.o exchange.o builder.o \
96		keys.o crc.o pixie.o wpscrack.o
	97	keys.o crc.o pixie.o wpscrack.o wpsmon.o main.o version.o
97	98
98	99	# Version of the Wireless Tools
99	100	WT_VERSION := $(shell sed -ne "/WT_VERSION/{s:$[^0-9]*$::;p;q;}" < lwe/iwlib.h )

102	103	# Always use local header for wireless extensions
103	104	WEXT_HEADER = lwe/wireless.$(WE_VERSION).h
104	105
	106	GENH = lwe/wireless.h version.h
105	107
106	108	all: wash reaver
107	109

111	113	-DCONFIG_TLS_INTERNAL_SERVER -fno-strict-aliasing
112	114
113	115
114		wash: $(WASH_OBJS) $(LIB_OBJS)
115		$(CC) $(CFLAGS) $(INC) $(WASH_OBJS) $(LIB_OBJS) $(LDFLAGS) -o wash
	116	wash: reaver
	117	ln -sf ./reaver wash
116	118
117		reaver: $(REAVER_OBJS) $(LIB_OBJS)
118		$(CC) $(CFLAGS) $(INC) $(REAVER_OBJS) $(LIB_OBJS) $(LDFLAGS) -o reaver
	119	reaver: $(PROG_OBJS) $(LIB_OBJS)
	120	$(CC) $(CFLAGS) $(INC) $(PROG_OBJS) $(LIB_OBJS) $(LDFLAGS) -o reaver
	121
	122	version.o: version.h
	123	version.h: $(wildcard $(srcdir)/VERSION $(srcdir)/../.git)
	124	printf '#define R_VERSION "%s"\n' "$$(cd $(srcdir); sh version.sh)" > $@
119	125
120	126	lwe/wireless.h: $(WEXT_HEADER)
121	127	cp $(WEXT_HEADER) lwe/wireless.h
122	128
123		$(WASH_OBJS) $(REAVER_OBJS) $(LWE_OBJS): lwe/wireless.h
	129	$(PROG_OBJS) $(LWE_OBJS): lwe/wireless.h
124	130
125	131	install: wash reaver
126		install -D -m 755 wash $(DESTDIR)$(exec_prefix)/bin/wash
127		install -D -m 755 reaver $(DESTDIR)$(exec_prefix)/bin/reaver
	132	$(INSTALL) -D -m 755 wash $(DESTDIR)$(exec_prefix)/bin/wash
	133	$(INSTALL) -D -m 755 reaver $(DESTDIR)$(exec_prefix)/bin/reaver
128	134	@# create directory used to store *.wpc files;
129	135	@# if not found defaults to "." i.e. current dir
130		install -d $(DESTDIR)$(CONFDIR)
	136	$(MKDIRP) $(DESTDIR)$(CONFDIR)
131	137
132	138	clean:
133		rm -f ~ .o reaver wash
134		rm -rf *.cache config.status config.log
135		rm -f $(LIB_OBJS)
136		rm -f lwe/wireless.h
	139	rm -f reaver wash
	140	rm -f $(LIB_OBJS) $(PROG_OBJS)
	141	rm -f $(GENH)
137	142
138		cleanbin:
139		rm -f @bindir@/reaver @bindir@/wash @bindir@/walsh
140
141		distclean: cleanbin clean
	143	distclean: clean
142	144	rm -rf $(CONFDIR)
143	145
144		.PHONY: all clean cleanbin distclean install
	146	.PHONY: all clean distclean install
145	147

-0

src/VERSION less more

1.6.4

+19

-3

src/argsparser.c less more

30	30	* files in the program, then also delete it here.
31	31	*/
32	32
	33	#include <stdio.h>
	34	#include <getopt.h>
	35	#include <ctype.h>
	36	#include "globule.h"
	37	#include "defs.h"
	38	#include "iface.h"
33	39	#include "argsparser.h"
34	40	#include "pixie.h"
	41	#include "misc.h"
35	42
36	43	/* Processes Reaver command line options */
37	44	int process_arguments(int argc, char **argv)

41	48	int long_opt_index = 0;
42	49	char bssid[MAC_ADDR_LEN] = { 0 };
43	50	char mac[MAC_ADDR_LEN] = { 0 };
44		char *short_options = "KZb:e:m:i:t:d:c:T:x:r:g:l:o:p:s:C:A5ELfnqvDShwN";
	51	char *short_options = "b:e:m:i:t:d:c:T:x:r:g:l:o:p:s:C:KZA5ELfnqvDShwN6J";
45	52	struct option long_options[] = {
46	53	{ "pixie-dust", no_argument, NULL, 'K' },
47	54	{ "interface", required_argument, NULL, 'i' },

68	75	{ "fixed", no_argument, NULL, 'f' },
69	76	{ "daemonize", no_argument, NULL, 'D' },
70	77	{ "5ghz", no_argument, NULL, '5' },
	78	{ "repeat-m6", no_argument, NULL, '6' },
71	79	{ "nack", no_argument, NULL, 'n' },
72	80	{ "quiet", no_argument, NULL, 'q' },
73	81	{ "verbose", no_argument, NULL, 'v' },
74	82	{ "win7", no_argument, NULL, 'w' },
75	83	{ "help", no_argument, NULL, 'h' },
	84	{ "timeout-is-nack", no_argument, NULL, 'J' },
76	85	{ 0, 0, 0, 0 }
77	86	};
78	87

114	123	case '5':
115	124	set_wifi_band(AN_BAND);
116	125	break;
	126	case '6':
	127	set_repeat_m6(1);
	128	break;
117	129	case 'd':
118	130	set_delay(atoi(optarg));
119	131	break;

157	169	set_dh_small(1);
158	170	break;
159	171	case 'n':
160		set_timeout_is_nack(0);
	172	cprintf(INFO, "[+] ignoring obsolete -n switch\n");
	173	break;
	174	case 'J':
	175	set_timeout_is_nack(1);
161	176	break;
162	177	case 'f':
163	178	set_fixed_channel(1);

196	211	set_lock_delay(DEFAULT_LOCK_DELAY);
197	212	set_debug(INFO);
198	213	set_auto_channel_select(1);
199		set_timeout_is_nack(1);
	214	set_timeout_is_nack(0);
200	215	set_oo_send_nack(1);
201	216	set_wifi_band(BG_BAND);
	217	set_validate_fcs(1);
202	218	pixie.do_pixie = 0;
203	219	set_pin_string_mode(0);
204	220	}

-6

src/argsparser.h less more

33	33	#ifndef _ARGPARSER_H_
34	34	#define _ARGPARSER_H_
35	35
36		#include <stdio.h>
37		#include <getopt.h>
38		#include "defs.h"
39		#include "iface.h"
40		#include "config.h"
41
42	36	int process_arguments(int argc, char **argv);
43	37	void init_default_settings(void);
44	38	void parse_recurring_delay(char *arg);

+207

-275

src/builder.c less more

31	31	*/
32	32
33	33	#include "builder.h"
34
35		void build_radio_tap_header(size_t len)
36		{
37		struct radio_tap_header *rt_header = NULL;
38		void *buf = NULL;
39
40		buf = malloc(sizeof(struct radio_tap_header));
41		if(buf)
42		{
43		memset((void *) buf, 0, sizeof(struct radio_tap_header));
44		rt_header = (struct radio_tap_header *) buf;
45
46		*len = sizeof(struct radio_tap_header);
47		rt_header->len = __cpu_to_le16(*len);
48		}
49
50		return buf;
51		}
52
53		void build_dot11_frame_header(uint16_t fc, size_t len)
54		{
55		struct dot11_frame_header *header = NULL;
56		void *buf = NULL;
	34	#include <assert.h>
	35
	36	size_t build_radio_tap_header(struct radio_tap_header *rt_header)
	37	{
	38	memcpy(rt_header, "\0\0" "\x08\0" "\0\0\0\0", 8);
	39	return sizeof(*rt_header);
	40	}
	41
	42	size_t build_dot11_frame_header_m(struct dot11_frame_header *fh, uint16_t fc, unsigned char dstmac[6])
	43	{
57	44	static uint16_t frag_seq;
58	45
59		buf = malloc(sizeof(struct dot11_frame_header));
60		if(buf)
61		{
62		*len = sizeof(struct dot11_frame_header);
63		memset((void *) buf, 0, sizeof(struct dot11_frame_header));
64		header = (struct dot11_frame_header *) buf;
65
66		frag_seq += SEQ_MASK;
67
68		header->duration = __cpu_to_le16(DEFAULT_DURATION);
69		header->fc = __cpu_to_le16(fc);
70		header->frag_seq = __cpu_to_le16(frag_seq);
71
72		memcpy((void *) header->addr1, get_bssid(), MAC_ADDR_LEN);
73		memcpy((void *) header->addr2, get_mac(), MAC_ADDR_LEN);
74		memcpy((void *) header->addr3, get_bssid(), MAC_ADDR_LEN);
75		}
76
77		return buf;
78		}
79
80		void build_authentication_management_frame(size_t len)
81		{
82		struct authentication_management_frame *frame = NULL;
83		void *buf = NULL;
84
85		buf = malloc(sizeof(struct authentication_management_frame));
86		if(buf)
87		{
88		*len = sizeof(struct authentication_management_frame);
89		memset((void ) buf, 0, len);
90		frame = (struct authentication_management_frame *) buf;
91
92		frame->algorithm = __cpu_to_le16(OPEN_SYSTEM);
93		frame->sequence = __cpu_to_le16(1);
94		frame->status = 0;
95		}
96
97		return buf;
98		}
99
100		void build_association_management_frame(size_t len)
101		{
102		struct association_request_management_frame *frame = NULL;
103		void *buf = NULL;
104
105		buf = malloc(sizeof(struct association_request_management_frame));
106		if(buf)
107		{
108		*len = sizeof(struct association_request_management_frame);
109		memset((void ) buf, 0, len);
110		frame = (struct association_request_management_frame *) buf;
111
112		frame->capability = __cpu_to_le16(get_ap_capability());
113		frame->listen_interval = __cpu_to_le16(LISTEN_INTERVAL);
114		}
115
116		return buf;
117		}
118
119		void build_llc_header(size_t len)
120		{
121		struct llc_header *header = NULL;
122		void *buf = NULL;
123
124		buf = malloc(sizeof(struct llc_header));
125		if(buf)
126		{
127		*len = sizeof(struct llc_header);
128		memset((void *) buf, 0, sizeof(struct llc_header));
129		header = (struct llc_header *) buf;
130
131		header->dsap = LLC_SNAP;
132		header->ssap = LLC_SNAP;
133		header->control_field = UNNUMBERED_FRAME;
134		header->type = __cpu_to_be16(DOT1X_AUTHENTICATION);
135
136		}
137
138		return buf;
	46	frag_seq += SEQ_MASK;
	47
	48	fh->duration = end_htole16(DEFAULT_DURATION);
	49	fh->fc = end_htole16(fc);
	50	fh->frag_seq = end_htole16(frag_seq);
	51
	52	memcpy(fh->addr1, dstmac, MAC_ADDR_LEN);
	53	memcpy(fh->addr2, get_mac(), MAC_ADDR_LEN);
	54	memcpy(fh->addr3, dstmac, MAC_ADDR_LEN);
	55
	56	return sizeof *fh;
	57	}
	58
	59	size_t build_dot11_frame_header(struct dot11_frame_header *fh, uint16_t fc) {
	60	return build_dot11_frame_header_m(fh, fc, get_bssid());
	61	}
	62
	63	size_t build_dot11_frame_header_broadcast(struct dot11_frame_header *fh, uint16_t fc) {
	64	return build_dot11_frame_header_m(fh, fc, "\xff\xff\xff\xff\xff\xff");
	65	}
	66
	67	size_t build_authentication_management_frame(struct authentication_management_frame *f)
	68	{
	69	f->algorithm = end_htole16(OPEN_SYSTEM);
	70	f->sequence = end_htole16(1);
	71	f->status = 0;
	72
	73	return sizeof *f;
	74	}
	75
	76	size_t build_association_management_frame(struct association_request_management_frame *f)
	77	{
	78	f->capability = end_htole16(get_ap_capability());
	79	f->listen_interval = end_htole16(LISTEN_INTERVAL);
	80
	81	return sizeof *f;
	82	}
	83
	84	static size_t build_llc_header(struct llc_header *h)
	85	{
	86	h->dsap = LLC_SNAP;
	87	h->ssap = LLC_SNAP;
	88	h->control_field = UNNUMBERED_FRAME;
	89	h->org_code[0] = 0;
	90	h->org_code[1] = 0;
	91	h->org_code[2] = 0;
	92	h->type = end_htobe16(DOT1X_AUTHENTICATION);
	93
	94	return sizeof *h;
139	95	}
140	96
141	97	void build_wps_probe_request(unsigned char bssid, char essid, size_t len)

149	105	// ESSIDs, after finding out their real ESSID by watching other client's probes.
150	106
151	107	struct tagged_parameter ssid_tag = { 0 };
152		void rt_header = NULL, dot11_header = NULL, *packet = NULL;
	108	void *packet = NULL;
153	109	size_t offset = 0, rt_len = 0, dot11_len = 0, ssid_tag_len = 0, packet_len = 0;
154
155		if(essid != NULL)
	110	int broadcast = !memcmp(bssid, "\xff\xff\xff\xff\xff\xff", 6);
	111
	112	if(!broadcast && essid != NULL)
156	113	{
157	114	ssid_tag.len = (uint8_t) strlen(essid);
158	115	}

164	121	ssid_tag.number = SSID_TAG_NUMBER;
165	122	ssid_tag_len = ssid_tag.len + sizeof(struct tagged_parameter);
166	123
167		rt_header = build_radio_tap_header(&rt_len);
168		dot11_header = build_dot11_frame_header(FC_PROBE_REQUEST, &dot11_len);
169
170		if(rt_header && dot11_header)
171		{
172		packet_len = rt_len + dot11_len + ssid_tag_len;
173
174		#define TAG_SUPPORTED_RATES "\x01\x08\x02\x04\x0b\x16\x0c\x12\x18\x24"
175		#define TAG_EXT_RATES "\x32\x04\x30\x48\x60\x6c"
176		// it seems some OS don't send this tag, so leave it away
177		//#define TAG_DS_PARAM "\x03\x01\x07"
178		#define TAG_HT_CAPS "\x2d\x1a\x72\x01\x13\xff\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
179
180		// maybe we should leave this away too, it is usually not sent, but the
181		// AP responds with WPS info anyway
182		#define WPS_PROBE_IE "\xdd\x09\x00\x50\xf2\x04\x10\x4a\x00\x01\x10"
183
184		#define ALL_TAGS TAG_SUPPORTED_RATES TAG_EXT_RATES TAG_HT_CAPS WPS_PROBE_IE
185
186		packet_len += sizeof(ALL_TAGS) -1;
187
188		packet = malloc(packet_len);
189
190		if(packet)
191		{
192		memset((void *) packet, 0, packet_len);
193		memcpy((void *) packet, rt_header, rt_len);
194		offset += rt_len;
195		memcpy((void ) ((char ) packet+offset), dot11_header, dot11_len);
196		offset += dot11_len;
197		memcpy((void ) ((char ) packet+offset), (void *) &ssid_tag, sizeof(ssid_tag));
198		offset += sizeof(ssid_tag);
199		memcpy((void ) ((char ) packet+offset), essid, ssid_tag.len);
200		offset += ssid_tag.len;
201
202		memcpy(packet+offset, ALL_TAGS, sizeof(ALL_TAGS) -1);
203		offset += sizeof(ALL_TAGS) -1;
204
205		*len = packet_len;
206		}
207		}
208
209		if(rt_header) free((void *) rt_header);
210		if(dot11_header) free((void *) dot11_header);
	124	struct radio_tap_header rt_header;
	125	rt_len = build_radio_tap_header(&rt_header);
	126	struct dot11_frame_header dot11_header;
	127	dot11_len = build_dot11_frame_header_m(&dot11_header, FC_PROBE_REQUEST, bssid);
	128
	129	packet_len = rt_len + dot11_len + ssid_tag_len;
	130
	131	#define TAG_SUPPORTED_RATES "\x01\x08\x02\x04\x0b\x16\x0c\x12\x18\x24"
	132	#define TAG_EXT_RATES "\x32\x04\x30\x48\x60\x6c"
	133	// it seems some OS don't send this tag, so leave it away
	134	//#define TAG_DS_PARAM "\x03\x01\x07"
	135	#define TAG_HT_CAPS "\x2d\x1a\x72\x01\x13\xff\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
	136
	137	// maybe we should leave this away too, it is usually not sent, but the
	138	// AP responds with WPS info anyway
	139	#define WPS_PROBE_IE "\xdd\x09\x00\x50\xf2\x04\x10\x4a\x00\x01\x10"
	140
	141	#define ALL_TAGS TAG_SUPPORTED_RATES TAG_EXT_RATES TAG_HT_CAPS WPS_PROBE_IE
	142
	143	packet_len += sizeof(ALL_TAGS) -1;
	144
	145	packet = malloc(packet_len);
	146
	147	if(packet)
	148	{
	149	memset((void *) packet, 0, packet_len);
	150	memcpy((void *) packet, &rt_header, rt_len);
	151	offset += rt_len;
	152	memcpy((void ) ((char ) packet+offset), &dot11_header, dot11_len);
	153	offset += dot11_len;
	154	memcpy((void ) ((char ) packet+offset), (void *) &ssid_tag, sizeof(ssid_tag));
	155	offset += sizeof(ssid_tag);
	156	memcpy((void ) ((char ) packet+offset), essid, ssid_tag.len);
	157	offset += ssid_tag.len;
	158
	159	memcpy(packet+offset, ALL_TAGS, sizeof(ALL_TAGS) -1);
	160	offset += sizeof(ALL_TAGS) -1;
	161
	162	*len = packet_len;
	163	}
211	164
212	165	return packet;
213	166	}

215	168	/* Wrapper function for Radio Tap / Dot11 / LLC */
216	169	void build_snap_packet(size_t len)
217	170	{
218		void rt_header = NULL, dot11_header = NULL, llc_header = NULL, packet = NULL;
	171	void *packet = NULL;
219	172	size_t rt_len = 0, dot11_len = 0, llc_len = 0, packet_len = 0;
220
221		rt_header = build_radio_tap_header(&rt_len);
222		dot11_header = build_dot11_frame_header(FC_STANDARD, &dot11_len);
223		llc_header = build_llc_header(&llc_len);
224
225		if(rt_header && dot11_header && llc_header)
226		{
227		packet_len = rt_len + dot11_len + llc_len;
228		packet = malloc(packet_len);
229
230		if(packet)
231		{
232		memset((void *) packet, 0, packet_len);
233		memcpy((void *) packet, rt_header, rt_len);
234		memcpy((void ) ((char ) packet+rt_len), dot11_header, dot11_len);
235		memcpy((void ) ((char ) packet+rt_len+dot11_len), llc_header, llc_len);
236
237		*len = packet_len;
238		}
239
240		free((void *) rt_header);
241		free((void *) dot11_header);
242		free((void *) llc_header);
	173	struct radio_tap_header rt_header;
	174	struct dot11_frame_header dot11_header;
	175	struct llc_header llc_header;
	176
	177	rt_len = build_radio_tap_header(&rt_header);
	178	dot11_len = build_dot11_frame_header(&dot11_header, FC_STANDARD);
	179	llc_len = build_llc_header(&llc_header);
	180
	181	packet_len = rt_len + dot11_len + llc_len;
	182	packet = malloc(packet_len);
	183
	184	if(packet)
	185	{
	186	memset((void *) packet, 0, packet_len);
	187	memcpy((void *) packet, &rt_header, rt_len);
	188	memcpy((void ) ((char ) packet+rt_len), &dot11_header, dot11_len);
	189	memcpy((void ) ((char ) packet+rt_len+dot11_len), &llc_header, llc_len);
	190
	191	*len = packet_len;
243	192	}
244	193
245	194	return packet;

301	250	header = (struct wfa_expanded_header *) buf;
302	251
303	252	memcpy(header->id, WFA_VENDOR_ID, sizeof(header->id));
304		header->type = __cpu_to_be32(SIMPLE_CONFIG);
	253	header->type = end_htobe32(SIMPLE_CONFIG);
305	254	header->opcode = op_code;
306	255	}
307	256

452	401	return buf;
453	402	}
454	403
455		void build_tagged_parameter(uint8_t number, uint8_t size, size_t len)
456		{
457		struct tagged_parameter *param = malloc(sizeof(struct tagged_parameter));
458		if(param)
459		{
460		*len = sizeof(struct tagged_parameter);
461		param->number = number;
462		param->len = size;
463		}
464		return param;
465		}
466
467		void build_ssid_tagged_parameter(size_t len)
468		{
469		void buf = NULL, ssid_param = NULL;
470		size_t ssid_len = 0, ssid_param_len = 0, buf_len = 0;
471
472		if(get_ssid())
473		{
474		ssid_len = strlen(get_ssid());
475		}
476
477		ssid_param = build_tagged_parameter(SSID_TAG_NUMBER, ssid_len, &ssid_param_len);
478
479		if(ssid_param)
480		{
481		buf_len = ssid_param_len + ssid_len;
482		buf = malloc(buf_len);
483		if(buf)
484		{
485		*len = buf_len;
486		memset((void *) buf, 0, buf_len);
487
488		memcpy((void *) buf, ssid_param, ssid_param_len);
489		memcpy((void ) ((char ) buf+ssid_param_len), get_ssid(), ssid_len);
490		}
491
492		free((void *) ssid_param);
493		}
494
495		return buf;
496		}
497
498		void build_wps_tagged_parameter(size_t len)
499		{
500		void buf = NULL, wps_param = NULL;
501		size_t buf_len = 0, wps_param_len = 0;
502
503		wps_param = build_tagged_parameter(WPS_TAG_NUMBER, WPS_TAG_SIZE, &wps_param_len);
504
505		if(wps_param)
506		{
507		buf_len = wps_param_len + WPS_TAG_SIZE;
508		buf = malloc(buf_len);
509		if(buf)
510		{
511		*len = buf_len;
512		memset((void *) buf, 0, buf_len);
513
514		memcpy((void *) buf, wps_param, wps_param_len);
515		memcpy((void ) ((char ) buf+wps_param_len), WPS_REGISTRAR_TAG, WPS_TAG_SIZE);
516		}
517
518		free((void *) wps_param);
519		}
520
521		return buf;
522		}
523
524		void build_supported_rates_tagged_parameter(size_t len)
525		{
526		char buf = NULL, supported_rates = NULL, *extended_rates = NULL;
527		unsigned char srates = NULL, erates = NULL;
528		int srates_tag_size = 0, erates_tag_size = 0;
529		size_t buf_len = 0, srates_len = 0, erates_len = 0, offset = 0;
	404	static size_t build_tagged_parameter(struct tagged_parameter *tag, uint8_t number, uint8_t size)
	405	{
	406	tag->number = number;
	407	tag->len = size;
	408
	409	return sizeof *tag;
	410	}
	411
	412	size_t build_ssid_tagged_parameter(unsigned char buf[IW_ESSID_MAX_SIZE+2], char *essid)
	413	{
	414	struct tagged_parameter ssid_param;
	415	size_t ssid_len = strlen(essid), ssid_param_len;
	416
	417	ssid_param_len = build_tagged_parameter(&ssid_param, SSID_TAG_NUMBER, ssid_len);
	418	assert(ssid_param_len == 2);
	419	assert(2 == sizeof (struct tagged_parameter));
	420	memcpy(buf, &ssid_param, sizeof ssid_param);
	421	memcpy(buf+2, essid, ssid_len);
	422
	423	return 2 + ssid_len;
	424	}
	425
	426	size_t build_wps_tagged_parameter(unsigned char buf[2+WPS_TAG_SIZE])
	427	{
	428	size_t wps_param_len;
	429	struct tagged_parameter wps_param;
	430
	431	wps_param_len = build_tagged_parameter(&wps_param, WPS_TAG_NUMBER, WPS_TAG_SIZE);
	432	assert(wps_param_len == 2);
	433	assert(2 == sizeof (struct tagged_parameter));
	434
	435	memcpy(buf, &wps_param, sizeof wps_param);
	436	memcpy(buf+2, WPS_REGISTRAR_TAG, WPS_TAG_SIZE);
	437
	438	return 2+WPS_TAG_SIZE;
	439	}
	440
	441	size_t build_supported_rates_tagged_parameter(unsigned char *buf, size_t buflen)
	442	{
	443	unsigned char erates, srates;
	444	int srates_tag_size, erates_tag_size;
	445	size_t i, len, srates_len, erates_len, offset = 0;
	446
	447	struct tagged_parameter supported_rates, extended_rates;
530	448
531	449	srates = get_ap_rates(&srates_tag_size);
	450	assert(sizeof(struct tagged_parameter) + srates_tag_size < buflen);
	451
	452	srates_len = build_tagged_parameter(&supported_rates, SRATES_TAG_NUMBER, srates_tag_size);
	453	memcpy(buf, &supported_rates, srates_len);
	454	offset += srates_len;
	455
	456	memcpy(buf+offset, srates, srates_tag_size);
	457	for(i=offset; i<offset+srates_tag_size; i++)
	458	buf[i] = buf[i] & 0x7f; // remove (B) bit
	459
	460	offset += srates_tag_size;
	461
532	462	erates = get_ap_ext_rates(&erates_tag_size);
533		supported_rates = build_tagged_parameter(SRATES_TAG_NUMBER, srates_tag_size, &srates_len);
534		extended_rates = build_tagged_parameter(ERATES_TAG_NUMBER, erates_tag_size, &erates_len);
535
536		if(supported_rates && extended_rates)
537		{
538		buf_len = srates_len + erates_len + srates_tag_size + erates_tag_size;
539		buf = malloc(buf_len);
540		if(buf)
541		{
542		*len = buf_len;
543
544		memcpy(buf, supported_rates, srates_len);
545		offset += srates_len;
546		memcpy(buf+offset, srates, srates_tag_size);
547		offset += srates_tag_size;
548		memcpy(buf+offset, extended_rates, erates_len);
549		offset += erates_len;
550		memcpy(buf+offset, erates, erates_tag_size);
551		}
552		}
553
554		if(supported_rates) free(supported_rates);
555		if(extended_rates) free(extended_rates);
556		return buf;
557		}
	463	erates_len = build_tagged_parameter(&extended_rates, ERATES_TAG_NUMBER, erates_tag_size);
	464
	465	len = srates_len + erates_len + srates_tag_size + erates_tag_size;
	466	assert(len < buflen);
	467
	468	memcpy(buf+offset, &extended_rates, erates_len);
	469	offset += erates_len;
	470	memcpy(buf+offset, erates, erates_tag_size);
	471
	472	return len;
	473	}
	474
	475	size_t build_htcaps_parameter(unsigned char *buf, size_t buflen)
	476	{
	477	unsigned char* htcaps;
	478	int htlen; size_t taglen;
	479	if((htcaps = get_ap_htcaps(&htlen)) == NULL)
	480	return 0;
	481	struct tagged_parameter tag_htcaps;
	482	taglen = build_tagged_parameter(&tag_htcaps, HT_CAPS_TAG_NUMBER, htlen);
	483	if(taglen + htlen >= buflen)
	484	return 0; /* having HT caps is usually not critical, so better return nothing */
	485
	486	memcpy(buf, &tag_htcaps, taglen);
	487	memcpy(buf + taglen, htcaps, htlen);
	488	return taglen + htlen;
	489	}

+14

-9

src/builder.h less more

60	60	#define WFA_VENDOR_ID "\x00\x37\x2A"
61	61
62	62
63		void build_radio_tap_header(size_t len);
64		void build_dot11_frame_header(uint16_t fc, size_t len);
65		void build_authentication_management_frame(size_t len);
66		void build_association_management_frame(size_t len);
67		void build_llc_header(size_t len);
	63	#ifndef IW_ESSID_MAX_SIZE
	64	#define IW_ESSID_MAX_SIZE 32
	65	#endif
	66
	67	size_t build_radio_tap_header(struct radio_tap_header *rt_header);
	68	size_t build_dot11_frame_header(struct dot11_frame_header *fh, uint16_t fc);
	69	size_t build_association_management_frame(struct association_request_management_frame *f);
	70	size_t build_authentication_management_frame(struct authentication_management_frame *f);
	71
	72	size_t build_ssid_tagged_parameter(unsigned char buf[IW_ESSID_MAX_SIZE+2], char *essid);
	73	size_t build_supported_rates_tagged_parameter(unsigned char *buf, size_t buflen);
	74	size_t build_wps_tagged_parameter(unsigned char buf[2+WPS_TAG_SIZE]);
	75	size_t build_htcaps_parameter(unsigned char *buf, size_t buflen);
	76
68	77	void build_wps_probe_request(unsigned char bssid, char essid, size_t len);
69	78	void build_snap_packet(size_t len);
70	79	void build_dot1X_header(uint8_t type, uint16_t payload_len, size_t len);

72	81	void build_eapol_start_packet(size_t len);
73	82	void build_eap_packet(const void payload, uint16_t payload_len, size_t *len);
74	83	void build_eap_failure_packet(size_t len);
75		void build_tagged_parameter(uint8_t number, uint8_t size, size_t len);
76		void build_ssid_tagged_parameter(size_t len);
77		void build_wps_tagged_parameter(size_t len);
78		void build_supported_rates_tagged_parameter(size_t len);
79	84
80	85	#endif

-6

~~src/common/version.h~~ less more

0		#ifndef VERSION_H
1		#define VERSION_H
2
3		#define VERSION_STR "0.7.3"
4
5		#endif /* VERSION_H */

+50

-9

src/configure less more

0	0	#! /bin/sh
1	1	# Guess values for system-dependent variables and create Makefiles.
2		# Generated by GNU Autoconf 2.69 for reaver 1.6.3.
	2	# Generated by GNU Autoconf 2.69 for reaver 1.6.4.
3	3	#
4	4	#
5	5	# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.

576	576	# Identity of this package.
577	577	PACKAGE_NAME='reaver'
578	578	PACKAGE_TARNAME='reaver'
579		PACKAGE_VERSION='1.6.3'
580		PACKAGE_STRING='reaver 1.6.3'
	579	PACKAGE_VERSION='1.6.4'
	580	PACKAGE_STRING='reaver 1.6.4'
581	581	PACKAGE_BUGREPORT=''
582	582	PACKAGE_URL=''
583	583

1222	1222	# Omit some internal or obsolete options to make the list less imposing.
1223	1223	# This message is too long to be a string in the A/UX 3.1 sh.
1224	1224	cat <<_ACEOF
1225		\`configure' configures reaver 1.6.3 to adapt to many kinds of systems.
	1225	\`configure' configures reaver 1.6.4 to adapt to many kinds of systems.
1226	1226
1227	1227	Usage: $0 [OPTION]... [VAR=VALUE]...
1228	1228

1283	1283
1284	1284	if test -n "$ac_init_help"; then
1285	1285	case $ac_init_help in
1286		short \| recursive ) echo "Configuration of reaver 1.6.3:";;
	1286	short \| recursive ) echo "Configuration of reaver 1.6.4:";;
1287	1287	esac
1288	1288	cat <<\_ACEOF
1289	1289

1371	1371	test -n "$ac_init_help" && exit $ac_status
1372	1372	if $ac_init_version; then
1373	1373	cat <<\_ACEOF
1374		reaver configure 1.6.3
	1374	reaver configure 1.6.4
1375	1375	generated by GNU Autoconf 2.69
1376	1376
1377	1377	Copyright (C) 2012 Free Software Foundation, Inc.

1669	1669	This file contains any messages produced by compilers while
1670	1670	running configure, to aid debugging if configure makes a mistake.
1671	1671
1672		It was created by reaver $as_me 1.6.3, which was
	1672	It was created by reaver $as_me 1.6.4, which was
1673	1673	generated by GNU Autoconf 2.69. Invocation command line was
1674	1674
1675	1675	$ $0 $@

2017	2017	ac_compiler_gnu=$ac_cv_c_compiler_gnu
2018	2018
2019	2019
	2020
2020	2021	ac_config_files="$ac_config_files config.mak"
2021	2022
2022	2023	ac_ext=c

3298	3299	enableval=$enable_savetocurrent; CFLAGS="$CFLAGS -DSAVETOCURRENT"
3299	3300	fi
3300	3301
	3302
	3303	DESIRED_FLAGS="-Werror-unknown-warning-option -Wno-unused-but-set-variable"
	3304	for flag in $DESIRED_FLAGS; do
	3305
	3306	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking to see if compiler understands $flag" >&5
	3307	$as_echo_n "checking to see if compiler understands $flag... " >&6; }
	3308
	3309	save_CFLAGS="$CFLAGS"
	3310	CFLAGS="$CFLAGS $flag"
	3311
	3312	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
	3313	/* end confdefs.h. */
	3314
	3315	int
	3316	main ()
	3317	{
	3318
	3319	;
	3320	return 0;
	3321	}
	3322	_ACEOF
	3323	if ac_fn_c_try_compile "$LINENO"; then :
	3324	flag_ok=yes
	3325	else
	3326	flag_ok=no
	3327	fi
	3328	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
	3329	CFLAGS="$save_CFLAGS"
	3330
	3331	if test "X$flag_ok" = Xyes ; then
	3332	CFLAGS="$CFLAGS $flag"
	3333	true
	3334	else
	3335
	3336	true
	3337	fi
	3338	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $flag_ok" >&5
	3339	$as_echo "$flag_ok" >&6; }
	3340
	3341	done
3301	3342
3302	3343	cp confdefs.h config.h
3303	3344

3845	3886	# report actual input values of CONFIG_FILES etc. instead of their
3846	3887	# values after options handling.
3847	3888	ac_log="
3848		This file was extended by reaver $as_me 1.6.3, which was
	3889	This file was extended by reaver $as_me 1.6.4, which was
3849	3890	generated by GNU Autoconf 2.69. Invocation command line was
3850	3891
3851	3892	CONFIG_FILES = $CONFIG_FILES

3898	3939	cat >>$CONFIG_STATUS <<_ACEOF \|\| ac_write_fail=1
3899	3940	ac_cs_config="`$as_echo "$ac_configure_args" \| sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
3900	3941	ac_cs_version="\\
3901		reaver config.status 1.6.3
	3942	reaver config.status 1.6.4
3902	3943	configured by $0, generated by GNU Autoconf 2.69,
3903	3944	with options \\"\$ac_cs_config\\"
3904	3945

-1

src/configure.ac less more

0		AC_INIT(reaver, 1.6.3)
	0	define(VERSION_STRING, esyscmd(cat VERSION \| tr -d '\n'))
	1	AC_INIT(reaver, VERSION_STRING)
	2	AC_CONFIG_MACRO_DIR([m4])
1	3	AC_CONFIG_FILES([config.mak])
2	4	AC_PROG_CC
3	5	AC_LANG(C)

14	16	[saves the current session file to the directory reaver was started from])
15	17	, [ CFLAGS="$CFLAGS -DSAVETOCURRENT" ])
16	18
	19	DESIRED_FLAGS="-Werror-unknown-warning-option -Wno-unused-but-set-variable"
	20	for flag in $DESIRED_FLAGS; do
	21	AS_COMPILER_FLAG([$flag], [CFLAGS="$CFLAGS $flag"])
	22	done
	23
17	24	cp confdefs.h config.h
18	25
19	26	AC_SUBST(target, $PACKAGE_NAME)

+15

-0

src/cprintf.h less more

	0	#ifndef CPRINTF_H
	1	#define CPRINTF_H
	2
	3	enum debug_level
	4	{
	5	CRITICAL = 0,
	6	INFO = 1,
	7	WARNING = 2,
	8	VERBOSE = 3,
	9	DEBUG = 4
	10	};
	11
	12	void cprintf(enum debug_level level, const char *fmt, ...);
	13
	14	#endif

+28

-50

src/defs.h less more

40	40	#include <string.h>
41	41	#include <time.h>
42	42	#include <pcap.h>
43		#include <asm/byteorder.h>
	43	#include "utils/endianness.h"
44	44
45	45	#include "wps.h"
	46	#include "cprintf.h"
46	47
47	48	#define NULL_MAC "\x00\x00\x00\x00\x00\x00"
48	49	#define DEFAULT_MAX_NUM_PROBES 15

56	57	#define WPS_TAG_NUMBER 0xDD
57	58	#define VENDOR_SPECIFIC_TAG 0xDD
58	59	#define RSN_TAG_NUMBER 0x30
	60	#define HT_CAPS_TAG_NUMBER 0x2d
59	61
60	62	#define CAPABILITY_WEP 0x10
61	63

86	88	#define DEFAULT_TIMEOUT 10 /* Seconds */
87	89	#define DEFAULT_LOCK_DELAY 60 /* Seconds */
88	90	#define SEC_TO_US 1000000 /* uSeconds in a Second */
89
90		#define TSFT_SIZE 8
91		#define FLAGS_SIZE 1
92		#define RATE_SIZE 1
93		#define CHANNEL_SIZE 4
94		#define FHSS_SIZE 2
95
96		#define TSFT_ALIGNMENT 8
97		#define CHANNEL_ALIGNMENT 2
98
99		#define RADIOTAP_ALIGN(offset, a) \
100		offset = (offset + (a) - 1) & ~((a) - 1)
101	91
102	92	#define WPS_DEVICE_NAME "Glau"
103	93	#define WPS_MANUFACTURER "Microsoft"

119	109	KEY1_WIP = 0,
120	110	KEY2_WIP = 1,
121	111	KEY_DONE = 2
122		};
123
124		enum debug_level
125		{
126		CRITICAL = 0,
127		INFO = 1,
128		WARNING = 2,
129		VERBOSE = 3,
130		DEBUG = 4
131	112	};
132	113
133	114	enum eap_codes

187	168	M8 = 0x0C,
188	169	DONE = 0x0F,
189	170	NACK = 0x0E
190		};
191
192		enum rt_header_flags
193		{
194		TSFT_FLAG = 0x01,
195		FLAGS_FLAG = 0x02,
196		RATE_FLAG = 0x04,
197		CHANNEL_FLAG = 0x08,
198		FHSS_FLAG = 0x10,
199		SSI_FLAG = 0x20,
200	171	};
201	172
202	173	enum wfa_elements

350	321	#define IEEE80211_STYPE_QOS_CFPOLL 0x00E0
351	322	#define IEEE80211_STYPE_QOS_CFACKPOLL 0x00F0
352	323
	324	/* these types denote that the values are stored in a specific byte order */
	325	typedef uint16_t le16;
	326	typedef uint32_t le32;
	327
	328	typedef uint16_t be16;
	329	typedef uint32_t be32;
	330
353	331	#pragma pack(1)
354	332	struct radio_tap_header
355	333	{
356		uint8_t revision;
	334	uint8_t revision;
357	335	uint8_t pad;
358		__le16 len;
359		__le32 flags;
	336	le16 len;
	337	le32 flags;
360	338	};
361	339
362	340	struct dot11_frame_header
363	341	{
364		__le16 fc;
365		__le16 duration;
	342	le16 fc;
	343	le16 duration;
366	344	unsigned char addr1[MAC_ADDR_LEN];
367	345	unsigned char addr2[MAC_ADDR_LEN];
368	346	unsigned char addr3[MAC_ADDR_LEN];
369		__le16 frag_seq;
	347	le16 frag_seq;
370	348	};
371	349
372	350	struct authentication_management_frame
373	351	{
374		__le16 algorithm;
375		__le16 sequence;
376		__le16 status;
	352	le16 algorithm;
	353	le16 sequence;
	354	le16 status;
377	355	};
378	356
379	357	struct association_request_management_frame
380	358	{
381		__le16 capability;
382		__le16 listen_interval;
	359	le16 capability;
	360	le16 listen_interval;
383	361	};
384	362
385	363	struct association_response_management_frame
386	364	{
387		__le16 capability;
388		__le16 status;
389		__le16 id;
	365	le16 capability;
	366	le16 status;
	367	le16 id;
390	368	};
391	369
392	370	struct beacon_management_frame
393	371	{
394	372	unsigned char timestamp[TIMESTAMP_LEN];
395		__le16 beacon_interval;
396		__le16 capability;
	373	le16 beacon_interval;
	374	le16 capability;
397	375	};
398	376
399	377	struct llc_header

402	380	uint8_t ssap;
403	381	uint8_t control_field;
404	382	unsigned char org_code[3];
405		__be16 type;
	383	be16 type;
406	384	};
407	385
408	386	struct dot1X_header

423	401	struct wfa_expanded_header
424	402	{
425	403	unsigned char id[3];
426		__be32 type;
	404	be32 type;
427	405	uint8_t opcode;
428	406	uint8_t flags;
429	407	};

+128

-126

src/exchange.c less more

50	50	/* Initiate an EAP session */
51	51	send_eapol_start();
52	52
53		/*
	53	/*
54	54	* Loop until:
55	55	*
56		* o The pin has been cracked
57		* o An EAP_FAIL packet is received
58		* o We receive a NACK message
	56	* o The pin has been cracked
	57	* o An EAP_FAIL packet is received
	58	* o We receive a NACK message
59	59	* o We hit an unrecoverable receive timeout
60	60	*/
61		while((get_key_status() != KEY_DONE) &&
	61	while((get_key_status() != KEY_DONE) &&
62	62	!terminated &&
63		!got_nack &&
	63	!got_nack &&
64	64	!premature_timeout)
65	65	{
66	66	tx_type = 0;

72	72
73	73	packet = next_packet(&header);
74	74	if(packet == NULL)
75		{
76	75	break;
77		}
78	76
79	77	packet_type = process_packet(packet, &header);
80	78	memset((void *) packet, 0, header.len);
81
	79	if(packet_type != UNKNOWN)
82	80	switch(packet_type)
83	81	{
84	82	case IDENTITY_REQUEST:

120	118	}
121	119	if(m4_sent && !m6_sent)
122	120	{
123		tx_type = SEND_M6;
	121	tx_type = SEND_M6;
124	122	m6_sent = 1;
125		}
	123	} else if(m6_sent && get_repeat_m6()) {
	124	tx_type = SEND_M6;
	125	m6_sent = 1;
	126	}
	127
126	128	else if(get_oo_send_nack())
127	129	{
128	130	tx_type = SEND_WSC_NACK;

133	135	cprintf(VERBOSE, "[+] Received M7 message\n");
134	136	/* Fall through */
135	137	case DONE:
136		if(get_key_status() == KEY2_WIP)
	138	if(get_key_status() == KEY2_WIP)
137	139	{
138	140	set_key_status(KEY_DONE);
139	141	}

147	149	terminated = 1;
148	150	break;
149	151	default:
150		if(packet_type != 0)
151		{
152		cprintf(VERBOSE, "[!] WARNING: Unexpected packet received (0x%.02X), terminating transaction\n", packet_type);
153		terminated = 1;
154		}
	152	cprintf(VERBOSE, "[!] WARNING: Unexpected packet received (0x%.02X), terminating transaction\n", packet_type);
	153	terminated = 1;
155	154	break;
156	155	}
157	156

163	162	{
164	163	send_msg(tx_type);
165	164	}
166		/*
	165	/*
167	166	* If get_oo_send_nack is 0, then when out of order packets come, we don't
168	167	* NACK them. However, this also means that we wait infinitely for the expected
169	168	* packet, since the timer is started by send_msg. Manually start the timer to

196	195	premature_timeout = 1;
197	196	}
198	197	}
199		}
	198	}
200	199
201	200	/*
202	201	* There are four states that can signify a pin failure:

217	216	{
218	217	/* The AP is properly sending WSC_NACKs, so don't treat future timeouts as pin failures. */
219	218	set_timeout_is_nack(0);
220
	219
221	220	ret_val = KEY_REJECTED;
222	221	}
223	222	else

227	226	}
228	227	else if(premature_timeout)
229	228	{
230		/*
	229	/*
231	230	* Some WPS implementations simply drop the connection on the floor instead of sending a NACK.
232	231	* We need to be able to handle this, but at the same time using a timeout on the M5/M7 messages
233	232	* can result in false negatives. Thus, treating M5/M7 receive timeouts as NACKs can be disabled.

257	256	ret_val = UNKNOWN_ERROR;
258	257	}
259	258
260		/*
	259	/*
261	260	* Always completely terminate the WPS session, else some WPS state machines may
262	261	* get stuck in their current state and won't accept new WPS registrar requests
263	262	* until rebooted.
264		*
	263	*
265	264	* Stop the receive timer that is started by the termination transmission.
266	265	*/
267	266	send_wsc_nack();
268	267	stop_timer();
269
	268
270	269	if(get_eap_terminate() \|\| ret_val == EAP_FAIL)
271	270	{
272	271	send_termination();
273	272	stop_timer();
274	273	}
275
	274
276	275	return ret_val;
	276	}
	277
	278	static int is_data_packet(struct dot11_frame_header *frame_header)
	279	{
	280	int fctype = frame_header->fc & end_htole16(IEEE80211_FCTL_FTYPE \| IEEE80211_FCTL_STYPE);
	281	if (fctype == end_htole16(IEEE80211_FTYPE_DATA \| IEEE80211_STYPE_DATA))
	282	return 1;
	283	if (fctype == end_htole16(IEEE80211_FTYPE_DATA \| IEEE80211_STYPE_QOS_DATA))
	284	return 2;
	285	return 0;
	286	}
	287
	288	static int is_packet_for_us(struct dot11_frame_header *frame_header)
	289	{
	290	return (
	291	(memcmp(frame_header->addr1, get_mac(), MAC_ADDR_LEN) == 0)
	292	);
277	293	}
278	294
279	295	/*

291	307	struct wfa_expanded_header *wfa = NULL;
292	308	const void *wps_msg = NULL;
293	309	size_t wps_msg_len = 0;
294		enum wps_type type = UNKNOWN;
295	310	struct wps_data *wps = NULL;
296	311
297	312	if(packet == NULL \|\| header == NULL)

305	320
306	321	/* Cast the radio tap and 802.11 frame headers and parse out the Frame Control field */
307	322	rt_header = (struct radio_tap_header *) packet;
308		size_t rt_header_len = __le16_to_cpu(rt_header->len);
309		frame_header = (struct dot11_frame_header *) (packet+rt_header_len);
	323	size_t offset = end_le16toh(rt_header->len);
	324	frame_header = (struct dot11_frame_header *) (packet+offset);
	325	offset += sizeof(struct dot11_frame_header);
310	326
311	327	/* Does the BSSID/source address match our target BSSID? */
312		if(memcmp(frame_header->addr3, get_bssid(), MAC_ADDR_LEN) == 0)
313		{
314		/* Is this a data packet sent to our MAC address? */
315		if (((frame_header->fc & __cpu_to_le16(IEEE80211_FCTL_FTYPE \| IEEE80211_FCTL_STYPE)) ==
316		__cpu_to_le16(IEEE80211_FTYPE_DATA \| IEEE80211_STYPE_DATA)) &&
317		(memcmp(frame_header->addr1, get_mac(), MAC_ADDR_LEN) == 0))
318		{
319		llc = (struct llc_header *) (packet +
320		rt_header_len +
321		sizeof(struct dot11_frame_header)
322		);
323
324		/* All packets in our exchanges will be 802.1x */
325		if(llc->type == __cpu_to_be16(DOT1X_AUTHENTICATION))
326		{
327		dot1x = (struct dot1X_header *) (packet +
328		rt_header_len +
329		sizeof(struct dot11_frame_header) +
330		sizeof(struct llc_header)
331		);
332
333		/* All packets in our exchanges will be EAP packets */
334		if(dot1x->type == DOT1X_EAP_PACKET && (header->len >= EAP_PACKET_SIZE))
335		{
336		eap = (struct eap_header *) (packet +
337		rt_header_len +
338		sizeof(struct dot11_frame_header) +
339		sizeof(struct llc_header) +
340		sizeof(struct dot1X_header)
341		);
342
343		/* EAP session termination. Break and move on. */
344		if(eap->code == EAP_FAILURE)
345		{
346		type = TERMINATE;
347		}
348		/* If we've received an EAP request and then this should be a WPS message */
349		else if(eap->code == EAP_REQUEST)
350		{
351		/* The EAP header builder needs this ID value */
352		set_eap_id(eap->id);
353
354		/* Stop the receive timer that was started by the last send_packet() */
355		stop_timer();
356
357		/* Check to see if we received an EAP identity request */
358		if(eap->type == EAP_IDENTITY)
359		{
360		/* We've initiated an EAP session, so reset the counter */
361		set_eapol_start_count(0);
362
363		type = IDENTITY_REQUEST;
364		}
365		/* An expanded EAP type indicates a probable WPS message */
366		else if((eap->type == EAP_EXPANDED) && (header->len > WFA_PACKET_SIZE))
367		{
368		wfa = (struct wfa_expanded_header *) (packet +
369		rt_header_len +
370		sizeof(struct dot11_frame_header) +
371		sizeof(struct llc_header) +
372		sizeof(struct dot1X_header) +
373		sizeof(struct eap_header)
374		);
375
376		/* Verify that this is a WPS message */
377		if(wfa->type == __cpu_to_be32(SIMPLE_CONFIG))
378		{
379		wps_msg_len = (size_t) ntohs(eap->len) -
380		sizeof(struct eap_header) -
381		sizeof(struct wfa_expanded_header);
382
383		wps_msg = (const void *) (packet +
384		rt_header_len +
385		sizeof(struct dot11_frame_header) +
386		sizeof(struct llc_header) +
387		sizeof(struct dot1X_header) +
388		sizeof(struct eap_header) +
389		sizeof(struct wfa_expanded_header)
390		);
391
392		/* Save the current WPS state. This way if we get a NACK message, we can
393		* determine what state we were in when the NACK arrived.
394		*/
395		wps = get_wps();
396		set_last_wps_state(wps->state);
397		set_opcode(wfa->opcode);
398
399		/* Process the WPS message and send a response */
400		type = process_wps_message(wps_msg, wps_msg_len);
401		}
402		}
403		}
404		}
405		}
406		}
407		}
408
409		return type;
	328	if(memcmp(frame_header->addr3, get_bssid(), MAC_ADDR_LEN) != 0)
	329	return UNKNOWN;
	330
	331	/* Is this a packet sent to our MAC address? */
	332	if(!is_packet_for_us(frame_header))
	333	return UNKNOWN;
	334
	335	int data_pkt_type;
	336
	337	/* Is this a data packet ? */
	338	if(!(data_pkt_type = is_data_packet(frame_header)))
	339	return UNKNOWN;
	340
	341	if(data_pkt_type == 2) /* QOS */
	342	offset += 2;
	343
	344	llc = (struct llc_header *) (packet + offset);
	345	offset += sizeof(struct llc_header);
	346
	347	/* All packets in our exchanges will be 802.1x */
	348	if(llc->type != end_htobe16(DOT1X_AUTHENTICATION))
	349	return UNKNOWN;
	350
	351
	352	dot1x = (struct dot1X_header *) (packet + offset);
	353	offset += sizeof(struct dot1X_header);
	354
	355	/* All packets in our exchanges will be EAP packets */
	356	if(!(dot1x->type == DOT1X_EAP_PACKET && (header->len >= EAP_PACKET_SIZE)))
	357	return UNKNOWN;
	358
	359
	360	eap = (struct eap_header *) (packet + offset);
	361	offset += sizeof(struct eap_header);
	362
	363	/* EAP session termination. Break and move on. */
	364	if(eap->code == EAP_FAILURE)
	365	return TERMINATE;
	366
	367	/* If we've received an EAP request and then this should be a WPS message */
	368	if(eap->code != EAP_REQUEST)
	369	return UNKNOWN;
	370
	371	/* The EAP header builder needs this ID value */
	372	set_eap_id(eap->id);
	373
	374	/* Stop the receive timer that was started by the last send_packet() */
	375	stop_timer();
	376
	377	/* Check to see if we received an EAP identity request */
	378	if(eap->type == EAP_IDENTITY)
	379	{
	380	/* We've initiated an EAP session, so reset the counter */
	381	set_eapol_start_count(0);
	382
	383	return IDENTITY_REQUEST;
	384	}
	385
	386	/* An expanded EAP type indicates a probable WPS message */
	387	if(!((eap->type == EAP_EXPANDED) && (header->len > WFA_PACKET_SIZE)))
	388	return UNKNOWN;
	389
	390	wfa = (struct wfa_expanded_header *) (packet + offset);
	391	offset += sizeof(struct wfa_expanded_header);
	392
	393	/* Verify that this is a WPS message */
	394	if(wfa->type != end_htobe32(SIMPLE_CONFIG))
	395	return UNKNOWN;
	396
	397	wps_msg_len = (size_t) ntohs(eap->len) -
	398	sizeof(struct eap_header) -
	399	sizeof(struct wfa_expanded_header);
	400
	401	wps_msg = (const void *) (packet + offset);
	402
	403	/* Save the current WPS state. This way if we get a NACK message, we can
	404	* determine what state we were in when the NACK arrived.
	405	*/
	406	wps = get_wps();
	407	set_last_wps_state(wps->state);
	408	set_opcode(wfa->opcode);
	409
	410	/* Process the WPS message and send a response */
	411	return process_wps_message(wps_msg, wps_msg_len);
410	412	}
411	413
412	414	/* Processes a received WPS message and returns the message type */

+27

-0

src/globule.c less more

32	32
33	33	#include "globule.h"
34	34
	35	struct globals *globule;
	36
35	37	int globule_init()
36	38	{
37	39	int ret = 0;

41	43	{
42	44	memset(globule, 0, sizeof(struct globals));
43	45	ret = 1;
	46	globule->resend_timeout_usec = 200000;
	47
44	48	}
45	49
46	50	return ret;

530	534	return globule->wps;
531	535	}
532	536
	537	void set_ap_htcaps(unsigned char *value, int len)
	538	{
	539	free(globule->htcaps);
	540	globule->htcaps = malloc(len);
	541	globule->htcaps_len = len;
	542	memcpy(globule->htcaps, value, len);
	543	}
	544
	545	unsigned char get_ap_htcaps(int len)
	546	{
	547	*len = globule->htcaps_len;
	548	return globule->htcaps;
	549	}
	550
533	551	void set_ap_rates(unsigned char *value, int len)
534	552	{
535	553	if(globule->ap_rates)

610	628	return globule->vendor_oui+1;
611	629	}
612	630
	631	void set_repeat_m6(int val) {
	632	globule->repeat_m6 = val;
	633	}
	634
	635	int get_repeat_m6(void) {
	636	return globule->repeat_m6;
	637	}
	638
	639

+15

-1

src/globule.h less more

87	87
88	88	int out_of_time; /* Set to 1 when sigalrm sounds */
89	89
	90	unsigned long long resend_timeout_usec; /* how many microsecs to wait before resending last packet */
	91
90	92	enum debug_level debug; /* Current debug level: INFO \| CRITICAL \| WARNING \| VERBOSE */
91	93
92	94	int eapol_start_count; /* Tracks how many times in a row we've attempted to start and EAP session */

98	100	int wifi_band; /* Determines if we use the A/N bands or B/G bands */
99	101
100	102	int channel; /* Holds the current channel number */
	103
	104	int repeat_m6; /* Repeat M6 upon receipt of out-of-order M5s */
101	105
102	106	int max_num_probes; /* Maximum number of probe requests to send to an AP during survey mode */
103	107

114	118	unsigned char mac[MAC_ADDR_LEN]; /* Source MAC address */
115	119
116	120	unsigned char vendor_oui[1+3]; /* the first byte contains 1 if set, 0 if not, the next 3 bytes the actual vendor OUI */
	121
	122	unsigned char htcaps; / Wireless N HT capabilities of the AP */
	123
	124	int htcaps_len; /* lenght of the Wireless N HT capabilities of the AP */
117	125
118	126	unsigned char ap_rates; / Supported rates IE data, as reported by the AP */
119	127

143	151	* wpa_supplicant's wps_data structure, needed for almost all wpa_supplicant
144	152	* function calls.
145	153	*/
146		} *globule;
	154	};
	155
	156	extern struct globals *globule;
147	157
148	158	int globule_init();
149	159	void globule_deinit();

241	251	unsigned char get_ap_rates(int len);
242	252	void set_ap_ext_rates(unsigned char *value, int len);
243	253	unsigned char get_ap_ext_rates(int len);
	254	void set_ap_htcaps(unsigned char *value, int len);
	255	unsigned char get_ap_htcaps(int len);
244	256	void set_exec_string(char *string);
245	257	char *get_exec_string(void);
246	258	void set_oo_send_nack(int value);
247	259	int get_oo_send_nack(void);
248	260	void set_vendor(int, const unsigned char*);
249	261	unsigned char *get_vendor(void);
	262	void set_repeat_m6(int);
	263	int get_repeat_m6(void);
250	264	#endif

+49

-0

src/iface.c less more

31	31	*/
32	32
33	33	#include "iface.h"
	34	#include "lwe/iwlib.h"
	35	#include "globule.h"
	36	#include <net/if.h>
	37	#include <netinet/in.h>
	38	#include <sys/ioctl.h>
	39	#include <stdlib.h>
34	40
	41	#if defined(__FreeBSD__) \|\| defined(__APPLE__)
	42	#include <ifaddrs.h>
	43	#include <net/if_dl.h>
	44	int read_iface_mac() {
	45	struct ifaddrs* iflist;
	46	int found = 0;
	47	if (getifaddrs(&iflist) == 0) {
	48	struct ifaddrs* cur;
	49	for (cur = iflist; cur; cur = cur->ifa_next) {
	50	if ((cur->ifa_addr->sa_family == AF_LINK) &&
	51	(strcmp(cur->ifa_name, get_iface()) == 0) &&
	52	cur->ifa_addr) {
	53	struct sockaddr_dl* sdl = (struct sockaddr_dl*)cur->ifa_addr;
	54	set_mac(LLADDR(sdl));
	55	found = 1;
	56	break;
	57	}
	58	}
	59	freeifaddrs(iflist);
	60	}
	61	return found;
	62	}
	63	#else
35	64	/* Populates globule->mac with the MAC address of the interface globule->iface */
36	65	int read_iface_mac()
37	66	{

67	96
68	97	return ret_val;
69	98	}
	99	#endif
70	100
71	101	/*
72	102	* Goes to the next 802.11 channel.

111	141	}
112	142
113	143	/* Sets the 802.11 channel for the selected interface */
	144	#ifdef __APPLE__
	145	int change_channel(int channel)
	146	{
	147	cprintf(VERBOSE, "[+] Switching %s to channel %d\n", get_iface(), channel);
	148	// Unfortunately, there is no API to change the channel
	149	pid_t pid = fork();
	150	if (!pid) {
	151	char chan_arg[32];
	152	sprintf(chan_arg, "-c%d", channel);
	153	char* argv[] = {"/System/Library/PrivateFrameworks/Apple80211.framework/Resources/airport", chan_arg, NULL};
	154	execve("/System/Library/PrivateFrameworks/Apple80211.framework/Resources/airport", argv, NULL);
	155	}
	156	int status;
	157	waitpid(pid,&status,0);
	158	set_channel(channel);
	159	return 0;
	160	}
	161	#else
114	162	int change_channel(int channel)
115	163	{
116	164	int skfd = 0, ret_val = 0;

145	193
146	194	return ret_val;
147	195	}
	196	#endif

-9

src/iface.h less more

33	33	#ifndef IFACE_H
34	34	#define IFACE_H
35	35
36		#include <sys/ioctl.h>
37		#include <net/if.h>
38		#include <netinet/in.h>
39		#include "lwe/iwlib.h"
40
41		#include "defs.h"
42		#include "globule.h"
43		#include "misc.h"
44
45	36	#define BG_BAND 0
46	37	#define AN_BAND 1
47	38

+40

-6

src/init.c less more

117	117	/* Initializes pcap capture settings and returns a pcap handle on success, NULL on error */
118	118	pcap_t capture_init(char capture_source)
119	119	{
120		pcap_t *handle = NULL;
	120	pcap_t *handle;
121	121	char errbuf[PCAP_ERRBUF_SIZE] = { 0 };
122
123		handle = pcap_open_live(capture_source, 65536, 1, 0, errbuf);
124		if(!handle)
125		{
126		handle = pcap_open_offline(capture_source, errbuf);
	122	int status;
	123
	124	handle = pcap_open_offline(capture_source, errbuf);
	125	if(handle) return handle;
	126
	127	#ifdef __APPLE__
	128	// must disassociate from any current AP. This is the only way.
	129	pid_t pid = fork();
	130	if (!pid) {
	131	char* argv[] = {"/System/Library/PrivateFrameworks/Apple80211.framework/Resources/airport", "-z", NULL};
	132	execve("/System/Library/PrivateFrameworks/Apple80211.framework/Resources/airport", argv, NULL);
	133	}
	134	waitpid(pid,&status,0);
	135	#endif
	136
	137	handle = pcap_create(capture_source, errbuf);
	138	if (handle) {
	139	pcap_set_snaplen(handle, 65536);
	140	pcap_set_timeout(handle, 50);
	141	pcap_set_rfmon(handle, 1);
	142	pcap_set_promisc(handle, 1);
	143	if(!(status = pcap_activate(handle)))
	144	return handle;
	145	if(status == PCAP_ERROR_RFMON_NOTSUP) {
	146	pcap_set_rfmon(handle, 0);
	147	status = pcap_activate(handle);
	148	if(!status) return handle;
	149	}
	150	cprintf(CRITICAL, "[X] ERROR: pcap_activate status %d\n", status);
	151	if(status == PCAP_ERROR_NO_SUCH_DEVICE)
	152	cprintf(CRITICAL, "[X] PCAP: no such device\n");
	153	/* TODO : print nice error message for other codes */
	154	pcap_close(handle);
	155	handle = 0;
	156	}
	157
	158	if(!handle) {
	159	cprintf(CRITICAL, "couldn't get pcap handle, exiting\n");
	160	exit(1);
127	161	}
128	162
129	163	return handle;

+64

-0

src/install.sh less more

	0	#!/bin/sh
	1	#
	2	# This is an actually-safe install command which installs the new
	3	# file atomically in the new location, rather than overwriting
	4	# existing files.
	5	#
	6
	7	usage() {
	8	printf "usage: %s [-D] [-l] [-m mode] src dest\n" "$0" 1>&2
	9	exit 1
	10	}
	11
	12	mkdirp=
	13	symlink=
	14	mode=755
	15
	16	while getopts Dlm: name ; do
	17	case "$name" in
	18	D) mkdirp=yes ;;
	19	l) symlink=yes ;;
	20	m) mode=$OPTARG ;;
	21	?) usage ;;
	22	esac
	23	done
	24	shift $(($OPTIND - 1))
	25
	26	test "$#" -eq 2 \|\| usage
	27	src=$1
	28	dst=$2
	29	tmp="$dst.tmp.$$"
	30
	31	case "$dst" in
	32	*/) printf "%s: %s ends in /\n", "$0" "$dst" 1>&2 ; exit 1 ;;
	33	esac
	34
	35	set -C
	36	set -e
	37
	38	if test "$mkdirp" ; then
	39	umask 022
	40	case "$2" in
	41	/) mkdir -p "${dst%/*}" ;;
	42	esac
	43	fi
	44
	45	trap 'rm -f "$tmp"' EXIT INT QUIT TERM HUP
	46
	47	umask 077
	48
	49	if test "$symlink" ; then
	50	ln -s "$1" "$tmp"
	51	else
	52	cat < "$1" > "$tmp"
	53	chmod "$mode" "$tmp"
	54	fi
	55
	56	mv -f "$tmp" "$2"
	57	test -d "$2" && {
	58	rm -f "$2/$tmp"
	59	printf "%s: %s is a directory\n" "$0" "$dst" 1>&2
	60	exit 1
	61	}
	62
	63	exit 0

-17

src/libwps/libwps.c less more

11	11	#define LIBWPS_C
12	12
13	13	#include "libwps.h"
	14	#include "../utils/common.h"
	15	#include "../cprintf.h"
14	16	#include <assert.h>
15	17
16	18	static char* append(char* s1, char *s2) {

34	36	return new;
35	37	}
36	38
37		static char* sanitize_string(char *s) {
38		size_t i,j, l = strlen(s), ls=l;
39		for(i=0;i<ls;i++) if(s[i] < ' ' \|\| s[i] > 127) l += 4;
40		char *new = malloc(l+1);
41		if(!new) return 0;
42		for(i=0,j=0;i<ls;i++) {
43		if(s[i] < ' ' \|\| s[i] > 127) {
44		sprintf(new + j, "\\\\x%02x", s[i] & 0xff);
45		j += 4;
46		} else new[j] = s[i];
47		j++;
48		}
49		new[j] = 0;
50		return new;
51		}
52
53	39	char wps_data_to_json(const charbssid, const char ssid, int channel, int rssi, const unsigned char vendor, struct libwps_data *wps) {
54	40	size_t ol = 0, nl = 0, ns = 0;
55	41	char json_str = 0, old = strdup("{"), *tmp;

59	45	json_str = append_and_free(old, buf, 1);
60	46	old = json_str;
61	47
62		nl = snprintf(buf, sizeof buf, "\"essid\" : \"%s\", ", ssid);
	48	tmp = sanitize_string(ssid);
	49	nl = snprintf(buf, sizeof buf, "\"essid\" : \"%s\", ", tmp);
	50	free(tmp);
63	51	json_str = append_and_free(old, buf, 1);
64	52	old = json_str;
65	53

218	206	rt_header = (struct radio_tap_header *) libwps_radio_header(packet, len);
219	207
220	208	offset = rt_header->len + sizeof(struct dot11_frame_header) + sizeof(struct management_frame);
	209	if(offset > len) {
	210	cprintf(CRITICAL, "corrupt data received, terminating!\n");
	211	exit(1);
	212	}
221	213	data = (packet + offset);
222	214	data_len = (len - offset);
223	215

+18

-6

src/lwe/iwlib.c less more

152	152	iw_sockets_open(void)
153	153	{
154	154	static const int families[] = {
155		AF_INET, AF_IPX, AF_AX25, AF_APPLETALK
	155	AF_INET, AF_IPX,
	156	#ifdef AF_AX25
	157	AF_AX25,
	158	#endif
	159	AF_APPLETALK
156	160	};
157	161	unsigned int i;
158	162	int sock;

379	383	struct iw_range * range;
380	384
381	385	/* Avoid "Unused parameter" warning */
382		args = args; count = count;
	386	(void) args; (void) count;
383	387
384	388	/* If no wireless name : no wireless extensions.
385	389	* This enable us to treat the SIOCGIWRANGE failure below properly. */

754	758	*/
755	759	if(info->has_mode)
756	760	{
757		strncpy(wrq.ifr_name, ifname, IFNAMSIZ);
	761	strncpy(wrq.ifr_ifrn.ifrn_name, ifname, IFNAMSIZ);
758	762	wrq.u.mode = info->mode;
759	763
760	764	if(iw_get_ext(skfd, ifname, SIOCSIWMODE, &wrq) < 0)

1271	1275	wrq.u.data.pointer = (caddr_t) stats;
1272	1276	wrq.u.data.length = sizeof(struct iw_statistics);
1273	1277	wrq.u.data.flags = 1; /* Clear updated flag */
1274		strncpy(wrq.ifr_name, ifname, IFNAMSIZ);
	1278	strncpy(wrq.ifr_ifrn.ifrn_name, ifname, IFNAMSIZ);
1275	1279	if(iw_get_ext(skfd, ifname, SIOCGIWSTATS, &wrq) < 0)
1276	1280	return(-1);
1277	1281

1550	1554	iw_pass_key(const char * input,
1551	1555	unsigned char * key)
1552	1556	{
1553		input = input; key = key;
	1557	(void) input; (void) key;
1554	1558	fprintf(stderr, "Error: Passphrase not implemented\n");
1555	1559	return(-1);
1556	1560	}

1924	1928	* manage address display and input...
1925	1929	*/
1926	1930
	1931	#if 0
1927	1932	/------------------------------------------------------------------/
1928	1933	/*
1929	1934	* Check if interface support the right MAC address type...

1956	1961
1957	1962	return(0);
1958	1963	}
1959
	1964	#endif
1960	1965
1961	1966	/------------------------------------------------------------------/
1962	1967	/*

2059	2064	return(buf);
2060	2065	}
2061	2066
	2067	#if 0
2062	2068	/------------------------------------------------------------------/
2063	2069	/*
2064	2070	* Display an Ethernet address in readable format.

2100	2106	iw_ether_ntop(ether_wap, buf);
2101	2107	return(buf);
2102	2108	}
	2109	#endif
2103	2110
2104	2111	/------------------------------------------------------------------/
2105	2112	/*

2219	2226	return(0);
2220	2227	}
2221	2228
	2229	#if 0
2222	2230	/------------------------------------------------------------------/
2223	2231	/*
2224	2232	* Input an address and convert to binary.

2305	2313
2306	2314	return(0);
2307	2315	}
	2316	#endif
2308	2317
2309	2318	/*********************** MISC SUBROUTINES ************************/
2310	2319

3018	3027	return(wscan);
3019	3028	}
3020	3029
	3030	#if 0
3021	3031	/------------------------------------------------------------------/
3022	3032	/*
3023	3033	* Initiate the scan procedure, and process results.

3211	3221	/* End - return -1 or 0 */
3212	3222	return(delay);
3213	3223	}
	3224	#endif
	3225

-2

src/lwe/iwlib.h less more

20	20	#define _GNU_SOURCE
21	21	#undef _BSD_SOURCE
22	22	#define _BSD_SOURCE
	23	#include <sys/socket.h>
23	24	#include <sys/types.h>
24	25	#include <sys/ioctl.h>
25	26	#include <stdio.h>

54	55
55	56	/* Private copy of Wireless extensions (in this directoty) */
56	57	#include "wireless.h"
	58
	59	#ifndef ETH_ALEN
	60	#define ETH_ALEN 6
	61	#endif
57	62
58	63	/* Make gcc understant that when we say inline, we mean it.
59	64	* I really hate when the compiler is trying to be more clever than me,

504	509	struct iwreq * pwrq) /* Fixed part of the request */
505	510	{
506	511	/* Set device name */
507		strncpy(pwrq->ifr_name, ifname, IFNAMSIZ);
	512	strncpy(pwrq->ifr_ifrn.ifrn_name, ifname, IFNAMSIZ);
508	513	/* Do the request */
509	514	return(ioctl(skfd, request, pwrq));
510	515	}

520	525	struct iwreq * pwrq) /* Fixed part of the request */
521	526	{
522	527	/* Set device name */
523		strncpy(pwrq->ifr_name, ifname, IFNAMSIZ);
	528	strncpy(pwrq->ifr_ifrn.ifrn_name, ifname, IFNAMSIZ);
524	529	/* Do the request */
525	530	return(ioctl(skfd, request, pwrq));
526	531	}

+64

-0

src/m4/as-compiler-flag.m4 less more

	0	dnl as-compiler-flag.m4 0.1.0
	1
	2	dnl autostars m4 macro for detection of compiler flags
	3
	4	dnl David Schleef <[email protected]>
	5	dnl Tim-Philipp Müller <tim centricular net>
	6
	7	dnl AS_COMPILER_FLAG(CFLAGS, ACTION-IF-ACCEPTED, [ACTION-IF-NOT-ACCEPTED])
	8	dnl Tries to compile with the given CFLAGS.
	9	dnl Runs ACTION-IF-ACCEPTED if the compiler can compile with the flags,
	10	dnl and ACTION-IF-NOT-ACCEPTED otherwise.
	11
	12	AC_DEFUN([AS_COMPILER_FLAG],
	13	[
	14	AC_MSG_CHECKING([to see if compiler understands $1])
	15
	16	save_CFLAGS="$CFLAGS"
	17	CFLAGS="$CFLAGS $1"
	18
	19	AC_TRY_COMPILE([ ], [], [flag_ok=yes], [flag_ok=no])
	20	CFLAGS="$save_CFLAGS"
	21
	22	if test "X$flag_ok" = Xyes ; then
	23	$2
	24	true
	25	else
	26	$3
	27	true
	28	fi
	29	AC_MSG_RESULT([$flag_ok])
	30	])
	31
	32	dnl AS_CXX_COMPILER_FLAG(CPPFLAGS, ACTION-IF-ACCEPTED, [ACTION-IF-NOT-ACCEPTED])
	33	dnl Tries to compile with the given CPPFLAGS.
	34	dnl Runs ACTION-IF-ACCEPTED if the compiler can compile with the flags,
	35	dnl and ACTION-IF-NOT-ACCEPTED otherwise.
	36
	37	AC_DEFUN([AS_CXX_COMPILER_FLAG],
	38	[
	39	AC_REQUIRE([AC_PROG_CXX])
	40
	41	AC_MSG_CHECKING([to see if c++ compiler understands $1])
	42
	43	save_CPPFLAGS="$CPPFLAGS"
	44	CPPFLAGS="$CPPFLAGS $1"
	45
	46	AC_LANG_PUSH(C++)
	47
	48	AC_TRY_COMPILE([ ], [], [flag_ok=yes], [flag_ok=no])
	49	CPPFLAGS="$save_CPPFLAGS"
	50
	51	if test "X$flag_ok" = Xyes ; then
	52	$2
	53	true
	54	else
	55	$3
	56	true
	57	fi
	58
	59	AC_LANG_POP(C++)
	60
	61	AC_MSG_RESULT([$flag_ok])
	62	])
	63

+26

-0

src/main.c less more

	0	#include <string.h>
	1
	2	extern int reaver_main(int argc, char **argv);
	3	extern int wash_main(int argc, char **argv);
	4
	5	#define C_REAVER 0
	6	#define C_WASH 1
	7
	8	int main(int argc, char** argv) {
	9	char *e = strrchr(argv[0], '/');
	10	if(!e) e = argv[0];
	11	else e++;
	12	int command = C_REAVER;
	13	if(!strcmp(e, "reaver")) command = C_REAVER;
	14	else
	15	if(!strcmp(e, "wash")) command = C_WASH;
	16	else
	17	if(strstr(e, "wash")) command = C_WASH;
	18	else
	19	if(strstr(e, "reaver")) command = C_REAVER;
	20
	21	if(command == C_WASH)
	22	return wash_main(argc, argv);
	23	else
	24	return reaver_main(argc, argv);
	25	}

-1

src/misc.h less more

40	40	#include "defs.h"
41	41	#include "init.h"
42	42	#include "globule.h"
	43	#include "cprintf.h"
43	44
44	45	char mac2str(unsigned char mac, char delim);
45	46	void str2mac(char str, unsigned char mac);
46		void cprintf(enum debug_level level, const char *fmt, ...);
47	47	void daemonize(void);
48	48	void pcap_sleep(int seconds);
49	49

-0

src/pixie.c less more

	0	#include <sys/types.h>
0	1	#include "pixie.h"
1	2	#include "globule.h"
2	3	#include <stdio.h>

+134

-0

src/radiotap_flags.h less more

	0	#ifndef RADIOTAP_FLAGS_H
	1	#define RADIOTAP_FLAGS_H
	2
	3	/* (C) 2014 - 2017 rofl0r
	4	released under the public domain.
	5	*/
	6
	7	#include <stdint.h>
	8
	9	/* prevent redefining the same types when the official radiotap
	10	header is in use too */
	11	#ifndef IEEE80211RADIOTAP_H
	12
	13	struct ieee80211_radiotap_header {
	14	uint8_t it_version;
	15	uint8_t it_pad;
	16	uint16_t it_len;
	17	uint32_t it_present;
	18	};
	19
	20	enum ieee80211_radiotap_type {
	21	IEEE80211_RADIOTAP_TSFT = 0,
	22	IEEE80211_RADIOTAP_FLAGS = 1,
	23	IEEE80211_RADIOTAP_RATE = 2,
	24	IEEE80211_RADIOTAP_CHANNEL = 3,
	25	IEEE80211_RADIOTAP_FHSS = 4,
	26	IEEE80211_RADIOTAP_DBM_ANTSIGNAL = 5,
	27	IEEE80211_RADIOTAP_DBM_ANTNOISE = 6,
	28	IEEE80211_RADIOTAP_LOCK_QUALITY = 7,
	29	IEEE80211_RADIOTAP_TX_ATTENUATION = 8,
	30	IEEE80211_RADIOTAP_DB_TX_ATTENUATION = 9,
	31	IEEE80211_RADIOTAP_DBM_TX_POWER = 10,
	32	IEEE80211_RADIOTAP_ANTENNA = 11,
	33	IEEE80211_RADIOTAP_DB_ANTSIGNAL = 12,
	34	IEEE80211_RADIOTAP_DB_ANTNOISE = 13,
	35	IEEE80211_RADIOTAP_RX_FLAGS = 14,
	36	IEEE80211_RADIOTAP_TX_FLAGS = 15,
	37	IEEE80211_RADIOTAP_RTS_RETRIES = 16,
	38	IEEE80211_RADIOTAP_DATA_RETRIES = 17,
	39	IEEE80211_RADIOTAP_XCHANNEL = 18,
	40	IEEE80211_RADIOTAP_MCS = 19,
	41	IEEE80211_RADIOTAP_AMPDU_STATUS = 20,
	42	IEEE80211_RADIOTAP_VHT = 21,
	43	IEEE80211_RADIOTAP_TIMESTAMP = 22,
	44	IEEE80211_RADIOTAP_RADIOTAP_NAMESPACE = 29,
	45	IEEE80211_RADIOTAP_VENDOR_NAMESPACE = 30,
	46	IEEE80211_RADIOTAP_EXT = 31
	47	};
	48
	49	#endif
	50
	51	static const unsigned char ieee80211_radiotap_type_size[] = {
	52	[IEEE80211_RADIOTAP_TSFT] = 8,
	53	[IEEE80211_RADIOTAP_FLAGS] = 1,
	54	[IEEE80211_RADIOTAP_RATE] = 1,
	55	[IEEE80211_RADIOTAP_CHANNEL] = 2*2,
	56	[IEEE80211_RADIOTAP_FHSS] = 2,
	57	[IEEE80211_RADIOTAP_DBM_ANTSIGNAL] = 1,
	58	[IEEE80211_RADIOTAP_DBM_ANTNOISE] = 1,
	59	[IEEE80211_RADIOTAP_LOCK_QUALITY] = 2,
	60	[IEEE80211_RADIOTAP_TX_ATTENUATION] = 2,
	61	[IEEE80211_RADIOTAP_DB_TX_ATTENUATION] = 2,
	62	[IEEE80211_RADIOTAP_DBM_TX_POWER] = 1,
	63	[IEEE80211_RADIOTAP_ANTENNA] = 1,
	64	[IEEE80211_RADIOTAP_DB_ANTSIGNAL] = 1,
	65	[IEEE80211_RADIOTAP_DB_ANTNOISE] = 1,
	66	[IEEE80211_RADIOTAP_RX_FLAGS] = 2,
	67	[IEEE80211_RADIOTAP_TX_FLAGS] = 2,
	68	[IEEE80211_RADIOTAP_RTS_RETRIES] = 1,
	69	[IEEE80211_RADIOTAP_DATA_RETRIES] = 1,
	70	[IEEE80211_RADIOTAP_MCS] = 1+1+1,
	71	[IEEE80211_RADIOTAP_AMPDU_STATUS] = 4+2+1+1,
	72	[IEEE80211_RADIOTAP_VHT] = 12,
	73	[IEEE80211_RADIOTAP_TIMESTAMP] = 12,
	74	};
	75
	76	static const unsigned char ieee80211_radiotap_type_align[] = {
	77	[IEEE80211_RADIOTAP_TSFT] = 8,
	78	[IEEE80211_RADIOTAP_FLAGS] = 1,
	79	[IEEE80211_RADIOTAP_RATE] = 1,
	80	[IEEE80211_RADIOTAP_CHANNEL] = 2,
	81	[IEEE80211_RADIOTAP_FHSS] = 2,
	82	[IEEE80211_RADIOTAP_DBM_ANTSIGNAL] = 1,
	83	[IEEE80211_RADIOTAP_DBM_ANTNOISE] = 1,
	84	[IEEE80211_RADIOTAP_LOCK_QUALITY] = 2,
	85	[IEEE80211_RADIOTAP_TX_ATTENUATION] = 2,
	86	[IEEE80211_RADIOTAP_DB_TX_ATTENUATION] = 2,
	87	[IEEE80211_RADIOTAP_DBM_TX_POWER] = 1,
	88	[IEEE80211_RADIOTAP_ANTENNA] = 1,
	89	[IEEE80211_RADIOTAP_DB_ANTSIGNAL] = 1,
	90	[IEEE80211_RADIOTAP_DB_ANTNOISE] = 1,
	91	[IEEE80211_RADIOTAP_RX_FLAGS] = 2,
	92	[IEEE80211_RADIOTAP_TX_FLAGS] = 2,
	93	[IEEE80211_RADIOTAP_RTS_RETRIES] = 1,
	94	[IEEE80211_RADIOTAP_DATA_RETRIES] = 1,
	95	[IEEE80211_RADIOTAP_MCS] = 1,
	96	[IEEE80211_RADIOTAP_AMPDU_STATUS] = 4,
	97	[IEEE80211_RADIOTAP_VHT] = 2,
	98	[IEEE80211_RADIOTAP_TIMESTAMP] = 8,
	99	};
	100
	101	/* get offset of the specified flag, starting from start_off */
	102	static uint32_t rt_get_flag_offset(uint32_t pflags, uint32_t which, uint32_t start_off)
	103	{
	104	unsigned i,c=start_off;
	105	for(i=0;i<which;i++) if(pflags & (1U << i)) {
	106	c+= c & (ieee80211_radiotap_type_align[i]-1);
	107	c+= ieee80211_radiotap_type_size[i];
	108	}
	109	return c;
	110	}
	111
	112	#include <string.h>
	113
	114	#include "utils/endianness.h"
	115
	116	/* get present flags and offset of just after the radiotap header end.
	117	returns 1 on succes, 0 on bogus data */
	118	static int rt_get_presentflags(const void data, size_t len, uint32_t pflags, uint32_t *offset)
	119	{
	120	const struct ieee80211_radiotap_header* rh = data;
	121	offset = sizeof(rh);
	122	uint32_t fc = *pflags = end_le32toh(rh->it_present);
	123	while(fc & (1U << IEEE80211_RADIOTAP_EXT)) {
	124	if (*offset > len - 4) return 0;
	125	memcpy(&fc, data + *offset, 4);
	126	fc = end_le32toh(fc);
	127	*offset += 4;
	128	}
	129	return 1;
	130	}
	131
	132	#endif
	133

+30

-4

src/send.c less more

152	152	send_msg(SEND_WSC_NACK);
153	153	}
154	154
	155	/* store last packet */
	156	static size_t last_len;
	157	static unsigned char last_packet[4096];
	158
	159	int resend_last_packet(void) {
	160	return send_packet(last_packet, last_len, 0);
	161	}
	162
155	163	/*
156	164	* All transmissions are handled here to ensure that the receive timer
157	165	* is always started immediately after a packet is transmitted.
158	166	*/
159		int send_packet(const void *packet, size_t len, int use_timer)
160		{
	167	static int send_packet_real(const void *packet, size_t len, int use_timer) {
161	168	int ret_val = 0;
162	169
163	170	if(pcap_inject(get_handle(), packet, len) == len)
164	171	{
165	172	ret_val = 1;
166	173	}
167
168		if (use_timer) start_timer();
	174
	175	if (use_timer) {
	176	if(len < sizeof last_packet) {
	177	memcpy(last_packet, packet, len);
	178	last_len = len;
	179	}
	180	start_timer();
	181	}
169	182
170	183	return ret_val;
	184
171	185	}
	186
	187	int send_packet_internal(const char* callerfunc, const char* file, int callerline,
	188	const void *packet, size_t len, int use_timer)
	189	{
	190	cprintf(DEBUG, "send_packet called from %s() %s:%d\n", callerfunc, file, callerline);
	191	int i, ret;
	192	#define CNT 1
	193	for(i=0;i<CNT;i++) {
	194	ret = send_packet_real(packet, len, i==CNT-1 ? use_timer : 0);
	195	}
	196	return ret;
	197	}

-1

src/send.h less more

46	46	int send_msg(int type);
47	47	void send_termination();
48	48	void send_wsc_nack();
49		int send_packet(const void *packet, size_t len, int use_timer);
	49
	50	#define send_packet(a, b, c) send_packet_internal(__FUNCTION__, __FILE__, __LINE__, a, b, c)
	51
	52	int resend_last_packet(void);
	53	int send_packet_internal(const char* callerfunc, const char* file, int callerline,
	54	const void *packet, size_t len, int use_timer);
50	55
51	56	#endif

-1

src/session.c less more

284	284	}
285	285
286	286	/* If we got an SSID from the WPS data, then use that; else, use whatever was used to associate with the AP */
287		if(!essid \|\| strlen(essid) < 0)
	287	if(!essid \|\| strlen(essid) == 0)
288	288	{
289	289	essid = get_ssid();
290	290	}

-1

src/session.h less more

38	38	#include "defs.h"
39	39	#include "misc.h"
40	40	#include "globule.h"
41		#include "config.h"
42	41
43	42	#ifndef CONF_DIR
44	43	#define CONF_DIR "/etc/reaver"

+36

-21

src/sigalrm.c less more

31	31	*/
32	32
33	33	#include "sigalrm.h"
	34	#include "send.h"
34	35
35	36	/* Initializes SIGALRM handler */
36	37	void sigalrm_init()

43	44	sigaction (SIGALRM, &act, 0);
44	45	}
45	46
	47	static void rewind_timer() {
	48	struct itimerval timer = {0};
	49
	50	timer.it_value.tv_usec = globule->resend_timeout_usec;
	51
	52	set_out_of_time(0);
	53
	54	setitimer(ITIMER_REAL, &timer, 0);
	55	}
	56
	57	static unsigned timeout_ticks;
	58	static unsigned long long timeout_usec;
	59
46	60	/* Starts receive timer. Called from send_packet() after a packet is trasmitted */
47	61	void start_timer()
48	62	{
49		struct itimerval timer;
50	63	struct wps_data *wps = get_wps();
	64	timeout_ticks = 0;
51	65
52		memset(&timer, 0, sizeof(struct itimerval));
53
54		/*
	66	/*
55	67	* The M5 and M7 messages have very fast turn around times -
56		* typically a few hundreths of a second. We don't want to wait
57		* around forever to see if we get them or not, so use a short
58		* timeout value when waiting for those messages.
	68	* typically a few hundreths of a second. We don't want to wait
	69	* around forever to see if we get them or not, so use a short
	70	* timeout value when waiting for those messages.
59	71	* Ignore this timeout if we know the AP responds with NACKs when
60	72	* the wrong pin is supplied instead of not responding at all.
61	73	*/
62	74	if(get_timeout_is_nack() &&
63	75	(wps->state == RECV_M5 \|\| wps->state == RECV_M7))
64	76	{
65		timer.it_value.tv_usec = get_m57_timeout();
66		}
67		else
68		{
69		/*
70		* Other messages may take up to 2 seconds to respond -
71		* wait a little longer for them.
72		*/
73		timer.it_value.tv_sec = get_rx_timeout();
	77	timeout_usec = get_m57_timeout();
	78	} else {
	79	/*
	80	* Other messages may take up to 2 seconds to respond -
	81	* wait a little longer for them.
	82	*/
	83	timeout_usec = get_rx_timeout() * 1000000LL;
74	84	}
75	85
76		set_out_of_time(0);
77
78		setitimer(ITIMER_REAL, &timer, 0);
	86	rewind_timer();
79	87	}
80	88
81	89	/* Timer is stopped by process_packet() when any valid EAP packet is received */

93	101	/* Handles SIGALRM interrupts */
94	102	void alarm_handler(int x)
95	103	{
96		set_out_of_time(1);
97		cprintf(VERBOSE, "[!] WARNING: Receive timeout occurred\n");
	104	timeout_ticks++;
	105
	106	if(timeout_ticks * globule->resend_timeout_usec > timeout_usec) {
	107	set_out_of_time(1);
	108	cprintf(VERBOSE, "[!] WARNING: Receive timeout occurred\n");
	109	} else {
	110	resend_last_packet();
	111	rewind_timer();
	112	}
98	113	}
99	114

-11003

~~src/test~~ less more

0		8
1		0
2		0
3		1234
4		0000
5		0123
6		1111
7		2222
8		3333
9		4444
10		5555
11		6666
12		7777
13		8888
14		9999
15		0001
16		0002
17		0003
18		0004
19		0005
20		0006
21		0007
22		0008
23		0009
24		0010
25		0011
26		0012
27		0013
28		0014
29		0015
30		0016
31		0017
32		0018
33		0019
34		0020
35		0021
36		0022
37		0023
38		0024
39		0025
40		0026
41		0027
42		0028
43		0029
44		0030
45		0031
46		0032
47		0033
48		0034
49		0035
50		0036
51		0037
52		0038
53		0039
54		0040
55		0041
56		0042
57		0043
58		0044
59		0045
60		0046
61		0047
62		0048
63		0049
64		0050
65		0051
66		0052
67		0053
68		0054
69		0055
70		0056
71		0057
72		0058
73		0059
74		0060
75		0061
76		0062
77		0063
78		0064
79		0065
80		0066
81		0067
82		0068
83		0069
84		0070
85		0071
86		0072
87		0073
88		0074
89		0075
90		0076
91		0077
92		0078
93		0079
94		0080
95		0081
96		0082
97		0083
98		0084
99		0085
100		0086
101		0087
102		0088
103		0089
104		0090
105		0091
106		0092
107		0093
108		0094
109		0095
110		0096
111		0097
112		0098
113		0099
114		0100
115		0101
116		0102
117		0103
118		0104
119		0105
120		0106
121		0107
122		0108
123		0109
124		0110
125		0111
126		0112
127		0113
128		0114
129		0115
130		0116
131		0117
132		0118
133		0119
134		0120
135		0121
136		0122
137		0124
138		0125
139		0126
140		0127
141		0128
142		0129
143		0130
144		0131
145		0132
146		0133
147		0134
148		0135
149		0136
150		0137
151		0138
152		0139
153		0140
154		0141
155		0142
156		0143
157		0144
158		0145
159		0146
160		0147
161		0148
162		0149
163		0150
164		0151
165		0152
166		0153
167		0154
168		0155
169		0156
170		0157
171		0158
172		0159
173		0160
174		0161
175		0162
176		0163
177		0164
178		0165
179		0166
180		0167
181		0168
182		0169
183		0170
184		0171
185		0172
186		0173
187		0174
188		0175
189		0176
190		0177
191		0178
192		0179
193		0180
194		0181
195		0182
196		0183
197		0184
198		0185
199		0186
200		0187
201		0188
202		0189
203		0190
204		0191
205		0192
206		0193
207		0194
208		0195
209		0196
210		0197
211		0198
212		0199
213		0200
214		0201
215		0202
216		0203
217		0204
218		0205
219		0206
220		0207
221		0208
222		0209
223		0210
224		0211
225		0212
226		0213
227		0214
228		0215
229		0216
230		0217
231		0218
232		0219
233		0220
234		0221
235		0222
236		0223
237		0224
238		0225
239		0226
240		0227
241		0228
242		0229
243		0230
244		0231
245		0232
246		0233
247		0234
248		0235
249		0236
250		0237
251		0238
252		0239
253		0240
254		0241
255		0242
256		0243
257		0244
258		0245
259		0246
260		0247
261		0248
262		0249
263		0250
264		0251
265		0252
266		0253
267		0254
268		0255
269		0256
270		0257
271		0258
272		0259
273		0260
274		0261
275		0262
276		0263
277		0264
278		0265
279		0266
280		0267
281		0268
282		0269
283		0270
284		0271
285		0272
286		0273
287		0274
288		0275
289		0276
290		0277
291		0278
292		0279
293		0280
294		0281
295		0282
296		0283
297		0284
298		0285
299		0286
300		0287
301		0288
302		0289
303		0290
304		0291
305		0292
306		0293
307		0294
308		0295
309		0296
310		0297
311		0298
312		0299
313		0300
314		0301
315		0302
316		0303
317		0304
318		0305
319		0306
320		0307
321		0308
322		0309
323		0310
324		0311
325		0312
326		0313
327		0314
328		0315
329		0316
330		0317
331		0318
332		0319
333		0320
334		0321
335		0322
336		0323
337		0324
338		0325
339		0326
340		0327
341		0328
342		0329
343		0330
344		0331
345		0332
346		0333
347		0334
348		0335
349		0336
350		0337
351		0338
352		0339
353		0340
354		0341
355		0342
356		0343
357		0344
358		0345
359		0346
360		0347
361		0348
362		0349
363		0350
364		0351
365		0352
366		0353
367		0354
368		0355
369		0356
370		0357
371		0358
372		0359
373		0360
374		0361
375		0362
376		0363
377		0364
378		0365
379		0366
380		0367
381		0368
382		0369
383		0370
384		0371
385		0372
386		0373
387		0374
388		0375
389		0376
390		0377
391		0378
392		0379
393		0380
394		0381
395		0382
396		0383
397		0384
398		0385
399		0386
400		0387
401		0388
402		0389
403		0390
404		0391
405		0392
406		0393
407		0394
408		0395
409		0396
410		0397
411		0398
412		0399
413		0400
414		0401
415		0402
416		0403
417		0404
418		0405
419		0406
420		0407
421		0408
422		0409
423		0410
424		0411
425		0412
426		0413
427		0414
428		0415
429		0416
430		0417
431		0418
432		0419
433		0420
434		0421
435		0422
436		0423
437		0424
438		0425
439		0426
440		0427
441		0428
442		0429
443		0430
444		0431
445		0432
446		0433
447		0434
448		0435
449		0436
450		0437
451		0438
452		0439
453		0440
454		0441
455		0442
456		0443
457		0444
458		0445
459		0446
460		0447
461		0448
462		0449
463		0450
464		0451
465		0452
466		0453
467		0454
468		0455
469		0456
470		0457
471		0458
472		0459
473		0460
474		0461
475		0462
476		0463
477		0464
478		0465
479		0466
480		0467
481		0468
482		0469
483		0470
484		0471
485		0472
486		0473
487		0474
488		0475
489		0476
490		0477
491		0478
492		0479
493		0480
494		0481
495		0482
496		0483
497		0484
498		0485
499		0486
500		0487
501		0488
502		0489
503		0490
504		0491
505		0492
506		0493
507		0494
508		0495
509		0496
510		0497
511		0498
512		0499
513		0500
514		0501
515		0502
516		0503
517		0504
518		0505
519		0506
520		0507
521		0508
522		0509
523		0510
524		0511
525		0512
526		0513
527		0514
528		0515
529		0516
530		0517
531		0518
532		0519
533		0520
534		0521
535		0522
536		0523
537		0524
538		0525
539		0526
540		0527
541		0528
542		0529
543		0530
544		0531
545		0532
546		0533
547		0534
548		0535
549		0536
550		0537
551		0538
552		0539
553		0540
554		0541
555		0542
556		0543
557		0544
558		0545
559		0546
560		0547
561		0548
562		0549
563		0550
564		0551
565		0552
566		0553
567		0554
568		0555
569		0556
570		0557
571		0558
572		0559
573		0560
574		0561
575		0562
576		0563
577		0564
578		0565
579		0566
580		0567
581		0568
582		0569
583		0570
584		0571
585		0572
586		0573
587		0574
588		0575
589		0576
590		0577
591		0578
592		0579
593		0580
594		0581
595		0582
596		0583
597		0584
598		0585
599		0586
600		0587
601		0588
602		0589
603		0590
604		0591
605		0592
606		0593
607		0594
608		0595
609		0596
610		0597
611		0598
612		0599
613		0600
614		0601
615		0602
616		0603
617		0604
618		0605
619		0606
620		0607
621		0608
622		0609
623		0610
624		0611
625		0612
626		0613
627		0614
628		0615
629		0616
630		0617
631		0618
632		0619
633		0620
634		0621
635		0622
636		0623
637		0624
638		0625
639		0626
640		0627
641		0628
642		0629
643		0630
644		0631
645		0632
646		0633
647		0634
648		0635
649		0636
650		0637
651		0638
652		0639
653		0640
654		0641
655		0642
656		0643
657		0644
658		0645
659		0646
660		0647
661		0648
662		0649
663		0650
664		0651
665		0652
666		0653
667		0654
668		0655
669		0656
670		0657
671		0658
672		0659
673		0660
674		0661
675		0662
676		0663
677		0664
678		0665
679		0666
680		0667
681		0668
682		0669
683		0670
684		0671
685		0672
686		0673
687		0674
688		0675
689		0676
690		0677
691		0678
692		0679
693		0680
694		0681
695		0682
696		0683
697		0684
698		0685
699		0686
700		0687
701		0688
702		0689
703		0690
704		0691
705		0692
706		0693
707		0694
708		0695
709		0696
710		0697
711		0698
712		0699
713		0700
714		0701
715		0702
716		0703
717		0704
718		0705
719		0706
720		0707
721		0708
722		0709
723		0710
724		0711
725		0712
726		0713
727		0714
728		0715
729		0716
730		0717
731		0718
732		0719
733		0720
734		0721
735		0722
736		0723
737		0724
738		0725
739		0726
740		0727
741		0728
742		0729
743		0730
744		0731
745		0732
746		0733
747		0734
748		0735
749		0736
750		0737
751		0738
752		0739
753		0740
754		0741
755		0742
756		0743
757		0744
758		0745
759		0746
760		0747
761		0748
762		0749
763		0750
764		0751
765		0752
766		0753
767		0754
768		0755
769		0756
770		0757
771		0758
772		0759
773		0760
774		0761
775		0762
776		0763
777		0764
778		0765
779		0766
780		0767
781		0768
782		0769
783		0770
784		0771
785		0772
786		0773
787		0774
788		0775
789		0776
790		0777
791		0778
792		0779
793		0780
794		0781
795		0782
796		0783
797		0784
798		0785
799		0786
800		0787
801		0788
802		0789
803		0790
804		0791
805		0792
806		0793
807		0794
808		0795
809		0796
810		0797
811		0798
812		0799
813		0800
814		0801
815		0802
816		0803
817		0804
818		0805
819		0806
820		0807
821		0808
822		0809
823		0810
824		0811
825		0812
826		0813
827		0814
828		0815
829		0816
830		0817
831		0818
832		0819
833		0820
834		0821
835		0822
836		0823
837		0824
838		0825
839		0826
840		0827
841		0828
842		0829
843		0830
844		0831
845		0832
846		0833
847		0834
848		0835
849		0836
850		0837
851		0838
852		0839
853		0840
854		0841
855		0842
856		0843
857		0844
858		0845
859		0846
860		0847
861		0848
862		0849
863		0850
864		0851
865		0852
866		0853
867		0854
868		0855
869		0856
870		0857
871		0858
872		0859
873		0860
874		0861
875		0862
876		0863
877		0864
878		0865
879		0866
880		0867
881		0868
882		0869
883		0870
884		0871
885		0872
886		0873
887		0874
888		0875
889		0876
890		0877
891		0878
892		0879
893		0880
894		0881
895		0882
896		0883
897		0884
898		0885
899		0886
900		0887
901		0888
902		0889
903		0890
904		0891
905		0892
906		0893
907		0894
908		0895
909		0896
910		0897
911		0898
912		0899
913		0900
914		0901
915		0902
916		0903
917		0904
918		0905
919		0906
920		0907
921		0908
922		0909
923		0910
924		0911
925		0912
926		0913
927		0914
928		0915
929		0916
930		0917
931		0918
932		0919
933		0920
934		0921
935		0922
936		0923
937		0924
938		0925
939		0926
940		0927
941		0928
942		0929
943		0930
944		0931
945		0932
946		0933
947		0934
948		0935
949		0936
950		0937
951		0938
952		0939
953		0940
954		0941
955		0942
956		0943
957		0944
958		0945
959		0946
960		0947
961		0948
962		0949
963		0950
964		0951
965		0952
966		0953
967		0954
968		0955
969		0956
970		0957
971		0958
972		0959
973		0960
974		0961
975		0962
976		0963
977		0964
978		0965
979		0966
980		0967
981		0968
982		0969
983		0970
984		0971
985		0972
986		0973
987		0974
988		0975
989		0976
990		0977
991		0978
992		0979
993		0980
994		0981
995		0982
996		0983
997		0984
998		0985
999		0986
1000		0987
1001		0988
1002		0989
1003		0990
1004		0991
1005		0992
1006		0993
1007		0994
1008		0995
1009		0996
1010		0997
1011		0998
1012		0999
1013		1000
1014		1001
1015		1002
1016		1003
1017		1004
1018		1005
1019		1006
1020		1007
1021		1008
1022		1009
1023		1010
1024		1011
1025		1012
1026		1013
1027		1014
1028		1015
1029		1016
1030		1017
1031		1018
1032		1019
1033		1020
1034		1021
1035		1022
1036		1023
1037		1024
1038		1025
1039		1026
1040		1027
1041		1028
1042		1029
1043		1030
1044		1031
1045		1032
1046		1033
1047		1034
1048		1035
1049		1036
1050		1037
1051		1038
1052		1039
1053		1040
1054		1041
1055		1042
1056		1043
1057		1044
1058		1045
1059		1046
1060		1047
1061		1048
1062		1049
1063		1050
1064		1051
1065		1052
1066		1053
1067		1054
1068		1055
1069		1056
1070		1057
1071		1058
1072		1059
1073		1060
1074		1061
1075		1062
1076		1063
1077		1064
1078		1065
1079		1066
1080		1067
1081		1068
1082		1069
1083		1070
1084		1071
1085		1072
1086		1073
1087		1074
1088		1075
1089		1076
1090		1077
1091		1078
1092		1079
1093		1080
1094		1081
1095		1082
1096		1083
1097		1084
1098		1085
1099		1086
1100		1087
1101		1088
1102		1089
1103		1090
1104		1091
1105		1092
1106		1093
1107		1094
1108		1095
1109		1096
1110		1097
1111		1098
1112		1099
1113		1100
1114		1101
1115		1102
1116		1103
1117		1104
1118		1105
1119		1106
1120		1107
1121		1108
1122		1109
1123		1110
1124		1112
1125		1113
1126		1114
1127		1115
1128		1116
1129		1117
1130		1118
1131		1119
1132		1120
1133		1121
1134		1122
1135		1123
1136		1124
1137		1125
1138		1126
1139		1127
1140		1128
1141		1129
1142		1130
1143		1131
1144		1132
1145		1133
1146		1134
1147		1135
1148		1136
1149		1137
1150		1138
1151		1139
1152		1140
1153		1141
1154		1142
1155		1143
1156		1144
1157		1145
1158		1146
1159		1147
1160		1148
1161		1149
1162		1150
1163		1151
1164		1152
1165		1153
1166		1154
1167		1155
1168		1156
1169		1157
1170		1158
1171		1159
1172		1160
1173		1161
1174		1162
1175		1163
1176		1164
1177		1165
1178		1166
1179		1167
1180		1168
1181		1169
1182		1170
1183		1171
1184		1172
1185		1173
1186		1174
1187		1175
1188		1176
1189		1177
1190		1178
1191		1179
1192		1180
1193		1181
1194		1182
1195		1183
1196		1184
1197		1185
1198		1186
1199		1187
1200		1188
1201		1189
1202		1190
1203		1191
1204		1192
1205		1193
1206		1194
1207		1195
1208		1196
1209		1197
1210		1198
1211		1199
1212		1200
1213		1201
1214		1202
1215		1203
1216		1204
1217		1205
1218		1206
1219		1207
1220		1208
1221		1209
1222		1210
1223		1211
1224		1212
1225		1213
1226		1214
1227		1215
1228		1216
1229		1217
1230		1218
1231		1219
1232		1220
1233		1221
1234		1222
1235		1223
1236		1224
1237		1225
1238		1226
1239		1227
1240		1228
1241		1229
1242		1230
1243		1231
1244		1232
1245		1233
1246		1235
1247		1236
1248		1237
1249		1238
1250		1239
1251		1240
1252		1241
1253		1242
1254		1243
1255		1244
1256		1245
1257		1246
1258		1247
1259		1248
1260		1249
1261		1250
1262		1251
1263		1252
1264		1253
1265		1254
1266		1255
1267		1256
1268		1257
1269		1258
1270		1259
1271		1260
1272		1261
1273		1262
1274		1263
1275		1264
1276		1265
1277		1266
1278		1267
1279		1268
1280		1269
1281		1270
1282		1271
1283		1272
1284		1273
1285		1274
1286		1275
1287		1276
1288		1277
1289		1278
1290		1279
1291		1280
1292		1281
1293		1282
1294		1283
1295		1284
1296		1285
1297		1286
1298		1287
1299		1288
1300		1289
1301		1290
1302		1291
1303		1292
1304		1293
1305		1294
1306		1295
1307		1296
1308		1297
1309		1298
1310		1299
1311		1300
1312		1301
1313		1302
1314		1303
1315		1304
1316		1305
1317		1306
1318		1307
1319		1308
1320		1309
1321		1310
1322		1311
1323		1312
1324		1313
1325		1314
1326		1315
1327		1316
1328		1317
1329		1318
1330		1319
1331		1320
1332		1321
1333		1322
1334		1323
1335		1324
1336		1325
1337		1326
1338		1327
1339		1328
1340		1329
1341		1330
1342		1331
1343		1332
1344		1333
1345		1334
1346		1335
1347		1336
1348		1337
1349		1338
1350		1339
1351		1340
1352		1341
1353		1342
1354		1343
1355		1344
1356		1345
1357		1346
1358		1347
1359		1348
1360		1349
1361		1350
1362		1351
1363		1352
1364		1353
1365		1354
1366		1355
1367		1356
1368		1357
1369		1358
1370		1359
1371		1360
1372		1361
1373		1362
1374		1363
1375		1364
1376		1365
1377		1366
1378		1367
1379		1368
1380		1369
1381		1370
1382		1371
1383		1372
1384		1373
1385		1374
1386		1375
1387		1376
1388		1377
1389		1378
1390		1379
1391		1380
1392		1381
1393		1382
1394		1383
1395		1384
1396		1385
1397		1386
1398		1387
1399		1388
1400		1389
1401		1390
1402		1391
1403		1392
1404		1393
1405		1394
1406		1395
1407		1396
1408		1397
1409		1398
1410		1399
1411		1400
1412		1401
1413		1402
1414		1403
1415		1404
1416		1405
1417		1406
1418		1407
1419		1408
1420		1409
1421		1410
1422		1411
1423		1412
1424		1413
1425		1414
1426		1415
1427		1416
1428		1417
1429		1418
1430		1419
1431		1420
1432		1421
1433		1422
1434		1423
1435		1424
1436		1425
1437		1426
1438		1427
1439		1428
1440		1429
1441		1430
1442		1431
1443		1432
1444		1433
1445		1434
1446		1435
1447		1436
1448		1437
1449		1438
1450		1439
1451		1440
1452		1441
1453		1442
1454		1443
1455		1444
1456		1445
1457		1446
1458		1447
1459		1448
1460		1449
1461		1450
1462		1451
1463		1452
1464		1453
1465		1454
1466		1455
1467		1456
1468		1457
1469		1458
1470		1459
1471		1460
1472		1461
1473		1462
1474		1463
1475		1464
1476		1465
1477		1466
1478		1467
1479		1468
1480		1469
1481		1470
1482		1471
1483		1472
1484		1473
1485		1474
1486		1475
1487		1476
1488		1477
1489		1478
1490		1479
1491		1480
1492		1481
1493		1482
1494		1483
1495		1484
1496		1485
1497		1486
1498		1487
1499		1488
1500		1489
1501		1490
1502		1491
1503		1492
1504		1493
1505		1494
1506		1495
1507		1496
1508		1497
1509		1498
1510		1499
1511		1500
1512		1501
1513		1502
1514		1503
1515		1504
1516		1505
1517		1506
1518		1507
1519		1508
1520		1509
1521		1510
1522		1511
1523		1512
1524		1513
1525		1514
1526		1515
1527		1516
1528		1517
1529		1518
1530		1519
1531		1520
1532		1521
1533		1522
1534		1523
1535		1524
1536		1525
1537		1526
1538		1527
1539		1528
1540		1529
1541		1530
1542		1531
1543		1532
1544		1533
1545		1534
1546		1535
1547		1536
1548		1537
1549		1538
1550		1539
1551		1540
1552		1541
1553		1542
1554		1543
1555		1544
1556		1545
1557		1546
1558		1547
1559		1548
1560		1549
1561		1550
1562		1551
1563		1552
1564		1553
1565		1554
1566		1555
1567		1556
1568		1557
1569		1558
1570		1559
1571		1560
1572		1561
1573		1562
1574		1563
1575		1564
1576		1565
1577		1566
1578		1567
1579		1568
1580		1569
1581		1570
1582		1571
1583		1572
1584		1573
1585		1574
1586		1575
1587		1576
1588		1577
1589		1578
1590		1579
1591		1580
1592		1581
1593		1582
1594		1583
1595		1584
1596		1585
1597		1586
1598		1587
1599		1588
1600		1589
1601		1590
1602		1591
1603		1592
1604		1593
1605		1594
1606		1595
1607		1596
1608		1597
1609		1598
1610		1599
1611		1600
1612		1601
1613		1602
1614		1603
1615		1604
1616		1605
1617		1606
1618		1607
1619		1608
1620		1609
1621		1610
1622		1611
1623		1612
1624		1613
1625		1614
1626		1615
1627		1616
1628		1617
1629		1618
1630		1619
1631		1620
1632		1621
1633		1622
1634		1623
1635		1624
1636		1625
1637		1626
1638		1627
1639		1628
1640		1629
1641		1630
1642		1631
1643		1632
1644		1633
1645		1634
1646		1635
1647		1636
1648		1637
1649		1638
1650		1639
1651		1640
1652		1641
1653		1642
1654		1643
1655		1644
1656		1645
1657		1646
1658		1647
1659		1648
1660		1649
1661		1650
1662		1651
1663		1652
1664		1653
1665		1654
1666		1655
1667		1656
1668		1657
1669		1658
1670		1659
1671		1660
1672		1661
1673		1662
1674		1663
1675		1664
1676		1665
1677		1666
1678		1667
1679		1668
1680		1669
1681		1670
1682		1671
1683		1672
1684		1673
1685		1674
1686		1675
1687		1676
1688		1677
1689		1678
1690		1679
1691		1680
1692		1681
1693		1682
1694		1683
1695		1684
1696		1685
1697		1686
1698		1687
1699		1688
1700		1689
1701		1690
1702		1691
1703		1692
1704		1693
1705		1694
1706		1695
1707		1696
1708		1697
1709		1698
1710		1699
1711		1700
1712		1701
1713		1702
1714		1703
1715		1704
1716		1705
1717		1706
1718		1707
1719		1708
1720		1709
1721		1710
1722		1711
1723		1712
1724		1713
1725		1714
1726		1715
1727		1716
1728		1717
1729		1718
1730		1719
1731		1720
1732		1721
1733		1722
1734		1723
1735		1724
1736		1725
1737		1726
1738		1727
1739		1728
1740		1729
1741		1730
1742		1731
1743		1732
1744		1733
1745		1734
1746		1735
1747		1736
1748		1737
1749		1738
1750		1739
1751		1740
1752		1741
1753		1742
1754		1743
1755		1744
1756		1745
1757		1746
1758		1747
1759		1748
1760		1749
1761		1750
1762		1751
1763		1752
1764		1753
1765		1754
1766		1755
1767		1756
1768		1757
1769		1758
1770		1759
1771		1760
1772		1761
1773		1762
1774		1763
1775		1764
1776		1765
1777		1766
1778		1767
1779		1768
1780		1769
1781		1770
1782		1771
1783		1772
1784		1773
1785		1774
1786		1775
1787		1776
1788		1777
1789		1778
1790		1779
1791		1780
1792		1781
1793		1782
1794		1783
1795		1784
1796		1785
1797		1786
1798		1787
1799		1788
1800		1789
1801		1790
1802		1791
1803		1792
1804		1793
1805		1794
1806		1795
1807		1796
1808		1797
1809		1798
1810		1799
1811		1800
1812		1801
1813		1802
1814		1803
1815		1804
1816		1805
1817		1806
1818		1807
1819		1808
1820		1809
1821		1810
1822		1811
1823		1812
1824		1813
1825		1814
1826		1815
1827		1816
1828		1817
1829		1818
1830		1819
1831		1820
1832		1821
1833		1822
1834		1823
1835		1824
1836		1825
1837		1826
1838		1827
1839		1828
1840		1829
1841		1830
1842		1831
1843		1832
1844		1833
1845		1834
1846		1835
1847		1836
1848		1837
1849		1838
1850		1839
1851		1840
1852		1841
1853		1842
1854		1843
1855		1844
1856		1845
1857		1846
1858		1847
1859		1848
1860		1849
1861		1850
1862		1851
1863		1852
1864		1853
1865		1854
1866		1855
1867		1856
1868		1857
1869		1858
1870		1859
1871		1860
1872		1861
1873		1862
1874		1863
1875		1864
1876		1865
1877		1866
1878		1867
1879		1868
1880		1869
1881		1870
1882		1871
1883		1872
1884		1873
1885		1874
1886		1875
1887		1876
1888		1877
1889		1878
1890		1879
1891		1880
1892		1881
1893		1882
1894		1883
1895		1884
1896		1885
1897		1886
1898		1887
1899		1888
1900		1889
1901		1890
1902		1891
1903		1892
1904		1893
1905		1894
1906		1895
1907		1896
1908		1897
1909		1898
1910		1899
1911		1900
1912		1901
1913		1902
1914		1903
1915		1904
1916		1905
1917		1906
1918		1907
1919		1908
1920		1909
1921		1910
1922		1911
1923		1912
1924		1913
1925		1914
1926		1915
1927		1916
1928		1917
1929		1918
1930		1919
1931		1920
1932		1921
1933		1922
1934		1923
1935		1924
1936		1925
1937		1926
1938		1927
1939		1928
1940		1929
1941		1930
1942		1931
1943		1932
1944		1933
1945		1934
1946		1935
1947		1936
1948		1937
1949		1938
1950		1939
1951		1940
1952		1941
1953		1942
1954		1943
1955		1944
1956		1945
1957		1946
1958		1947
1959		1948
1960		1949
1961		1950
1962		1951
1963		1952
1964		1953
1965		1954
1966		1955
1967		1956
1968		1957
1969		1958
1970		1959
1971		1960
1972		1961
1973		1962
1974		1963
1975		1964
1976		1965
1977		1966
1978		1967
1979		1968
1980		1969
1981		1970
1982		1971
1983		1972
1984		1973
1985		1974
1986		1975
1987		1976
1988		1977
1989		1978
1990		1979
1991		1980
1992		1981
1993		1982
1994		1983
1995		1984
1996		1985
1997		1986
1998		1987
1999		1988
2000		1989
2001		1990
2002		1991
2003		1992
2004		1993
2005		1994
2006		1995
2007		1996
2008		1997
2009		1998
2010		1999
2011		2000
2012		2001
2013		2002
2014		2003
2015		2004
2016		2005
2017		2006
2018		2007
2019		2008
2020		2009
2021		2010
2022		2011
2023		2012
2024		2013
2025		2014
2026		2015
2027		2016
2028		2017
2029		2018
2030		2019
2031		2020
2032		2021
2033		2022
2034		2023
2035		2024
2036		2025
2037		2026
2038		2027
2039		2028
2040		2029
2041		2030
2042		2031
2043		2032
2044		2033
2045		2034
2046		2035
2047		2036
2048		2037
2049		2038
2050		2039
2051		2040
2052		2041
2053		2042
2054		2043
2055		2044
2056		2045
2057		2046
2058		2047
2059		2048
2060		2049
2061		2050
2062		2051
2063		2052
2064		2053
2065		2054
2066		2055
2067		2056
2068		2057
2069		2058
2070		2059
2071		2060
2072		2061
2073		2062
2074		2063
2075		2064
2076		2065
2077		2066
2078		2067
2079		2068
2080		2069
2081		2070
2082		2071
2083		2072
2084		2073
2085		2074
2086		2075
2087		2076
2088		2077
2089		2078
2090		2079
2091		2080
2092		2081
2093		2082
2094		2083
2095		2084
2096		2085
2097		2086
2098		2087
2099		2088
2100		2089
2101		2090
2102		2091
2103		2092
2104		2093
2105		2094
2106		2095
2107		2096
2108		2097
2109		2098
2110		2099
2111		2100
2112		2101
2113		2102
2114		2103
2115		2104
2116		2105
2117		2106
2118		2107
2119		2108
2120		2109
2121		2110
2122		2111
2123		2112
2124		2113
2125		2114
2126		2115
2127		2116
2128		2117
2129		2118
2130		2119
2131		2120
2132		2121
2133		2122
2134		2123
2135		2124
2136		2125
2137		2126
2138		2127
2139		2128
2140		2129
2141		2130
2142		2131
2143		2132
2144		2133
2145		2134
2146		2135
2147		2136
2148		2137
2149		2138
2150		2139
2151		2140
2152		2141
2153		2142
2154		2143
2155		2144
2156		2145
2157		2146
2158		2147
2159		2148
2160		2149
2161		2150
2162		2151
2163		2152
2164		2153
2165		2154
2166		2155
2167		2156
2168		2157
2169		2158
2170		2159
2171		2160
2172		2161
2173		2162
2174		2163
2175		2164
2176		2165
2177		2166
2178		2167
2179		2168
2180		2169
2181		2170
2182		2171
2183		2172
2184		2173
2185		2174
2186		2175
2187		2176
2188		2177
2189		2178
2190		2179
2191		2180
2192		2181
2193		2182
2194		2183
2195		2184
2196		2185
2197		2186
2198		2187
2199		2188
2200		2189
2201		2190
2202		2191
2203		2192
2204		2193
2205		2194
2206		2195
2207		2196
2208		2197
2209		2198
2210		2199
2211		2200
2212		2201
2213		2202
2214		2203
2215		2204
2216		2205
2217		2206
2218		2207
2219		2208
2220		2209
2221		2210
2222		2211
2223		2212
2224		2213
2225		2214
2226		2215
2227		2216
2228		2217
2229		2218
2230		2219
2231		2220
2232		2221
2233		2223
2234		2224
2235		2225
2236		2226
2237		2227
2238		2228
2239		2229
2240		2230
2241		2231
2242		2232
2243		2233
2244		2234
2245		2235
2246		2236
2247		2237
2248		2238
2249		2239
2250		2240
2251		2241
2252		2242
2253		2243
2254		2244
2255		2245
2256		2246
2257		2247
2258		2248
2259		2249
2260		2250
2261		2251
2262		2252
2263		2253
2264		2254
2265		2255
2266		2256
2267		2257
2268		2258
2269		2259
2270		2260
2271		2261
2272		2262
2273		2263
2274		2264
2275		2265
2276		2266
2277		2267
2278		2268
2279		2269
2280		2270
2281		2271
2282		2272
2283		2273
2284		2274
2285		2275
2286		2276
2287		2277
2288		2278
2289		2279
2290		2280
2291		2281
2292		2282
2293		2283
2294		2284
2295		2285
2296		2286
2297		2287
2298		2288
2299		2289
2300		2290
2301		2291
2302		2292
2303		2293
2304		2294
2305		2295
2306		2296
2307		2297
2308		2298
2309		2299
2310		2300
2311		2301
2312		2302
2313		2303
2314		2304
2315		2305
2316		2306
2317		2307
2318		2308
2319		2309
2320		2310
2321		2311
2322		2312
2323		2313
2324		2314
2325		2315
2326		2316
2327		2317
2328		2318
2329		2319
2330		2320
2331		2321
2332		2322
2333		2323
2334		2324
2335		2325
2336		2326
2337		2327
2338		2328
2339		2329
2340		2330
2341		2331
2342		2332
2343		2333
2344		2334
2345		2335
2346		2336
2347		2337
2348		2338
2349		2339
2350		2340
2351		2341
2352		2342
2353		2343
2354		2344
2355		2345
2356		2346
2357		2347
2358		2348
2359		2349
2360		2350
2361		2351
2362		2352
2363		2353
2364		2354
2365		2355
2366		2356
2367		2357
2368		2358
2369		2359
2370		2360
2371		2361
2372		2362
2373		2363
2374		2364
2375		2365
2376		2366
2377		2367
2378		2368
2379		2369
2380		2370
2381		2371
2382		2372
2383		2373
2384		2374
2385		2375
2386		2376
2387		2377
2388		2378
2389		2379
2390		2380
2391		2381
2392		2382
2393		2383
2394		2384
2395		2385
2396		2386
2397		2387
2398		2388
2399		2389
2400		2390
2401		2391
2402		2392
2403		2393
2404		2394
2405		2395
2406		2396
2407		2397
2408		2398
2409		2399
2410		2400
2411		2401
2412		2402
2413		2403
2414		2404
2415		2405
2416		2406
2417		2407
2418		2408
2419		2409
2420		2410
2421		2411
2422		2412
2423		2413
2424		2414
2425		2415
2426		2416
2427		2417
2428		2418
2429		2419
2430		2420
2431		2421
2432		2422
2433		2423
2434		2424
2435		2425
2436		2426
2437		2427
2438		2428
2439		2429
2440		2430
2441		2431
2442		2432
2443		2433
2444		2434
2445		2435
2446		2436
2447		2437
2448		2438
2449		2439
2450		2440
2451		2441
2452		2442
2453		2443
2454		2444
2455		2445
2456		2446
2457		2447
2458		2448
2459		2449
2460		2450
2461		2451
2462		2452
2463		2453
2464		2454
2465		2455
2466		2456
2467		2457
2468		2458
2469		2459
2470		2460
2471		2461
2472		2462
2473		2463
2474		2464
2475		2465
2476		2466
2477		2467
2478		2468
2479		2469
2480		2470
2481		2471
2482		2472
2483		2473
2484		2474
2485		2475
2486		2476
2487		2477
2488		2478
2489		2479
2490		2480
2491		2481
2492		2482
2493		2483
2494		2484
2495		2485
2496		2486
2497		2487
2498		2488
2499		2489
2500		2490
2501		2491
2502		2492
2503		2493
2504		2494
2505		2495
2506		2496
2507		2497
2508		2498
2509		2499
2510		2500
2511		2501
2512		2502
2513		2503
2514		2504
2515		2505
2516		2506
2517		2507
2518		2508
2519		2509
2520		2510
2521		2511
2522		2512
2523		2513
2524		2514
2525		2515
2526		2516
2527		2517
2528		2518
2529		2519
2530		2520
2531		2521
2532		2522
2533		2523
2534		2524
2535		2525
2536		2526
2537		2527
2538		2528
2539		2529
2540		2530
2541		2531
2542		2532
2543		2533
2544		2534
2545		2535
2546		2536
2547		2537
2548		2538
2549		2539
2550		2540
2551		2541
2552		2542
2553		2543
2554		2544
2555		2545
2556		2546
2557		2547
2558		2548
2559		2549
2560		2550
2561		2551
2562		2552
2563		2553
2564		2554
2565		2555
2566		2556
2567		2557
2568		2558
2569		2559
2570		2560
2571		2561
2572		2562
2573		2563
2574		2564
2575		2565
2576		2566
2577		2567
2578		2568
2579		2569
2580		2570
2581		2571
2582		2572
2583		2573
2584		2574
2585		2575
2586		2576
2587		2577
2588		2578
2589		2579
2590		2580
2591		2581
2592		2582
2593		2583
2594		2584
2595		2585
2596		2586
2597		2587
2598		2588
2599		2589
2600		2590
2601		2591
2602		2592
2603		2593
2604		2594
2605		2595
2606		2596
2607		2597
2608		2598
2609		2599
2610		2600
2611		2601
2612		2602
2613		2603
2614		2604
2615		2605
2616		2606
2617		2607
2618		2608
2619		2609
2620		2610
2621		2611
2622		2612
2623		2613
2624		2614
2625		2615
2626		2616
2627		2617
2628		2618
2629		2619
2630		2620
2631		2621
2632		2622
2633		2623
2634		2624
2635		2625
2636		2626
2637		2627
2638		2628
2639		2629
2640		2630
2641		2631
2642		2632
2643		2633
2644		2634
2645		2635
2646		2636
2647		2637
2648		2638
2649		2639
2650		2640
2651		2641
2652		2642
2653		2643
2654		2644
2655		2645
2656		2646
2657		2647
2658		2648
2659		2649
2660		2650
2661		2651
2662		2652
2663		2653
2664		2654
2665		2655
2666		2656
2667		2657
2668		2658
2669		2659
2670		2660
2671		2661
2672		2662
2673		2663
2674		2664
2675		2665
2676		2666
2677		2667
2678		2668
2679		2669
2680		2670
2681		2671
2682		2672
2683		2673
2684		2674
2685		2675
2686		2676
2687		2677
2688		2678
2689		2679
2690		2680
2691		2681
2692		2682
2693		2683
2694		2684
2695		2685
2696		2686
2697		2687
2698		2688
2699		2689
2700		2690
2701		2691
2702		2692
2703		2693
2704		2694
2705		2695
2706		2696
2707		2697
2708		2698
2709		2699
2710		2700
2711		2701
2712		2702
2713		2703
2714		2704
2715		2705
2716		2706
2717		2707
2718		2708
2719		2709
2720		2710
2721		2711
2722		2712
2723		2713
2724		2714
2725		2715
2726		2716
2727		2717
2728		2718
2729		2719
2730		2720
2731		2721
2732		2722
2733		2723
2734		2724
2735		2725
2736		2726
2737		2727
2738		2728
2739		2729
2740		2730
2741		2731
2742		2732
2743		2733
2744		2734
2745		2735
2746		2736
2747		2737
2748		2738
2749		2739
2750		2740
2751		2741
2752		2742
2753		2743
2754		2744
2755		2745
2756		2746
2757		2747
2758		2748
2759		2749
2760		2750
2761		2751
2762		2752
2763		2753
2764		2754
2765		2755
2766		2756
2767		2757
2768		2758
2769		2759
2770		2760
2771		2761
2772		2762
2773		2763
2774		2764
2775		2765
2776		2766
2777		2767
2778		2768
2779		2769
2780		2770
2781		2771
2782		2772
2783		2773
2784		2774
2785		2775
2786		2776
2787		2777
2788		2778
2789		2779
2790		2780
2791		2781
2792		2782
2793		2783
2794		2784
2795		2785
2796		2786
2797		2787
2798		2788
2799		2789
2800		2790
2801		2791
2802		2792
2803		2793
2804		2794
2805		2795
2806		2796
2807		2797
2808		2798
2809		2799
2810		2800
2811		2801
2812		2802
2813		2803
2814		2804
2815		2805
2816		2806
2817		2807
2818		2808
2819		2809
2820		2810
2821		2811
2822		2812
2823		2813
2824		2814
2825		2815
2826		2816
2827		2817
2828		2818
2829		2819
2830		2820
2831		2821
2832		2822
2833		2823
2834		2824
2835		2825
2836		2826
2837		2827
2838		2828
2839		2829
2840		2830
2841		2831
2842		2832
2843		2833
2844		2834
2845		2835
2846		2836
2847		2837
2848		2838
2849		2839
2850		2840
2851		2841
2852		2842
2853		2843
2854		2844
2855		2845
2856		2846
2857		2847
2858		2848
2859		2849
2860		2850
2861		2851
2862		2852
2863		2853
2864		2854
2865		2855
2866		2856
2867		2857
2868		2858
2869		2859
2870		2860
2871		2861
2872		2862
2873		2863
2874		2864
2875		2865
2876		2866
2877		2867
2878		2868
2879		2869
2880		2870
2881		2871
2882		2872
2883		2873
2884		2874
2885		2875
2886		2876
2887		2877
2888		2878
2889		2879
2890		2880
2891		2881
2892		2882
2893		2883
2894		2884
2895		2885
2896		2886
2897		2887
2898		2888
2899		2889
2900		2890
2901		2891
2902		2892
2903		2893
2904		2894
2905		2895
2906		2896
2907		2897
2908		2898
2909		2899
2910		2900
2911		2901
2912		2902
2913		2903
2914		2904
2915		2905
2916		2906
2917		2907
2918		2908
2919		2909
2920		2910
2921		2911
2922		2912
2923		2913
2924		2914
2925		2915
2926		2916
2927		2917
2928		2918
2929		2919
2930		2920
2931		2921
2932		2922
2933		2923
2934		2924
2935		2925
2936		2926
2937		2927
2938		2928
2939		2929
2940		2930
2941		2931
2942		2932
2943		2933
2944		2934
2945		2935
2946		2936
2947		2937
2948		2938
2949		2939
2950		2940
2951		2941
2952		2942
2953		2943
2954		2944
2955		2945
2956		2946
2957		2947
2958		2948
2959		2949
2960		2950
2961		2951
2962		2952
2963		2953
2964		2954
2965		2955
2966		2956
2967		2957
2968		2958
2969		2959
2970		2960
2971		2961
2972		2962
2973		2963
2974		2964
2975		2965
2976		2966
2977		2967
2978		2968
2979		2969
2980		2970
2981		2971
2982		2972
2983		2973
2984		2974
2985		2975
2986		2976
2987		2977
2988		2978
2989		2979
2990		2980
2991		2981
2992		2982
2993		2983
2994		2984
2995		2985
2996		2986
2997		2987
2998		2988
2999		2989
3000		2990
3001		2991
3002		2992
3003		2993
3004		2994
3005		2995
3006		2996
3007		2997
3008		2998
3009		2999
3010		3000
3011		3001
3012		3002
3013		3003
3014		3004
3015		3005
3016		3006
3017		3007
3018		3008
3019		3009
3020		3010
3021		3011
3022		3012
3023		3013
3024		3014
3025		3015
3026		3016
3027		3017
3028		3018
3029		3019
3030		3020
3031		3021
3032		3022
3033		3023
3034		3024
3035		3025
3036		3026
3037		3027
3038		3028
3039		3029
3040		3030
3041		3031
3042		3032
3043		3033
3044		3034
3045		3035
3046		3036
3047		3037
3048		3038
3049		3039
3050		3040
3051		3041
3052		3042
3053		3043
3054		3044
3055		3045
3056		3046
3057		3047
3058		3048
3059		3049
3060		3050
3061		3051
3062		3052
3063		3053
3064		3054
3065		3055
3066		3056
3067		3057
3068		3058
3069		3059
3070		3060
3071		3061
3072		3062
3073		3063
3074		3064
3075		3065
3076		3066
3077		3067
3078		3068
3079		3069
3080		3070
3081		3071
3082		3072
3083		3073
3084		3074
3085		3075
3086		3076
3087		3077
3088		3078
3089		3079
3090		3080
3091		3081
3092		3082
3093		3083
3094		3084
3095		3085
3096		3086
3097		3087
3098		3088
3099		3089
3100		3090
3101		3091
3102		3092
3103		3093
3104		3094
3105		3095
3106		3096
3107		3097
3108		3098
3109		3099
3110		3100
3111		3101
3112		3102
3113		3103
3114		3104
3115		3105
3116		3106
3117		3107
3118		3108
3119		3109
3120		3110
3121		3111
3122		3112
3123		3113
3124		3114
3125		3115
3126		3116
3127		3117
3128		3118
3129		3119
3130		3120
3131		3121
3132		3122
3133		3123
3134		3124
3135		3125
3136		3126
3137		3127
3138		3128
3139		3129
3140		3130
3141		3131
3142		3132
3143		3133
3144		3134
3145		3135
3146		3136
3147		3137
3148		3138
3149		3139
3150		3140
3151		3141
3152		3142
3153		3143
3154		3144
3155		3145
3156		3146
3157		3147
3158		3148
3159		3149
3160		3150
3161		3151
3162		3152
3163		3153
3164		3154
3165		3155
3166		3156
3167		3157
3168		3158
3169		3159
3170		3160
3171		3161
3172		3162
3173		3163
3174		3164
3175		3165
3176		3166
3177		3167
3178		3168
3179		3169
3180		3170
3181		3171
3182		3172
3183		3173
3184		3174
3185		3175
3186		3176
3187		3177
3188		3178
3189		3179
3190		3180
3191		3181
3192		3182
3193		3183
3194		3184
3195		3185
3196		3186
3197		3187
3198		3188
3199		3189
3200		3190
3201		3191
3202		3192
3203		3193
3204		3194
3205		3195
3206		3196
3207		3197
3208		3198
3209		3199
3210		3200
3211		3201
3212		3202
3213		3203
3214		3204
3215		3205
3216		3206
3217		3207
3218		3208
3219		3209
3220		3210
3221		3211
3222		3212
3223		3213
3224		3214
3225		3215
3226		3216
3227		3217
3228		3218
3229		3219
3230		3220
3231		3221
3232		3222
3233		3223
3234		3224
3235		3225
3236		3226
3237		3227
3238		3228
3239		3229
3240		3230
3241		3231
3242		3232
3243		3233
3244		3234
3245		3235
3246		3236
3247		3237
3248		3238
3249		3239
3250		3240
3251		3241
3252		3242
3253		3243
3254		3244
3255		3245
3256		3246
3257		3247
3258		3248
3259		3249
3260		3250
3261		3251
3262		3252
3263		3253
3264		3254
3265		3255
3266		3256
3267		3257
3268		3258
3269		3259
3270		3260
3271		3261
3272		3262
3273		3263
3274		3264
3275		3265
3276		3266
3277		3267
3278		3268
3279		3269
3280		3270
3281		3271
3282		3272
3283		3273
3284		3274
3285		3275
3286		3276
3287		3277
3288		3278
3289		3279
3290		3280
3291		3281
3292		3282
3293		3283
3294		3284
3295		3285
3296		3286
3297		3287
3298		3288
3299		3289
3300		3290
3301		3291
3302		3292
3303		3293
3304		3294
3305		3295
3306		3296
3307		3297
3308		3298
3309		3299
3310		3300
3311		3301
3312		3302
3313		3303
3314		3304
3315		3305
3316		3306
3317		3307
3318		3308
3319		3309
3320		3310
3321		3311
3322		3312
3323		3313
3324		3314
3325		3315
3326		3316
3327		3317
3328		3318
3329		3319
3330		3320
3331		3321
3332		3322
3333		3323
3334		3324
3335		3325
3336		3326
3337		3327
3338		3328
3339		3329
3340		3330
3341		3331
3342		3332
3343		3334
3344		3335
3345		3336
3346		3337
3347		3338
3348		3339
3349		3340
3350		3341
3351		3342
3352		3343
3353		3344
3354		3345
3355		3346
3356		3347
3357		3348
3358		3349
3359		3350
3360		3351
3361		3352
3362		3353
3363		3354
3364		3355
3365		3356
3366		3357
3367		3358
3368		3359
3369		3360
3370		3361
3371		3362
3372		3363
3373		3364
3374		3365
3375		3366
3376		3367
3377		3368
3378		3369
3379		3370
3380		3371
3381		3372
3382		3373
3383		3374
3384		3375
3385		3376
3386		3377
3387		3378
3388		3379
3389		3380
3390		3381
3391		3382
3392		3383
3393		3384
3394		3385
3395		3386
3396		3387
3397		3388
3398		3389
3399		3390
3400		3391
3401		3392
3402		3393
3403		3394
3404		3395
3405		3396
3406		3397
3407		3398
3408		3399
3409		3400
3410		3401
3411		3402
3412		3403
3413		3404
3414		3405
3415		3406
3416		3407
3417		3408
3418		3409
3419		3410
3420		3411
3421		3412
3422		3413
3423		3414
3424		3415
3425		3416
3426		3417
3427		3418
3428		3419
3429		3420
3430		3421
3431		3422
3432		3423
3433		3424
3434		3425
3435		3426
3436		3427
3437		3428
3438		3429
3439		3430
3440		3431
3441		3432
3442		3433
3443		3434
3444		3435
3445		3436
3446		3437
3447		3438
3448		3439
3449		3440
3450		3441
3451		3442
3452		3443
3453		3444
3454		3445
3455		3446
3456		3447
3457		3448
3458		3449
3459		3450
3460		3451
3461		3452
3462		3453
3463		3454
3464		3455
3465		3456
3466		3457
3467		3458
3468		3459
3469		3460
3470		3461
3471		3462
3472		3463
3473		3464
3474		3465
3475		3466
3476		3467
3477		3468
3478		3469
3479		3470
3480		3471
3481		3472
3482		3473
3483		3474
3484		3475
3485		3476
3486		3477
3487		3478
3488		3479
3489		3480
3490		3481
3491		3482
3492		3483
3493		3484
3494		3485
3495		3486
3496		3487
3497		3488
3498		3489
3499		3490
3500		3491
3501		3492
3502		3493
3503		3494
3504		3495
3505		3496
3506		3497
3507		3498
3508		3499
3509		3500
3510		3501
3511		3502
3512		3503
3513		3504
3514		3505
3515		3506
3516		3507
3517		3508
3518		3509
3519		3510
3520		3511
3521		3512
3522		3513
3523		3514
3524		3515
3525		3516
3526		3517
3527		3518
3528		3519
3529		3520
3530		3521
3531		3522
3532		3523
3533		3524
3534		3525
3535		3526
3536		3527
3537		3528
3538		3529
3539		3530
3540		3531
3541		3532
3542		3533
3543		3534
3544		3535
3545		3536
3546		3537
3547		3538
3548		3539
3549		3540
3550		3541
3551		3542
3552		3543
3553		3544
3554		3545
3555		3546
3556		3547
3557		3548
3558		3549
3559		3550
3560		3551
3561		3552
3562		3553
3563		3554
3564		3555
3565		3556
3566		3557
3567		3558
3568		3559
3569		3560
3570		3561
3571		3562
3572		3563
3573		3564
3574		3565
3575		3566
3576		3567
3577		3568
3578		3569
3579		3570
3580		3571
3581		3572
3582		3573
3583		3574
3584		3575
3585		3576
3586		3577
3587		3578
3588		3579
3589		3580
3590		3581
3591		3582
3592		3583
3593		3584
3594		3585
3595		3586
3596		3587
3597		3588
3598		3589
3599		3590
3600		3591
3601		3592
3602		3593
3603		3594
3604		3595
3605		3596
3606		3597
3607		3598
3608		3599
3609		3600
3610		3601
3611		3602
3612		3603
3613		3604
3614		3605
3615		3606
3616		3607
3617		3608
3618		3609
3619		3610
3620		3611
3621		3612
3622		3613
3623		3614
3624		3615
3625		3616
3626		3617
3627		3618
3628		3619
3629		3620
3630		3621
3631		3622
3632		3623
3633		3624
3634		3625
3635		3626
3636		3627
3637		3628
3638		3629
3639		3630
3640		3631
3641		3632
3642		3633
3643		3634
3644		3635
3645		3636
3646		3637
3647		3638
3648		3639
3649		3640
3650		3641
3651		3642
3652		3643
3653		3644
3654		3645
3655		3646
3656		3647
3657		3648
3658		3649
3659		3650
3660		3651
3661		3652
3662		3653
3663		3654
3664		3655
3665		3656
3666		3657
3667		3658
3668		3659
3669		3660
3670		3661
3671		3662
3672		3663
3673		3664
3674		3665
3675		3666
3676		3667
3677		3668
3678		3669
3679		3670
3680		3671
3681		3672
3682		3673
3683		3674
3684		3675
3685		3676
3686		3677
3687		3678
3688		3679
3689		3680
3690		3681
3691		3682
3692		3683
3693		3684
3694		3685
3695		3686
3696		3687
3697		3688
3698		3689
3699		3690
3700		3691
3701		3692
3702		3693
3703		3694
3704		3695
3705		3696
3706		3697
3707		3698
3708		3699
3709		3700
3710		3701
3711		3702
3712		3703
3713		3704
3714		3705
3715		3706
3716		3707
3717		3708
3718		3709
3719		3710
3720		3711
3721		3712
3722		3713
3723		3714
3724		3715
3725		3716
3726		3717
3727		3718
3728		3719
3729		3720
3730		3721
3731		3722
3732		3723
3733		3724
3734		3725
3735		3726
3736		3727
3737		3728
3738		3729
3739		3730
3740		3731
3741		3732
3742		3733
3743		3734
3744		3735
3745		3736
3746		3737
3747		3738
3748		3739
3749		3740
3750		3741
3751		3742
3752		3743
3753		3744
3754		3745
3755		3746
3756		3747
3757		3748
3758		3749
3759		3750
3760		3751
3761		3752
3762		3753
3763		3754
3764		3755
3765		3756
3766		3757
3767		3758
3768		3759
3769		3760
3770		3761
3771		3762
3772		3763
3773		3764
3774		3765
3775		3766
3776		3767
3777		3768
3778		3769
3779		3770
3780		3771
3781		3772
3782		3773
3783		3774
3784		3775
3785		3776
3786		3777
3787		3778
3788		3779
3789		3780
3790		3781
3791		3782
3792		3783
3793		3784
3794		3785
3795		3786
3796		3787
3797		3788
3798		3789
3799		3790
3800		3791
3801		3792
3802		3793
3803		3794
3804		3795
3805		3796
3806		3797
3807		3798
3808		3799
3809		3800
3810		3801
3811		3802
3812		3803
3813		3804
3814		3805
3815		3806
3816		3807
3817		3808
3818		3809
3819		3810
3820		3811
3821		3812
3822		3813
3823		3814
3824		3815
3825		3816
3826		3817
3827		3818
3828		3819
3829		3820
3830		3821
3831		3822
3832		3823
3833		3824
3834		3825
3835		3826
3836		3827
3837		3828
3838		3829
3839		3830
3840		3831
3841		3832
3842		3833
3843		3834
3844		3835
3845		3836
3846		3837
3847		3838
3848		3839
3849		3840
3850		3841
3851		3842
3852		3843
3853		3844
3854		3845
3855		3846
3856		3847
3857		3848
3858		3849
3859		3850
3860		3851
3861		3852
3862		3853
3863		3854
3864		3855
3865		3856
3866		3857
3867		3858
3868		3859
3869		3860
3870		3861
3871		3862
3872		3863
3873		3864
3874		3865
3875		3866
3876		3867
3877		3868
3878		3869
3879		3870
3880		3871
3881		3872
3882		3873
3883		3874
3884		3875
3885		3876
3886		3877
3887		3878
3888		3879
3889		3880
3890		3881
3891		3882
3892		3883
3893		3884
3894		3885
3895		3886
3896		3887
3897		3888
3898		3889
3899		3890
3900		3891
3901		3892
3902		3893
3903		3894
3904		3895
3905		3896
3906		3897
3907		3898
3908		3899
3909		3900
3910		3901
3911		3902
3912		3903
3913		3904
3914		3905
3915		3906
3916		3907
3917		3908
3918		3909
3919		3910
3920		3911
3921		3912
3922		3913
3923		3914
3924		3915
3925		3916
3926		3917
3927		3918
3928		3919
3929		3920
3930		3921
3931		3922
3932		3923
3933		3924
3934		3925
3935		3926
3936		3927
3937		3928
3938		3929
3939		3930
3940		3931
3941		3932
3942		3933
3943		3934
3944		3935
3945		3936
3946		3937
3947		3938
3948		3939
3949		3940
3950		3941
3951		3942
3952		3943
3953		3944
3954		3945
3955		3946
3956		3947
3957		3948
3958		3949
3959		3950
3960		3951
3961		3952
3962		3953
3963		3954
3964		3955
3965		3956
3966		3957
3967		3958
3968		3959
3969		3960
3970		3961
3971		3962
3972		3963
3973		3964
3974		3965
3975		3966
3976		3967
3977		3968
3978		3969
3979		3970
3980		3971
3981		3972
3982		3973
3983		3974
3984		3975
3985		3976
3986		3977
3987		3978
3988		3979
3989		3980
3990		3981
3991		3982
3992		3983
3993		3984
3994		3985
3995		3986
3996		3987
3997		3988
3998		3989
3999		3990
4000		3991
4001		3992
4002		3993
4003		3994
4004		3995
4005		3996
4006		3997
4007		3998
4008		3999
4009		4000
4010		4001
4011		4002
4012		4003
4013		4004
4014		4005
4015		4006
4016		4007
4017		4008
4018		4009
4019		4010
4020		4011
4021		4012
4022		4013
4023		4014
4024		4015
4025		4016
4026		4017
4027		4018
4028		4019
4029		4020
4030		4021
4031		4022
4032		4023
4033		4024
4034		4025
4035		4026
4036		4027
4037		4028
4038		4029
4039		4030
4040		4031
4041		4032
4042		4033
4043		4034
4044		4035
4045		4036
4046		4037
4047		4038
4048		4039
4049		4040
4050		4041
4051		4042
4052		4043
4053		4044
4054		4045
4055		4046
4056		4047
4057		4048
4058		4049
4059		4050
4060		4051
4061		4052
4062		4053
4063		4054
4064		4055
4065		4056
4066		4057
4067		4058
4068		4059
4069		4060
4070		4061
4071		4062
4072		4063
4073		4064
4074		4065
4075		4066
4076		4067
4077		4068
4078		4069
4079		4070
4080		4071
4081		4072
4082		4073
4083		4074
4084		4075
4085		4076
4086		4077
4087		4078
4088		4079
4089		4080
4090		4081
4091		4082
4092		4083
4093		4084
4094		4085
4095		4086
4096		4087
4097		4088
4098		4089
4099		4090
4100		4091
4101		4092
4102		4093
4103		4094
4104		4095
4105		4096
4106		4097
4107		4098
4108		4099
4109		4100
4110		4101
4111		4102
4112		4103
4113		4104
4114		4105
4115		4106
4116		4107
4117		4108
4118		4109
4119		4110
4120		4111
4121		4112
4122		4113
4123		4114
4124		4115
4125		4116
4126		4117
4127		4118
4128		4119
4129		4120
4130		4121
4131		4122
4132		4123
4133		4124
4134		4125
4135		4126
4136		4127
4137		4128
4138		4129
4139		4130
4140		4131
4141		4132
4142		4133
4143		4134
4144		4135
4145		4136
4146		4137
4147		4138
4148		4139
4149		4140
4150		4141
4151		4142
4152		4143
4153		4144
4154		4145
4155		4146
4156		4147
4157		4148
4158		4149
4159		4150
4160		4151
4161		4152
4162		4153
4163		4154
4164		4155
4165		4156
4166		4157
4167		4158
4168		4159
4169		4160
4170		4161
4171		4162
4172		4163
4173		4164
4174		4165
4175		4166
4176		4167
4177		4168
4178		4169
4179		4170
4180		4171
4181		4172
4182		4173
4183		4174
4184		4175
4185		4176
4186		4177
4187		4178
4188		4179
4189		4180
4190		4181
4191		4182
4192		4183
4193		4184
4194		4185
4195		4186
4196		4187
4197		4188
4198		4189
4199		4190
4200		4191
4201		4192
4202		4193
4203		4194
4204		4195
4205		4196
4206		4197
4207		4198
4208		4199
4209		4200
4210		4201
4211		4202
4212		4203
4213		4204
4214		4205
4215		4206
4216		4207
4217		4208
4218		4209
4219		4210
4220		4211
4221		4212
4222		4213
4223		4214
4224		4215
4225		4216
4226		4217
4227		4218
4228		4219
4229		4220
4230		4221
4231		4222
4232		4223
4233		4224
4234		4225
4235		4226
4236		4227
4237		4228
4238		4229
4239		4230
4240		4231
4241		4232
4242		4233
4243		4234
4244		4235
4245		4236
4246		4237
4247		4238
4248		4239
4249		4240
4250		4241
4251		4242
4252		4243
4253		4244
4254		4245
4255		4246
4256		4247
4257		4248
4258		4249
4259		4250
4260		4251
4261		4252
4262		4253
4263		4254
4264		4255
4265		4256
4266		4257
4267		4258
4268		4259
4269		4260
4270		4261
4271		4262
4272		4263
4273		4264
4274		4265
4275		4266
4276		4267
4277		4268
4278		4269
4279		4270
4280		4271
4281		4272
4282		4273
4283		4274
4284		4275
4285		4276
4286		4277
4287		4278
4288		4279
4289		4280
4290		4281
4291		4282
4292		4283
4293		4284
4294		4285
4295		4286
4296		4287
4297		4288
4298		4289
4299		4290
4300		4291
4301		4292
4302		4293
4303		4294
4304		4295
4305		4296
4306		4297
4307		4298
4308		4299
4309		4300
4310		4301
4311		4302
4312		4303
4313		4304
4314		4305
4315		4306
4316		4307
4317		4308
4318		4309
4319		4310
4320		4311
4321		4312
4322		4313
4323		4314
4324		4315
4325		4316
4326		4317
4327		4318
4328		4319
4329		4320
4330		4321
4331		4322
4332		4323
4333		4324
4334		4325
4335		4326
4336		4327
4337		4328
4338		4329
4339		4330
4340		4331
4341		4332
4342		4333
4343		4334
4344		4335
4345		4336
4346		4337
4347		4338
4348		4339
4349		4340
4350		4341
4351		4342
4352		4343
4353		4344
4354		4345
4355		4346
4356		4347
4357		4348
4358		4349
4359		4350
4360		4351
4361		4352
4362		4353
4363		4354
4364		4355
4365		4356
4366		4357
4367		4358
4368		4359
4369		4360
4370		4361
4371		4362
4372		4363
4373		4364
4374		4365
4375		4366
4376		4367
4377		4368
4378		4369
4379		4370
4380		4371
4381		4372
4382		4373
4383		4374
4384		4375
4385		4376
4386		4377
4387		4378
4388		4379
4389		4380
4390		4381
4391		4382
4392		4383
4393		4384
4394		4385
4395		4386
4396		4387
4397		4388
4398		4389
4399		4390
4400		4391
4401		4392
4402		4393
4403		4394
4404		4395
4405		4396
4406		4397
4407		4398
4408		4399
4409		4400
4410		4401
4411		4402
4412		4403
4413		4404
4414		4405
4415		4406
4416		4407
4417		4408
4418		4409
4419		4410
4420		4411
4421		4412
4422		4413
4423		4414
4424		4415
4425		4416
4426		4417
4427		4418
4428		4419
4429		4420
4430		4421
4431		4422
4432		4423
4433		4424
4434		4425
4435		4426
4436		4427
4437		4428
4438		4429
4439		4430
4440		4431
4441		4432
4442		4433
4443		4434
4444		4435
4445		4436
4446		4437
4447		4438
4448		4439
4449		4440
4450		4441
4451		4442
4452		4443
4453		4445
4454		4446
4455		4447
4456		4448
4457		4449
4458		4450
4459		4451
4460		4452
4461		4453
4462		4454
4463		4455
4464		4456
4465		4457
4466		4458
4467		4459
4468		4460
4469		4461
4470		4462
4471		4463
4472		4464
4473		4465
4474		4466
4475		4467
4476		4468
4477		4469
4478		4470
4479		4471
4480		4472
4481		4473
4482		4474
4483		4475
4484		4476
4485		4477
4486		4478
4487		4479
4488		4480
4489		4481
4490		4482
4491		4483
4492		4484
4493		4485
4494		4486
4495		4487
4496		4488
4497		4489
4498		4490
4499		4491
4500		4492
4501		4493
4502		4494
4503		4495
4504		4496
4505		4497
4506		4498
4507		4499
4508		4500
4509		4501
4510		4502
4511		4503
4512		4504
4513		4505
4514		4506
4515		4507
4516		4508
4517		4509
4518		4510
4519		4511
4520		4512
4521		4513
4522		4514
4523		4515
4524		4516
4525		4517
4526		4518
4527		4519
4528		4520
4529		4521
4530		4522
4531		4523
4532		4524
4533		4525
4534		4526
4535		4527
4536		4528
4537		4529
4538		4530
4539		4531
4540		4532
4541		4533
4542		4534
4543		4535
4544		4536
4545		4537
4546		4538
4547		4539
4548		4540
4549		4541
4550		4542
4551		4543
4552		4544
4553		4545
4554		4546
4555		4547
4556		4548
4557		4549
4558		4550
4559		4551
4560		4552
4561		4553
4562		4554
4563		4555
4564		4556
4565		4557
4566		4558
4567		4559
4568		4560
4569		4561
4570		4562
4571		4563
4572		4564
4573		4565
4574		4566
4575		4567
4576		4568
4577		4569
4578		4570
4579		4571
4580		4572
4581		4573
4582		4574
4583		4575
4584		4576
4585		4577
4586		4578
4587		4579
4588		4580
4589		4581
4590		4582
4591		4583
4592		4584
4593		4585
4594		4586
4595		4587
4596		4588
4597		4589
4598		4590
4599		4591
4600		4592
4601		4593
4602		4594
4603		4595
4604		4596
4605		4597
4606		4598
4607		4599
4608		4600
4609		4601
4610		4602
4611		4603
4612		4604
4613		4605
4614		4606
4615		4607
4616		4608
4617		4609
4618		4610
4619		4611
4620		4612
4621		4613
4622		4614
4623		4615
4624		4616
4625		4617
4626		4618
4627		4619
4628		4620
4629		4621
4630		4622
4631		4623
4632		4624
4633		4625
4634		4626
4635		4627
4636		4628
4637		4629
4638		4630
4639		4631
4640		4632
4641		4633
4642		4634
4643		4635
4644		4636
4645		4637
4646		4638
4647		4639
4648		4640
4649		4641
4650		4642
4651		4643
4652		4644
4653		4645
4654		4646
4655		4647
4656		4648
4657		4649
4658		4650
4659		4651
4660		4652
4661		4653
4662		4654
4663		4655
4664		4656
4665		4657
4666		4658
4667		4659
4668		4660
4669		4661
4670		4662
4671		4663
4672		4664
4673		4665
4674		4666
4675		4667
4676		4668
4677		4669
4678		4670
4679		4671
4680		4672
4681		4673
4682		4674
4683		4675
4684		4676
4685		4677
4686		4678
4687		4679
4688		4680
4689		4681
4690		4682
4691		4683
4692		4684
4693		4685
4694		4686
4695		4687
4696		4688
4697		4689
4698		4690
4699		4691
4700		4692
4701		4693
4702		4694
4703		4695
4704		4696
4705		4697
4706		4698
4707		4699
4708		4700
4709		4701
4710		4702
4711		4703
4712		4704
4713		4705
4714		4706
4715		4707
4716		4708
4717		4709
4718		4710
4719		4711
4720		4712
4721		4713
4722		4714
4723		4715
4724		4716
4725		4717
4726		4718
4727		4719
4728		4720
4729		4721
4730		4722
4731		4723
4732		4724
4733		4725
4734		4726
4735		4727
4736		4728
4737		4729
4738		4730
4739		4731
4740		4732
4741		4733
4742		4734
4743		4735
4744		4736
4745		4737
4746		4738
4747		4739
4748		4740
4749		4741
4750		4742
4751		4743
4752		4744
4753		4745
4754		4746
4755		4747
4756		4748
4757		4749
4758		4750
4759		4751
4760		4752
4761		4753
4762		4754
4763		4755
4764		4756
4765		4757
4766		4758
4767		4759
4768		4760
4769		4761
4770		4762
4771		4763
4772		4764
4773		4765
4774		4766
4775		4767
4776		4768
4777		4769
4778		4770
4779		4771
4780		4772
4781		4773
4782		4774
4783		4775
4784		4776
4785		4777
4786		4778
4787		4779
4788		4780
4789		4781
4790		4782
4791		4783
4792		4784
4793		4785
4794		4786
4795		4787
4796		4788
4797		4789
4798		4790
4799		4791
4800		4792
4801		4793
4802		4794
4803		4795
4804		4796
4805		4797
4806		4798
4807		4799
4808		4800
4809		4801
4810		4802
4811		4803
4812		4804
4813		4805
4814		4806
4815		4807
4816		4808
4817		4809
4818		4810
4819		4811
4820		4812
4821		4813
4822		4814
4823		4815
4824		4816
4825		4817
4826		4818
4827		4819
4828		4820
4829		4821
4830		4822
4831		4823
4832		4824
4833		4825
4834		4826
4835		4827
4836		4828
4837		4829
4838		4830
4839		4831
4840		4832
4841		4833
4842		4834
4843		4835
4844		4836
4845		4837
4846		4838
4847		4839
4848		4840
4849		4841
4850		4842
4851		4843
4852		4844
4853		4845
4854		4846
4855		4847
4856		4848
4857		4849
4858		4850
4859		4851
4860		4852
4861		4853
4862		4854
4863		4855
4864		4856
4865		4857
4866		4858
4867		4859
4868		4860
4869		4861
4870		4862
4871		4863
4872		4864
4873		4865
4874		4866
4875		4867
4876		4868
4877		4869
4878		4870
4879		4871
4880		4872
4881		4873
4882		4874
4883		4875
4884		4876
4885		4877
4886		4878
4887		4879
4888		4880
4889		4881
4890		4882
4891		4883
4892		4884
4893		4885
4894		4886
4895		4887
4896		4888
4897		4889
4898		4890
4899		4891
4900		4892
4901		4893
4902		4894
4903		4895
4904		4896
4905		4897
4906		4898
4907		4899
4908		4900
4909		4901
4910		4902
4911		4903
4912		4904
4913		4905
4914		4906
4915		4907
4916		4908
4917		4909
4918		4910
4919		4911
4920		4912
4921		4913
4922		4914
4923		4915
4924		4916
4925		4917
4926		4918
4927		4919
4928		4920
4929		4921
4930		4922
4931		4923
4932		4924
4933		4925
4934		4926
4935		4927
4936		4928
4937		4929
4938		4930
4939		4931
4940		4932
4941		4933
4942		4934
4943		4935
4944		4936
4945		4937
4946		4938
4947		4939
4948		4940
4949		4941
4950		4942
4951		4943
4952		4944
4953		4945
4954		4946
4955		4947
4956		4948
4957		4949
4958		4950
4959		4951
4960		4952
4961		4953
4962		4954
4963		4955
4964		4956
4965		4957
4966		4958
4967		4959
4968		4960
4969		4961
4970		4962
4971		4963
4972		4964
4973		4965
4974		4966
4975		4967
4976		4968
4977		4969
4978		4970
4979		4971
4980		4972
4981		4973
4982		4974
4983		4975
4984		4976
4985		4977
4986		4978
4987		4979
4988		4980
4989		4981
4990		4982
4991		4983
4992		4984
4993		4985
4994		4986
4995		4987
4996		4988
4997		4989
4998		4990
4999		4991
5000		4992
5001		4993
5002		4994
5003		4995
5004		4996
5005		4997
5006		4998
5007		4999
5008		5000
5009		5001
5010		5002
5011		5003
5012		5004
5013		5005
5014		5006
5015		5007
5016		5008
5017		5009
5018		5010
5019		5011
5020		5012
5021		5013
5022		5014
5023		5015
5024		5016
5025		5017
5026		5018
5027		5019
5028		5020
5029		5021
5030		5022
5031		5023
5032		5024
5033		5025
5034		5026
5035		5027
5036		5028
5037		5029
5038		5030
5039		5031
5040		5032
5041		5033
5042		5034
5043		5035
5044		5036
5045		5037
5046		5038
5047		5039
5048		5040
5049		5041
5050		5042
5051		5043
5052		5044
5053		5045
5054		5046
5055		5047
5056		5048
5057		5049
5058		5050
5059		5051
5060		5052
5061		5053
5062		5054
5063		5055
5064		5056
5065		5057
5066		5058
5067		5059
5068		5060
5069		5061
5070		5062
5071		5063
5072		5064
5073		5065
5074		5066
5075		5067
5076		5068
5077		5069
5078		5070
5079		5071
5080		5072
5081		5073
5082		5074
5083		5075
5084		5076
5085		5077
5086		5078
5087		5079
5088		5080
5089		5081
5090		5082
5091		5083
5092		5084
5093		5085
5094		5086
5095		5087
5096		5088
5097		5089
5098		5090
5099		5091
5100		5092
5101		5093
5102		5094
5103		5095
5104		5096
5105		5097
5106		5098
5107		5099
5108		5100
5109		5101
5110		5102
5111		5103
5112		5104
5113		5105
5114		5106
5115		5107
5116		5108
5117		5109
5118		5110
5119		5111
5120		5112
5121		5113
5122		5114
5123		5115
5124		5116
5125		5117
5126		5118
5127		5119
5128		5120
5129		5121
5130		5122
5131		5123
5132		5124
5133		5125
5134		5126
5135		5127
5136		5128
5137		5129
5138		5130
5139		5131
5140		5132
5141		5133
5142		5134
5143		5135
5144		5136
5145		5137
5146		5138
5147		5139
5148		5140
5149		5141
5150		5142
5151		5143
5152		5144
5153		5145
5154		5146
5155		5147
5156		5148
5157		5149
5158		5150
5159		5151
5160		5152
5161		5153
5162		5154
5163		5155
5164		5156
5165		5157
5166		5158
5167		5159
5168		5160
5169		5161
5170		5162
5171		5163
5172		5164
5173		5165
5174		5166
5175		5167
5176		5168
5177		5169
5178		5170
5179		5171
5180		5172
5181		5173
5182		5174
5183		5175
5184		5176
5185		5177
5186		5178
5187		5179
5188		5180
5189		5181
5190		5182
5191		5183
5192		5184
5193		5185
5194		5186
5195		5187
5196		5188
5197		5189
5198		5190
5199		5191
5200		5192
5201		5193
5202		5194
5203		5195
5204		5196
5205		5197
5206		5198
5207		5199
5208		5200
5209		5201
5210		5202
5211		5203
5212		5204
5213		5205
5214		5206
5215		5207
5216		5208
5217		5209
5218		5210
5219		5211
5220		5212
5221		5213
5222		5214
5223		5215
5224		5216
5225		5217
5226		5218
5227		5219
5228		5220
5229		5221
5230		5222
5231		5223
5232		5224
5233		5225
5234		5226
5235		5227
5236		5228
5237		5229
5238		5230
5239		5231
5240		5232
5241		5233
5242		5234
5243		5235
5244		5236
5245		5237
5246		5238
5247		5239
5248		5240
5249		5241
5250		5242
5251		5243
5252		5244
5253		5245
5254		5246
5255		5247
5256		5248
5257		5249
5258		5250
5259		5251
5260		5252
5261		5253
5262		5254
5263		5255
5264		5256
5265		5257
5266		5258
5267		5259
5268		5260
5269		5261
5270		5262
5271		5263
5272		5264
5273		5265
5274		5266
5275		5267
5276		5268
5277		5269
5278		5270
5279		5271
5280		5272
5281		5273
5282		5274
5283		5275
5284		5276
5285		5277
5286		5278
5287		5279
5288		5280
5289		5281
5290		5282
5291		5283
5292		5284
5293		5285
5294		5286
5295		5287
5296		5288
5297		5289
5298		5290
5299		5291
5300		5292
5301		5293
5302		5294
5303		5295
5304		5296
5305		5297
5306		5298
5307		5299
5308		5300
5309		5301
5310		5302
5311		5303
5312		5304
5313		5305
5314		5306
5315		5307
5316		5308
5317		5309
5318		5310
5319		5311
5320		5312
5321		5313
5322		5314
5323		5315
5324		5316
5325		5317
5326		5318
5327		5319
5328		5320
5329		5321
5330		5322
5331		5323
5332		5324
5333		5325
5334		5326
5335		5327
5336		5328
5337		5329
5338		5330
5339		5331
5340		5332
5341		5333
5342		5334
5343		5335
5344		5336
5345		5337
5346		5338
5347		5339
5348		5340
5349		5341
5350		5342
5351		5343
5352		5344
5353		5345
5354		5346
5355		5347
5356		5348
5357		5349
5358		5350
5359		5351
5360		5352
5361		5353
5362		5354
5363		5355
5364		5356
5365		5357
5366		5358
5367		5359
5368		5360
5369		5361
5370		5362
5371		5363
5372		5364
5373		5365
5374		5366
5375		5367
5376		5368
5377		5369
5378		5370
5379		5371
5380		5372
5381		5373
5382		5374
5383		5375
5384		5376
5385		5377
5386		5378
5387		5379
5388		5380
5389		5381
5390		5382
5391		5383
5392		5384
5393		5385
5394		5386
5395		5387
5396		5388
5397		5389
5398		5390
5399		5391
5400		5392
5401		5393
5402		5394
5403		5395
5404		5396
5405		5397
5406		5398
5407		5399
5408		5400
5409		5401
5410		5402
5411		5403
5412		5404
5413		5405
5414		5406
5415		5407
5416		5408
5417		5409
5418		5410
5419		5411
5420		5412
5421		5413
5422		5414
5423		5415
5424		5416
5425		5417
5426		5418
5427		5419
5428		5420
5429		5421
5430		5422
5431		5423
5432		5424
5433		5425
5434		5426
5435		5427
5436		5428
5437		5429
5438		5430
5439		5431
5440		5432
5441		5433
5442		5434
5443		5435
5444		5436
5445		5437
5446		5438
5447		5439
5448		5440
5449		5441
5450		5442
5451		5443
5452		5444
5453		5445
5454		5446
5455		5447
5456		5448
5457		5449
5458		5450
5459		5451
5460		5452
5461		5453
5462		5454
5463		5455
5464		5456
5465		5457
5466		5458
5467		5459
5468		5460
5469		5461
5470		5462
5471		5463
5472		5464
5473		5465
5474		5466
5475		5467
5476		5468
5477		5469
5478		5470
5479		5471
5480		5472
5481		5473
5482		5474
5483		5475
5484		5476
5485		5477
5486		5478
5487		5479
5488		5480
5489		5481
5490		5482
5491		5483
5492		5484
5493		5485
5494		5486
5495		5487
5496		5488
5497		5489
5498		5490
5499		5491
5500		5492
5501		5493
5502		5494
5503		5495
5504		5496
5505		5497
5506		5498
5507		5499
5508		5500
5509		5501
5510		5502
5511		5503
5512		5504
5513		5505
5514		5506
5515		5507
5516		5508
5517		5509
5518		5510
5519		5511
5520		5512
5521		5513
5522		5514
5523		5515
5524		5516
5525		5517
5526		5518
5527		5519
5528		5520
5529		5521
5530		5522
5531		5523
5532		5524
5533		5525
5534		5526
5535		5527
5536		5528
5537		5529
5538		5530
5539		5531
5540		5532
5541		5533
5542		5534
5543		5535
5544		5536
5545		5537
5546		5538
5547		5539
5548		5540
5549		5541
5550		5542
5551		5543
5552		5544
5553		5545
5554		5546
5555		5547
5556		5548
5557		5549
5558		5550
5559		5551
5560		5552
5561		5553
5562		5554
5563		5556
5564		5557
5565		5558
5566		5559
5567		5560
5568		5561
5569		5562
5570		5563
5571		5564
5572		5565
5573		5566
5574		5567
5575		5568
5576		5569
5577		5570
5578		5571
5579		5572
5580		5573
5581		5574
5582		5575
5583		5576
5584		5577
5585		5578
5586		5579
5587		5580
5588		5581
5589		5582
5590		5583
5591		5584
5592		5585
5593		5586
5594		5587
5595		5588
5596		5589
5597		5590
5598		5591
5599		5592
5600		5593
5601		5594
5602		5595
5603		5596
5604		5597
5605		5598
5606		5599
5607		5600
5608		5601
5609		5602
5610		5603
5611		5604
5612		5605
5613		5606
5614		5607
5615		5608
5616		5609
5617		5610
5618		5611
5619		5612
5620		5613
5621		5614
5622		5615
5623		5616
5624		5617
5625		5618
5626		5619
5627		5620
5628		5621
5629		5622
5630		5623
5631		5624
5632		5625
5633		5626
5634		5627
5635		5628
5636		5629
5637		5630
5638		5631
5639		5632
5640		5633
5641		5634
5642		5635
5643		5636
5644		5637
5645		5638
5646		5639
5647		5640
5648		5641
5649		5642
5650		5643
5651		5644
5652		5645
5653		5646
5654		5647
5655		5648
5656		5649
5657		5650
5658		5651
5659		5652
5660		5653
5661		5654
5662		5655
5663		5656
5664		5657
5665		5658
5666		5659
5667		5660
5668		5661
5669		5662
5670		5663
5671		5664
5672		5665
5673		5666
5674		5667
5675		5668
5676		5669
5677		5670
5678		5671
5679		5672
5680		5673
5681		5674
5682		5675
5683		5676
5684		5677
5685		5678
5686		5679
5687		5680
5688		5681
5689		5682
5690		5683
5691		5684
5692		5685
5693		5686
5694		5687
5695		5688
5696		5689
5697		5690
5698		5691
5699		5692
5700		5693
5701		5694
5702		5695
5703		5696
5704		5697
5705		5698
5706		5699
5707		5700
5708		5701
5709		5702
5710		5703
5711		5704
5712		5705
5713		5706
5714		5707
5715		5708
5716		5709
5717		5710
5718		5711
5719		5712
5720		5713
5721		5714
5722		5715
5723		5716
5724		5717
5725		5718
5726		5719
5727		5720
5728		5721
5729		5722
5730		5723
5731		5724
5732		5725
5733		5726
5734		5727
5735		5728
5736		5729
5737		5730
5738		5731
5739		5732
5740		5733
5741		5734
5742		5735
5743		5736
5744		5737
5745		5738
5746		5739
5747		5740
5748		5741
5749		5742
5750		5743
5751		5744
5752		5745
5753		5746
5754		5747
5755		5748
5756		5749
5757		5750
5758		5751
5759		5752
5760		5753
5761		5754
5762		5755
5763		5756
5764		5757
5765		5758
5766		5759
5767		5760
5768		5761
5769		5762
5770		5763
5771		5764
5772		5765
5773		5766
5774		5767
5775		5768
5776		5769
5777		5770
5778		5771
5779		5772
5780		5773
5781		5774
5782		5775
5783		5776
5784		5777
5785		5778
5786		5779
5787		5780
5788		5781
5789		5782
5790		5783
5791		5784
5792		5785
5793		5786
5794		5787
5795		5788
5796		5789
5797		5790
5798		5791
5799		5792
5800		5793
5801		5794
5802		5795
5803		5796
5804		5797
5805		5798
5806		5799
5807		5800
5808		5801
5809		5802
5810		5803
5811		5804
5812		5805
5813		5806
5814		5807
5815		5808
5816		5809
5817		5810
5818		5811
5819		5812
5820		5813
5821		5814
5822		5815
5823		5816
5824		5817
5825		5818
5826		5819
5827		5820
5828		5821
5829		5822
5830		5823
5831		5824
5832		5825
5833		5826
5834		5827
5835		5828
5836		5829
5837		5830
5838		5831
5839		5832
5840		5833
5841		5834
5842		5835
5843		5836
5844		5837
5845		5838
5846		5839
5847		5840
5848		5841
5849		5842
5850		5843
5851		5844
5852		5845
5853		5846
5854		5847
5855		5848
5856		5849
5857		5850
5858		5851
5859		5852
5860		5853
5861		5854
5862		5855
5863		5856
5864		5857
5865		5858
5866		5859
5867		5860
5868		5861
5869		5862
5870		5863
5871		5864
5872		5865
5873		5866
5874		5867
5875		5868
5876		5869
5877		5870
5878		5871
5879		5872
5880		5873
5881		5874
5882		5875
5883		5876
5884		5877
5885		5878
5886		5879
5887		5880
5888		5881
5889		5882
5890		5883
5891		5884
5892		5885
5893		5886
5894		5887
5895		5888
5896		5889
5897		5890
5898		5891
5899		5892
5900		5893
5901		5894
5902		5895
5903		5896
5904		5897
5905		5898
5906		5899
5907		5900
5908		5901
5909		5902
5910		5903
5911		5904
5912		5905
5913		5906
5914		5907
5915		5908
5916		5909
5917		5910
5918		5911
5919		5912
5920		5913
5921		5914
5922		5915
5923		5916
5924		5917
5925		5918
5926		5919
5927		5920
5928		5921
5929		5922
5930		5923
5931		5924
5932		5925
5933		5926
5934		5927
5935		5928
5936		5929
5937		5930
5938		5931
5939		5932
5940		5933
5941		5934
5942		5935
5943		5936
5944		5937
5945		5938
5946		5939
5947		5940
5948		5941
5949		5942
5950		5943
5951		5944
5952		5945
5953		5946
5954		5947
5955		5948
5956		5949
5957		5950
5958		5951
5959		5952
5960		5953
5961		5954
5962		5955
5963		5956
5964		5957
5965		5958
5966		5959
5967		5960
5968		5961
5969		5962
5970		5963
5971		5964
5972		5965
5973		5966
5974		5967
5975		5968
5976		5969
5977		5970
5978		5971
5979		5972
5980		5973
5981		5974
5982		5975
5983		5976
5984		5977
5985		5978
5986		5979
5987		5980
5988		5981
5989		5982
5990		5983
5991		5984
5992		5985
5993		5986
5994		5987
5995		5988
5996		5989
5997		5990
5998		5991
5999		5992
6000		5993
6001		5994
6002		5995
6003		5996
6004		5997
6005		5998
6006		5999
6007		6000
6008		6001
6009		6002
6010		6003
6011		6004
6012		6005
6013		6006
6014		6007
6015		6008
6016		6009
6017		6010
6018		6011
6019		6012
6020		6013
6021		6014
6022		6015
6023		6016
6024		6017
6025		6018
6026		6019
6027		6020
6028		6021
6029		6022
6030		6023
6031		6024
6032		6025
6033		6026
6034		6027
6035		6028
6036		6029
6037		6030
6038		6031
6039		6032
6040		6033
6041		6034
6042		6035
6043		6036
6044		6037
6045		6038
6046		6039
6047		6040
6048		6041
6049		6042
6050		6043
6051		6044
6052		6045
6053		6046
6054		6047
6055		6048
6056		6049
6057		6050
6058		6051
6059		6052
6060		6053
6061		6054
6062		6055
6063		6056
6064		6057
6065		6058
6066		6059
6067		6060
6068		6061
6069		6062
6070		6063
6071		6064
6072		6065
6073		6066
6074		6067
6075		6068
6076		6069
6077		6070
6078		6071
6079		6072
6080		6073
6081		6074
6082		6075
6083		6076
6084		6077
6085		6078
6086		6079
6087		6080
6088		6081
6089		6082
6090		6083
6091		6084
6092		6085
6093		6086
6094		6087
6095		6088
6096		6089
6097		6090
6098		6091
6099		6092
6100		6093
6101		6094
6102		6095
6103		6096
6104		6097
6105		6098
6106		6099
6107		6100
6108		6101
6109		6102
6110		6103
6111		6104
6112		6105
6113		6106
6114		6107
6115		6108
6116		6109
6117		6110
6118		6111
6119		6112
6120		6113
6121		6114
6122		6115
6123		6116
6124		6117
6125		6118
6126		6119
6127		6120
6128		6121
6129		6122
6130		6123
6131		6124
6132		6125
6133		6126
6134		6127
6135		6128
6136		6129
6137		6130
6138		6131
6139		6132
6140		6133
6141		6134
6142		6135
6143		6136
6144		6137
6145		6138
6146		6139
6147		6140
6148		6141
6149		6142
6150		6143
6151		6144
6152		6145
6153		6146
6154		6147
6155		6148
6156		6149
6157		6150
6158		6151
6159		6152
6160		6153
6161		6154
6162		6155
6163		6156
6164		6157
6165		6158
6166		6159
6167		6160
6168		6161
6169		6162
6170		6163
6171		6164
6172		6165
6173		6166
6174		6167
6175		6168
6176		6169
6177		6170
6178		6171
6179		6172
6180		6173
6181		6174
6182		6175
6183		6176
6184		6177
6185		6178
6186		6179
6187		6180
6188		6181
6189		6182
6190		6183
6191		6184
6192		6185
6193		6186
6194		6187
6195		6188
6196		6189
6197		6190
6198		6191
6199		6192
6200		6193
6201		6194
6202		6195
6203		6196
6204		6197
6205		6198
6206		6199
6207		6200
6208		6201
6209		6202
6210		6203
6211		6204
6212		6205
6213		6206
6214		6207
6215		6208
6216		6209
6217		6210
6218		6211
6219		6212
6220		6213
6221		6214
6222		6215
6223		6216
6224		6217
6225		6218
6226		6219
6227		6220
6228		6221
6229		6222
6230		6223
6231		6224
6232		6225
6233		6226
6234		6227
6235		6228
6236		6229
6237		6230
6238		6231
6239		6232
6240		6233
6241		6234
6242		6235
6243		6236
6244		6237
6245		6238
6246		6239
6247		6240
6248		6241
6249		6242
6250		6243
6251		6244
6252		6245
6253		6246
6254		6247
6255		6248
6256		6249
6257		6250
6258		6251
6259		6252
6260		6253
6261		6254
6262		6255
6263		6256
6264		6257
6265		6258
6266		6259
6267		6260
6268		6261
6269		6262
6270		6263
6271		6264
6272		6265
6273		6266
6274		6267
6275		6268
6276		6269
6277		6270
6278		6271
6279		6272
6280		6273
6281		6274
6282		6275
6283		6276
6284		6277
6285		6278
6286		6279
6287		6280
6288		6281
6289		6282
6290		6283
6291		6284
6292		6285
6293		6286
6294		6287
6295		6288
6296		6289
6297		6290
6298		6291
6299		6292
6300		6293
6301		6294
6302		6295
6303		6296
6304		6297
6305		6298
6306		6299
6307		6300
6308		6301
6309		6302
6310		6303
6311		6304
6312		6305
6313		6306
6314		6307
6315		6308
6316		6309
6317		6310
6318		6311
6319		6312
6320		6313
6321		6314
6322		6315
6323		6316
6324		6317
6325		6318
6326		6319
6327		6320
6328		6321
6329		6322
6330		6323
6331		6324
6332		6325
6333		6326
6334		6327
6335		6328
6336		6329
6337		6330
6338		6331
6339		6332
6340		6333
6341		6334
6342		6335
6343		6336
6344		6337
6345		6338
6346		6339
6347		6340
6348		6341
6349		6342
6350		6343
6351		6344
6352		6345
6353		6346
6354		6347
6355		6348
6356		6349
6357		6350
6358		6351
6359		6352
6360		6353
6361		6354
6362		6355
6363		6356
6364		6357
6365		6358
6366		6359
6367		6360
6368		6361
6369		6362
6370		6363
6371		6364
6372		6365
6373		6366
6374		6367
6375		6368
6376		6369
6377		6370
6378		6371
6379		6372
6380		6373
6381		6374
6382		6375
6383		6376
6384		6377
6385		6378
6386		6379
6387		6380
6388		6381
6389		6382
6390		6383
6391		6384
6392		6385
6393		6386
6394		6387
6395		6388
6396		6389
6397		6390
6398		6391
6399		6392
6400		6393
6401		6394
6402		6395
6403		6396
6404		6397
6405		6398
6406		6399
6407		6400
6408		6401
6409		6402
6410		6403
6411		6404
6412		6405
6413		6406
6414		6407
6415		6408
6416		6409
6417		6410
6418		6411
6419		6412
6420		6413
6421		6414
6422		6415
6423		6416
6424		6417
6425		6418
6426		6419
6427		6420
6428		6421
6429		6422
6430		6423
6431		6424
6432		6425
6433		6426
6434		6427
6435		6428
6436		6429
6437		6430
6438		6431
6439		6432
6440		6433
6441		6434
6442		6435
6443		6436
6444		6437
6445		6438
6446		6439
6447		6440
6448		6441
6449		6442
6450		6443
6451		6444
6452		6445
6453		6446
6454		6447
6455		6448
6456		6449
6457		6450
6458		6451
6459		6452
6460		6453
6461		6454
6462		6455
6463		6456
6464		6457
6465		6458
6466		6459
6467		6460
6468		6461
6469		6462
6470		6463
6471		6464
6472		6465
6473		6466
6474		6467
6475		6468
6476		6469
6477		6470
6478		6471
6479		6472
6480		6473
6481		6474
6482		6475
6483		6476
6484		6477
6485		6478
6486		6479
6487		6480
6488		6481
6489		6482
6490		6483
6491		6484
6492		6485
6493		6486
6494		6487
6495		6488
6496		6489
6497		6490
6498		6491
6499		6492
6500		6493
6501		6494
6502		6495
6503		6496
6504		6497
6505		6498
6506		6499
6507		6500
6508		6501
6509		6502
6510		6503
6511		6504
6512		6505
6513		6506
6514		6507
6515		6508
6516		6509
6517		6510
6518		6511
6519		6512
6520		6513
6521		6514
6522		6515
6523		6516
6524		6517
6525		6518
6526		6519
6527		6520
6528		6521
6529		6522
6530		6523
6531		6524
6532		6525
6533		6526
6534		6527
6535		6528
6536		6529
6537		6530
6538		6531
6539		6532
6540		6533
6541		6534
6542		6535
6543		6536
6544		6537
6545		6538
6546		6539
6547		6540
6548		6541
6549		6542
6550		6543
6551		6544
6552		6545
6553		6546
6554		6547
6555		6548
6556		6549
6557		6550
6558		6551
6559		6552
6560		6553
6561		6554
6562		6555
6563		6556
6564		6557
6565		6558
6566		6559
6567		6560
6568		6561
6569		6562
6570		6563
6571		6564
6572		6565
6573		6566
6574		6567
6575		6568
6576		6569
6577		6570
6578		6571
6579		6572
6580		6573
6581		6574
6582		6575
6583		6576
6584		6577
6585		6578
6586		6579
6587		6580
6588		6581
6589		6582
6590		6583
6591		6584
6592		6585
6593		6586
6594		6587
6595		6588
6596		6589
6597		6590
6598		6591
6599		6592
6600		6593
6601		6594
6602		6595
6603		6596
6604		6597
6605		6598
6606		6599
6607		6600
6608		6601
6609		6602
6610		6603
6611		6604
6612		6605
6613		6606
6614		6607
6615		6608
6616		6609
6617		6610
6618		6611
6619		6612
6620		6613
6621		6614
6622		6615
6623		6616
6624		6617
6625		6618
6626		6619
6627		6620
6628		6621
6629		6622
6630		6623
6631		6624
6632		6625
6633		6626
6634		6627
6635		6628
6636		6629
6637		6630
6638		6631
6639		6632
6640		6633
6641		6634
6642		6635
6643		6636
6644		6637
6645		6638
6646		6639
6647		6640
6648		6641
6649		6642
6650		6643
6651		6644
6652		6645
6653		6646
6654		6647
6655		6648
6656		6649
6657		6650
6658		6651
6659		6652
6660		6653
6661		6654
6662		6655
6663		6656
6664		6657
6665		6658
6666		6659
6667		6660
6668		6661
6669		6662
6670		6663
6671		6664
6672		6665
6673		6667
6674		6668
6675		6669
6676		6670
6677		6671
6678		6672
6679		6673
6680		6674
6681		6675
6682		6676
6683		6677
6684		6678
6685		6679
6686		6680
6687		6681
6688		6682
6689		6683
6690		6684
6691		6685
6692		6686
6693		6687
6694		6688
6695		6689
6696		6690
6697		6691
6698		6692
6699		6693
6700		6694
6701		6695
6702		6696
6703		6697
6704		6698
6705		6699
6706		6700
6707		6701
6708		6702
6709		6703
6710		6704
6711		6705
6712		6706
6713		6707
6714		6708
6715		6709
6716		6710
6717		6711
6718		6712
6719		6713
6720		6714
6721		6715
6722		6716
6723		6717
6724		6718
6725		6719
6726		6720
6727		6721
6728		6722
6729		6723
6730		6724
6731		6725
6732		6726
6733		6727
6734		6728
6735		6729
6736		6730
6737		6731
6738		6732
6739		6733
6740		6734
6741		6735
6742		6736
6743		6737
6744		6738
6745		6739
6746		6740
6747		6741
6748		6742
6749		6743
6750		6744
6751		6745
6752		6746
6753		6747
6754		6748
6755		6749
6756		6750
6757		6751
6758		6752
6759		6753
6760		6754
6761		6755
6762		6756
6763		6757
6764		6758
6765		6759
6766		6760
6767		6761
6768		6762
6769		6763
6770		6764
6771		6765
6772		6766
6773		6767
6774		6768
6775		6769
6776		6770
6777		6771
6778		6772
6779		6773
6780		6774
6781		6775
6782		6776
6783		6777
6784		6778
6785		6779
6786		6780
6787		6781
6788		6782
6789		6783
6790		6784
6791		6785
6792		6786
6793		6787
6794		6788
6795		6789
6796		6790
6797		6791
6798		6792
6799		6793
6800		6794
6801		6795
6802		6796
6803		6797
6804		6798
6805		6799
6806		6800
6807		6801
6808		6802
6809		6803
6810		6804
6811		6805
6812		6806
6813		6807
6814		6808
6815		6809
6816		6810
6817		6811
6818		6812
6819		6813
6820		6814
6821		6815
6822		6816
6823		6817
6824		6818
6825		6819
6826		6820
6827		6821
6828		6822
6829		6823
6830		6824
6831		6825
6832		6826
6833		6827
6834		6828
6835		6829
6836		6830
6837		6831
6838		6832
6839		6833
6840		6834
6841		6835
6842		6836
6843		6837
6844		6838
6845		6839
6846		6840
6847		6841
6848		6842
6849		6843
6850		6844
6851		6845
6852		6846
6853		6847
6854		6848
6855		6849
6856		6850
6857		6851
6858		6852
6859		6853
6860		6854
6861		6855
6862		6856
6863		6857
6864		6858
6865		6859
6866		6860
6867		6861
6868		6862
6869		6863
6870		6864
6871		6865
6872		6866
6873		6867
6874		6868
6875		6869
6876		6870
6877		6871
6878		6872
6879		6873
6880		6874
6881		6875
6882		6876
6883		6877
6884		6878
6885		6879
6886		6880
6887		6881
6888		6882
6889		6883
6890		6884
6891		6885
6892		6886
6893		6887
6894		6888
6895		6889
6896		6890
6897		6891
6898		6892
6899		6893
6900		6894
6901		6895
6902		6896
6903		6897
6904		6898
6905		6899
6906		6900
6907		6901
6908		6902
6909		6903
6910		6904
6911		6905
6912		6906
6913		6907
6914		6908
6915		6909
6916		6910
6917		6911
6918		6912
6919		6913
6920		6914
6921		6915
6922		6916
6923		6917
6924		6918
6925		6919
6926		6920
6927		6921
6928		6922
6929		6923
6930		6924
6931		6925
6932		6926
6933		6927
6934		6928
6935		6929
6936		6930
6937		6931
6938		6932
6939		6933
6940		6934
6941		6935
6942		6936
6943		6937
6944		6938
6945		6939
6946		6940
6947		6941
6948		6942
6949		6943
6950		6944
6951		6945
6952		6946
6953		6947
6954		6948
6955		6949
6956		6950
6957		6951
6958		6952
6959		6953
6960		6954
6961		6955
6962		6956
6963		6957
6964		6958
6965		6959
6966		6960
6967		6961
6968		6962
6969		6963
6970		6964
6971		6965
6972		6966
6973		6967
6974		6968
6975		6969
6976		6970
6977		6971
6978		6972
6979		6973
6980		6974
6981		6975
6982		6976
6983		6977
6984		6978
6985		6979
6986		6980
6987		6981
6988		6982
6989		6983
6990		6984
6991		6985
6992		6986
6993		6987
6994		6988
6995		6989
6996		6990
6997		6991
6998		6992
6999		6993
7000		6994
7001		6995
7002		6996
7003		6997
7004		6998
7005		6999
7006		7000
7007		7001
7008		7002
7009		7003
7010		7004
7011		7005
7012		7006
7013		7007
7014		7008
7015		7009
7016		7010
7017		7011
7018		7012
7019		7013
7020		7014
7021		7015
7022		7016
7023		7017
7024		7018
7025		7019
7026		7020
7027		7021
7028		7022
7029		7023
7030		7024
7031		7025
7032		7026
7033		7027
7034		7028
7035		7029
7036		7030
7037		7031
7038		7032
7039		7033
7040		7034
7041		7035
7042		7036
7043		7037
7044		7038
7045		7039
7046		7040
7047		7041
7048		7042
7049		7043
7050		7044
7051		7045
7052		7046
7053		7047
7054		7048
7055		7049
7056		7050
7057		7051
7058		7052
7059		7053
7060		7054
7061		7055
7062		7056
7063		7057
7064		7058
7065		7059
7066		7060
7067		7061
7068		7062
7069		7063
7070		7064
7071		7065
7072		7066
7073		7067
7074		7068
7075		7069
7076		7070
7077		7071
7078		7072
7079		7073
7080		7074
7081		7075
7082		7076
7083		7077
7084		7078
7085		7079
7086		7080
7087		7081
7088		7082
7089		7083
7090		7084
7091		7085
7092		7086
7093		7087
7094		7088
7095		7089
7096		7090
7097		7091
7098		7092
7099		7093
7100		7094
7101		7095
7102		7096
7103		7097
7104		7098
7105		7099
7106		7100
7107		7101
7108		7102
7109		7103
7110		7104
7111		7105
7112		7106
7113		7107
7114		7108
7115		7109
7116		7110
7117		7111
7118		7112
7119		7113
7120		7114
7121		7115
7122		7116
7123		7117
7124		7118
7125		7119
7126		7120
7127		7121
7128		7122
7129		7123
7130		7124
7131		7125
7132		7126
7133		7127
7134		7128
7135		7129
7136		7130
7137		7131
7138		7132
7139		7133
7140		7134
7141		7135
7142		7136
7143		7137
7144		7138
7145		7139
7146		7140
7147		7141
7148		7142
7149		7143
7150		7144
7151		7145
7152		7146
7153		7147
7154		7148
7155		7149
7156		7150
7157		7151
7158		7152
7159		7153
7160		7154
7161		7155
7162		7156
7163		7157
7164		7158
7165		7159
7166		7160
7167		7161
7168		7162
7169		7163
7170		7164
7171		7165
7172		7166
7173		7167
7174		7168
7175		7169
7176		7170
7177		7171
7178		7172
7179		7173
7180		7174
7181		7175
7182		7176
7183		7177
7184		7178
7185		7179
7186		7180
7187		7181
7188		7182
7189		7183
7190		7184
7191		7185
7192		7186
7193		7187
7194		7188
7195		7189
7196		7190
7197		7191
7198		7192
7199		7193
7200		7194
7201		7195
7202		7196
7203		7197
7204		7198
7205		7199
7206		7200
7207		7201
7208		7202
7209		7203
7210		7204
7211		7205
7212		7206
7213		7207
7214		7208
7215		7209
7216		7210
7217		7211
7218		7212
7219		7213
7220		7214
7221		7215
7222		7216
7223		7217
7224		7218
7225		7219
7226		7220
7227		7221
7228		7222
7229		7223
7230		7224
7231		7225
7232		7226
7233		7227
7234		7228
7235		7229
7236		7230
7237		7231
7238		7232
7239		7233
7240		7234
7241		7235
7242		7236
7243		7237
7244		7238
7245		7239
7246		7240
7247		7241
7248		7242
7249		7243
7250		7244
7251		7245
7252		7246
7253		7247
7254		7248
7255		7249
7256		7250
7257		7251
7258		7252
7259		7253
7260		7254
7261		7255
7262		7256
7263		7257
7264		7258
7265		7259
7266		7260
7267		7261
7268		7262
7269		7263
7270		7264
7271		7265
7272		7266
7273		7267
7274		7268
7275		7269
7276		7270
7277		7271
7278		7272
7279		7273
7280		7274
7281		7275
7282		7276
7283		7277
7284		7278
7285		7279
7286		7280
7287		7281
7288		7282
7289		7283
7290		7284
7291		7285
7292		7286
7293		7287
7294		7288
7295		7289
7296		7290
7297		7291
7298		7292
7299		7293
7300		7294
7301		7295
7302		7296
7303		7297
7304		7298
7305		7299
7306		7300
7307		7301
7308		7302
7309		7303
7310		7304
7311		7305
7312		7306
7313		7307
7314		7308
7315		7309
7316		7310
7317		7311
7318		7312
7319		7313
7320		7314
7321		7315
7322		7316
7323		7317
7324		7318
7325		7319
7326		7320
7327		7321
7328		7322
7329		7323
7330		7324
7331		7325
7332		7326
7333		7327
7334		7328
7335		7329
7336		7330
7337		7331
7338		7332
7339		7333
7340		7334
7341		7335
7342		7336
7343		7337
7344		7338
7345		7339
7346		7340
7347		7341
7348		7342
7349		7343
7350		7344
7351		7345
7352		7346
7353		7347
7354		7348
7355		7349
7356		7350
7357		7351
7358		7352
7359		7353
7360		7354
7361		7355
7362		7356
7363		7357
7364		7358
7365		7359
7366		7360
7367		7361
7368		7362
7369		7363
7370		7364
7371		7365
7372		7366
7373		7367
7374		7368
7375		7369
7376		7370
7377		7371
7378		7372
7379		7373
7380		7374
7381		7375
7382		7376
7383		7377
7384		7378
7385		7379
7386		7380
7387		7381
7388		7382
7389		7383
7390		7384
7391		7385
7392		7386
7393		7387
7394		7388
7395		7389
7396		7390
7397		7391
7398		7392
7399		7393
7400		7394
7401		7395
7402		7396
7403		7397
7404		7398
7405		7399
7406		7400
7407		7401
7408		7402
7409		7403
7410		7404
7411		7405
7412		7406
7413		7407
7414		7408
7415		7409
7416		7410
7417		7411
7418		7412
7419		7413
7420		7414
7421		7415
7422		7416
7423		7417
7424		7418
7425		7419
7426		7420
7427		7421
7428		7422
7429		7423
7430		7424
7431		7425
7432		7426
7433		7427
7434		7428
7435		7429
7436		7430
7437		7431
7438		7432
7439		7433
7440		7434
7441		7435
7442		7436
7443		7437
7444		7438
7445		7439
7446		7440
7447		7441
7448		7442
7449		7443
7450		7444
7451		7445
7452		7446
7453		7447
7454		7448
7455		7449
7456		7450
7457		7451
7458		7452
7459		7453
7460		7454
7461		7455
7462		7456
7463		7457
7464		7458
7465		7459
7466		7460
7467		7461
7468		7462
7469		7463
7470		7464
7471		7465
7472		7466
7473		7467
7474		7468
7475		7469
7476		7470
7477		7471
7478		7472
7479		7473
7480		7474
7481		7475
7482		7476
7483		7477
7484		7478
7485		7479
7486		7480
7487		7481
7488		7482
7489		7483
7490		7484
7491		7485
7492		7486
7493		7487
7494		7488
7495		7489
7496		7490
7497		7491
7498		7492
7499		7493
7500		7494
7501		7495
7502		7496
7503		7497
7504		7498
7505		7499
7506		7500
7507		7501
7508		7502
7509		7503
7510		7504
7511		7505
7512		7506
7513		7507
7514		7508
7515		7509
7516		7510
7517		7511
7518		7512
7519		7513
7520		7514
7521		7515
7522		7516
7523		7517
7524		7518
7525		7519
7526		7520
7527		7521
7528		7522
7529		7523
7530		7524
7531		7525
7532		7526
7533		7527
7534		7528
7535		7529
7536		7530
7537		7531
7538		7532
7539		7533
7540		7534
7541		7535
7542		7536
7543		7537
7544		7538
7545		7539
7546		7540
7547		7541
7548		7542
7549		7543
7550		7544
7551		7545
7552		7546
7553		7547
7554		7548
7555		7549
7556		7550
7557		7551
7558		7552
7559		7553
7560		7554
7561		7555
7562		7556
7563		7557
7564		7558
7565		7559
7566		7560
7567		7561
7568		7562
7569		7563
7570		7564
7571		7565
7572		7566
7573		7567
7574		7568
7575		7569
7576		7570
7577		7571
7578		7572
7579		7573
7580		7574
7581		7575
7582		7576
7583		7577
7584		7578
7585		7579
7586		7580
7587		7581
7588		7582
7589		7583
7590		7584
7591		7585
7592		7586
7593		7587
7594		7588
7595		7589
7596		7590
7597		7591
7598		7592
7599		7593
7600		7594
7601		7595
7602		7596
7603		7597
7604		7598
7605		7599
7606		7600
7607		7601
7608		7602
7609		7603
7610		7604
7611		7605
7612		7606
7613		7607
7614		7608
7615		7609
7616		7610
7617		7611
7618		7612
7619		7613
7620		7614
7621		7615
7622		7616
7623		7617
7624		7618
7625		7619
7626		7620
7627		7621
7628		7622
7629		7623
7630		7624
7631		7625
7632		7626
7633		7627
7634		7628
7635		7629
7636		7630
7637		7631
7638		7632
7639		7633
7640		7634
7641		7635
7642		7636
7643		7637
7644		7638
7645		7639
7646		7640
7647		7641
7648		7642
7649		7643
7650		7644
7651		7645
7652		7646
7653		7647
7654		7648
7655		7649
7656		7650
7657		7651
7658		7652
7659		7653
7660		7654
7661		7655
7662		7656
7663		7657
7664		7658
7665		7659
7666		7660
7667		7661
7668		7662
7669		7663
7670		7664
7671		7665
7672		7666
7673		7667
7674		7668
7675		7669
7676		7670
7677		7671
7678		7672
7679		7673
7680		7674
7681		7675
7682		7676
7683		7677
7684		7678
7685		7679
7686		7680
7687		7681
7688		7682
7689		7683
7690		7684
7691		7685
7692		7686
7693		7687
7694		7688
7695		7689
7696		7690
7697		7691
7698		7692
7699		7693
7700		7694
7701		7695
7702		7696
7703		7697
7704		7698
7705		7699
7706		7700
7707		7701
7708		7702
7709		7703
7710		7704
7711		7705
7712		7706
7713		7707
7714		7708
7715		7709
7716		7710
7717		7711
7718		7712
7719		7713
7720		7714
7721		7715
7722		7716
7723		7717
7724		7718
7725		7719
7726		7720
7727		7721
7728		7722
7729		7723
7730		7724
7731		7725
7732		7726
7733		7727
7734		7728
7735		7729
7736		7730
7737		7731
7738		7732
7739		7733
7740		7734
7741		7735
7742		7736
7743		7737
7744		7738
7745		7739
7746		7740
7747		7741
7748		7742
7749		7743
7750		7744
7751		7745
7752		7746
7753		7747
7754		7748
7755		7749
7756		7750
7757		7751
7758		7752
7759		7753
7760		7754
7761		7755
7762		7756
7763		7757
7764		7758
7765		7759
7766		7760
7767		7761
7768		7762
7769		7763
7770		7764
7771		7765
7772		7766
7773		7767
7774		7768
7775		7769
7776		7770
7777		7771
7778		7772
7779		7773
7780		7774
7781		7775
7782		7776
7783		7778
7784		7779
7785		7780
7786		7781
7787		7782
7788		7783
7789		7784
7790		7785
7791		7786
7792		7787
7793		7788
7794		7789
7795		7790
7796		7791
7797		7792
7798		7793
7799		7794
7800		7795
7801		7796
7802		7797
7803		7798
7804		7799
7805		7800
7806		7801
7807		7802
7808		7803
7809		7804
7810		7805
7811		7806
7812		7807
7813		7808
7814		7809
7815		7810
7816		7811
7817		7812
7818		7813
7819		7814
7820		7815
7821		7816
7822		7817
7823		7818
7824		7819
7825		7820
7826		7821
7827		7822
7828		7823
7829		7824
7830		7825
7831		7826
7832		7827
7833		7828
7834		7829
7835		7830
7836		7831
7837		7832
7838		7833
7839		7834
7840		7835
7841		7836
7842		7837
7843		7838
7844		7839
7845		7840
7846		7841
7847		7842
7848		7843
7849		7844
7850		7845
7851		7846
7852		7847
7853		7848
7854		7849
7855		7850
7856		7851
7857		7852
7858		7853
7859		7854
7860		7855
7861		7856
7862		7857
7863		7858
7864		7859
7865		7860
7866		7861
7867		7862
7868		7863
7869		7864
7870		7865
7871		7866
7872		7867
7873		7868
7874		7869
7875		7870
7876		7871
7877		7872
7878		7873
7879		7874
7880		7875
7881		7876
7882		7877
7883		7878
7884		7879
7885		7880
7886		7881
7887		7882
7888		7883
7889		7884
7890		7885
7891		7886
7892		7887
7893		7888
7894		7889
7895		7890
7896		7891
7897		7892
7898		7893
7899		7894
7900		7895
7901		7896
7902		7897
7903		7898
7904		7899
7905		7900
7906		7901
7907		7902
7908		7903
7909		7904
7910		7905
7911		7906
7912		7907
7913		7908
7914		7909
7915		7910
7916		7911
7917		7912
7918		7913
7919		7914
7920		7915
7921		7916
7922		7917
7923		7918
7924		7919
7925		7920
7926		7921
7927		7922
7928		7923
7929		7924
7930		7925
7931		7926
7932		7927
7933		7928
7934		7929
7935		7930
7936		7931
7937		7932
7938		7933
7939		7934
7940		7935
7941		7936
7942		7937
7943		7938
7944		7939
7945		7940
7946		7941
7947		7942
7948		7943
7949		7944
7950		7945
7951		7946
7952		7947
7953		7948
7954		7949
7955		7950
7956		7951
7957		7952
7958		7953
7959		7954
7960		7955
7961		7956
7962		7957
7963		7958
7964		7959
7965		7960
7966		7961
7967		7962
7968		7963
7969		7964
7970		7965
7971		7966
7972		7967
7973		7968
7974		7969
7975		7970
7976		7971
7977		7972
7978		7973
7979		7974
7980		7975
7981		7976
7982		7977
7983		7978
7984		7979
7985		7980
7986		7981
7987		7982
7988		7983
7989		7984
7990		7985
7991		7986
7992		7987
7993		7988
7994		7989
7995		7990
7996		7991
7997		7992
7998		7993
7999		7994
8000		7995
8001		7996
8002		7997
8003		7998
8004		7999
8005		8000
8006		8001
8007		8002
8008		8003
8009		8004
8010		8005
8011		8006
8012		8007
8013		8008
8014		8009
8015		8010
8016		8011
8017		8012
8018		8013
8019		8014
8020		8015
8021		8016
8022		8017
8023		8018
8024		8019
8025		8020
8026		8021
8027		8022
8028		8023
8029		8024
8030		8025
8031		8026
8032		8027
8033		8028
8034		8029
8035		8030
8036		8031
8037		8032
8038		8033
8039		8034
8040		8035
8041		8036
8042		8037
8043		8038
8044		8039
8045		8040
8046		8041
8047		8042
8048		8043
8049		8044
8050		8045
8051		8046
8052		8047
8053		8048
8054		8049
8055		8050
8056		8051
8057		8052
8058		8053
8059		8054
8060		8055
8061		8056
8062		8057
8063		8058
8064		8059
8065		8060
8066		8061
8067		8062
8068		8063
8069		8064
8070		8065
8071		8066
8072		8067
8073		8068
8074		8069
8075		8070
8076		8071
8077		8072
8078		8073
8079		8074
8080		8075
8081		8076
8082		8077
8083		8078
8084		8079
8085		8080
8086		8081
8087		8082
8088		8083
8089		8084
8090		8085
8091		8086
8092		8087
8093		8088
8094		8089
8095		8090
8096		8091
8097		8092
8098		8093
8099		8094
8100		8095
8101		8096
8102		8097
8103		8098
8104		8099
8105		8100
8106		8101
8107		8102
8108		8103
8109		8104
8110		8105
8111		8106
8112		8107
8113		8108
8114		8109
8115		8110
8116		8111
8117		8112
8118		8113
8119		8114
8120		8115
8121		8116
8122		8117
8123		8118
8124		8119
8125		8120
8126		8121
8127		8122
8128		8123
8129		8124
8130		8125
8131		8126
8132		8127
8133		8128
8134		8129
8135		8130
8136		8131
8137		8132
8138		8133
8139		8134
8140		8135
8141		8136
8142		8137
8143		8138
8144		8139
8145		8140
8146		8141
8147		8142
8148		8143
8149		8144
8150		8145
8151		8146
8152		8147
8153		8148
8154		8149
8155		8150
8156		8151
8157		8152
8158		8153
8159		8154
8160		8155
8161		8156
8162		8157
8163		8158
8164		8159
8165		8160
8166		8161
8167		8162
8168		8163
8169		8164
8170		8165
8171		8166
8172		8167
8173		8168
8174		8169
8175		8170
8176		8171
8177		8172
8178		8173
8179		8174
8180		8175
8181		8176
8182		8177
8183		8178
8184		8179
8185		8180
8186		8181
8187		8182
8188		8183
8189		8184
8190		8185
8191		8186
8192		8187
8193		8188
8194		8189
8195		8190
8196		8191
8197		8192
8198		8193
8199		8194
8200		8195
8201		8196
8202		8197
8203		8198
8204		8199
8205		8200
8206		8201
8207		8202
8208		8203
8209		8204
8210		8205
8211		8206
8212		8207
8213		8208
8214		8209
8215		8210
8216		8211
8217		8212
8218		8213
8219		8214
8220		8215
8221		8216
8222		8217
8223		8218
8224		8219
8225		8220
8226		8221
8227		8222
8228		8223
8229		8224
8230		8225
8231		8226
8232		8227
8233		8228
8234		8229
8235		8230
8236		8231
8237		8232
8238		8233
8239		8234
8240		8235
8241		8236
8242		8237
8243		8238
8244		8239
8245		8240
8246		8241
8247		8242
8248		8243
8249		8244
8250		8245
8251		8246
8252		8247
8253		8248
8254		8249
8255		8250
8256		8251
8257		8252
8258		8253
8259		8254
8260		8255
8261		8256
8262		8257
8263		8258
8264		8259
8265		8260
8266		8261
8267		8262
8268		8263
8269		8264
8270		8265
8271		8266
8272		8267
8273		8268
8274		8269
8275		8270
8276		8271
8277		8272
8278		8273
8279		8274
8280		8275
8281		8276
8282		8277
8283		8278
8284		8279
8285		8280
8286		8281
8287		8282
8288		8283
8289		8284
8290		8285
8291		8286
8292		8287
8293		8288
8294		8289
8295		8290
8296		8291
8297		8292
8298		8293
8299		8294
8300		8295
8301		8296
8302		8297
8303		8298
8304		8299
8305		8300
8306		8301
8307		8302
8308		8303
8309		8304
8310		8305
8311		8306
8312		8307
8313		8308
8314		8309
8315		8310
8316		8311
8317		8312
8318		8313
8319		8314
8320		8315
8321		8316
8322		8317
8323		8318
8324		8319
8325		8320
8326		8321
8327		8322
8328		8323
8329		8324
8330		8325
8331		8326
8332		8327
8333		8328
8334		8329
8335		8330
8336		8331
8337		8332
8338		8333
8339		8334
8340		8335
8341		8336
8342		8337
8343		8338
8344		8339
8345		8340
8346		8341
8347		8342
8348		8343
8349		8344
8350		8345
8351		8346
8352		8347
8353		8348
8354		8349
8355		8350
8356		8351
8357		8352
8358		8353
8359		8354
8360		8355
8361		8356
8362		8357
8363		8358
8364		8359
8365		8360
8366		8361
8367		8362
8368		8363
8369		8364
8370		8365
8371		8366
8372		8367
8373		8368
8374		8369
8375		8370
8376		8371
8377		8372
8378		8373
8379		8374
8380		8375
8381		8376
8382		8377
8383		8378
8384		8379
8385		8380
8386		8381
8387		8382
8388		8383
8389		8384
8390		8385
8391		8386
8392		8387
8393		8388
8394		8389
8395		8390
8396		8391
8397		8392
8398		8393
8399		8394
8400		8395
8401		8396
8402		8397
8403		8398
8404		8399
8405		8400
8406		8401
8407		8402
8408		8403
8409		8404
8410		8405
8411		8406
8412		8407
8413		8408
8414		8409
8415		8410
8416		8411
8417		8412
8418		8413
8419		8414
8420		8415
8421		8416
8422		8417
8423		8418
8424		8419
8425		8420
8426		8421
8427		8422
8428		8423
8429		8424
8430		8425
8431		8426
8432		8427
8433		8428
8434		8429
8435		8430
8436		8431
8437		8432
8438		8433
8439		8434
8440		8435
8441		8436
8442		8437
8443		8438
8444		8439
8445		8440
8446		8441
8447		8442
8448		8443
8449		8444
8450		8445
8451		8446
8452		8447
8453		8448
8454		8449
8455		8450
8456		8451
8457		8452
8458		8453
8459		8454
8460		8455
8461		8456
8462		8457
8463		8458
8464		8459
8465		8460
8466		8461
8467		8462
8468		8463
8469		8464
8470		8465
8471		8466
8472		8467
8473		8468
8474		8469
8475		8470
8476		8471
8477		8472
8478		8473
8479		8474
8480		8475
8481		8476
8482		8477
8483		8478
8484		8479
8485		8480
8486		8481
8487		8482
8488		8483
8489		8484
8490		8485
8491		8486
8492		8487
8493		8488
8494		8489
8495		8490
8496		8491
8497		8492
8498		8493
8499		8494
8500		8495
8501		8496
8502		8497
8503		8498
8504		8499
8505		8500
8506		8501
8507		8502
8508		8503
8509		8504
8510		8505
8511		8506
8512		8507
8513		8508
8514		8509
8515		8510
8516		8511
8517		8512
8518		8513
8519		8514
8520		8515
8521		8516
8522		8517
8523		8518
8524		8519
8525		8520
8526		8521
8527		8522
8528		8523
8529		8524
8530		8525
8531		8526
8532		8527
8533		8528
8534		8529
8535		8530
8536		8531
8537		8532
8538		8533
8539		8534
8540		8535
8541		8536
8542		8537
8543		8538
8544		8539
8545		8540
8546		8541
8547		8542
8548		8543
8549		8544
8550		8545
8551		8546
8552		8547
8553		8548
8554		8549
8555		8550
8556		8551
8557		8552
8558		8553
8559		8554
8560		8555
8561		8556
8562		8557
8563		8558
8564		8559
8565		8560
8566		8561
8567		8562
8568		8563
8569		8564
8570		8565
8571		8566
8572		8567
8573		8568
8574		8569
8575		8570
8576		8571
8577		8572
8578		8573
8579		8574
8580		8575
8581		8576
8582		8577
8583		8578
8584		8579
8585		8580
8586		8581
8587		8582
8588		8583
8589		8584
8590		8585
8591		8586
8592		8587
8593		8588
8594		8589
8595		8590
8596		8591
8597		8592
8598		8593
8599		8594
8600		8595
8601		8596
8602		8597
8603		8598
8604		8599
8605		8600
8606		8601
8607		8602
8608		8603
8609		8604
8610		8605
8611		8606
8612		8607
8613		8608
8614		8609
8615		8610
8616		8611
8617		8612
8618		8613
8619		8614
8620		8615
8621		8616
8622		8617
8623		8618
8624		8619
8625		8620
8626		8621
8627		8622
8628		8623
8629		8624
8630		8625
8631		8626
8632		8627
8633		8628
8634		8629
8635		8630
8636		8631
8637		8632
8638		8633
8639		8634
8640		8635
8641		8636
8642		8637
8643		8638
8644		8639
8645		8640
8646		8641
8647		8642
8648		8643
8649		8644
8650		8645
8651		8646
8652		8647
8653		8648
8654		8649
8655		8650
8656		8651
8657		8652
8658		8653
8659		8654
8660		8655
8661		8656
8662		8657
8663		8658
8664		8659
8665		8660
8666		8661
8667		8662
8668		8663
8669		8664
8670		8665
8671		8666
8672		8667
8673		8668
8674		8669
8675		8670
8676		8671
8677		8672
8678		8673
8679		8674
8680		8675
8681		8676
8682		8677
8683		8678
8684		8679
8685		8680
8686		8681
8687		8682
8688		8683
8689		8684
8690		8685
8691		8686
8692		8687
8693		8688
8694		8689
8695		8690
8696		8691
8697		8692
8698		8693
8699		8694
8700		8695
8701		8696
8702		8697
8703		8698
8704		8699
8705		8700
8706		8701
8707		8702
8708		8703
8709		8704
8710		8705
8711		8706
8712		8707
8713		8708
8714		8709
8715		8710
8716		8711
8717		8712
8718		8713
8719		8714
8720		8715
8721		8716
8722		8717
8723		8718
8724		8719
8725		8720
8726		8721
8727		8722
8728		8723
8729		8724
8730		8725
8731		8726
8732		8727
8733		8728
8734		8729
8735		8730
8736		8731
8737		8732
8738		8733
8739		8734
8740		8735
8741		8736
8742		8737
8743		8738
8744		8739
8745		8740
8746		8741
8747		8742
8748		8743
8749		8744
8750		8745
8751		8746
8752		8747
8753		8748
8754		8749
8755		8750
8756		8751
8757		8752
8758		8753
8759		8754
8760		8755
8761		8756
8762		8757
8763		8758
8764		8759
8765		8760
8766		8761
8767		8762
8768		8763
8769		8764
8770		8765
8771		8766
8772		8767
8773		8768
8774		8769
8775		8770
8776		8771
8777		8772
8778		8773
8779		8774
8780		8775
8781		8776
8782		8777
8783		8778
8784		8779
8785		8780
8786		8781
8787		8782
8788		8783
8789		8784
8790		8785
8791		8786
8792		8787
8793		8788
8794		8789
8795		8790
8796		8791
8797		8792
8798		8793
8799		8794
8800		8795
8801		8796
8802		8797
8803		8798
8804		8799
8805		8800
8806		8801
8807		8802
8808		8803
8809		8804
8810		8805
8811		8806
8812		8807
8813		8808
8814		8809
8815		8810
8816		8811
8817		8812
8818		8813
8819		8814
8820		8815
8821		8816
8822		8817
8823		8818
8824		8819
8825		8820
8826		8821
8827		8822
8828		8823
8829		8824
8830		8825
8831		8826
8832		8827
8833		8828
8834		8829
8835		8830
8836		8831
8837		8832
8838		8833
8839		8834
8840		8835
8841		8836
8842		8837
8843		8838
8844		8839
8845		8840
8846		8841
8847		8842
8848		8843
8849		8844
8850		8845
8851		8846
8852		8847
8853		8848
8854		8849
8855		8850
8856		8851
8857		8852
8858		8853
8859		8854
8860		8855
8861		8856
8862		8857
8863		8858
8864		8859
8865		8860
8866		8861
8867		8862
8868		8863
8869		8864
8870		8865
8871		8866
8872		8867
8873		8868
8874		8869
8875		8870
8876		8871
8877		8872
8878		8873
8879		8874
8880		8875
8881		8876
8882		8877
8883		8878
8884		8879
8885		8880
8886		8881
8887		8882
8888		8883
8889		8884
8890		8885
8891		8886
8892		8887
8893		8889
8894		8890
8895		8891
8896		8892
8897		8893
8898		8894
8899		8895
8900		8896
8901		8897
8902		8898
8903		8899
8904		8900
8905		8901
8906		8902
8907		8903
8908		8904
8909		8905
8910		8906
8911		8907
8912		8908
8913		8909
8914		8910
8915		8911
8916		8912
8917		8913
8918		8914
8919		8915
8920		8916
8921		8917
8922		8918
8923		8919
8924		8920
8925		8921
8926		8922
8927		8923
8928		8924
8929		8925
8930		8926
8931		8927
8932		8928
8933		8929
8934		8930
8935		8931
8936		8932
8937		8933
8938		8934
8939		8935
8940		8936
8941		8937
8942		8938
8943		8939
8944		8940
8945		8941
8946		8942
8947		8943
8948		8944
8949		8945
8950		8946
8951		8947
8952		8948
8953		8949
8954		8950
8955		8951
8956		8952
8957		8953
8958		8954
8959		8955
8960		8956
8961		8957
8962		8958
8963		8959
8964		8960
8965		8961
8966		8962
8967		8963
8968		8964
8969		8965
8970		8966
8971		8967
8972		8968
8973		8969
8974		8970
8975		8971
8976		8972
8977		8973
8978		8974
8979		8975
8980		8976
8981		8977
8982		8978
8983		8979
8984		8980
8985		8981
8986		8982
8987		8983
8988		8984
8989		8985
8990		8986
8991		8987
8992		8988
8993		8989
8994		8990
8995		8991
8996		8992
8997		8993
8998		8994
8999		8995
9000		8996
9001		8997
9002		8998
9003		8999
9004		9000
9005		9001
9006		9002
9007		9003
9008		9004
9009		9005
9010		9006
9011		9007
9012		9008
9013		9009
9014		9010
9015		9011
9016		9012
9017		9013
9018		9014
9019		9015
9020		9016
9021		9017
9022		9018
9023		9019
9024		9020
9025		9021
9026		9022
9027		9023
9028		9024
9029		9025
9030		9026
9031		9027
9032		9028
9033		9029
9034		9030
9035		9031
9036		9032
9037		9033
9038		9034
9039		9035
9040		9036
9041		9037
9042		9038
9043		9039
9044		9040
9045		9041
9046		9042
9047		9043
9048		9044
9049		9045
9050		9046
9051		9047
9052		9048
9053		9049
9054		9050
9055		9051
9056		9052
9057		9053
9058		9054
9059		9055
9060		9056
9061		9057
9062		9058
9063		9059
9064		9060
9065		9061
9066		9062
9067		9063
9068		9064
9069		9065
9070		9066
9071		9067
9072		9068
9073		9069
9074		9070
9075		9071
9076		9072
9077		9073
9078		9074
9079		9075
9080		9076
9081		9077
9082		9078
9083		9079
9084		9080
9085		9081
9086		9082
9087		9083
9088		9084
9089		9085
9090		9086
9091		9087
9092		9088
9093		9089
9094		9090
9095		9091
9096		9092
9097		9093
9098		9094
9099		9095
9100		9096
9101		9097
9102		9098
9103		9099
9104		9100
9105		9101
9106		9102
9107		9103
9108		9104
9109		9105
9110		9106
9111		9107
9112		9108
9113		9109
9114		9110
9115		9111
9116		9112
9117		9113
9118		9114
9119		9115
9120		9116
9121		9117
9122		9118
9123		9119
9124		9120
9125		9121
9126		9122
9127		9123
9128		9124
9129		9125
9130		9126
9131		9127
9132		9128
9133		9129
9134		9130
9135		9131
9136		9132
9137		9133
9138		9134
9139		9135
9140		9136
9141		9137
9142		9138
9143		9139
9144		9140
9145		9141
9146		9142
9147		9143
9148		9144
9149		9145
9150		9146
9151		9147
9152		9148
9153		9149
9154		9150
9155		9151
9156		9152
9157		9153
9158		9154
9159		9155
9160		9156
9161		9157
9162		9158
9163		9159
9164		9160
9165		9161
9166		9162
9167		9163
9168		9164
9169		9165
9170		9166
9171		9167
9172		9168
9173		9169
9174		9170
9175		9171
9176		9172
9177		9173
9178		9174
9179		9175
9180		9176
9181		9177
9182		9178
9183		9179
9184		9180
9185		9181
9186		9182
9187		9183
9188		9184
9189		9185
9190		9186
9191		9187
9192		9188
9193		9189
9194		9190
9195		9191
9196		9192
9197		9193
9198		9194
9199		9195
9200		9196
9201		9197
9202		9198
9203		9199
9204		9200
9205		9201
9206		9202
9207		9203
9208		9204
9209		9205
9210		9206
9211		9207
9212		9208
9213		9209
9214		9210
9215		9211
9216		9212
9217		9213
9218		9214
9219		9215
9220		9216
9221		9217
9222		9218
9223		9219
9224		9220
9225		9221
9226		9222
9227		9223
9228		9224
9229		9225
9230		9226
9231		9227
9232		9228
9233		9229
9234		9230
9235		9231
9236		9232
9237		9233
9238		9234
9239		9235
9240		9236
9241		9237
9242		9238
9243		9239
9244		9240
9245		9241
9246		9242
9247		9243
9248		9244
9249		9245
9250		9246
9251		9247
9252		9248
9253		9249
9254		9250
9255		9251
9256		9252
9257		9253
9258		9254
9259		9255
9260		9256
9261		9257
9262		9258
9263		9259
9264		9260
9265		9261
9266		9262
9267		9263
9268		9264
9269		9265
9270		9266
9271		9267
9272		9268
9273		9269
9274		9270
9275		9271
9276		9272
9277		9273
9278		9274
9279		9275
9280		9276
9281		9277
9282		9278
9283		9279
9284		9280
9285		9281
9286		9282
9287		9283
9288		9284
9289		9285
9290		9286
9291		9287
9292		9288
9293		9289
9294		9290
9295		9291
9296		9292
9297		9293
9298		9294
9299		9295
9300		9296
9301		9297
9302		9298
9303		9299
9304		9300
9305		9301
9306		9302
9307		9303
9308		9304
9309		9305
9310		9306
9311		9307
9312		9308
9313		9309
9314		9310
9315		9311
9316		9312
9317		9313
9318		9314
9319		9315
9320		9316
9321		9317
9322		9318
9323		9319
9324		9320
9325		9321
9326		9322
9327		9323
9328		9324
9329		9325
9330		9326
9331		9327
9332		9328
9333		9329
9334		9330
9335		9331
9336		9332
9337		9333
9338		9334
9339		9335
9340		9336
9341		9337
9342		9338
9343		9339
9344		9340
9345		9341
9346		9342
9347		9343
9348		9344
9349		9345
9350		9346
9351		9347
9352		9348
9353		9349
9354		9350
9355		9351
9356		9352
9357		9353
9358		9354
9359		9355
9360		9356
9361		9357
9362		9358
9363		9359
9364		9360
9365		9361
9366		9362
9367		9363
9368		9364
9369		9365
9370		9366
9371		9367
9372		9368
9373		9369
9374		9370
9375		9371
9376		9372
9377		9373
9378		9374
9379		9375
9380		9376
9381		9377
9382		9378
9383		9379
9384		9380
9385		9381
9386		9382
9387		9383
9388		9384
9389		9385
9390		9386
9391		9387
9392		9388
9393		9389
9394		9390
9395		9391
9396		9392
9397		9393
9398		9394
9399		9395
9400		9396
9401		9397
9402		9398
9403		9399
9404		9400
9405		9401
9406		9402
9407		9403
9408		9404
9409		9405
9410		9406
9411		9407
9412		9408
9413		9409
9414		9410
9415		9411
9416		9412
9417		9413
9418		9414
9419		9415
9420		9416
9421		9417
9422		9418
9423		9419
9424		9420
9425		9421
9426		9422
9427		9423
9428		9424
9429		9425
9430		9426
9431		9427
9432		9428
9433		9429
9434		9430
9435		9431
9436		9432
9437		9433
9438		9434
9439		9435
9440		9436
9441		9437
9442		9438
9443		9439
9444		9440
9445		9441
9446		9442
9447		9443
9448		9444
9449		9445
9450		9446
9451		9447
9452		9448
9453		9449
9454		9450
9455		9451
9456		9452
9457		9453
9458		9454
9459		9455
9460		9456
9461		9457
9462		9458
9463		9459
9464		9460
9465		9461
9466		9462
9467		9463
9468		9464
9469		9465
9470		9466
9471		9467
9472		9468
9473		9469
9474		9470
9475		9471
9476		9472
9477		9473
9478		9474
9479		9475
9480		9476
9481		9477
9482		9478
9483		9479
9484		9480
9485		9481
9486		9482
9487		9483
9488		9484
9489		9485
9490		9486
9491		9487
9492		9488
9493		9489
9494		9490
9495		9491
9496		9492
9497		9493
9498		9494
9499		9495
9500		9496
9501		9497
9502		9498
9503		9499
9504		9500
9505		9501
9506		9502
9507		9503
9508		9504
9509		9505
9510		9506
9511		9507
9512		9508
9513		9509
9514		9510
9515		9511
9516		9512
9517		9513
9518		9514
9519		9515
9520		9516
9521		9517
9522		9518
9523		9519
9524		9520
9525		9521
9526		9522
9527		9523
9528		9524
9529		9525
9530		9526
9531		9527
9532		9528
9533		9529
9534		9530
9535		9531
9536		9532
9537		9533
9538		9534
9539		9535
9540		9536
9541		9537
9542		9538
9543		9539
9544		9540
9545		9541
9546		9542
9547		9543
9548		9544
9549		9545
9550		9546
9551		9547
9552		9548
9553		9549
9554		9550
9555		9551
9556		9552
9557		9553
9558		9554
9559		9555
9560		9556
9561		9557
9562		9558
9563		9559
9564		9560
9565		9561
9566		9562
9567		9563
9568		9564
9569		9565
9570		9566
9571		9567
9572		9568
9573		9569
9574		9570
9575		9571
9576		9572
9577		9573
9578		9574
9579		9575
9580		9576
9581		9577
9582		9578
9583		9579
9584		9580
9585		9581
9586		9582
9587		9583
9588		9584
9589		9585
9590		9586
9591		9587
9592		9588
9593		9589
9594		9590
9595		9591
9596		9592
9597		9593
9598		9594
9599		9595
9600		9596
9601		9597
9602		9598
9603		9599
9604		9600
9605		9601
9606		9602
9607		9603
9608		9604
9609		9605
9610		9606
9611		9607
9612		9608
9613		9609
9614		9610
9615		9611
9616		9612
9617		9613
9618		9614
9619		9615
9620		9616
9621		9617
9622		9618
9623		9619
9624		9620
9625		9621
9626		9622
9627		9623
9628		9624
9629		9625
9630		9626
9631		9627
9632		9628
9633		9629
9634		9630
9635		9631
9636		9632
9637		9633
9638		9634
9639		9635
9640		9636
9641		9637
9642		9638
9643		9639
9644		9640
9645		9641
9646		9642
9647		9643
9648		9644
9649		9645
9650		9646
9651		9647
9652		9648
9653		9649
9654		9650
9655		9651
9656		9652
9657		9653
9658		9654
9659		9655
9660		9656
9661		9657
9662		9658
9663		9659
9664		9660
9665		9661
9666		9662
9667		9663
9668		9664
9669		9665
9670		9666
9671		9667
9672		9668
9673		9669
9674		9670
9675		9671
9676		9672
9677		9673
9678		9674
9679		9675
9680		9676
9681		9677
9682		9678
9683		9679
9684		9680
9685		9681
9686		9682
9687		9683
9688		9684
9689		9685
9690		9686
9691		9687
9692		9688
9693		9689
9694		9690
9695		9691
9696		9692
9697		9693
9698		9694
9699		9695
9700		9696
9701		9697
9702		9698
9703		9699
9704		9700
9705		9701
9706		9702
9707		9703
9708		9704
9709		9705
9710		9706
9711		9707
9712		9708
9713		9709
9714		9710
9715		9711
9716		9712
9717		9713
9718		9714
9719		9715
9720		9716
9721		9717
9722		9718
9723		9719
9724		9720
9725		9721
9726		9722
9727		9723
9728		9724
9729		9725
9730		9726
9731		9727
9732		9728
9733		9729
9734		9730
9735		9731
9736		9732
9737		9733
9738		9734
9739		9735
9740		9736
9741		9737
9742		9738
9743		9739
9744		9740
9745		9741
9746		9742
9747		9743
9748		9744
9749		9745
9750		9746
9751		9747
9752		9748
9753		9749
9754		9750
9755		9751
9756		9752
9757		9753
9758		9754
9759		9755
9760		9756
9761		9757
9762		9758
9763		9759
9764		9760
9765		9761
9766		9762
9767		9763
9768		9764
9769		9765
9770		9766
9771		9767
9772		9768
9773		9769
9774		9770
9775		9771
9776		9772
9777		9773
9778		9774
9779		9775
9780		9776
9781		9777
9782		9778
9783		9779
9784		9780
9785		9781
9786		9782
9787		9783
9788		9784
9789		9785
9790		9786
9791		9787
9792		9788
9793		9789
9794		9790
9795		9791
9796		9792
9797		9793
9798		9794
9799		9795
9800		9796
9801		9797
9802		9798
9803		9799
9804		9800
9805		9801
9806		9802
9807		9803
9808		9804
9809		9805
9810		9806
9811		9807
9812		9808
9813		9809
9814		9810
9815		9811
9816		9812
9817		9813
9818		9814
9819		9815
9820		9816
9821		9817
9822		9818
9823		9819
9824		9820
9825		9821
9826		9822
9827		9823
9828		9824
9829		9825
9830		9826
9831		9827
9832		9828
9833		9829
9834		9830
9835		9831
9836		9832
9837		9833
9838		9834
9839		9835
9840		9836
9841		9837
9842		9838
9843		9839
9844		9840
9845		9841
9846		9842
9847		9843
9848		9844
9849		9845
9850		9846
9851		9847
9852		9848
9853		9849
9854		9850
9855		9851
9856		9852
9857		9853
9858		9854
9859		9855
9860		9856
9861		9857
9862		9858
9863		9859
9864		9860
9865		9861
9866		9862
9867		9863
9868		9864
9869		9865
9870		9866
9871		9867
9872		9868
9873		9869
9874		9870
9875		9871
9876		9872
9877		9873
9878		9874
9879		9875
9880		9876
9881		9877
9882		9878
9883		9879
9884		9880
9885		9881
9886		9882
9887		9883
9888		9884
9889		9885
9890		9886
9891		9887
9892		9888
9893		9889
9894		9890
9895		9891
9896		9892
9897		9893
9898		9894
9899		9895
9900		9896
9901		9897
9902		9898
9903		9899
9904		9900
9905		9901
9906		9902
9907		9903
9908		9904
9909		9905
9910		9906
9911		9907
9912		9908
9913		9909
9914		9910
9915		9911
9916		9912
9917		9913
9918		9914
9919		9915
9920		9916
9921		9917
9922		9918
9923		9919
9924		9920
9925		9921
9926		9922
9927		9923
9928		9924
9929		9925
9930		9926
9931		9927
9932		9928
9933		9929
9934		9930
9935		9931
9936		9932
9937		9933
9938		9934
9939		9935
9940		9936
9941		9937
9942		9938
9943		9939
9944		9940
9945		9941
9946		9942
9947		9943
9948		9944
9949		9945
9950		9946
9951		9947
9952		9948
9953		9949
9954		9950
9955		9951
9956		9952
9957		9953
9958		9954
9959		9955
9960		9956
9961		9957
9962		9958
9963		9959
9964		9960
9965		9961
9966		9962
9967		9963
9968		9964
9969		9965
9970		9966
9971		9967
9972		9968
9973		9969
9974		9970
9975		9971
9976		9972
9977		9973
9978		9974
9979		9975
9980		9976
9981		9977
9982		9978
9983		9979
9984		9980
9985		9981
9986		9982
9987		9983
9988		9984
9989		9985
9990		9986
9991		9987
9992		9988
9993		9989
9994		9990
9995		9991
9996		9992
9997		9993
9998		9994
9999		9995
10000		9996
10001		9997
10002		9998
10003		567
10004		000
10005		222
10006		333
10007		444
10008		555
10009		666
10010		777
10011		888
10012		999
10013		001
10014		002
10015		003
10016		004
10017		005
10018		006
10019		007
10020		008
10021		009
10022		010
10023		011
10024		012
10025		013
10026		014
10027		015
10028		016
10029		017
10030		018
10031		019
10032		020
10033		021
10034		022
10035		023
10036		024
10037		025
10038		026
10039		027
10040		028
10041		029
10042		030
10043		031
10044		032
10045		033
10046		034
10047		035
10048		036
10049		037
10050		038
10051		039
10052		040
10053		041
10054		042
10055		043
10056		044
10057		045
10058		046
10059		047
10060		048
10061		049
10062		050
10063		051
10064		052
10065		053
10066		054
10067		055
10068		056
10069		057
10070		058
10071		059
10072		060
10073		061
10074		062
10075		063
10076		064
10077		065
10078		066
10079		067
10080		068
10081		069
10082		070
10083		071
10084		072
10085		073
10086		074
10087		075
10088		076
10089		077
10090		078
10091		079
10092		080
10093		081
10094		082
10095		083
10096		084
10097		085
10098		086
10099		087
10100		088
10101		089
10102		090
10103		091
10104		092
10105		093
10106		094
10107		095
10108		096
10109		097
10110		098
10111		099
10112		100
10113		101
10114		102
10115		103
10116		104
10117		105
10118		106
10119		107
10120		108
10121		109
10122		110
10123		111
10124		112
10125		113
10126		114
10127		115
10128		116
10129		117
10130		118
10131		119
10132		120
10133		121
10134		122
10135		123
10136		124
10137		125
10138		126
10139		127
10140		128
10141		129
10142		130
10143		131
10144		132
10145		133
10146		134
10147		135
10148		136
10149		137
10150		138
10151		139
10152		140
10153		141
10154		142
10155		143
10156		144
10157		145
10158		146
10159		147
10160		148
10161		149
10162		150
10163		151
10164		152
10165		153
10166		154
10167		155
10168		156
10169		157
10170		158
10171		159
10172		160
10173		161
10174		162
10175		163
10176		164
10177		165
10178		166
10179		167
10180		168
10181		169
10182		170
10183		171
10184		172
10185		173
10186		174
10187		175
10188		176
10189		177
10190		178
10191		179
10192		180
10193		181
10194		182
10195		183
10196		184
10197		185
10198		186
10199		187
10200		188
10201		189
10202		190
10203		191
10204		192
10205		193
10206		194
10207		195
10208		196
10209		197
10210		198
10211		199
10212		200
10213		201
10214		202
10215		203
10216		204
10217		205
10218		206
10219		207
10220		208
10221		209
10222		210
10223		211
10224		212
10225		213
10226		214
10227		215
10228		216
10229		217
10230		218
10231		219
10232		220
10233		221
10234		223
10235		224
10236		225
10237		226
10238		227
10239		228
10240		229
10241		230
10242		231
10243		232
10244		233
10245		234
10246		235
10247		236
10248		237
10249		238
10250		239
10251		240
10252		241
10253		242
10254		243
10255		244
10256		245
10257		246
10258		247
10259		248
10260		249
10261		250
10262		251
10263		252
10264		253
10265		254
10266		255
10267		256
10268		257
10269		258
10270		259
10271		260
10272		261
10273		262
10274		263
10275		264
10276		265
10277		266
10278		267
10279		268
10280		269
10281		270
10282		271
10283		272
10284		273
10285		274
10286		275
10287		276
10288		277
10289		278
10290		279
10291		280
10292		281
10293		282
10294		283
10295		284
10296		285
10297		286
10298		287
10299		288
10300		289
10301		290
10302		291
10303		292
10304		293
10305		294
10306		295
10307		296
10308		297
10309		298
10310		299
10311		300
10312		301
10313		302
10314		303
10315		304
10316		305
10317		306
10318		307
10319		308
10320		309
10321		310
10322		311
10323		312
10324		313
10325		314
10326		315
10327		316
10328		317
10329		318
10330		319
10331		320
10332		321
10333		322
10334		323
10335		324
10336		325
10337		326
10338		327
10339		328
10340		329
10341		330
10342		331
10343		332
10344		334
10345		335
10346		336
10347		337
10348		338
10349		339
10350		340
10351		341
10352		342
10353		343
10354		344
10355		345
10356		346
10357		347
10358		348
10359		349
10360		350
10361		351
10362		352
10363		353
10364		354
10365		355
10366		356
10367		357
10368		358
10369		359
10370		360
10371		361
10372		362
10373		363
10374		364
10375		365
10376		366
10377		367
10378		368
10379		369
10380		370
10381		371
10382		372
10383		373
10384		374
10385		375
10386		376
10387		377
10388		378
10389		379
10390		380
10391		381
10392		382
10393		383
10394		384
10395		385
10396		386
10397		387
10398		388
10399		389
10400		390
10401		391
10402		392
10403		393
10404		394
10405		395
10406		396
10407		397
10408		398
10409		399
10410		400
10411		401
10412		402
10413		403
10414		404
10415		405
10416		406
10417		407
10418		408
10419		409
10420		410
10421		411
10422		412
10423		413
10424		414
10425		415
10426		416
10427		417
10428		418
10429		419
10430		420
10431		421
10432		422
10433		423
10434		424
10435		425
10436		426
10437		427
10438		428
10439		429
10440		430
10441		431
10442		432
10443		433
10444		434
10445		435
10446		436
10447		437
10448		438
10449		439
10450		440
10451		441
10452		442
10453		443
10454		445
10455		446
10456		447
10457		448
10458		449
10459		450
10460		451
10461		452
10462		453
10463		454
10464		455
10465		456
10466		457
10467		458
10468		459
10469		460
10470		461
10471		462
10472		463
10473		464
10474		465
10475		466
10476		467
10477		468
10478		469
10479		470
10480		471
10481		472
10482		473
10483		474
10484		475
10485		476
10486		477
10487		478
10488		479
10489		480
10490		481
10491		482
10492		483
10493		484
10494		485
10495		486
10496		487
10497		488
10498		489
10499		490
10500		491
10501		492
10502		493
10503		494
10504		495
10505		496
10506		497
10507		498
10508		499
10509		500
10510		501
10511		502
10512		503
10513		504
10514		505
10515		506
10516		507
10517		508
10518		509
10519		510
10520		511
10521		512
10522		513
10523		514
10524		515
10525		516
10526		517
10527		518
10528		519
10529		520
10530		521
10531		522
10532		523
10533		524
10534		525
10535		526
10536		527
10537		528
10538		529
10539		530
10540		531
10541		532
10542		533
10543		534
10544		535
10545		536
10546		537
10547		538
10548		539
10549		540
10550		541
10551		542
10552		543
10553		544
10554		545
10555		546
10556		547
10557		548
10558		549
10559		550
10560		551
10561		552
10562		553
10563		554
10564		556
10565		557
10566		558
10567		559
10568		560
10569		561
10570		562
10571		563
10572		564
10573		565
10574		566
10575		568
10576		569
10577		570
10578		571
10579		572
10580		573
10581		574
10582		575
10583		576
10584		577
10585		578
10586		579
10587		580
10588		581
10589		582
10590		583
10591		584
10592		585
10593		586
10594		587
10595		588
10596		589
10597		590
10598		591
10599		592
10600		593
10601		594
10602		595
10603		596
10604		597
10605		598
10606		599
10607		600
10608		601
10609		602
10610		603
10611		604
10612		605
10613		606
10614		607
10615		608
10616		609
10617		610
10618		611
10619		612
10620		613
10621		614
10622		615
10623		616
10624		617
10625		618
10626		619
10627		620
10628		621
10629		622
10630		623
10631		624
10632		625
10633		626
10634		627
10635		628
10636		629
10637		630
10638		631
10639		632
10640		633
10641		634
10642		635
10643		636
10644		637
10645		638
10646		639
10647		640
10648		641
10649		642
10650		643
10651		644
10652		645
10653		646
10654		647
10655		648
10656		649
10657		650
10658		651
10659		652
10660		653
10661		654
10662		655
10663		656
10664		657
10665		658
10666		659
10667		660
10668		661
10669		662
10670		663
10671		664
10672		665
10673		667
10674		668
10675		669
10676		670
10677		671
10678		672
10679		673
10680		674
10681		675
10682		676
10683		677
10684		678
10685		679
10686		680
10687		681
10688		682
10689		683
10690		684
10691		685
10692		686
10693		687
10694		688
10695		689
10696		690
10697		691
10698		692
10699		693
10700		694
10701		695
10702		696
10703		697
10704		698
10705		699
10706		700
10707		701
10708		702
10709		703
10710		704
10711		705
10712		706
10713		707
10714		708
10715		709
10716		710
10717		711
10718		712
10719		713
10720		714
10721		715
10722		716
10723		717
10724		718
10725		719
10726		720
10727		721
10728		722
10729		723
10730		724
10731		725
10732		726
10733		727
10734		728
10735		729
10736		730
10737		731
10738		732
10739		733
10740		734
10741		735
10742		736
10743		737
10744		738
10745		739
10746		740
10747		741
10748		742
10749		743
10750		744
10751		745
10752		746
10753		747
10754		748
10755		749
10756		750
10757		751
10758		752
10759		753
10760		754
10761		755
10762		756
10763		757
10764		758
10765		759
10766		760
10767		761
10768		762
10769		763
10770		764
10771		765
10772		766
10773		767
10774		768
10775		769
10776		770
10777		771
10778		772
10779		773
10780		774
10781		775
10782		776
10783		778
10784		779
10785		780
10786		781
10787		782
10788		783
10789		784
10790		785
10791		786
10792		787
10793		788
10794		789
10795		790
10796		791
10797		792
10798		793
10799		794
10800		795
10801		796
10802		797
10803		798
10804		799
10805		800
10806		801
10807		802
10808		803
10809		804
10810		805
10811		806
10812		807
10813		808
10814		809
10815		810
10816		811
10817		812
10818		813
10819		814
10820		815
10821		816
10822		817
10823		818
10824		819
10825		820
10826		821
10827		822
10828		823
10829		824
10830		825
10831		826
10832		827
10833		828
10834		829
10835		830
10836		831
10837		832
10838		833
10839		834
10840		835
10841		836
10842		837
10843		838
10844		839
10845		840
10846		841
10847		842
10848		843
10849		844
10850		845
10851		846
10852		847
10853		848
10854		849
10855		850
10856		851
10857		852
10858		853
10859		854
10860		855
10861		856
10862		857
10863		858
10864		859
10865		860
10866		861
10867		862
10868		863
10869		864
10870		865
10871		866
10872		867
10873		868
10874		869
10875		870
10876		871
10877		872
10878		873
10879		874
10880		875
10881		876
10882		877
10883		878
10884		879
10885		880
10886		881
10887		882
10888		883
10889		884
10890		885
10891		886
10892		887
10893		889
10894		890
10895		891
10896		892
10897		893
10898		894
10899		895
10900		896
10901		897
10902		898
10903		899
10904		900
10905		901
10906		902
10907		903
10908		904
10909		905
10910		906
10911		907
10912		908
10913		909
10914		910
10915		911
10916		912
10917		913
10918		914
10919		915
10920		916
10921		917
10922		918
10923		919
10924		920
10925		921
10926		922
10927		923
10928		924
10929		925
10930		926
10931		927
10932		928
10933		929
10934		930
10935		931
10936		932
10937		933
10938		934
10939		935
10940		936
10941		937
10942		938
10943		939
10944		940
10945		941
10946		942
10947		943
10948		944
10949		945
10950		946
10951		947
10952		948
10953		949
10954		950
10955		951
10956		952
10957		953
10958		954
10959		955
10960		956
10961		957
10962		958
10963		959
10964		960
10965		961
10966		962
10967		963
10968		964
10969		965
10970		966
10971		967
10972		968
10973		969
10974		970
10975		971
10976		972
10977		973
10978		974
10979		975
10980		976
10981		977
10982		978
10983		979
10984		980
10985		981
10986		982
10987		983
10988		984
10989		985
10990		986
10991		987
10992		988
10993		989
10994		990
10995		991
10996		992
10997		993
10998		994
10999		995
11000		996
11001		997
11002		998

-1

src/utils/base64.h less more

12	12	*/
13	13
14	14	#ifndef BASE64_H
15		#define BASE64_h
	15	#define BASE64_H
16	16
17	17	unsigned char * base64_encode(const unsigned char *src, size_t len,
18	18	size_t *out_len);

+18

-0

src/utils/common.c less more

360	360	{
361	361	return foo;
362	362	}
	363
	364	char* sanitize_string(const char *s) {
	365	if(!s) return strdup("(null)");
	366	size_t i,j, l = strlen(s), ls=l;
	367	for(i=0;i<ls;i++) if(s[i] < ' ' \|\| s[i] > 127) l += 4;
	368	char *new = malloc(l+1);
	369	if(!new) return 0;
	370	for(i=0,j=0;i<ls;i++) {
	371	if(s[i] < ' ' \|\| s[i] > 127) {
	372	sprintf(new + j, "\\\\x%02x", s[i] & 0xff);
	373	j += 4;
	374	} else new[j] = s[i];
	375	j++;
	376	}
	377	new[j] = 0;
	378	return new;
	379	}
	380

-0

src/utils/common.h less more

446	446	int wpa_snprintf_hex(char buf, size_t buf_size, const u8 data, size_t len);
447	447	int wpa_snprintf_hex_uppercase(char buf, size_t buf_size, const u8 data,
448	448	size_t len);
	449	char* sanitize_string(const char *s);
449	450
450	451	#ifdef CONFIG_NATIVE_WINDOWS
451	452	void wpa_unicode2ascii_inplace(TCHAR *str);

+263

-0

src/utils/endianness.h less more

	0	#ifndef ENDIANNESS_H
	1	#define ENDIANNESS_H
	2
	3	/* Public domain implementation for endianness detection and byte ordering on
	4	several platforms. In case the concept of public domain does not exist
	5	under your jurisdiction, you can consider it to be dual licensed
	6	under the MIT, Apache and WTFPL licenses.
	7
	8	Grab it and drop it into your project, include it and use
	9	the following macros to determine endianness:
	10
	11	ENDIANNESS_LE, ENDIANNESS_BE
	12
	13	e.g. #if ENDIANNESS_LE ...
	14
	15	or, even nicer without littering your code with #ifdefs:
	16
	17	if (ENDIANNESS_BE) { big_endian_code(); } else { little_endian_code(); }
	18
	19	... since the compiler can optimize away unused branches, this makes your
	20	code easier to read while not loosing any of the advantage of using
	21	conditional compilation, plus you get a free compile-time check of the
	22	unused code path (rarely used conditonally compiled code paths often get
	23	defunct over time if nobody checks them all the time).
	24
	25	To debug this header yourself, you can define ENDIANNESS_DEBUG to see
	26	warnings from where we take the defs for the specific target.
	27
	28	If you need only the conversion functions from big to little endian
	29	and vice versa, you may want to #define ENDIANNESS_PORTABLE_CONVERSION
	30	prior to including this header. That way, when the endiannes can't be
	31	determined at compile time, the code will fallback to a slower,
	32	but portable version of those functions.
	33	However, if using it, it's not guaranteed that ENDIANNESS_LE/BE
	34	will be defined.
	35	Most people however need only the conversion functions in their code,
	36	so if you stick to them you can safely turn the portable conversion on.
	37	*/
	38
	39	/* This should catch all modern GCCs and Clang */
	40	#if (defined __BYTE_ORDER__) && (defined __ORDER_LITTLE_ENDIAN__)
	41	# ifdef ENDIANNESS_DEBUG
	42	# warning "Taking endiannes from built-in __BYTE_ORDER__"
	43	# endif
	44	# if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
	45	# define ENDIANNESS_LE 1
	46	# define ENDIANNESS_BE 0
	47	# elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
	48	# define ENDIANNESS_LE 0
	49	# define ENDIANNESS_BE 1
	50	# endif
	51	/* Try to derive from arch/compiler-specific macros */
	52	#elif defined(_X86_) \|\| defined(__x86_64__) \|\| defined(__i386__) \|\| \
	53	defined(__i486__) \|\| defined(__i586__) \|\| defined(__i686__) \|\| \
	54	defined(__MIPSEL) \|\| defined(_MIPSEL) \|\| defined(MIPSEL) \|\| \
	55	defined(__ARMEL__) \|\| \
	56	(defined(__LITTLE_ENDIAN__) && __LITTLE_ENDIAN__ == 1) \|\| \
	57	(defined(_LITTLE_ENDIAN) && _LITTLE_ENDIAN == 1) \|\| \
	58	defined(_M_IX86) \|\| defined(_M_AMD64) /* MSVC */
	59	# ifdef ENDIANNESS_DEBUG
	60	# warning "Detected Little Endian target CPU"
	61	# endif
	62	# define ENDIANNESS_LE 1
	63	# define ENDIANNESS_BE 0
	64	#elif defined(__MIPSEB) \|\| defined(_MIPSEB) \|\| defined(MIPSEB) \|\| \
	65	defined(__MICROBLAZEEB__) \|\| defined(__ARMEB__) \|\| \
	66	(defined(__BIG_ENDIAN__) && __BIG_ENDIAN__ == 1) \|\| \
	67	(defined(_BIG_ENDIAN) && _BIG_ENDIAN == 1)
	68	# ifdef ENDIANNESS_DEBUG
	69	# warning "Detected Big Endian target CPU"
	70	# endif
	71	# define ENDIANNESS_LE 0
	72	# define ENDIANNESS_BE 1
	73	/* Try to get it from a header */
	74	#else
	75	# if defined(__linux)
	76	# ifdef ENDIANNESS_DEBUG
	77	# warning "Taking endiannes from endian.h"
	78	# endif
	79	# include <endian.h>
	80	# else
	81	# ifdef ENDIANNESS_DEBUG
	82	# warning "Taking endiannes from machine/endian.h"
	83	# endif
	84	# include <machine/endian.h>
	85	# endif
	86	#endif
	87
	88	#ifndef ENDIANNESS_LE
	89	# undef ENDIANNESS_BE
	90	# if defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN)
	91	# if __BYTE_ORDER == __LITTLE_ENDIAN
	92	# define ENDIANNESS_LE 1
	93	# define ENDIANNESS_BE 0
	94	# elif __BYTE_ORDER == __BIG_ENDIAN
	95	# define ENDIANNESS_LE 0
	96	# define ENDIANNESS_BE 1
	97	# endif
	98	# elif defined(BYTE_ORDER) && defined(LITTLE_ENDIAN)
	99	# if BYTE_ORDER == LITTLE_ENDIAN
	100	# define ENDIANNESS_LE 1
	101	# define ENDIANNESS_BE 0
	102	# elif BYTE_ORDER == BIG_ENDIAN
	103	# define ENDIANNESS_LE 0
	104	# define ENDIANNESS_BE 1
	105	# endif
	106	# endif
	107	#endif
	108
	109	/* In case the user passed one of -DENDIANNESS_LE or BE in CPPFLAS,
	110	set the second one too */
	111	#if defined(ENDIANNESS_LE) && !(defined(ENDIANNESS_BE))
	112	# if ENDIANNESS_LE == 0
	113	# define ENDIANNESS_BE 1
	114	# else
	115	# define ENDIANNESS_BE 0
	116	# endif
	117	#elif defined(ENDIANNESS_BE) && !(defined(ENDIANNESS_LE))
	118	# if ENDIANNESS_BE == 0
	119	# define ENDIANNESS_LE 1
	120	# else
	121	# define ENDIANNESS_LE 0
	122	# endif
	123	#endif
	124
	125	#if !(defined(ENDIANNESS_LE)) && !(defined(ENDIANNESS_PORTABLE_CONVERSION))
	126	# error "Sorry, we couldn't detect endiannes for your system! Please set -DENDIANNESS_LE=1 or 0 using your CPPFLAGS/CFLAGS and open an issue for your system on https://github.com/rofl0r/endianness.h - Thanks!"
	127	#endif
	128
	129	#include <stdint.h>
	130	#include <limits.h>
	131
	132	static __inline uint16_t end_bswap16(uint16_t __x)
	133	{
	134	return (__x<<8) \| (__x>>8);
	135	}
	136
	137	static __inline uint32_t end_bswap32(uint32_t __x)
	138	{
	139	return (__x>>24) \| (__x>>8&0xff00) \| (__x<<8&0xff0000) \| (__x<<24);
	140	}
	141
	142	static __inline uint64_t end_bswap64(uint64_t __x)
	143	{
	144	return ((end_bswap32(__x)+0ULL)<<32) \| (end_bswap32(__x>>32));
	145	}
	146
	147	static __inline uint16_t end_net2host16(uint16_t net_number)
	148	{
	149	uint16_t result = 0;
	150	int i;
	151	for (i = 0; i < (int)sizeof(result); i++) {
	152	result <<= CHAR_BIT;
	153	result += (((unsigned char *)&net_number)[i] & UCHAR_MAX);
	154	}
	155	return result;
	156	}
	157
	158	static __inline uint16_t end_host2net16(uint16_t native_number)
	159	{
	160	uint16_t result = 0;
	161	int i;
	162	for (i = (int)sizeof(result) - 1; i >= 0; i--) {
	163	((unsigned char *)&result)[i] = native_number & UCHAR_MAX;
	164	native_number >>= CHAR_BIT;
	165	}
	166	return result;
	167	}
	168
	169	static __inline uint32_t end_net2host32(uint32_t net_number)
	170	{
	171	uint32_t result = 0;
	172	int i;
	173	for (i = 0; i < (int)sizeof(result); i++) {
	174	result <<= CHAR_BIT;
	175	result += (((unsigned char *)&net_number)[i] & UCHAR_MAX);
	176	}
	177	return result;
	178	}
	179
	180	static __inline uint32_t end_host2net32(uint32_t native_number)
	181	{
	182	uint32_t result = 0;
	183	int i;
	184	for (i = (int)sizeof(result) - 1; i >= 0; i--) {
	185	((unsigned char *)&result)[i] = native_number & UCHAR_MAX;
	186	native_number >>= CHAR_BIT;
	187	}
	188	return result;
	189	}
	190
	191	static __inline uint64_t end_net2host64(uint64_t net_number)
	192	{
	193	uint64_t result = 0;
	194	int i;
	195	for (i = 0; i < (int)sizeof(result); i++) {
	196	result <<= CHAR_BIT;
	197	result += (((unsigned char *)&net_number)[i] & UCHAR_MAX);
	198	}
	199	return result;
	200	}
	201
	202	static __inline uint64_t end_host2net64(uint64_t native_number)
	203	{
	204	uint64_t result = 0;
	205	int i;
	206	for (i = (int)sizeof(result) - 1; i >= 0; i--) {
	207	((unsigned char *)&result)[i] = native_number & UCHAR_MAX;
	208	native_number >>= CHAR_BIT;
	209	}
	210	return result;
	211	}
	212
	213	#ifdef ENDIANNESS_LE
	214	# define end_htobe16(x) end_bswap16(x)
	215	# define end_be16toh(x) end_bswap16(x)
	216	# define end_htobe32(x) end_bswap32(x)
	217	# define end_be32toh(x) end_bswap32(x)
	218	# define end_htobe64(x) end_bswap64(x)
	219	# define end_be64toh(x) end_bswap64(x)
	220	# define end_htole16(x) (uint16_t)(x)
	221	# define end_le16toh(x) (uint16_t)(x)
	222	# define end_htole32(x) (uint32_t)(x)
	223	# define end_le32toh(x) (uint32_t)(x)
	224	# define end_htole64(x) (uint64_t)(x)
	225	# define end_le64toh(x) (uint64_t)(x)
	226	#elif ENDIANNESS_BE
	227	# define end_htobe16(x) (uint16_t)(x)
	228	# define end_be16toh(x) (uint16_t)(x)
	229	# define end_htobe32(x) (uint32_t)(x)
	230	# define end_be32toh(x) (uint32_t)(x)
	231	# define end_htobe64(x) (uint64_t)(x)
	232	# define end_be64toh(x) (uint64_t)(x)
	233	# define end_htole16(x) end_bswap16(x)
	234	# define end_le16toh(x) end_bswap16(x)
	235	# define end_htole32(x) end_bswap32(x)
	236	# define end_le32toh(x) end_bswap32(x)
	237	# define end_htole64(x) end_bswap64(x)
	238	# define end_le64toh(x) end_bswap64(x)
	239	#else
	240	/* Resort to slower, but neutral code */
	241	# define end_htobe16(x) end_host2net16(x)
	242	# define end_be16toh(x) end_net2host16(x)
	243	# define end_htobe32(x) end_host2net32(x)
	244	# define end_be32toh(x) end_net2host32(x)
	245	# define end_htobe64(x) end_host2net64(x)
	246	# define end_be64toh(x) end_net2host64(x)
	247	# define end_htole16(x) end_bswap_16(end_host2net16(x))
	248	# define end_le16toh(x) end_bswap_16(end_host2net16(x))
	249	# define end_htole32(x) end_bswap_32(end_host2net32(x))
	250	# define end_le32toh(x) end_bswap_32(end_host2net32(x))
	251	# define end_htole64(x) end_bswap_64(end_host2net64(x))
	252	# define end_le64toh(x) end_bswap_64(end_host2net64(x))
	253	#endif
	254
	255	#define end_ntoh16(x) end_be16toh(x)
	256	#define end_hton16(x) end_htobe16(x)
	257	#define end_ntoh32(x) end_be32toh(x)
	258	#define end_hton32(x) end_htobe32(x)
	259	#define end_ntoh64(x) end_be64toh(x)
	260	#define end_hton64(x) end_htobe64(x)
	261
	262	#endif

+105

-4

src/utils/radiotap.h less more

0		/* $FreeBSD: src/sys/net80211/ieee80211_radiotap.h,v 1.5 2005/01/22 20:12:05 sam Exp $ */
1		/* $NetBSD: ieee80211_radiotap.h,v 1.11 2005/06/22 06:16:02 dyoung Exp $ */
2
3	0	/*-
4	1	* Copyright (c) 2003, 2004 David Young. All rights reserved.
5	2	*

177	174	*
178	175	* Number of unicast retries a transmitted frame used.
179	176	*
	177	* IEEE80211_RADIOTAP_MCS u8, u8, u8 unitless
	178	*
	179	* Contains a bitmap of known fields/flags, the flags, and
	180	* the MCS index.
	181	*
	182	* IEEE80211_RADIOTAP_AMPDU_STATUS u32, u16, u8, u8 unitless
	183	*
	184	* Contains the AMPDU information for the subframe.
	185	*
	186	* IEEE80211_RADIOTAP_VHT u16, u8, u8, u8[4], u8, u8, u16
	187	*
	188	* Contains VHT information about this frame.
	189	*
	190	* IEEE80211_RADIOTAP_TIMESTAMP u64, u16, u8, u8 variable
	191	*
	192	* Contains timestamp information for this frame.
180	193	*/
181	194	enum ieee80211_radiotap_type {
182	195	IEEE80211_RADIOTAP_TSFT = 0,

197	210	IEEE80211_RADIOTAP_TX_FLAGS = 15,
198	211	IEEE80211_RADIOTAP_RTS_RETRIES = 16,
199	212	IEEE80211_RADIOTAP_DATA_RETRIES = 17,
	213
	214	IEEE80211_RADIOTAP_MCS = 19,
	215	IEEE80211_RADIOTAP_AMPDU_STATUS = 20,
	216	IEEE80211_RADIOTAP_VHT = 21,
	217	IEEE80211_RADIOTAP_TIMESTAMP = 22,
	218
	219	/* valid in every it_present bitmap, even vendor namespaces */
	220	IEEE80211_RADIOTAP_RADIOTAP_NAMESPACE = 29,
	221	IEEE80211_RADIOTAP_VENDOR_NAMESPACE = 30,
200	222	IEEE80211_RADIOTAP_EXT = 31
201	223	};
202	224

209	231	#define IEEE80211_CHAN_PASSIVE 0x0200 /* Only passive scan allowed */
210	232	#define IEEE80211_CHAN_DYN 0x0400 /* Dynamic CCK-OFDM channel */
211	233	#define IEEE80211_CHAN_GFSK 0x0800 /* GFSK channel (FHSS PHY) */
	234	#define IEEE80211_CHAN_GSM 0x1000 /* GSM (900 MHz) */
	235	#define IEEE80211_CHAN_STURBO 0x2000 /* Static Turbo */
	236	#define IEEE80211_CHAN_HALF 0x4000 /* Half channel (10 MHz wide) */
	237	#define IEEE80211_CHAN_QUARTER 0x8000 /* Quarter channel (5 MHz wide) */
212	238
213	239	/* For IEEE80211_RADIOTAP_FLAGS */
214	240	#define IEEE80211_RADIOTAP_F_CFP 0x01 /* sent/received

229	255	* 802.11 header and payload
230	256	* (to 32-bit boundary)
231	257	*/
	258	#define IEEE80211_RADIOTAP_F_BADFCS 0x40 /* bad FCS */
	259
232	260	/* For IEEE80211_RADIOTAP_RX_FLAGS */
233		#define IEEE80211_RADIOTAP_F_RX_BADFCS 0x0001 /* frame failed crc check */
	261	#define IEEE80211_RADIOTAP_F_RX_BADPLCP 0x0002 /* frame has bad PLCP */
234	262
235	263	/* For IEEE80211_RADIOTAP_TX_FLAGS */
236	264	#define IEEE80211_RADIOTAP_F_TX_FAIL 0x0001 /* failed due to excessive
237	265	* retries */
238	266	#define IEEE80211_RADIOTAP_F_TX_CTS 0x0002 /* used cts 'protection' */
239	267	#define IEEE80211_RADIOTAP_F_TX_RTS 0x0004 /* used rts/cts handshake */
	268	#define IEEE80211_RADIOTAP_F_TX_NOACK 0x0008 /* don't expect an ack */
	269
	270
	271	/* For IEEE80211_RADIOTAP_MCS */
	272	#define IEEE80211_RADIOTAP_MCS_HAVE_BW 0x01
	273	#define IEEE80211_RADIOTAP_MCS_HAVE_MCS 0x02
	274	#define IEEE80211_RADIOTAP_MCS_HAVE_GI 0x04
	275	#define IEEE80211_RADIOTAP_MCS_HAVE_FMT 0x08
	276	#define IEEE80211_RADIOTAP_MCS_HAVE_FEC 0x10
	277	#define IEEE80211_RADIOTAP_MCS_HAVE_STBC 0x20
	278
	279	#define IEEE80211_RADIOTAP_MCS_BW_MASK 0x03
	280	#define IEEE80211_RADIOTAP_MCS_BW_20 0
	281	#define IEEE80211_RADIOTAP_MCS_BW_40 1
	282	#define IEEE80211_RADIOTAP_MCS_BW_20L 2
	283	#define IEEE80211_RADIOTAP_MCS_BW_20U 3
	284	#define IEEE80211_RADIOTAP_MCS_SGI 0x04
	285	#define IEEE80211_RADIOTAP_MCS_FMT_GF 0x08
	286	#define IEEE80211_RADIOTAP_MCS_FEC_LDPC 0x10
	287	#define IEEE80211_RADIOTAP_MCS_STBC_MASK 0x60
	288	#define IEEE80211_RADIOTAP_MCS_STBC_1 1
	289	#define IEEE80211_RADIOTAP_MCS_STBC_2 2
	290	#define IEEE80211_RADIOTAP_MCS_STBC_3 3
	291
	292	#define IEEE80211_RADIOTAP_MCS_STBC_SHIFT 5
	293
	294	/* For IEEE80211_RADIOTAP_AMPDU_STATUS */
	295	#define IEEE80211_RADIOTAP_AMPDU_REPORT_ZEROLEN 0x0001
	296	#define IEEE80211_RADIOTAP_AMPDU_IS_ZEROLEN 0x0002
	297	#define IEEE80211_RADIOTAP_AMPDU_LAST_KNOWN 0x0004
	298	#define IEEE80211_RADIOTAP_AMPDU_IS_LAST 0x0008
	299	#define IEEE80211_RADIOTAP_AMPDU_DELIM_CRC_ERR 0x0010
	300	#define IEEE80211_RADIOTAP_AMPDU_DELIM_CRC_KNOWN 0x0020
	301
	302	/* For IEEE80211_RADIOTAP_VHT */
	303	#define IEEE80211_RADIOTAP_VHT_KNOWN_STBC 0x0001
	304	#define IEEE80211_RADIOTAP_VHT_KNOWN_TXOP_PS_NA 0x0002
	305	#define IEEE80211_RADIOTAP_VHT_KNOWN_GI 0x0004
	306	#define IEEE80211_RADIOTAP_VHT_KNOWN_SGI_NSYM_DIS 0x0008
	307	#define IEEE80211_RADIOTAP_VHT_KNOWN_LDPC_EXTRA_OFDM_SYM 0x0010
	308	#define IEEE80211_RADIOTAP_VHT_KNOWN_BEAMFORMED 0x0020
	309	#define IEEE80211_RADIOTAP_VHT_KNOWN_BANDWIDTH 0x0040
	310	#define IEEE80211_RADIOTAP_VHT_KNOWN_GROUP_ID 0x0080
	311	#define IEEE80211_RADIOTAP_VHT_KNOWN_PARTIAL_AID 0x0100
	312
	313	#define IEEE80211_RADIOTAP_VHT_FLAG_STBC 0x01
	314	#define IEEE80211_RADIOTAP_VHT_FLAG_TXOP_PS_NA 0x02
	315	#define IEEE80211_RADIOTAP_VHT_FLAG_SGI 0x04
	316	#define IEEE80211_RADIOTAP_VHT_FLAG_SGI_NSYM_M10_9 0x08
	317	#define IEEE80211_RADIOTAP_VHT_FLAG_LDPC_EXTRA_OFDM_SYM 0x10
	318	#define IEEE80211_RADIOTAP_VHT_FLAG_BEAMFORMED 0x20
	319
	320	#define IEEE80211_RADIOTAP_CODING_LDPC_USER0 0x01
	321	#define IEEE80211_RADIOTAP_CODING_LDPC_USER1 0x02
	322	#define IEEE80211_RADIOTAP_CODING_LDPC_USER2 0x04
	323	#define IEEE80211_RADIOTAP_CODING_LDPC_USER3 0x08
	324
	325	/* For IEEE80211_RADIOTAP_TIMESTAMP */
	326	#define IEEE80211_RADIOTAP_TIMESTAMP_UNIT_MASK 0x000F
	327	#define IEEE80211_RADIOTAP_TIMESTAMP_UNIT_MS 0x0000
	328	#define IEEE80211_RADIOTAP_TIMESTAMP_UNIT_US 0x0001
	329	#define IEEE80211_RADIOTAP_TIMESTAMP_UNIT_NS 0x0003
	330	#define IEEE80211_RADIOTAP_TIMESTAMP_SPOS_MASK 0x00F0
	331	#define IEEE80211_RADIOTAP_TIMESTAMP_SPOS_BEGIN_MDPU 0x0000
	332	#define IEEE80211_RADIOTAP_TIMESTAMP_SPOS_EO_MPDU 0x0010
	333	#define IEEE80211_RADIOTAP_TIMESTAMP_SPOS_EO_PPDU 0x0020
	334	#define IEEE80211_RADIOTAP_TIMESTAMP_SPOS_PLCP_SIG_ACQ 0x0030
	335	#define IEEE80211_RADIOTAP_TIMESTAMP_SPOS_UNKNOWN 0x00F0
	336
	337	#define IEEE80211_RADIOTAP_TIMESTAMP_FLAG_64BIT 0x00
	338	#define IEEE80211_RADIOTAP_TIMESTAMP_FLAG_32BIT 0x01
	339	#define IEEE80211_RADIOTAP_TIMESTAMP_FLAG_ACCURACY 0x02
	340
240	341
241	342	#endif /* IEEE80211_RADIOTAP_H */

-1

src/utils/vendor.c less more

17	17	{"\x00\x0c\xe7", "Mediatek"}, /* Mediatek MediaTek Inc. */
18	18	{"\x00\x1c\x51", "CelenoCo"}, /* Celeno Communications */
19	19	{"\x00\x50\x43", "MarvellS"}, /* Marvell Semiconductor, Inc. */
20		{"\x00\x50\xf2", "Microsof"} /* Microsoft */
	20	{"\x00\x26\x86", "Quantenn"}, /* Quantenna */
	21	{"\x00\x50\xf2", "Microsof"} /* Microsoft */
21	22	};
22	23
23	24	#define VENDOR_LIST_SIZE (sizeof(vendors)/sizeof(vendors[0]))

-0

src/version.c less more

	0	#include "version.h"
	1
	2	const char* get_version(void) {
	3	return R_VERSION;
	4	}

+14

-0

src/version.sh less more

	0	#!/bin/sh
	1
	2	BINDIR=$(dirname $(readlink -f "$0"))
	3
	4	if test -d "$BINDIR"/../.git ; then
	5	if type git >/dev/null 2>&1 ; then
	6	git describe --tags --match 'v[0-9]*' 2>/dev/null \
	7	\| sed -e 's/^v//' -e 's/-/-git-/'
	8	else
	9	sed 's/$/-git/' < VERSION
	10	fi
	11	else
	12	cat VERSION
	13	fi

-0

src/wps/wps.c less more

(No changes)

-0

src/wps/wps.h less more

(No changes)

-0

src/wps/wps_attr_build.c less more

(No changes)

-0

src/wps/wps_attr_parse.c less more

(No changes)

-0

src/wps/wps_attr_process.c less more

(No changes)

-0

src/wps/wps_common.c less more

(No changes)

-0

src/wps/wps_defs.h less more

(No changes)

-0

src/wps/wps_dev_attr.c less more

(No changes)

-0

src/wps/wps_dev_attr.h less more

(No changes)

-5

src/wps/wps_enrollee.c less more

1017	1017	}
1018	1018
1019	1019	if (attr.enrollee_nonce == NULL \|\|
1020		os_memcmp(wps->nonce_e, attr.enrollee_nonce, WPS_NONCE_LEN != 0)) {
	1020	os_memcmp(wps->nonce_e, attr.enrollee_nonce, WPS_NONCE_LEN) != 0) {
1021	1021	wpa_printf(MSG_DEBUG, "WPS: Mismatch in enrollee nonce");
1022	1022	return WPS_FAILURE;
1023	1023	}

1101	1101	}
1102	1102
1103	1103	if (attr.registrar_nonce == NULL \|\|
1104		os_memcmp(wps->nonce_r, attr.registrar_nonce, WPS_NONCE_LEN != 0))
	1104	os_memcmp(wps->nonce_r, attr.registrar_nonce, WPS_NONCE_LEN) != 0)
1105	1105	{
1106	1106	wpa_printf(MSG_DEBUG, "WPS: Mismatch in registrar nonce");
1107	1107	return WPS_FAILURE;
1108	1108	}
1109	1109
1110	1110	if (attr.enrollee_nonce == NULL \|\|
1111		os_memcmp(wps->nonce_e, attr.enrollee_nonce, WPS_NONCE_LEN != 0)) {
	1111	os_memcmp(wps->nonce_e, attr.enrollee_nonce, WPS_NONCE_LEN) != 0) {
1112	1112	wpa_printf(MSG_DEBUG, "WPS: Mismatch in enrollee nonce");
1113	1113	return WPS_FAILURE;
1114	1114	}

1153	1153	}
1154	1154
1155	1155	if (attr.registrar_nonce == NULL \|\|
1156		os_memcmp(wps->nonce_r, attr.registrar_nonce, WPS_NONCE_LEN != 0))
	1156	os_memcmp(wps->nonce_r, attr.registrar_nonce, WPS_NONCE_LEN) != 0)
1157	1157	{
1158	1158	wpa_printf(MSG_DEBUG, "WPS: Mismatch in registrar nonce");
1159	1159	wpa_hexdump(MSG_DEBUG, "WPS: Received Registrar Nonce",

1164	1164	}
1165	1165
1166	1166	if (attr.enrollee_nonce == NULL \|\|
1167		os_memcmp(wps->nonce_e, attr.enrollee_nonce, WPS_NONCE_LEN != 0)) {
	1167	os_memcmp(wps->nonce_e, attr.enrollee_nonce, WPS_NONCE_LEN) != 0) {
1168	1168	wpa_printf(MSG_DEBUG, "WPS: Mismatch in enrollee nonce");
1169	1169	wpa_hexdump(MSG_DEBUG, "WPS: Received Enrollee Nonce",
1170	1170	attr.enrollee_nonce, WPS_NONCE_LEN);

-0

src/wps/wps_i.h less more

(No changes)

-7

src/wps/wps_registrar.c less more

2477	2477	if (*attr.msg_type != WPS_M1 &&
2478	2478	(attr.registrar_nonce == NULL \|\|
2479	2479	os_memcmp(wps->nonce_r, attr.registrar_nonce,
2480		WPS_NONCE_LEN != 0))) {
	2480	WPS_NONCE_LEN) != 0)) {
2481	2481	wpa_printf(MSG_DEBUG, "WPS: Mismatch in registrar nonce");
2482	2482	return WPS_FAILURE;
2483	2483	}

2572	2572	#endif /* CONFIG_WPS_UPNP */
2573	2573
2574	2574	if (attr.registrar_nonce == NULL \|\|
2575		os_memcmp(wps->nonce_r, attr.registrar_nonce, WPS_NONCE_LEN != 0))
	2575	os_memcmp(wps->nonce_r, attr.registrar_nonce, WPS_NONCE_LEN) != 0)
2576	2576	{
2577	2577	wpa_printf(MSG_DEBUG, "WPS: Mismatch in registrar nonce");
2578	2578	return WPS_FAILURE;
2579	2579	}
2580	2580
2581	2581	if (attr.enrollee_nonce == NULL \|\|
2582		os_memcmp(wps->nonce_e, attr.enrollee_nonce, WPS_NONCE_LEN != 0)) {
	2582	os_memcmp(wps->nonce_e, attr.enrollee_nonce, WPS_NONCE_LEN) != 0) {
2583	2583	wpa_printf(MSG_DEBUG, "WPS: Mismatch in enrollee nonce");
2584	2584	return WPS_FAILURE;
2585	2585	}

2646	2646	#endif /* CONFIG_WPS_UPNP */
2647	2647
2648	2648	if (attr.registrar_nonce == NULL \|\|
2649		os_memcmp(wps->nonce_r, attr.registrar_nonce, WPS_NONCE_LEN != 0))
	2649	os_memcmp(wps->nonce_r, attr.registrar_nonce, WPS_NONCE_LEN) != 0)
2650	2650	{
2651	2651	wpa_printf(MSG_DEBUG, "WPS: Mismatch in registrar nonce");
2652	2652	return WPS_FAILURE;
2653	2653	}
2654	2654
2655	2655	if (attr.enrollee_nonce == NULL \|\|
2656		os_memcmp(wps->nonce_e, attr.enrollee_nonce, WPS_NONCE_LEN != 0)) {
	2656	os_memcmp(wps->nonce_e, attr.enrollee_nonce, WPS_NONCE_LEN) != 0) {
2657	2657	wpa_printf(MSG_DEBUG, "WPS: Mismatch in enrollee nonce");
2658	2658	return WPS_FAILURE;
2659	2659	}

2733	2733	#endif /* CONFIG_WPS_UPNP */
2734	2734
2735	2735	if (attr.registrar_nonce == NULL \|\|
2736		os_memcmp(wps->nonce_r, attr.registrar_nonce, WPS_NONCE_LEN != 0))
	2736	os_memcmp(wps->nonce_r, attr.registrar_nonce, WPS_NONCE_LEN) != 0)
2737	2737	{
2738	2738	wpa_printf(MSG_DEBUG, "WPS: Mismatch in registrar nonce");
2739	2739	return WPS_FAILURE;
2740	2740	}
2741	2741
2742	2742	if (attr.enrollee_nonce == NULL \|\|
2743		os_memcmp(wps->nonce_e, attr.enrollee_nonce, WPS_NONCE_LEN != 0)) {
	2743	os_memcmp(wps->nonce_e, attr.enrollee_nonce, WPS_NONCE_LEN) != 0) {
2744	2744	wpa_printf(MSG_DEBUG, "WPS: Mismatch in enrollee nonce");
2745	2745	return WPS_FAILURE;
2746	2746	}

-0

src/wps/wps_ufd.c less more

(No changes)

+15

-10

src/wpscrack.c less more

0	0	/*
1		* Reaver - Main and usage functions
	1	* Reaver - Main and reaver_usage functions
2	2	* Copyright (c) 2011, Tactical Network Solutions, Craig Heffner <[email protected]>
3	3	*
4	4	* This program is free software; you can redistribute it and/or modify

31	31	*/
32	32
33	33	#include "wpscrack.h"
	34	#include "iface.h"
34	35
35		int main(int argc, char **argv)
	36	extern const char* get_version(void);
	37	static int reaver_usage(char *prog_name);
	38
	39	int reaver_main(int argc, char **argv)
36	40	{
37	41	int ret_val = EXIT_FAILURE, r = 0;
38	42	time_t start_time = 0, end_time = 0;

41	45	globule_init();
42	46	init_default_settings();
43	47
44		fprintf(stderr, "\nReaver v%s WiFi Protected Setup Attack Tool\n", PACKAGE_VERSION);
	48	fprintf(stderr, "\nReaver v%s WiFi Protected Setup Attack Tool\n", get_version());
45	49	fprintf(stderr, "Copyright (c) 2011, Tactical Network Solutions, Craig Heffner <[email protected]>\n\n");
46	50
47	51	if(argc < 2)
48	52	{
49		ret_val = usage(argv[0]);
	53	ret_val = reaver_usage(argv[0]);
50	54	goto end;
51	55	}
52	56
53	57	/* Process the command line arguments */
54	58	if(process_arguments(argc, argv) == EXIT_FAILURE)
55	59	{
56		ret_val = usage(argv[0]);
	60	ret_val = reaver_usage(argv[0]);
57	61	goto end;
58	62	}
59	63
60		/* Double check usage */
	64	/* Double check reaver_usage */
61	65	if(!get_iface() \|\| (memcmp(get_bssid(), NULL_MAC, MAC_ADDR_LEN) == 0))
62	66	{
63		usage(argv[0]);
	67	reaver_usage(argv[0]);
64	68	goto end;
65	69	}
66	70

133	137	return ret_val;
134	138	}
135	139
136		int usage(char *prog_name)
	140	static int reaver_usage(char *prog_name)
137	141	{
138	142	float fail_timeout = 0;
139	143

153	157	fprintf(stderr, "\t-D, --daemonize Daemonize reaver\n");
154	158	fprintf(stderr, "\t-f, --fixed Disable channel hopping\n");
155	159	fprintf(stderr, "\t-5, --5ghz Use 5GHz 802.11 channels\n");
	160	//fprintf(stderr, "\t-6, --repeat-m6 Send M6 again upon duplicated M5 reception\n");
156	161	fprintf(stderr, "\t-v, --verbose Display non-critical warnings (-vv or -vvv for more)\n");
157	162	fprintf(stderr, "\t-q, --quiet Only display critical messages\n");
158	163	fprintf(stderr, "\t-h, --help Show help\n");

171	176	fprintf(stderr, "\t-S, --dh-small Use small DH keys to improve crack speed\n");
172	177	fprintf(stderr, "\t-L, --ignore-locks Ignore locked state reported by the target AP\n");
173	178	fprintf(stderr, "\t-E, --eap-terminate Terminate each WPS session with an EAP FAIL packet\n");
174		fprintf(stderr, "\t-n, --nack Target AP always sends a NACK [Auto]\n");
	179	fprintf(stderr, "\t-J, --timeout-is-nack Treat timeout as NACK (DIR-300/320)\n");
175	180	fprintf(stderr, "\t-w, --win7 Mimic a Windows 7 registrar [False]\n");
176	181	fprintf(stderr, "\t-K, --pixie-dust Run pixiedust attack\n");
177	182	fprintf(stderr, "\t-Z Run pixiedust attack\n");
178	183
179		fprintf(stderr, "\nExample:\n\t%s -i mon0 -b 00:90:4C:C1:AC:21 -vv\n\n", prog_name);
	184	fprintf(stderr, "\nExample:\n\t%s -i wlan0mon -b 00:90:4C:C1:AC:21 -vv\n\n", prog_name);
180	185
181	186	return EXIT_FAILURE;
182	187	}

-1

src/wpscrack.h less more

42	42	#define BELL_COUNT 4
43	43
44	44	void parse_recurring_delay(char *arg);
45		int usage(char *prog_name);
46	45
47	46	#endif

+20

-14

src/wpsmon.c less more

35	35	#include "utils/vendor.h"
36	36	#include "send.h"
37	37
	38	extern const char* get_version(void);
	39	static void wash_usage(char *prog);
	40
38	41	int show_all_aps = 0;
39	42	int json_mode = 0;
40	43

96	99	return seen_list[x].vendor_oui+1;
97	100	return 0;
98	101	}
99		int main(int argc, char *argv[])
	102	int wash_main(int argc, char *argv[])
100	103	{
101	104	int c = 0;
102	105	FILE *fp = NULL;

122	125	{ 0, 0, 0, 0 }
123	126	};
124	127
125		fprintf(stderr, "\nWash v%s WiFi Protected Setup Scan Tool\n", PACKAGE_VERSION);
	128	fprintf(stderr, "\nWash v%s WiFi Protected Setup Scan Tool\n", get_version());
126	129	fprintf(stderr, "Copyright (c) 2011, Tactical Network Solutions, Craig Heffner\n\n");
127	130
128	131	globule_init();
129	132	set_auto_channel_select(0);
130	133	set_wifi_band(BG_BAND);
131	134	set_debug(INFO);
132		set_validate_fcs(0);
	135	set_validate_fcs(1);
133	136	set_log_file(stdout);
134	137	set_max_num_probes(DEFAULT_MAX_NUM_PROBES);
135	138

175	178	show_all_aps = 1;
176	179	break;
177	180	default:
178		usage(argv[0]);
	181	wash_usage(argv[0]);
179	182	goto end;
180	183	}
181	184

194	197	/* The interface value won't be set if capture files were specified; else, there should have been an interface specified */
195	198	if(!get_iface() && source != PCAP_FILE)
196	199	{
197		usage(argv[0]);
	200	wash_usage(argv[0]);
198	201	goto end;
199	202	}
200	203	else if(get_iface())

206	209	if(get_iface() && source == PCAP_FILE)
207	210	{
208	211	cprintf(CRITICAL, "[X] ERROR: -i and -f options cannot be used together.\n");
209		usage(argv[0]);
	212	wash_usage(argv[0]);
210	213	goto end;
211	214	}
212	215

267	270	if(pcap_compile(get_handle(), &bpf, PACKET_FILTER, 0, 0) != 0)
268	271	{
269	272	cprintf(CRITICAL, "[X] ERROR: Failed to compile packet filter\n");
	273	cprintf(CRITICAL, "[X] PCAP: %s\n", pcap_geterr(get_handle()));
270	274	goto end;
271	275	}
272	276

365	369	}
366	370
367	371	rt_header = (struct radio_tap_header *) radio_header(packet, header->len);
368		size_t rt_header_len = __le16_to_cpu(rt_header->len);
	372	size_t rt_header_len = end_le16toh(rt_header->len);
369	373	frame_header = (struct dot11_frame_header *) (packet + rt_header_len);
370	374
371	375	/* If a specific BSSID was specified, only parse packets from that BSSID */

399	403	channel_changed = 1;
400	404	}
401	405
402		unsigned fsub_type = frame_header->fc & __cpu_to_le16(IEEE80211_FCTL_STYPE);
403
404		int is_beacon = fsub_type == __cpu_to_le16(IEEE80211_STYPE_BEACON);
405		int is_probe_resp = fsub_type == __cpu_to_le16(IEEE80211_STYPE_PROBE_RESP);
	406	unsigned fsub_type = frame_header->fc & end_htole16(IEEE80211_FCTL_STYPE);
	407
	408	int is_beacon = fsub_type == end_htole16(IEEE80211_STYPE_BEACON);
	409	int is_probe_resp = fsub_type == end_htole16(IEEE80211_STYPE_PROBE_RESP);
406	410
407	411	if(is_probe_resp \|\| is_beacon) {
408	412	wps_parsed = parse_wps_parameters(packet, header->len, wps);

433	437	} else lock_display = NO;
434	438
435	439	char* vendor = get_vendor_string(get_ap_vendor(bssid));
	440	char* sane_ssid = sanitize_string(ssid);
436	441	if(wps->version > 0)
437		cprintf(INFO, "%17s %3d %.2d %d.%d %3s %8s %s\n", bssid, channel, rssi, (wps->version >> 4), (wps->version & 0x0F), lock_display, vendor ? vendor : " ", ssid);
	442	cprintf(INFO, "%17s %3d %.2d %d.%d %3s %8s %s\n", bssid, channel, rssi, (wps->version >> 4), (wps->version & 0x0F), lock_display, vendor ? vendor : " ", sane_ssid);
438	443	else
439		cprintf(INFO, "%17s %3d %.2d %8s %s\n", bssid, channel, rssi, vendor ? vendor : " ", ssid);
	444	cprintf(INFO, "%17s %3d %.2d %8s %s\n", bssid, channel, rssi, vendor ? vendor : " ", sane_ssid);
	445	free(sane_ssid);
440	446	}
441	447
442	448	if(probe_sent)

495	501	next_channel();
496	502	}
497	503
498		void usage(char *prog)
	504	static void wash_usage(char *prog)
499	505	{
500	506	fprintf(stderr, "Required Arguments:\n");
501	507	fprintf(stderr, "\t-i, --interface=<iface> Interface to capture packets on\n");

-2

src/wpsmon.h less more

45	45	#include "iface.h"
46	46	#include "80211.h"
47	47	#include "builder.h"
48		#include "config.h"
49	48
50	49	#define INTERFACE 0
51	50	#define PCAP_FILE 1

102	101	void mark_bssid(unsigned char *bssid);
103	102	void free_bssid_list(unsigned char **list, int count);
104	103	void sigalrm_handler(int x);
105		void usage(char *prog);
106	104
107	105	#endif