static int service_run(int log_to_file, int debug) {
SERVICE_TABLE_ENTRY service_table[2];
int rc;
service_table[0].lpServiceName = service_get_name();
service_table[0].lpServiceProc = service_main;
service_table[1].lpServiceName = NULL;
service_table[1].lpServiceProc = NULL;
if (!StartServiceCtrlDispatcher(service_table)) {
rc = ERRNO_WINAPI_OFFSET + GetLastError();
if (rc == ERRNO_WINAPI_OFFSET + ERROR_FAILED_SERVICE_CONTROLLER_CONNECT) {
log_info("Could not start as service, starting as console application");
_run_as_service = 0;
_pause_before_exit = started_by_explorer();
return generic_main(log_to_file, debug);
} else {
log_error("Could not start service control dispatcher: %s (%d)",
get_errno_name(rc), rc);
log_exit();
config_exit();
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
/**
* 清理窗口管理器
* 就不写注释了 函数名写的已经很明白。。
**/
si_t window_manager_exit()
{
application_exit();
cursor_exit();
graph_exit();
comm_exit();
event_exit();
config_exit();
terminal_exit();
return 0;
}
int main(int argc, char* argv[])
{
if (argc == 2) {
if (strcmp("--disable-watchdog", argv[1]) == 0) {
watchdog_disabled = true;
}
}
int fd;
if (!watchdog_disabled) {
fd = open(WATCHDOG_PATH, O_RDWR);
if (fd < -1) {
printf("Cannot open watchdog\n");
exit(EXIT_FAILURE);
}
}
logger_startup();
char buf[1024];
config_init("/root/beaglebone.conf");
beagleblue_init(&parser_parse);
halosuit_init();
automation_init();
soc_init();
logger_log("Initialization complete");
// if loop takes longer than 45 secs watchdog will reboot the system
while (1) {
// sends status information to android phone and google glass
serializer_serialize(buf);
beagleblue_android_send(buf);
beagleblue_glass_send(buf);
if (!watchdog_disabled) {
// kick watchdog
ioctl(fd, WDIOC_KEEPALIVE, NULL);
}
sleep(SERIALIZE_DELAY);
}
// close(fd);
automation_exit();
halosuit_exit();
config_exit();
beagleblue_exit();
beagleblue_join();
logger_log("Exiting halosuit");
return 0;
}
int
main(int argc, char **argv)
{
int rc = 0;
rc = config_load();
if (rc) {
ERROR("configuration loading failed\n");
exit(EXIT_FAILURE);
}
rc = uloop_init();
if (rc) {
ERROR("uloop init failed\n");
exit(EXIT_FAILURE);
}
rc = ssh_netconf_init();
if (rc) {
ERROR("ssh init failed\n");
exit(EXIT_FAILURE);
}
rc = ubus_init();
if (rc) {
ERROR("ubus init failed\n");
exit(EXIT_FAILURE);
}
LOG("freenetconfd is listening on address:'%s', port:'%s'\n", config.addr, config.port);
/* main loop */
uloop_run();
ssh_netconf_exit();
uloop_done();
ubus_exit();
config_exit();
return EXIT_SUCCESS;
}
// 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 cgiMain(void){
cgiFilePtr file;
char fileNameOnServer[512]={0};
char buffer[pic_max_len];
int got = 0;
int filelen = 0;
Ctcp *conn_fileserver = NULL;
char s_data[512];
logo_recv_webclient_t data;
uint32_t pic_type = 0;
uint32_t branchtype = 0;
logo_recv_fileServ_t* recv_data = NULL;
log_init("/cgi/log/",(log_lvl_t)8,log_size,0,"");
cgiHeaderContentType((char *)"text/html");
cgiFormString((char*)"session_key",s_data,512);
if(strlen(s_data) == 0){
CGI_ERROR_LOG("session_key error:len[%u] [%s]",strlen(s_data),s_data);
cgi_print_result(recv_data,fileNameOnServer,pic_type,branchtype,FAIL,session_key_err);
return FAIL;
}
parse_web_data(s_data,&data);
if(data.cnt >CNT_MAX){
CGI_ERROR_LOG("thumb cnt error[%u]",data.cnt);
cgi_print_result(recv_data,fileNameOnServer,pic_type,branchtype,FAIL,thumb_cnt_err);
return FAIL;
}
if(cgiFormFileName((char *)"file",fileNameOnServer, sizeof(fileNameOnServer)) !=cgiFormSuccess){
CGI_ERROR_LOG("could not retrieve filename, file: %s", fileNameOnServer);
cgi_print_result(recv_data,"",pic_type,branchtype,FAIL,retrieve_filename_err);
return FAIL;
}
char tfilename[128];
if(cgiFormSuccess != cgiGetFilePath((char *)"file",tfilename,sizeof(tfilename))){
CGI_ERROR_LOG("GET FILE PATH ERROR");
cgi_print_result(recv_data,"",pic_type,branchtype,FAIL,retrieve_filename_err);
return FAIL;
}
cgiFormFileSize((char *)"file", &filelen);
if(filelen > pic_max_len){
CGI_ERROR_LOG("file size is too big");
cgi_print_result(recv_data,fileNameOnServer,pic_type,branchtype,FAIL,image_size_err);
return FAIL;
}
if (cgiFormFileOpen((char *)"file", &file) != cgiFormSuccess) {
CGI_ERROR_LOG("could not open the file");
cgi_print_result(recv_data,fileNameOnServer,pic_type,branchtype,FAIL,open_file_err);
return FAIL;
}
if(-1 == config_init("/opt/taomee/cgi_conf/bench.conf")){
CGI_ERROR_LOG("read conf_file error");
cgi_print_result(recv_data,fileNameOnServer,pic_type,branchtype,FAIL,unknown_err);
return FAIL;
}
char *bind_ip = config_get_strval("bind_ip");
if(data.ip != inet_addr(bind_ip)){
struct in_addr addr1;
memcpy(&addr1, &(data.ip), 4);
CGI_ERROR_LOG("request is forbidden bind_ip[%d %s],req_ip[%u %s]",inet_addr(bind_ip),bind_ip,data.ip,inet_ntoa(addr1));
cgi_print_result(recv_data,fileNameOnServer,pic_type,branchtype,FAIL,hostid_err);
return FAIL;
}
time_t now_time;
now_time = time(NULL);
if((now_time - data.time) > 5*60){
CGI_ERROR_LOG("upload timeout nowtime[%u] data.time[%u]",now_time,data.time);
cgi_print_result(recv_data,fileNameOnServer,pic_type,branchtype,FAIL,timeout_err);
return FAIL;
}
conn_fileserver = new Ctcp(config_get_strval("bind_fileserver_ip"),config_get_intval("bind_fileserver_port", 0),0,10);
if(cgiFormFileRead(file, buffer, pic_max_len, &got) ==cgiFormSuccess){
if(got > 0){
uint8_t filedate[8];
memcpy(filedate,(uint8_t*)buffer,8);
parse_uploadfile_type(&pic_type ,&branchtype,filedate);
if(pic_type == 2){
CGI_ERROR_LOG("image type error.");
delete conn_fileserver;
cgiFormFileClose(file);
cgi_print_result(recv_data,fileNameOnServer,pic_type,branchtype,FAIL,image_type_err);
config_exit();
return FAIL;
}
if(NULL == cgi_create_image(branchtype, got, buffer)){
CGI_ERROR_LOG("invalid file");
delete conn_fileserver;
cgiFormFileClose(file);
cgi_print_result(recv_data,fileNameOnServer,pic_type,branchtype,FAIL,invalid_file);
config_exit();
return FAIL;
}
cgiFormFileClose(file);
recv_data = connect_with_fileserver(buffer,conn_fileserver,&data,filelen,pic_type,branchtype,tfilename);
if(recv_data == NULL){
CGI_ERROR_LOG("cgi connect fileserver error");
delete conn_fileserver;
cgi_print_result(recv_data,fileNameOnServer,pic_type,branchtype,FAIL,net_err);
config_exit();
return FAIL;
}
delete conn_fileserver;
cgi_print_result(recv_data,fileNameOnServer,pic_type,branchtype,SUCC,0);
config_exit();
return SUCC;
}
}
CGI_ERROR_LOG("cgi read file error:got=%d",got);
delete conn_fileserver;
cgiFormFileClose(file);
cgi_print_result(recv_data,fileNameOnServer,pic_type,branchtype,FAIL,read_file_err);
config_exit();
return FAIL;
}
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 c;
int start_event = 0;
bool foreground = false;
while (1) {
c = getopt_long(argc, argv, "fhbgv", long_opts, NULL);
if (c == EOF)
break;
switch (c) {
case 'b':
start_event |= START_BOOT;
break;
case 'f':
foreground = true;
break;
case 'g':
start_event |= START_GET_RPC_METHOD;
break;
case 'h':
print_help();
exit(EXIT_SUCCESS);
case 'v':
print_version();
exit(EXIT_SUCCESS);
default:
print_help();
exit(EXIT_FAILURE);
}
}
log_message(NAME, L_DEBUG, "daemon started\n");
setlocale(LC_CTYPE, "");
umask(0037);
if (getuid() != 0) {
D("run %s as root\n", NAME);
exit(EXIT_FAILURE);
}
/* run early cwmp initialization */
cwmp = calloc(1, sizeof(struct cwmp_internal));
if (!cwmp) return -1;
INIT_LIST_HEAD(&cwmp->events);
INIT_LIST_HEAD(&cwmp->notifications);
INIT_LIST_HEAD(&cwmp->downloads);
INIT_LIST_HEAD(&cwmp->scheduled_informs);
uloop_init();
backup_init();
config_load();
cwmp_init_deviceid();
if (start_event & START_BOOT) {
cwmp_add_event(EVENT_BOOT, NULL, 0, EVENT_BACKUP);
cwmp_add_inform_timer();
}
if (start_event & START_GET_RPC_METHOD) {
cwmp->get_rpc_methods = true;
cwmp_add_event(EVENT_PERIODIC, NULL, 0, EVENT_BACKUP);
cwmp_add_inform_timer();
}
if (netlink_init()) {
D("netlink initialization failed\n");
exit(EXIT_FAILURE);
}
if (ubus_init()) D("ubus initialization failed\n");
http_server_init();
pid_t pid, sid;
if (!foreground) {
pid = fork();
if (pid < 0)
exit(EXIT_FAILURE);
if (pid > 0)
exit(EXIT_SUCCESS);
sid = setsid();
if (sid < 0) {
D("setsid() returned error\n");
exit(EXIT_FAILURE);
}
char *directory = "/";
if ((chdir(directory)) < 0) {
D("chdir() returned error\n");
exit(EXIT_FAILURE);
}
}
log_message(NAME, L_DEBUG, "entering main loop\n");
uloop_run();
ubus_exit();
uloop_done();
http_client_exit();
xml_exit();
config_exit();
cwmp_free_deviceid();
free(cwmp);
closelog();
log_message(NAME, L_DEBUG, "exiting\n");
return 0;
}
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;
}
