main.c revision 214503 
1/*
2 * hostapd / main()
3 * Copyright (c) 2002-2010, Jouni Malinen <j@w1.fi>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 *
9 * Alternatively, this software may be distributed under the terms of BSD
10 * license.
11 *
12 * See README and COPYING for more details.
13 */
14
15#include "utils/includes.h"
16#ifndef CONFIG_NATIVE_WINDOWS
17#include <syslog.h>
18#endif /* CONFIG_NATIVE_WINDOWS */
19
20#include "utils/common.h"
21#include "utils/eloop.h"
22#include "crypto/tls.h"
23#include "common/version.h"
24#include "drivers/driver.h"
25#include "eap_server/eap.h"
26#include "eap_server/tncs.h"
27#include "ap/hostapd.h"
28#include "ap/ap_config.h"
29#include "config_file.h"
30#include "eap_register.h"
31#include "dump_state.h"
32#include "ctrl_iface.h"
33
34
35extern int wpa_debug_level;
36extern int wpa_debug_show_keys;
37extern int wpa_debug_timestamp;
38
39
40struct hapd_interfaces {
41	size_t count;
42	struct hostapd_iface **iface;
43};
44
45
46static int hostapd_for_each_interface(struct hapd_interfaces *interfaces,
47				      int (*cb)(struct hostapd_iface *iface,
48						void *ctx), void *ctx)
49{
50	size_t i;
51	int ret;
52
53	for (i = 0; i < interfaces->count; i++) {
54		ret = cb(interfaces->iface[i], ctx);
55		if (ret)
56			return ret;
57	}
58
59	return 0;
60}
61
62
63#ifndef CONFIG_NO_HOSTAPD_LOGGER
64static void hostapd_logger_cb(void *ctx, const u8 *addr, unsigned int module,
65			      int level, const char *txt, size_t len)
66{
67	struct hostapd_data *hapd = ctx;
68	char *format, *module_str;
69	int maxlen;
70	int conf_syslog_level, conf_stdout_level;
71	unsigned int conf_syslog, conf_stdout;
72
73	maxlen = len + 100;
74	format = os_malloc(maxlen);
75	if (!format)
76		return;
77
78	if (hapd && hapd->conf) {
79		conf_syslog_level = hapd->conf->logger_syslog_level;
80		conf_stdout_level = hapd->conf->logger_stdout_level;
81		conf_syslog = hapd->conf->logger_syslog;
82		conf_stdout = hapd->conf->logger_stdout;
83	} else {
84		conf_syslog_level = conf_stdout_level = 0;
85		conf_syslog = conf_stdout = (unsigned int) -1;
86	}
87
88	switch (module) {
89	case HOSTAPD_MODULE_IEEE80211:
90		module_str = "IEEE 802.11";
91		break;
92	case HOSTAPD_MODULE_IEEE8021X:
93		module_str = "IEEE 802.1X";
94		break;
95	case HOSTAPD_MODULE_RADIUS:
96		module_str = "RADIUS";
97		break;
98	case HOSTAPD_MODULE_WPA:
99		module_str = "WPA";
100		break;
101	case HOSTAPD_MODULE_DRIVER:
102		module_str = "DRIVER";
103		break;
104	case HOSTAPD_MODULE_IAPP:
105		module_str = "IAPP";
106		break;
107	case HOSTAPD_MODULE_MLME:
108		module_str = "MLME";
109		break;
110	default:
111		module_str = NULL;
112		break;
113	}
114
115	if (hapd && hapd->conf && addr)
116		os_snprintf(format, maxlen, "%s: STA " MACSTR "%s%s: %s",
117			    hapd->conf->iface, MAC2STR(addr),
118			    module_str ? " " : "", module_str, txt);
119	else if (hapd && hapd->conf)
120		os_snprintf(format, maxlen, "%s:%s%s %s",
121			    hapd->conf->iface, module_str ? " " : "",
122			    module_str, txt);
123	else if (addr)
124		os_snprintf(format, maxlen, "STA " MACSTR "%s%s: %s",
125			    MAC2STR(addr), module_str ? " " : "",
126			    module_str, txt);
127	else
128		os_snprintf(format, maxlen, "%s%s%s",
129			    module_str, module_str ? ": " : "", txt);
130
131	if ((conf_stdout & module) && level >= conf_stdout_level) {
132		wpa_debug_print_timestamp();
133		printf("%s\n", format);
134	}
135
136#ifndef CONFIG_NATIVE_WINDOWS
137	if ((conf_syslog & module) && level >= conf_syslog_level) {
138		int priority;
139		switch (level) {
140		case HOSTAPD_LEVEL_DEBUG_VERBOSE:
141		case HOSTAPD_LEVEL_DEBUG:
142			priority = LOG_DEBUG;
143			break;
144		case HOSTAPD_LEVEL_INFO:
145			priority = LOG_INFO;
146			break;
147		case HOSTAPD_LEVEL_NOTICE:
148			priority = LOG_NOTICE;
149			break;
150		case HOSTAPD_LEVEL_WARNING:
151			priority = LOG_WARNING;
152			break;
153		default:
154			priority = LOG_INFO;
155			break;
156		}
157		syslog(priority, "%s", format);
158	}
159#endif /* CONFIG_NATIVE_WINDOWS */
160
161	os_free(format);
162}
163#endif /* CONFIG_NO_HOSTAPD_LOGGER */
164
165
166/**
167 * hostapd_init - Allocate and initialize per-interface data
168 * @config_file: Path to the configuration file
169 * Returns: Pointer to the allocated interface data or %NULL on failure
170 *
171 * This function is used to allocate main data structures for per-interface
172 * data. The allocated data buffer will be freed by calling
173 * hostapd_cleanup_iface().
174 */
175static struct hostapd_iface * hostapd_init(const char *config_file)
176{
177	struct hostapd_iface *hapd_iface = NULL;
178	struct hostapd_config *conf = NULL;
179	struct hostapd_data *hapd;
180	size_t i;
181
182	hapd_iface = os_zalloc(sizeof(*hapd_iface));
183	if (hapd_iface == NULL)
184		goto fail;
185
186	hapd_iface->reload_config = hostapd_reload_config;
187	hapd_iface->config_read_cb = hostapd_config_read;
188	hapd_iface->config_fname = os_strdup(config_file);
189	if (hapd_iface->config_fname == NULL)
190		goto fail;
191	hapd_iface->ctrl_iface_init = hostapd_ctrl_iface_init;
192	hapd_iface->ctrl_iface_deinit = hostapd_ctrl_iface_deinit;
193	hapd_iface->for_each_interface = hostapd_for_each_interface;
194
195	conf = hostapd_config_read(hapd_iface->config_fname);
196	if (conf == NULL)
197		goto fail;
198	hapd_iface->conf = conf;
199
200	hapd_iface->num_bss = conf->num_bss;
201	hapd_iface->bss = os_zalloc(conf->num_bss *
202				    sizeof(struct hostapd_data *));
203	if (hapd_iface->bss == NULL)
204		goto fail;
205
206	for (i = 0; i < conf->num_bss; i++) {
207		hapd = hapd_iface->bss[i] =
208			hostapd_alloc_bss_data(hapd_iface, conf,
209					       &conf->bss[i]);
210		if (hapd == NULL)
211			goto fail;
212		hapd->msg_ctx = hapd;
213	}
214
215	return hapd_iface;
216
217fail:
218	if (conf)
219		hostapd_config_free(conf);
220	if (hapd_iface) {
221		os_free(hapd_iface->config_fname);
222		os_free(hapd_iface->bss);
223		os_free(hapd_iface);
224	}
225	return NULL;
226}
227
228
229static int hostapd_driver_init(struct hostapd_iface *iface)
230{
231	struct wpa_init_params params;
232	size_t i;
233	struct hostapd_data *hapd = iface->bss[0];
234	struct hostapd_bss_config *conf = hapd->conf;
235	u8 *b = conf->bssid;
236
237	if (hapd->driver == NULL || hapd->driver->hapd_init == NULL) {
238		wpa_printf(MSG_ERROR, "No hostapd driver wrapper available");
239		return -1;
240	}
241
242	/* Initialize the driver interface */
243	if (!(b[0] | b[1] | b[2] | b[3] | b[4] | b[5]))
244		b = NULL;
245
246	os_memset(&params, 0, sizeof(params));
247	params.bssid = b;
248	params.ifname = hapd->conf->iface;
249	params.ssid = (const u8 *) hapd->conf->ssid.ssid;
250	params.ssid_len = hapd->conf->ssid.ssid_len;
251	params.test_socket = hapd->conf->test_socket;
252	params.use_pae_group_addr = hapd->conf->use_pae_group_addr;
253
254	params.num_bridge = hapd->iface->num_bss;
255	params.bridge = os_zalloc(hapd->iface->num_bss * sizeof(char *));
256	if (params.bridge == NULL)
257		return -1;
258	for (i = 0; i < hapd->iface->num_bss; i++) {
259		struct hostapd_data *bss = hapd->iface->bss[i];
260		if (bss->conf->bridge[0])
261			params.bridge[i] = bss->conf->bridge;
262	}
263
264	params.own_addr = hapd->own_addr;
265
266	hapd->drv_priv = hapd->driver->hapd_init(hapd, &params);
267	os_free(params.bridge);
268	if (hapd->drv_priv == NULL) {
269		wpa_printf(MSG_ERROR, "%s driver initialization failed.",
270			   hapd->driver->name);
271		hapd->driver = NULL;
272		return -1;
273	}
274
275	return 0;
276}
277
278
279static void hostapd_interface_deinit_free(struct hostapd_iface *iface)
280{
281	const struct wpa_driver_ops *driver;
282	void *drv_priv;
283	if (iface == NULL)
284		return;
285	driver = iface->bss[0]->driver;
286	drv_priv = iface->bss[0]->drv_priv;
287	hostapd_interface_deinit(iface);
288	if (driver && driver->hapd_deinit)
289		driver->hapd_deinit(drv_priv);
290	hostapd_interface_free(iface);
291}
292
293
294static struct hostapd_iface *
295hostapd_interface_init(struct hapd_interfaces *interfaces,
296		       const char *config_fname, int debug)
297{
298	struct hostapd_iface *iface;
299	int k;
300
301	wpa_printf(MSG_ERROR, "Configuration file: %s", config_fname);
302	iface = hostapd_init(config_fname);
303	if (!iface)
304		return NULL;
305	iface->interfaces = interfaces;
306
307	for (k = 0; k < debug; k++) {
308		if (iface->bss[0]->conf->logger_stdout_level > 0)
309			iface->bss[0]->conf->logger_stdout_level--;
310	}
311
312	if (hostapd_driver_init(iface) ||
313	    hostapd_setup_interface(iface)) {
314		hostapd_interface_deinit_free(iface);
315		return NULL;
316	}
317
318	return iface;
319}
320
321
322/**
323 * handle_term - SIGINT and SIGTERM handler to terminate hostapd process
324 */
325static void handle_term(int sig, void *signal_ctx)
326{
327	wpa_printf(MSG_DEBUG, "Signal %d received - terminating", sig);
328	eloop_terminate();
329}
330
331
332#ifndef CONFIG_NATIVE_WINDOWS
333
334static int handle_reload_iface(struct hostapd_iface *iface, void *ctx)
335{
336	if (hostapd_reload_config(iface) < 0) {
337		wpa_printf(MSG_WARNING, "Failed to read new configuration "
338			   "file - continuing with old.");
339	}
340	return 0;
341}
342
343
344/**
345 * handle_reload - SIGHUP handler to reload configuration
346 */
347static void handle_reload(int sig, void *signal_ctx)
348{
349	struct hapd_interfaces *interfaces = signal_ctx;
350	wpa_printf(MSG_DEBUG, "Signal %d received - reloading configuration",
351		   sig);
352	hostapd_for_each_interface(interfaces, handle_reload_iface, NULL);
353}
354
355
356static void handle_dump_state(int sig, void *signal_ctx)
357{
358#ifdef HOSTAPD_DUMP_STATE
359	struct hapd_interfaces *interfaces = signal_ctx;
360	hostapd_for_each_interface(interfaces, handle_dump_state_iface, NULL);
361#endif /* HOSTAPD_DUMP_STATE */
362}
363#endif /* CONFIG_NATIVE_WINDOWS */
364
365
366static int hostapd_global_init(struct hapd_interfaces *interfaces)
367{
368	hostapd_logger_register_cb(hostapd_logger_cb);
369
370	if (eap_server_register_methods()) {
371		wpa_printf(MSG_ERROR, "Failed to register EAP methods");
372		return -1;
373	}
374
375	if (eloop_init()) {
376		wpa_printf(MSG_ERROR, "Failed to initialize event loop");
377		return -1;
378	}
379
380#ifndef CONFIG_NATIVE_WINDOWS
381	eloop_register_signal(SIGHUP, handle_reload, interfaces);
382	eloop_register_signal(SIGUSR1, handle_dump_state, interfaces);
383#endif /* CONFIG_NATIVE_WINDOWS */
384	eloop_register_signal_terminate(handle_term, interfaces);
385
386#ifndef CONFIG_NATIVE_WINDOWS
387	openlog("hostapd", 0, LOG_DAEMON);
388#endif /* CONFIG_NATIVE_WINDOWS */
389
390	return 0;
391}
392
393
394static void hostapd_global_deinit(const char *pid_file)
395{
396#ifdef EAP_SERVER_TNC
397	tncs_global_deinit();
398#endif /* EAP_SERVER_TNC */
399
400	eloop_destroy();
401
402#ifndef CONFIG_NATIVE_WINDOWS
403	closelog();
404#endif /* CONFIG_NATIVE_WINDOWS */
405
406	eap_server_unregister_methods();
407
408	os_daemonize_terminate(pid_file);
409}
410
411
412static int hostapd_global_run(struct hapd_interfaces *ifaces, int daemonize,
413			      const char *pid_file)
414{
415#ifdef EAP_SERVER_TNC
416	int tnc = 0;
417	size_t i, k;
418
419	for (i = 0; !tnc && i < ifaces->count; i++) {
420		for (k = 0; k < ifaces->iface[i]->num_bss; k++) {
421			if (ifaces->iface[i]->bss[0]->conf->tnc) {
422				tnc++;
423				break;
424			}
425		}
426	}
427
428	if (tnc && tncs_global_init() < 0) {
429		wpa_printf(MSG_ERROR, "Failed to initialize TNCS");
430		return -1;
431	}
432#endif /* EAP_SERVER_TNC */
433
434	if (daemonize && os_daemonize(pid_file)) {
435		perror("daemon");
436		return -1;
437	}
438
439	eloop_run();
440
441	return 0;
442}
443
444
445static void show_version(void)
446{
447	fprintf(stderr,
448		"hostapd v" VERSION_STR "\n"
449		"User space daemon for IEEE 802.11 AP management,\n"
450		"IEEE 802.1X/WPA/WPA2/EAP/RADIUS Authenticator\n"
451		"Copyright (c) 2002-2010, Jouni Malinen <j@w1.fi> "
452		"and contributors\n");
453}
454
455
456static void usage(void)
457{
458	show_version();
459	fprintf(stderr,
460		"\n"
461		"usage: hostapd [-hdBKtv] [-P <PID file>] "
462		"<configuration file(s)>\n"
463		"\n"
464		"options:\n"
465		"   -h   show this usage\n"
466		"   -d   show more debug messages (-dd for even more)\n"
467		"   -B   run daemon in the background\n"
468		"   -P   PID file\n"
469		"   -K   include key data in debug messages\n"
470		"   -t   include timestamps in some debug messages\n"
471		"   -v   show hostapd version\n");
472
473	exit(1);
474}
475
476
477int main(int argc, char *argv[])
478{
479	struct hapd_interfaces interfaces;
480	int ret = 1;
481	size_t i;
482	int c, debug = 0, daemonize = 0;
483	char *pid_file = NULL;
484
485	if (os_program_init())
486		return -1;
487
488	for (;;) {
489		c = getopt(argc, argv, "BdhKP:tv");
490		if (c < 0)
491			break;
492		switch (c) {
493		case 'h':
494			usage();
495			break;
496		case 'd':
497			debug++;
498			if (wpa_debug_level > 0)
499				wpa_debug_level--;
500			break;
501		case 'B':
502			daemonize++;
503			break;
504		case 'K':
505			wpa_debug_show_keys++;
506			break;
507		case 'P':
508			os_free(pid_file);
509			pid_file = os_rel2abs_path(optarg);
510			break;
511		case 't':
512			wpa_debug_timestamp++;
513			break;
514		case 'v':
515			show_version();
516			exit(1);
517			break;
518
519		default:
520			usage();
521			break;
522		}
523	}
524
525	if (optind == argc)
526		usage();
527
528	interfaces.count = argc - optind;
529	interfaces.iface = os_malloc(interfaces.count *
530				     sizeof(struct hostapd_iface *));
531	if (interfaces.iface == NULL) {
532		wpa_printf(MSG_ERROR, "malloc failed\n");
533		return -1;
534	}
535
536	if (hostapd_global_init(&interfaces))
537		return -1;
538
539	/* Initialize interfaces */
540	for (i = 0; i < interfaces.count; i++) {
541		interfaces.iface[i] = hostapd_interface_init(&interfaces,
542							     argv[optind + i],
543							     debug);
544		if (!interfaces.iface[i])
545			goto out;
546	}
547
548	if (hostapd_global_run(&interfaces, daemonize, pid_file))
549		goto out;
550
551	ret = 0;
552
553 out:
554	/* Deinitialize all interfaces */
555	for (i = 0; i < interfaces.count; i++)
556		hostapd_interface_deinit_free(interfaces.iface[i]);
557	os_free(interfaces.iface);
558
559	hostapd_global_deinit(pid_file);
560	os_free(pid_file);
561
562	os_program_deinit();
563
564	return ret;
565}
566