void
event_errx(int eval, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
warn_helper_(EVENT_LOG_ERR, NULL, fmt, ap);
va_end(ap);
event_exit(eval);
}
void
event_err(int eval, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
_warn_helper(_EVENT_LOG_ERR, strerror(errno), fmt, ap);
va_end(ap);
event_exit(eval);
}
void
event_sock_err(int eval, evutil_socket_t sock, const char *fmt, ...)
{
va_list ap;
int err = evutil_socket_geterror(sock);
va_start(ap, fmt);
_warn_helper(_EVENT_LOG_ERR, evutil_socket_error_to_string(err), fmt, ap);
va_end(ap);
event_exit(eval);
}
/**
* 清理窗口管理器
* 就不写注释了 函数名写的已经很明白。。
**/
si_t window_manager_exit()
{
application_exit();
cursor_exit();
graph_exit();
comm_exit();
event_exit();
config_exit();
terminal_exit();
return 0;
}
static void plugin_exit(OhmPlugin *plugin)
{
(void)plugin;
OHM_INFO("buttons: exit ...");
if (bdata != NULL) {
if (bdata->tsrc)
g_source_remove(bdata->tsrc);
event_exit(bdata->ev);
free(bdata);
}
}
static bool write_packet(vpn_packet_t *packet) {
if(state != 2) {
logger(DEBUG_TRAFFIC, LOG_DEBUG, "Dropping packet of %d bytes to %s: not connected to UML yet",
packet->len, device_info);
return false;
}
logger(DEBUG_TRAFFIC, LOG_DEBUG, "Writing packet of %d bytes to %s",
packet->len, device_info);
if(write(write_fd, DATA(packet), packet->len) < 0) {
if(errno != EINTR && errno != EAGAIN) {
logger(DEBUG_ALWAYS, LOG_ERR, "Can't write to %s %s: %s", device_info, device, strerror(errno));
event_exit();
}
return false;
}
return true;
}
// NOTE: this function needs to call RegisterServiceCtrlHandlerEx and
// SetServiceStatus in all circumstances if brickd is running as service
static int generic_main(int log_to_file, int debug) {
int exit_code = EXIT_FAILURE;
const char *mutex_name = "Global\\Tinkerforge-Brick-Daemon-Single-Instance";
HANDLE mutex_handle = NULL;
int mutex_error = 0;
DWORD service_exit_code = NO_ERROR;
int rc;
char filename[1024];
int i;
FILE *logfile = NULL;
WSADATA wsa_data;
DEV_BROADCAST_DEVICEINTERFACE notification_filter;
HDEVNOTIFY notification_handle;
mutex_handle = OpenMutex(SYNCHRONIZE, FALSE, mutex_name);
if (mutex_handle == NULL) {
rc = GetLastError();
if (rc == ERROR_ACCESS_DENIED) {
rc = service_is_running();
if (rc < 0) {
mutex_error = 1;
// FIXME: set service_exit_code
goto error_mutex;
} else if (rc) {
mutex_error = 1;
service_exit_code = ERROR_SERVICE_ALREADY_RUNNING;
log_error("Could not start as %s, another instance is already running as service",
_run_as_service ? "service" : "console application");
goto error_mutex;
}
}
if (rc != ERROR_FILE_NOT_FOUND) {
mutex_error = 1;
// FIXME: set service_exit_code
rc += ERRNO_WINAPI_OFFSET;
log_error("Could not open single instance mutex: %s (%d)",
get_errno_name(rc), rc);
goto error_mutex;
}
}
if (mutex_handle != NULL) {
mutex_error = 1;
service_exit_code = ERROR_SERVICE_ALREADY_RUNNING;
log_error("Could not start as %s, another instance is already running",
_run_as_service ? "service" : "console application");
goto error_mutex;
}
mutex_handle = CreateMutex(NULL, FALSE, mutex_name);
if (mutex_handle == NULL) {
mutex_error = 1;
// FIXME: set service_exit_code
rc = ERRNO_WINAPI_OFFSET + GetLastError();
log_error("Could not create single instance mutex: %s (%d)",
get_errno_name(rc), rc);
goto error_mutex;
}
if (!_run_as_service &&
!SetConsoleCtrlHandler(console_ctrl_handler, TRUE)) {
rc = ERRNO_WINAPI_OFFSET + GetLastError();
log_warn("Could not set console control handler: %s (%d)",
get_errno_name(rc), rc);
}
if (log_to_file) {
if (GetModuleFileName(NULL, filename, sizeof(filename)) == 0) {
rc = ERRNO_WINAPI_OFFSET + GetLastError();
log_warn("Could not get module file name: %s (%d)",
get_errno_name(rc), rc);
} else {
i = strlen(filename);
if (i < 4) {
log_warn("Module file name '%s' is too short", filename);
} else {
strcpy(filename + i - 3, "log");
logfile = fopen(filename, "a+");
if (logfile == NULL) {
log_warn("Could not open logfile '%s'", filename);
} else {
log_set_file(logfile);
}
}
}
}
if (debug) {
log_set_level(LOG_CATEGORY_EVENT, LOG_LEVEL_DEBUG);
log_set_level(LOG_CATEGORY_USB, LOG_LEVEL_DEBUG);
log_set_level(LOG_CATEGORY_NETWORK, LOG_LEVEL_DEBUG);
log_set_level(LOG_CATEGORY_HOTPLUG, LOG_LEVEL_DEBUG);
log_set_level(LOG_CATEGORY_OTHER, LOG_LEVEL_DEBUG);
} else {
log_set_level(LOG_CATEGORY_EVENT, config_get_log_level(LOG_CATEGORY_EVENT));
log_set_level(LOG_CATEGORY_USB, config_get_log_level(LOG_CATEGORY_USB));
log_set_level(LOG_CATEGORY_NETWORK, config_get_log_level(LOG_CATEGORY_NETWORK));
log_set_level(LOG_CATEGORY_HOTPLUG, config_get_log_level(LOG_CATEGORY_HOTPLUG));
log_set_level(LOG_CATEGORY_OTHER, config_get_log_level(LOG_CATEGORY_OTHER));
}
if (_run_as_service) {
log_info("Brick Daemon %s started (as service)", VERSION_STRING);
} else {
log_info("Brick Daemon %s started", VERSION_STRING);
}
if (config_has_error()) {
log_warn("Errors found in config file '%s', run with --check-config option for details",
_config_filename);
}
// initialize service status
error_mutex:
if (_run_as_service) {
if (service_init(service_control_handler) < 0) {
// FIXME: set service_exit_code
goto error;
}
if (!mutex_error) {
// service is starting
service_set_status(SERVICE_START_PENDING, NO_ERROR);
}
}
if (mutex_error) {
goto error;
}
// initialize WinSock2
if (WSAStartup(MAKEWORD(2, 2), &wsa_data) != 0) {
// FIXME: set service_exit_code
rc = ERRNO_WINAPI_OFFSET + WSAGetLastError();
log_error("Could not initialize Windows Sockets 2.2: %s (%d)",
get_errno_name(rc), rc);
goto error_event;
}
if (event_init() < 0) {
// FIXME: set service_exit_code
goto error_event;
}
if (usb_init() < 0) {
// FIXME: set service_exit_code
goto error_usb;
}
// create notification pipe
if (pipe_create(_notification_pipe) < 0) {
// FIXME: set service_exit_code
log_error("Could not create notification pipe: %s (%d)",
get_errno_name(errno), errno);
goto error_pipe;
}
if (event_add_source(_notification_pipe[0], EVENT_SOURCE_TYPE_GENERIC,
EVENT_READ, forward_notifications, NULL) < 0) {
// FIXME: set service_exit_code
goto error_pipe_add;
}
// register device notification
ZeroMemory(¬ification_filter, sizeof(notification_filter));
notification_filter.dbcc_size = sizeof(notification_filter);
notification_filter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
notification_filter.dbcc_classguid = GUID_DEVINTERFACE_USB_DEVICE;
if (_run_as_service) {
notification_handle = RegisterDeviceNotification((HANDLE)service_get_status_handle(),
¬ification_filter,
DEVICE_NOTIFY_SERVICE_HANDLE);
} else {
if (message_pump_start() < 0) {
// FIXME: set service_exit_code
goto error_pipe_add;
}
notification_handle = RegisterDeviceNotification(_message_pump_hwnd,
¬ification_filter,
DEVICE_NOTIFY_WINDOW_HANDLE);
}
if (notification_handle == NULL) {
// FIXME: set service_exit_code
rc = ERRNO_WINAPI_OFFSET + GetLastError();
log_error("Could not register for device notification: %s (%d)",
get_errno_name(rc), rc);
goto error_notification;
}
if (network_init() < 0) {
// FIXME: set service_exit_code
goto error_network;
}
// running
if (_run_as_service) {
service_set_status(SERVICE_RUNNING, NO_ERROR);
}
if (event_run() < 0) {
// FIXME: set service_exit_code
goto error_run;
}
exit_code = EXIT_SUCCESS;
error_run:
network_exit();
error_network:
UnregisterDeviceNotification(notification_handle);
error_notification:
if (!_run_as_service) {
message_pump_stop();
}
event_remove_source(_notification_pipe[0], EVENT_SOURCE_TYPE_GENERIC);
error_pipe_add:
pipe_destroy(_notification_pipe);
error_pipe:
usb_exit();
error_usb:
event_exit();
error_event:
log_info("Brick Daemon %s stopped", VERSION_STRING);
error:
log_exit();
config_exit();
if (_run_as_service) {
// because the service process can be terminated at any time after
// entering SERVICE_STOPPED state the mutex is closed beforehand,
// even though this creates a tiny time window in which the service
// is still running but the mutex is not held anymore
if (mutex_handle != NULL) {
CloseHandle(mutex_handle);
}
// service is now stopped
service_set_status(SERVICE_STOPPED, service_exit_code);
} else {
if (_pause_before_exit) {
printf("Press any key to exit...\n");
getch();
}
if (mutex_handle != NULL) {
CloseHandle(mutex_handle);
}
}
return exit_code;
}
int main(int argc, char **argv) {
int exit_code = EXIT_FAILURE;
int i;
bool help = false;
bool version = false;
bool check_config = false;
bool daemon = false;
const char *debug_filter = NULL;
int pid_fd = -1;
#ifdef BRICKD_WITH_LIBUDEV
bool initialized_udev = false;
#endif
for (i = 1; i < argc; ++i) {
if (strcmp(argv[i], "--help") == 0) {
help = true;
} else if (strcmp(argv[i], "--version") == 0) {
version = true;
} else if (strcmp(argv[i], "--check-config") == 0) {
check_config = true;
} else if (strcmp(argv[i], "--daemon") == 0) {
daemon = true;
} else if (strcmp(argv[i], "--debug") == 0) {
if (i + 1 < argc && strncmp(argv[i + 1], "--", 2) != 0) {
debug_filter = argv[++i];
} else {
debug_filter = "";
}
} else {
fprintf(stderr, "Unknown option '%s'\n\n", argv[i]);
print_usage();
return EXIT_FAILURE;
}
}
if (help) {
print_usage();
return EXIT_SUCCESS;
}
if (version) {
printf("%s\n", VERSION_STRING);
return EXIT_SUCCESS;
}
if (prepare_paths() < 0) {
return EXIT_FAILURE;
}
if (check_config) {
return config_check(_config_filename) < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}
config_init(_config_filename);
if (config_has_error()) {
fprintf(stderr, "Error(s) occurred while reading config file '%s'\n",
_config_filename);
goto error_config;
}
log_init();
if (daemon) {
pid_fd = daemon_start(_log_filename, &_log_file, _pid_filename, true);
} else {
pid_fd = pid_file_acquire(_pid_filename, getpid());
if (pid_fd == PID_FILE_ALREADY_ACQUIRED) {
fprintf(stderr, "Already running according to '%s'\n", _pid_filename);
}
}
if (pid_fd < 0) {
goto error_pid_file;
}
log_info("Brick Daemon %s started (pid: %u, daemonized: %d)",
VERSION_STRING, getpid(), daemon ? 1 : 0);
if (debug_filter != NULL) {
log_enable_debug_override(debug_filter);
}
if (config_has_warning()) {
log_warn("Warning(s) in config file '%s', run with --check-config option for details",
_config_filename);
}
if (event_init() < 0) {
goto error_event;
}
if (signal_init(handle_sighup, handle_sigusr1) < 0) {
goto error_signal;
}
if (hardware_init() < 0) {
goto error_hardware;
}
if (usb_init() < 0) {
goto error_usb;
}
#ifdef BRICKD_WITH_LIBUDEV
if (!usb_has_hotplug()) {
if (udev_init() < 0) {
goto error_udev;
}
initialized_udev = true;
}
#endif
if (network_init() < 0) {
goto error_network;
}
if (mesh_init() < 0) {
goto error_mesh;
}
#ifdef BRICKD_WITH_RED_BRICK
if (gpio_init() < 0) {
goto error_gpio;
}
if (redapid_init() < 0) {
goto error_redapid;
}
if (red_stack_init() < 0) {
goto error_red_stack;
}
if (red_extension_init() < 0) {
goto error_red_extension;
}
if (red_usb_gadget_init() < 0) {
goto error_red_usb_gadget;
}
red_led_set_trigger(RED_LED_GREEN, config_get_option_value("led_trigger.green")->symbol);
red_led_set_trigger(RED_LED_RED, config_get_option_value("led_trigger.red")->symbol);
#endif
if (event_run(network_cleanup_clients_and_zombies) < 0) {
goto error_run;
}
#ifdef BRICKD_WITH_RED_BRICK
hardware_announce_disconnect();
network_announce_red_brick_disconnect();
red_usb_gadget_announce_red_brick_disconnect();
#endif
exit_code = EXIT_SUCCESS;
error_run:
#ifdef BRICKD_WITH_RED_BRICK
red_usb_gadget_exit();
error_red_usb_gadget:
red_extension_exit();
error_red_extension:
red_stack_exit();
error_red_stack:
redapid_exit();
error_redapid:
//gpio_exit();
error_gpio:
#endif
network_exit();
error_mesh:
mesh_exit();
error_network:
#ifdef BRICKD_WITH_LIBUDEV
if (initialized_udev) {
udev_exit();
}
error_udev:
#endif
usb_exit();
error_usb:
hardware_exit();
error_hardware:
signal_exit();
error_signal:
event_exit();
error_event:
log_info("Brick Daemon %s stopped", VERSION_STRING);
error_pid_file:
if (pid_fd >= 0) {
pid_file_release(_pid_filename, pid_fd);
}
log_exit();
error_config:
config_exit();
return exit_code;
}
// NOTE: this function needs to call RegisterServiceCtrlHandlerEx and
// SetServiceStatus in all circumstances if brickd is running as service
static int generic_main(bool log_to_file, bool debug, bool libusb_debug) {
int exit_code = EXIT_FAILURE;
const char *mutex_name = "Global\\Tinkerforge-Brick-Daemon-Single-Instance";
HANDLE mutex_handle = NULL;
bool fatal_error = false;
DWORD service_exit_code = NO_ERROR;
int rc;
char filename[1024];
int i;
FILE *log_file = NULL;
WSADATA wsa_data;
DEV_BROADCAST_DEVICEINTERFACE notification_filter;
HDEVNOTIFY notification_handle;
mutex_handle = OpenMutex(SYNCHRONIZE, FALSE, mutex_name);
if (mutex_handle == NULL) {
rc = GetLastError();
if (rc == ERROR_ACCESS_DENIED) {
rc = service_is_running();
if (rc < 0) {
fatal_error = true;
// FIXME: set service_exit_code
goto error_mutex;
} else if (rc) {
fatal_error = true;
service_exit_code = ERROR_SERVICE_ALREADY_RUNNING;
log_error("Could not start as %s, another instance is already running as service",
_run_as_service ? "service" : "console application");
goto error_mutex;
}
}
if (rc != ERROR_FILE_NOT_FOUND) {
fatal_error = true;
// FIXME: set service_exit_code
rc += ERRNO_WINAPI_OFFSET;
log_error("Could not open single instance mutex: %s (%d)",
get_errno_name(rc), rc);
goto error_mutex;
}
}
if (mutex_handle != NULL) {
fatal_error = true;
service_exit_code = ERROR_SERVICE_ALREADY_RUNNING;
log_error("Could not start as %s, another instance is already running",
_run_as_service ? "service" : "console application");
goto error_mutex;
}
mutex_handle = CreateMutex(NULL, FALSE, mutex_name);
if (mutex_handle == NULL) {
fatal_error = true;
// FIXME: set service_exit_code
rc = ERRNO_WINAPI_OFFSET + GetLastError();
log_error("Could not create single instance mutex: %s (%d)",
get_errno_name(rc), rc);
goto error_mutex;
}
if (log_to_file) {
if (GetModuleFileName(NULL, filename, sizeof(filename)) == 0) {
rc = ERRNO_WINAPI_OFFSET + GetLastError();
log_warn("Could not get module file name: %s (%d)",
get_errno_name(rc), rc);
} else {
i = strlen(filename);
if (i < 4) {
log_warn("Module file name '%s' is too short", filename);
} else {
filename[i - 3] = '\0';
string_append(filename, "log", sizeof(filename));
log_file = fopen(filename, "a+");
if (log_file == NULL) {
log_warn("Could not open log file '%s'", filename);
} else {
printf("Logging to '%s'\n", filename);
log_set_file(log_file);
}
}
}
} else if (_run_as_service) {
log_set_file(NULL);
}
if (!_run_as_service &&
!SetConsoleCtrlHandler(console_ctrl_handler, TRUE)) {
rc = ERRNO_WINAPI_OFFSET + GetLastError();
log_warn("Could not set console control handler: %s (%d)",
get_errno_name(rc), rc);
}
log_set_debug_override(debug);
log_set_level(LOG_CATEGORY_EVENT, config_get_option("log_level.event")->value.log_level);
log_set_level(LOG_CATEGORY_USB, config_get_option("log_level.usb")->value.log_level);
log_set_level(LOG_CATEGORY_NETWORK, config_get_option("log_level.network")->value.log_level);
log_set_level(LOG_CATEGORY_HOTPLUG, config_get_option("log_level.hotplug")->value.log_level);
log_set_level(LOG_CATEGORY_HARDWARE, config_get_option("log_level.hardware")->value.log_level);
log_set_level(LOG_CATEGORY_WEBSOCKET, config_get_option("log_level.websocket")->value.log_level);
log_set_level(LOG_CATEGORY_OTHER, config_get_option("log_level.other")->value.log_level);
if (config_has_error()) {
log_error("Error(s) in config file '%s', run with --check-config option for details",
_config_filename);
fatal_error = true;
goto error_config;
}
if (_run_as_service) {
log_info("Brick Daemon %s started (as service)", VERSION_STRING);
} else {
log_info("Brick Daemon %s started", VERSION_STRING);
}
if (config_has_warning()) {
log_warn("Warning(s) in config file '%s', run with --check-config option for details",
_config_filename);
}
// initialize service status
error_config:
error_mutex:
if (_run_as_service) {
if (service_init(service_control_handler) < 0) {
// FIXME: set service_exit_code
goto error;
}
if (!fatal_error) {
// service is starting
service_set_status(SERVICE_START_PENDING, NO_ERROR);
}
}
if (fatal_error) {
goto error;
}
// initialize WinSock2
if (WSAStartup(MAKEWORD(2, 2), &wsa_data) != 0) {
// FIXME: set service_exit_code
rc = ERRNO_WINAPI_OFFSET + WSAGetLastError();
log_error("Could not initialize Windows Sockets 2.2: %s (%d)",
get_errno_name(rc), rc);
goto error_event;
}
if (event_init() < 0) {
// FIXME: set service_exit_code
goto error_event;
}
if (hardware_init() < 0) {
// FIXME: set service_exit_code
goto error_hardware;
}
if (usb_init(libusb_debug) < 0) {
// FIXME: set service_exit_code
goto error_usb;
}
// create notification pipe
if (pipe_create(&_notification_pipe) < 0) {
// FIXME: set service_exit_code
log_error("Could not create notification pipe: %s (%d)",
get_errno_name(errno), errno);
goto error_pipe;
}
if (event_add_source(_notification_pipe.read_end, EVENT_SOURCE_TYPE_GENERIC,
EVENT_READ, forward_notifications, NULL) < 0) {
// FIXME: set service_exit_code
goto error_pipe_add;
}
// register device notification
ZeroMemory(¬ification_filter, sizeof(notification_filter));
notification_filter.dbcc_size = sizeof(notification_filter);
notification_filter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
notification_filter.dbcc_classguid = GUID_DEVINTERFACE_USB_DEVICE;
if (_run_as_service) {
notification_handle = RegisterDeviceNotification((HANDLE)service_get_status_handle(),
¬ification_filter,
DEVICE_NOTIFY_SERVICE_HANDLE);
} else {
if (message_pump_start() < 0) {
// FIXME: set service_exit_code
goto error_pipe_add;
}
notification_handle = RegisterDeviceNotification(_message_pump_hwnd,
¬ification_filter,
DEVICE_NOTIFY_WINDOW_HANDLE);
}
if (notification_handle == NULL) {
// FIXME: set service_exit_code
rc = ERRNO_WINAPI_OFFSET + GetLastError();
log_error("Could not register for device notification: %s (%d)",
get_errno_name(rc), rc);
goto error_notification;
}
if (network_init() < 0) {
// FIXME: set service_exit_code
goto error_network;
}
// running
if (_run_as_service) {
service_set_status(SERVICE_RUNNING, NO_ERROR);
}
if (event_run(network_cleanup_clients_and_zombies) < 0) {
// FIXME: set service_exit_code
goto error_run;
}
exit_code = EXIT_SUCCESS;
error_run:
network_exit();
error_network:
UnregisterDeviceNotification(notification_handle);
error_notification:
if (!_run_as_service) {
message_pump_stop();
}
event_remove_source(_notification_pipe.read_end, EVENT_SOURCE_TYPE_GENERIC);
error_pipe_add:
pipe_destroy(&_notification_pipe);
error_pipe:
usb_exit();
error_usb:
hardware_exit();
error_hardware:
event_exit();
error_event:
log_info("Brick Daemon %s stopped", VERSION_STRING);
error:
if (!_run_as_service) {
// unregister the console handler before exiting the log. otherwise a
// control event might be send to the control handler after the log
// is not available anymore and the control handler tries to write a
// log messages triggering a crash. this situation could easily be
// created by clicking the close button of the command prompt window
// while the getch call is waiting for the user to press a key.
SetConsoleCtrlHandler(console_ctrl_handler, FALSE);
}
log_exit();
config_exit();
if (_run_as_service) {
// because the service process can be terminated at any time after
// entering SERVICE_STOPPED state the mutex is closed beforehand,
// even though this creates a tiny time window in which the service
// is still running but the mutex is not held anymore
if (mutex_handle != NULL) {
CloseHandle(mutex_handle);
}
// service is now stopped
service_set_status(SERVICE_STOPPED, service_exit_code);
} else {
if (_pause_before_exit) {
printf("Press any key to exit...\n");
getch();
}
if (mutex_handle != NULL) {
CloseHandle(mutex_handle);
}
}
return exit_code;
}
int main(int argc, char **argv) {
int exit_code = EXIT_FAILURE;
int i;
bool help = false;
bool version = false;
bool check_config = false;
bool daemon = false;
const char *debug_filter = NULL;
int pid_fd = -1;
for (i = 1; i < argc; ++i) {
if (strcmp(argv[i], "--help") == 0) {
help = true;
} else if (strcmp(argv[i], "--version") == 0) {
version = true;
} else if (strcmp(argv[i], "--check-config") == 0) {
check_config = true;
} else if (strcmp(argv[i], "--daemon") == 0) {
daemon = true;
} else if (strcmp(argv[i], "--debug") == 0) {
if (i + 1 < argc && strncmp(argv[i + 1], "--", 2) != 0) {
debug_filter = argv[++i];
} else {
debug_filter = "";
}
} else {
fprintf(stderr, "Unknown option '%s'\n\n", argv[i]);
print_usage();
return EXIT_FAILURE;
}
}
if (help) {
print_usage();
return EXIT_SUCCESS;
}
if (version) {
printf("%s\n", VERSION_STRING);
return EXIT_SUCCESS;
}
read_image_version();
_x11_enabled = access("/etc/tf_x11_enabled", F_OK) == 0;
if (prepare_paths() < 0) {
return EXIT_FAILURE;
}
if (check_config) {
return config_check(_config_filename) < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}
config_init(_config_filename);
if (config_has_error()) {
fprintf(stderr, "Error(s) occurred while reading config file '%s'",
_config_filename);
goto error_config;
}
log_init();
if (daemon) {
pid_fd = daemon_start(_log_filename, _pid_filename, 1);
} else {
pid_fd = pid_file_acquire(_pid_filename, getpid());
if (pid_fd == PID_FILE_ALREADY_ACQUIRED) {
fprintf(stderr, "Already running according to '%s'\n", _pid_filename);
}
}
if (pid_fd < 0) {
goto error_pid_file;
}
if (daemon && _x11_enabled) {
log_info("RED Brick API Daemon %s started (daemonized, X11 enabled) on %s image",
VERSION_STRING, _image_version);
} else if (daemon) {
log_info("RED Brick API Daemon %s started (daemonized) on %s image",
VERSION_STRING, _image_version);
} else if (_x11_enabled) {
log_info("RED Brick API Daemon %s started (X11 enabled) on %s image",
VERSION_STRING, _image_version);
} else {
log_info("RED Brick API Daemon %s started on %s image",
VERSION_STRING, _image_version);
}
if (debug_filter != NULL) {
log_enable_debug_override(debug_filter);
}
if (config_has_warning()) {
log_warn("Warning(s) in config file '%s', run with --check-config option for details",
_config_filename);
}
if (event_init() < 0) {
goto error_event;
}
if (signal_init(handle_sighup, NULL) < 0) {
goto error_signal;
}
if (process_monitor_init() < 0) {
goto error_process_monitor;
}
if (cron_init() < 0) {
goto error_cron;
}
if (inventory_init() < 0) {
goto error_inventory;
}
if (api_init() < 0) {
goto error_api;
}
if (network_init(_brickd_socket_filename, _cron_socket_filename) < 0) {
goto error_network;
}
if (inventory_load_programs() < 0) {
goto error_load_programs;
}
if (event_run(network_cleanup_brickd_and_socats) < 0) {
goto error_run;
}
exit_code = EXIT_SUCCESS;
error_run:
inventory_unload_programs();
error_load_programs:
network_exit();
error_network:
api_exit();
error_api:
inventory_exit();
error_inventory:
cron_exit();
error_cron:
process_monitor_exit();
error_process_monitor:
signal_exit();
error_signal:
event_exit();
error_event:
log_info("RED Brick API Daemon %s stopped", VERSION_STRING);
error_pid_file:
if (pid_fd >= 0) {
pid_file_release(_pid_filename, pid_fd);
}
log_exit();
error_config:
config_exit();
return exit_code;
}
int main(int argc, char **argv) {
int exit_code = EXIT_FAILURE;
int i;
bool help = false;
bool version = false;
bool check_config = false;
bool daemon = false;
bool debug = false;
bool libusb_debug = false;
int pid_fd = -1;
#ifdef BRICKD_WITH_LIBUDEV
bool initialized_udev = false;
#endif
for (i = 1; i < argc; ++i) {
if (strcmp(argv[i], "--help") == 0) {
help = true;
} else if (strcmp(argv[i], "--version") == 0) {
version = true;
} else if (strcmp(argv[i], "--check-config") == 0) {
check_config = true;
} else if (strcmp(argv[i], "--daemon") == 0) {
daemon = true;
} else if (strcmp(argv[i], "--debug") == 0) {
debug = true;
} else if (strcmp(argv[i], "--libusb-debug") == 0) {
libusb_debug = true;
} else {
fprintf(stderr, "Unknown option '%s'\n\n", argv[i]);
print_usage();
return EXIT_FAILURE;
}
}
if (help) {
print_usage();
return EXIT_SUCCESS;
}
if (version) {
printf("%s\n", VERSION_STRING);
return EXIT_SUCCESS;
}
if (prepare_paths() < 0) {
return EXIT_FAILURE;
}
if (check_config) {
return config_check(_config_filename) < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}
config_init(_config_filename);
log_init();
if (daemon) {
pid_fd = daemon_start(_log_filename, _pid_filename, true);
} else {
pid_fd = pid_file_acquire(_pid_filename, getpid());
if (pid_fd == PID_FILE_ALREADY_ACQUIRED) {
fprintf(stderr, "Already running according to '%s'\n", _pid_filename);
}
}
if (pid_fd < 0) {
goto error_log;
}
log_set_debug_override(debug);
log_set_level(LOG_CATEGORY_EVENT, config_get_option("log_level.event")->value.log_level);
log_set_level(LOG_CATEGORY_USB, config_get_option("log_level.usb")->value.log_level);
log_set_level(LOG_CATEGORY_NETWORK, config_get_option("log_level.network")->value.log_level);
log_set_level(LOG_CATEGORY_HOTPLUG, config_get_option("log_level.hotplug")->value.log_level);
log_set_level(LOG_CATEGORY_HARDWARE, config_get_option("log_level.hardware")->value.log_level);
log_set_level(LOG_CATEGORY_WEBSOCKET, config_get_option("log_level.websocket")->value.log_level);
#ifdef BRICKD_WITH_RED_BRICK
log_set_level(LOG_CATEGORY_RED_BRICK, config_get_option("log_level.red_brick")->value.log_level);
log_set_level(LOG_CATEGORY_SPI, config_get_option("log_level.spi")->value.log_level);
log_set_level(LOG_CATEGORY_RS485, config_get_option("log_level.rs485")->value.log_level);
#endif
log_set_level(LOG_CATEGORY_OTHER, config_get_option("log_level.other")->value.log_level);
if (config_has_error()) {
log_error("Error(s) in config file '%s', run with --check-config option for details",
_config_filename);
goto error_config;
}
if (daemon) {
log_info("Brick Daemon %s started (daemonized)", VERSION_STRING);
} else {
log_info("Brick Daemon %s started", VERSION_STRING);
}
if (config_has_warning()) {
log_error("Warning(s) in config file '%s', run with --check-config option for details",
_config_filename);
}
if (event_init() < 0) {
goto error_event;
}
if (signal_init(handle_sigusr1) < 0) {
goto error_signal;
}
if (hardware_init() < 0) {
goto error_hardware;
}
if (usb_init(libusb_debug) < 0) {
goto error_usb;
}
#ifdef BRICKD_WITH_LIBUDEV
if (!usb_has_hotplug()) {
if (udev_init() < 0) {
goto error_udev;
}
initialized_udev = true;
}
#endif
if (network_init() < 0) {
goto error_network;
}
#ifdef BRICKD_WITH_RED_BRICK
if (gpio_init() < 0) {
goto error_gpio;
}
if (red_usb_gadget_init() < 0) {
goto error_red_usb_gadget;
}
if (redapid_init() < 0) {
goto error_redapid;
}
if (red_stack_init() < 0) {
goto error_red_stack;
}
if (rs485_extension_init() < 0) {
goto error_rs485_extension;
}
#endif
if (event_run(network_cleanup_clients_and_zombies) < 0) {
goto error_run;
}
exit_code = EXIT_SUCCESS;
error_run:
#ifdef BRICKD_WITH_RED_BRICK
rs485_extension_exit();
error_rs485_extension:
red_stack_exit();
error_red_stack:
redapid_exit();
error_redapid:
red_usb_gadget_exit();
error_red_usb_gadget:
//gpio_exit();
error_gpio:
#endif
network_exit();
error_network:
#ifdef BRICKD_WITH_LIBUDEV
if (initialized_udev) {
udev_exit();
}
error_udev:
#endif
usb_exit();
error_usb:
hardware_exit();
error_hardware:
signal_exit();
error_signal:
event_exit();
error_event:
log_info("Brick Daemon %s stopped", VERSION_STRING);
error_config:
error_log:
log_exit();
if (pid_fd >= 0) {
pid_file_release(_pid_filename, pid_fd);
}
config_exit();
return exit_code;
}
int main(int argc, char **argv) {
int exit_code = EXIT_FAILURE;
int i;
bool help = false;
bool version = false;
bool check_config = false;
bool daemon = false;
const char *debug_filter = NULL;
bool libusb_debug = false;
int pid_fd = -1;
for (i = 1; i < argc; ++i) {
if (strcmp(argv[i], "--help") == 0) {
help = true;
} else if (strcmp(argv[i], "--version") == 0) {
version = true;
} else if (strcmp(argv[i], "--check-config") == 0) {
check_config = true;
} else if (strcmp(argv[i], "--daemon") == 0) {
daemon = true;
} else if (strcmp(argv[i], "--debug") == 0) {
if (i + 1 < argc && strncmp(argv[i + 1], "--", 2) != 0) {
debug_filter = argv[++i];
} else {
debug_filter = "";
}
} else if (strcmp(argv[i], "--libusb-debug") == 0) {
libusb_debug = true;
} else {
fprintf(stderr, "Unknown option '%s'\n\n", argv[i]);
print_usage();
return EXIT_FAILURE;
}
}
if (help) {
print_usage();
return EXIT_SUCCESS;
}
if (version) {
printf("%s\n", VERSION_STRING);
return EXIT_SUCCESS;
}
if (check_config) {
return config_check(CONFIG_FILENAME) < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}
config_init(CONFIG_FILENAME);
if (config_has_error()) {
fprintf(stderr, "Error(s) occurred while reading config file '%s'\n",
CONFIG_FILENAME);
goto error_config;
}
log_init();
if (daemon) {
pid_fd = daemon_start(LOG_FILENAME, PID_FILENAME, false);
} else {
pid_fd = pid_file_acquire(PID_FILENAME, getpid());
if (pid_fd == PID_FILE_ALREADY_ACQUIRED) {
fprintf(stderr, "Already running according to '%s'\n", PID_FILENAME);
}
}
if (pid_fd < 0) {
goto error_pid_file;
}
log_info("Brick Daemon %s started (pid: %u, daemonized: %d)",
VERSION_STRING, getpid(), daemon ? 1 : 0);
if (debug_filter != NULL) {
log_enable_debug_override(debug_filter);
}
if (config_has_warning()) {
log_warn("Warning(s) in config file '%s', run with --check-config option for details",
CONFIG_FILENAME);
}
if (event_init() < 0) {
goto error_event;
}
if (signal_init(NULL, handle_sigusr1) < 0) {
goto error_signal;
}
if (hardware_init() < 0) {
goto error_hardware;
}
if (usb_init(libusb_debug) < 0) {
goto error_usb;
}
if (iokit_init() < 0) {
goto error_iokit;
}
if (network_init() < 0) {
goto error_network;
}
if (event_run(network_cleanup_clients_and_zombies) < 0) {
goto error_run;
}
exit_code = EXIT_SUCCESS;
error_run:
network_exit();
error_network:
iokit_exit();
error_iokit:
usb_exit();
error_usb:
hardware_exit();
error_hardware:
signal_exit();
error_signal:
event_exit();
error_event:
log_info("Brick Daemon %s stopped", VERSION_STRING);
error_pid_file:
if (pid_fd >= 0) {
pid_file_release(PID_FILENAME, pid_fd);
}
log_exit();
error_config:
config_exit();
return exit_code;
}
static void stop_handler(void *data, int flags) {
event_exit();
}
static bool setup_device(void) {
struct sockaddr_un listen_sun;
static const int one = 1;
struct {
char zero;
int pid;
int usecs;
} name;
struct timeval tv;
if(!get_config_string(lookup_config(config_tree, "Device"), &device))
xasprintf(&device, LOCALSTATEDIR "/run/%s.umlsocket", identname);
get_config_string(lookup_config(config_tree, "Interface"), &iface);
device_info = "UML network socket";
if((write_fd = socket(PF_UNIX, SOCK_DGRAM, 0)) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Could not open write %s: %s", device_info, strerror(errno));
event_exit();
return false;
}
#ifdef FD_CLOEXEC
fcntl(write_fd, F_SETFD, FD_CLOEXEC);
#endif
setsockopt(write_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one);
if(fcntl(write_fd, F_SETFL, O_NONBLOCK) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "fcntl", strerror(errno));
event_exit();
return false;
}
if((data_fd = socket(PF_UNIX, SOCK_DGRAM, 0)) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Could not open data %s: %s", device_info, strerror(errno));
event_exit();
return false;
}
#ifdef FD_CLOEXEC
fcntl(data_fd, F_SETFD, FD_CLOEXEC);
#endif
setsockopt(data_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one);
if(fcntl(data_fd, F_SETFL, O_NONBLOCK) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "fcntl", strerror(errno));
event_exit();
return false;
}
name.zero = 0;
name.pid = getpid();
gettimeofday(&tv, NULL);
name.usecs = tv.tv_usec;
data_sun.sun_family = AF_UNIX;
memcpy(&data_sun.sun_path, &name, sizeof name);
if(bind(data_fd, (struct sockaddr *)&data_sun, sizeof data_sun) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Could not bind data %s: %s", device_info, strerror(errno));
event_exit();
return false;
}
if((listen_fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Could not open %s: %s", device_info,
strerror(errno));
return false;
}
#ifdef FD_CLOEXEC
fcntl(device_fd, F_SETFD, FD_CLOEXEC);
#endif
setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one);
if(fcntl(listen_fd, F_SETFL, O_NONBLOCK) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "fcntl", strerror(errno));
return false;
}
listen_sun.sun_family = AF_UNIX;
strncpy(listen_sun.sun_path, device, sizeof listen_sun.sun_path);
if(bind(listen_fd, (struct sockaddr *)&listen_sun, sizeof listen_sun) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Could not bind %s to %s: %s", device_info, device, strerror(errno));
return false;
}
if(listen(listen_fd, 1) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Could not listen on %s %s: %s", device_info, device, strerror(errno));
return false;
}
device_fd = listen_fd;
state = 0;
logger(DEBUG_ALWAYS, LOG_INFO, "%s is a %s", device, device_info);
if(routing_mode == RMODE_ROUTER)
overwrite_mac = true;
return true;
}
static bool read_packet(vpn_packet_t *packet) {
int inlen;
switch(state) {
case 0: {
struct sockaddr sa;
socklen_t salen = sizeof sa;
request_fd = accept(listen_fd, &sa, &salen);
if(request_fd < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Could not accept connection to %s %s: %s", device_info, device, strerror(errno));
return false;
}
#ifdef FD_CLOEXEC
fcntl(request_fd, F_SETFD, FD_CLOEXEC);
#endif
if(fcntl(listen_fd, F_SETFL, O_NONBLOCK) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "fcntl", strerror(errno));
event_exit();
return false;
}
close(listen_fd);
listen_fd = -1;
device_fd = request_fd;
state = 1;
return false;
}
case 1: {
if((inlen = read(request_fd, &request, sizeof request)) != sizeof request) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading request from %s %s: %s", device_info,
device, strerror(errno));
event_exit();
return false;
}
if(request.magic != 0xfeedface || request.version != 3 || request.type != REQ_NEW_CONTROL) {
logger(DEBUG_ALWAYS, LOG_ERR, "Unknown magic %x, version %d, request type %d from %s %s",
request.magic, request.version, request.type, device_info, device);
event_exit();
return false;
}
if(connect(write_fd, &request.sock, sizeof request.sock) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Could not bind write %s: %s", device_info, strerror(errno));
event_exit();
return false;
}
write(request_fd, &data_sun, sizeof data_sun);
device_fd = data_fd;
logger(DEBUG_ALWAYS, LOG_INFO, "Connection with UML established");
state = 2;
return false;
}
case 2: {
if((inlen = read(data_fd, DATA(packet), MTU)) <= 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info,
device, strerror(errno));
event_exit();
return false;
}
packet->len = inlen;
logger(DEBUG_TRAFFIC, LOG_DEBUG, "Read packet of %d bytes from %s", packet->len,
device_info);
return true;
}
default:
logger(DEBUG_ALWAYS, LOG_ERR, "Invalid value for state variable in " __FILE__);
abort();
}
}
