int main(int argc, char *argv[])
{
GDBusClient *client;
guint signal;
signal = setup_signalfd();
if (signal == 0)
return -errno;
connection = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, NULL);
main_loop = g_main_loop_new(NULL, FALSE);
g_dbus_attach_object_manager(connection);
printf("gatt-service unique name: %s\n",
dbus_bus_get_unique_name(connection));
create_services();
client = g_dbus_client_new(connection, "org.bluez", "/org/bluez");
g_dbus_client_set_connect_watch(client, connect_handler, NULL);
g_main_loop_run(main_loop);
g_dbus_client_unref(client);
g_source_remove(signal);
g_slist_free_full(services, g_free);
dbus_connection_unref(connection);
return 0;
}
int tester_run(void)
{
guint signal;
int ret;
if (!main_loop)
return EXIT_FAILURE;
if (option_list) {
g_main_loop_unref(main_loop);
return EXIT_SUCCESS;
}
signal = setup_signalfd();
g_idle_add(start_tester, NULL);
g_main_loop_run(main_loop);
g_source_remove(signal);
g_main_loop_unref(main_loop);
ret = tester_summarize();
g_list_free_full(test_list, test_destroy);
return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
int main(int argc, char **argv)
{
GOptionContext *context;
GError *err = NULL;
guint signal;
struct certmgr_service *service;
g_log_set_handler (NULL, G_LOG_LEVEL_MASK, log_handler, NULL);
g_message("Certificate Management Service %s", VERSION);
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (g_option_context_parse(context, &argc, &argv, &err) == FALSE) {
if (err != NULL) {
g_printerr("%s\n", err->message);
g_error_free(err);
exit(1);
}
g_printerr("An unknown error occurred\n");
exit(1);
}
g_option_context_free(context);
if (option_version == TRUE) {
printf("%s\n", VERSION);
exit(0);
}
if (option_detach == TRUE) {
if (daemon(0, 0)) {
perror("Can't start daemon");
return 1;
}
}
signal = setup_signalfd();
event_loop = g_main_loop_new(NULL, FALSE);
service = certmgr_service_create();
if (!service)
goto exit;
g_main_loop_run(event_loop);
exit:
g_source_remove(signal);
if (service)
certmgr_service_free(service);
g_main_loop_unref(event_loop);
return 0;
}
int main(int argc, char *argv[])
{
GOptionContext *context;
GError *error = NULL;
DBusConnection *dbus_conn;
GDBusClient *client;
guint signal;
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (g_option_context_parse(context, &argc, &argv, &error) == FALSE) {
if (error != NULL) {
g_printerr("%s\n", error->message);
g_error_free(error);
} else
g_printerr("An unknown error occurred\n");
exit(1);
}
g_option_context_free(context);
if (option_version == TRUE) {
g_print("%s\n", VERSION);
exit(0);
}
main_loop = g_main_loop_new(NULL, FALSE);
dbus_conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, NULL);
signal = setup_signalfd();
client = g_dbus_client_new(dbus_conn, "org.bluez", "/org/bluez");
g_dbus_client_set_connect_watch(client, connect_handler, client);
g_dbus_client_set_disconnect_watch(client, disconnect_handler, NULL);
g_main_loop_run(main_loop);
g_dbus_client_unref(client);
g_source_remove(signal);
dbus_connection_unref(dbus_conn);
g_main_loop_unref(main_loop);
return 0;
}
int main(int argc, char **argv)
{
GOptionContext *context;
GError *error = NULL;
guint signal_watch;
guint server_watch;
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (g_option_context_parse(context, &argc, &argv, &error) == FALSE) {
if (error != NULL) {
g_printerr("%s\n", error->message);
g_error_free(error);
} else
g_printerr("An unknown error occurred\n");
return EXIT_FAILURE;
}
g_option_context_free(context);
if (option_device == NULL) {
if (option_ifx == TRUE) {
option_device = g_strdup("/dev/ttyIFX0");
} else {
g_printerr("No valid device specified\n");
return EXIT_FAILURE;
}
}
main_loop = g_main_loop_new(NULL, FALSE);
signal_watch = setup_signalfd();
server_watch = setup_server();
g_main_loop_run(main_loop);
g_source_remove(server_watch);
g_source_remove(signal_watch);
g_main_loop_unref(main_loop);
g_free(option_device);
return EXIT_SUCCESS;
}
int interactive(const char *src, const char *dst,
const char *dst_type, int psm)
{
guint input;
guint signal;
opt_sec_level = g_strdup("low");
opt_src = g_strdup(src);
opt_dst = g_strdup(getChannelMac());
opt_dst_type = g_strdup("random");
opt_psm = psm;
prompt = g_string_new(NULL);
event_loop = g_main_loop_new(NULL, FALSE);
input = setup_standard_input();
signal = setup_signalfd();
rl_attempted_completion_function = commands_completion;
rl_erase_empty_line = 1;
rl_callback_handler_install(get_prompt(), parse_line);
g_timeout_add(1000,writehnd,NULL);
curl_global_init(CURL_GLOBAL_ALL);
g_main_loop_run(event_loop);
rl_callback_handler_remove();
cmd_disconnect(0, NULL);
g_source_remove(input);
g_source_remove(signal);
g_main_loop_unref(event_loop);
g_string_free(prompt, TRUE);
g_free(opt_src);
g_free(opt_dst);
g_free(opt_sec_level);
return 0;
}
int main(int ac, char *av[]) {
int rv = 0;
int sfd = setup_signalfd();
struct config *config = parse_config("amtredird.ini");
if (config && validate_config(config)) {
if (init_amt(config)) {
if (sfd != -1) {
rv = (run_server(config, sfd) == 0);
} else {
rv = 1;
}
teardown_amt(config);
}
} else {
rv = 1;
}
close(sfd);
free_config(config);
return rv;
}
int main(int argc, char *argv[])
{
GOptionContext *context;
GError *error = NULL;
DBusConnection *conn;
DBusError err;
guint signal;
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (!g_option_context_parse(context, &argc, &argv, &error)) {
if (error) {
g_printerr("%s\n", error->message);
g_error_free(error);
} else
g_printerr("An unknown error occurred\n");
exit(1);
}
g_option_context_free(context);
if (option_version) {
printf("%s\n", VERSION);
exit(0);
}
if (option_detach) {
if (daemon(0, 0)) {
perror("Can't start daemon");
exit(1);
}
}
if (mkdir(VPN_STATEDIR, S_IRUSR | S_IWUSR | S_IXUSR |
S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) < 0) {
if (errno != EEXIST)
perror("Failed to create state directory");
}
/*
* At some point the VPN stuff is migrated into VPN_STORAGEDIR
* and this mkdir() call can be removed.
*/
if (mkdir(STORAGEDIR, S_IRUSR | S_IWUSR | S_IXUSR |
S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) < 0) {
if (errno != EEXIST)
perror("Failed to create storage directory");
}
if (mkdir(VPN_STORAGEDIR, S_IRUSR | S_IWUSR | S_IXUSR |
S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) < 0) {
if (errno != EEXIST)
perror("Failed to create VPN storage directory");
}
umask(0077);
main_loop = g_main_loop_new(NULL, FALSE);
signal = setup_signalfd();
dbus_error_init(&err);
conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, VPN_SERVICE, &err);
if (!conn) {
if (dbus_error_is_set(&err)) {
fprintf(stderr, "%s\n", err.message);
dbus_error_free(&err);
} else
fprintf(stderr, "Can't register with system bus\n");
exit(1);
}
g_dbus_set_disconnect_function(conn, disconnect_callback, NULL, NULL);
__connman_log_init(argv[0], option_debug, option_detach, false,
"Connection Manager VPN daemon", VERSION);
__connman_dbus_init(conn);
__connman_inotify_init();
__connman_storage_init();
if (!option_config)
config_init(CONFIGMAINFILE);
else
config_init(option_config);
__connman_agent_init();
__vpn_provider_init(option_routes);
__vpn_manager_init();
__vpn_ipconfig_init();
__vpn_rtnl_init();
__connman_task_init();
__connman_plugin_init(option_plugin, option_noplugin);
__vpn_config_init();
__vpn_rtnl_start();
g_free(option_plugin);
g_free(option_noplugin);
g_main_loop_run(main_loop);
g_source_remove(signal);
__vpn_config_cleanup();
__connman_plugin_cleanup();
__connman_task_cleanup();
__vpn_rtnl_cleanup();
__vpn_ipconfig_cleanup();
__vpn_manager_cleanup();
__vpn_provider_cleanup();
__connman_agent_cleanup();
__connman_storage_cleanup();
__connman_inotify_cleanup();
__connman_dbus_cleanup();
__connman_log_cleanup(false);
dbus_connection_unref(conn);
g_main_loop_unref(main_loop);
g_free(option_debug);
return 0;
}
int main(int argc, char **argv)
{
GOptionContext *context;
GError *err = NULL;
DBusConnection *conn;
DBusError error;
guint signal;
#ifdef NEED_THREADS
if (g_thread_supported() == FALSE)
g_thread_init(NULL);
#endif
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (g_option_context_parse(context, &argc, &argv, &err) == FALSE) {
if (err != NULL) {
g_printerr("%s\n", err->message);
g_error_free(err);
return 1;
}
g_printerr("An unknown error occurred\n");
return 1;
}
g_option_context_free(context);
if (option_version == TRUE) {
printf("%s\n", VERSION);
exit(0);
}
if (option_detach == TRUE) {
if (daemon(0, 0)) {
perror("Can't start daemon");
return 1;
}
}
event_loop = g_main_loop_new(NULL, FALSE);
#ifdef NEED_THREADS
if (dbus_threads_init_default() == FALSE) {
fprintf(stderr, "Can't init usage of threads\n");
exit(1);
}
#endif
signal = setup_signalfd();
__ofono_log_init(argv[0], option_debug, option_detach,
option_backtrace);
dbus_error_init(&error);
conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, OFONO_SERVICE, &error);
if (conn == NULL) {
if (dbus_error_is_set(&error) == TRUE) {
ofono_error("Unable to hop onto D-Bus: %s",
error.message);
dbus_error_free(&error);
} else {
ofono_error("Unable to hop onto D-Bus");
}
goto cleanup;
}
g_dbus_set_disconnect_function(conn, system_bus_disconnected,
NULL, NULL);
__ofono_dbus_init(conn);
__ofono_modemwatch_init();
__ofono_manager_init();
__ofono_plugin_init(option_plugin, option_noplugin);
g_free(option_plugin);
g_free(option_noplugin);
g_main_loop_run(event_loop);
__ofono_plugin_cleanup();
__ofono_manager_cleanup();
__ofono_modemwatch_cleanup();
__ofono_dbus_cleanup();
dbus_connection_unref(conn);
cleanup:
g_source_remove(signal);
g_main_loop_unref(event_loop);
__ofono_log_cleanup(option_backtrace);
return 0;
}
int main(int argc, char **argv)
{
GOptionContext *context;
GError *err = NULL;
guint signal;
struct telephony_service *telservice;
struct wan_service *wanservice;
g_type_init();
g_log_set_handler (NULL, G_LOG_LEVEL_MASK, log_handler, NULL);
g_message("Telephony Interface Layer Daemon %s", VERSION);
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (g_option_context_parse(context, &argc, &argv, &err) == FALSE) {
if (err != NULL) {
g_printerr("%s\n", err->message);
g_error_free(err);
exit(1);
}
g_printerr("An unknown error occurred\n");
exit(1);
}
g_option_context_free(context);
if (option_version == TRUE) {
printf("%s\n", VERSION);
exit(0);
}
if (option_detach == TRUE) {
if (daemon(0, 0)) {
perror("Can't start daemon");
return 1;
}
}
signal = setup_signalfd();
event_loop = g_main_loop_new(NULL, FALSE);
ofono_init();
telservice = telephony_service_create();
wanservice = wan_service_create();
if(telservice && wanservice) {
g_main_loop_run(event_loop);
}
g_message("Cleaning up");
if(wanservice)
wan_service_free(wanservice);
if(telservice)
telephony_service_free(telservice);
ofono_exit();
g_source_remove(signal);
g_main_loop_unref(event_loop);
return 0;
}
int main(int argc, char *argv[])
{
GOptionContext *context;
GError *err = NULL;
guint signal;
#ifdef NEED_THREADS
if (g_thread_supported() == FALSE)
g_thread_init(NULL);
#endif
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (g_option_context_parse(context, &argc, &argv, &err) == FALSE) {
if (err != NULL) {
g_printerr("%s\n", err->message);
g_error_free(err);
} else
g_printerr("An unknown error occurred\n");
exit(EXIT_FAILURE);
}
g_option_context_free(context);
if (option_detach == TRUE) {
if (daemon(0, 0)) {
perror("Can't start daemon");
exit(1);
}
}
__obex_log_init("obexd", option_debug, option_detach);
DBG("Entering main loop");
main_loop = g_main_loop_new(NULL, FALSE);
signal = setup_signalfd();
#ifdef NEED_THREADS
if (dbus_threads_init_default() == FALSE) {
fprintf(stderr, "Can't init usage of threads\n");
exit(EXIT_FAILURE);
}
#endif
if (manager_init() == FALSE) {
error("manager_init failed");
exit(EXIT_FAILURE);
}
if (option_root == NULL)
option_root = g_strdup(DEFAULT_ROOT_PATH);
if (option_root[0] != '/') {
char *old_root = option_root, *home = getenv("HOME");
if (home) {
option_root = g_strdup_printf("%s/%s", home, old_root);
g_free(old_root);
}
}
if (option_capability == NULL)
option_capability = g_strdup(DEFAULT_CAP_FILE);
plugin_init(option_plugin, option_noplugin);
if (obex_server_init() < 0) {
error("obex_server_init failed");
exit(EXIT_FAILURE);
}
if (!root_folder_setup(option_root, option_root_setup)) {
error("Unable to setup root folder %s", option_root);
exit(EXIT_FAILURE);
}
g_main_loop_run(main_loop);
g_source_remove(signal);
obex_server_exit();
plugin_cleanup();
manager_cleanup();
g_main_loop_unref(main_loop);
g_free(option_capability);
g_free(option_root);
__obex_log_cleanup();
return 0;
}
int main(int argc, char *argv[])
{
GOptionContext *context;
GError *err = NULL;
guint signal;
set_version();
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (g_option_context_parse(context, &argc, &argv, &err) == FALSE) {
if (err != NULL) {
g_printerr("%s\n", err->message);
g_error_free(err);
} else
g_printerr("An unknown error occurred\n");
exit(EXIT_FAILURE);
}
g_option_context_free(context);
if (option_version == TRUE) {
printf("%s\n", VERSION);
exit(EXIT_SUCCESS);
}
signal = setup_signalfd();
if (!signal)
return EXIT_FAILURE;
if (option_dbg || option_mgmt_dbg)
__btd_log_init("*", 0);
else
__btd_log_init(NULL, 0);
if (!set_capabilities()) {
__btd_log_cleanup();
g_source_remove(signal);
return EXIT_FAILURE;
}
quit_timeout = g_timeout_add_seconds(STARTUP_GRACE_SECONDS,
quit_eventloop, NULL);
if (quit_timeout == 0) {
error("Failed to init startup timeout");
__btd_log_cleanup();
g_source_remove(signal);
return EXIT_FAILURE;
}
if (!bt_bluetooth_start(option_index, option_mgmt_dbg, adapter_ready)) {
__btd_log_cleanup();
g_source_remove(quit_timeout);
g_source_remove(signal);
return EXIT_FAILURE;
}
/* Use params: mtu = 0, flags = 0 */
start_sdp_server(0, 0);
DBG("Entering main loop");
event_loop = g_main_loop_new(NULL, FALSE);
g_main_loop_run(event_loop);
g_source_remove(signal);
if (quit_timeout > 0)
g_source_remove(quit_timeout);
cleanup_services();
stop_sdp_server();
bt_bluetooth_cleanup();
g_main_loop_unref(event_loop);
/* If no adapter was initialized, hal_ipc is NULL */
if (hal_ipc) {
ipc_unregister(hal_ipc, HAL_SERVICE_ID_CORE);
ipc_cleanup(hal_ipc);
}
info("Exit");
__btd_log_cleanup();
free(config_vendor);
free(config_model);
free(config_name);
free(config_serial);
free(config_fw_rev);
free(config_hw_rev);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
GOptionContext *context;
GError *error = NULL;
DBusConnection *conn;
DBusError err;
guint signal;
#ifdef NEED_THREADS
if (g_thread_supported() == FALSE)
g_thread_init(NULL);
#endif
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (g_option_context_parse(context, &argc, &argv, &error) == FALSE) {
if (error != NULL) {
g_printerr("%s\n", error->message);
g_error_free(error);
} else
g_printerr("An unknown error occurred\n");
exit(1);
}
g_option_context_free(context);
if (option_version == TRUE) {
printf("%s\n", VERSION);
exit(0);
}
if (option_detach == TRUE) {
if (daemon(0, 0)) {
perror("Can't start daemon");
exit(1);
}
}
if (mkdir(STATEDIR, S_IRUSR | S_IWUSR | S_IXUSR |
S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) < 0) {
if (errno != EEXIST)
perror("Failed to create state directory");
}
if (mkdir(STORAGEDIR, S_IRUSR | S_IWUSR | S_IXUSR |
S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) < 0) {
if (errno != EEXIST)
perror("Failed to create storage directory");
}
umask(0077);
main_loop = g_main_loop_new(NULL, FALSE);
#ifdef NEED_THREADS
if (dbus_threads_init_default() == FALSE) {
fprintf(stderr, "Can't init usage of threads\n");
exit(1);
}
#endif
signal = setup_signalfd();
dbus_error_init(&err);
conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, CONNMAN_SERVICE, &err);
if (conn == NULL) {
if (dbus_error_is_set(&err) == TRUE) {
fprintf(stderr, "%s\n", err.message);
dbus_error_free(&err);
} else
fprintf(stderr, "Can't register with system bus\n");
exit(1);
}
g_dbus_set_disconnect_function(conn, disconnect_callback, NULL, NULL);
__connman_log_init(argv[0], option_debug, option_detach,
option_backtrace, "Connection Manager", VERSION);
__connman_dbus_init(conn);
if (option_config == NULL)
config_init(CONFIGMAINFILE);
else
config_init(option_config);
__connman_inotify_init();
__connman_technology_init();
__connman_notifier_init();
__connman_agent_init();
__connman_service_init();
__connman_provider_init();
__connman_network_init();
__connman_device_init(option_device, option_nodevice);
__connman_ippool_init();
__connman_iptables_init();
__connman_firewall_init();
__connman_nat_init();
__connman_tethering_init();
__connman_counter_init();
__connman_manager_init();
__connman_config_init();
__connman_stats_init();
__connman_clock_init();
__connman_resolver_init(option_dnsproxy);
__connman_ipconfig_init();
__connman_rtnl_init();
__connman_task_init();
__connman_proxy_init();
__connman_detect_init();
__connman_session_init();
__connman_timeserver_init();
__connman_connection_init();
__connman_plugin_init(option_plugin, option_noplugin);
__connman_rtnl_start();
__connman_dhcp_init();
__connman_dhcpv6_init();
__connman_wpad_init();
__connman_wispr_init();
__connman_rfkill_init();
g_free(option_config);
g_free(option_device);
g_free(option_plugin);
g_free(option_nodevice);
g_free(option_noplugin);
#ifdef SYSTEMD
/* Tell systemd that we have started up */
if( option_systemd )
sd_notify(0, "READY=1");
#endif
g_main_loop_run(main_loop);
g_source_remove(signal);
__connman_rfkill_cleanup();
__connman_wispr_cleanup();
__connman_wpad_cleanup();
__connman_dhcpv6_cleanup();
__connman_dhcp_cleanup();
__connman_session_cleanup();
__connman_plugin_cleanup();
__connman_provider_cleanup();
__connman_connection_cleanup();
__connman_timeserver_cleanup();
__connman_detect_cleanup();
__connman_proxy_cleanup();
__connman_task_cleanup();
__connman_rtnl_cleanup();
__connman_resolver_cleanup();
__connman_clock_cleanup();
__connman_stats_cleanup();
__connman_config_cleanup();
__connman_manager_cleanup();
__connman_counter_cleanup();
__connman_tethering_cleanup();
__connman_nat_cleanup();
__connman_firewall_cleanup();
__connman_iptables_cleanup();
__connman_ippool_cleanup();
__connman_device_cleanup();
__connman_network_cleanup();
__connman_service_cleanup();
__connman_agent_cleanup();
__connman_ipconfig_cleanup();
__connman_notifier_cleanup();
__connman_technology_cleanup();
__connman_inotify_cleanup();
__connman_dbus_cleanup();
__connman_log_cleanup(option_backtrace);
dbus_connection_unref(conn);
g_main_loop_unref(main_loop);
if (connman_settings.pref_timeservers != NULL)
g_strfreev(connman_settings.pref_timeservers);
g_free(connman_settings.auto_connect);
g_free(connman_settings.preferred_techs);
g_strfreev(connman_settings.fallback_nameservers);
g_strfreev(connman_settings.blacklisted_interfaces);
g_strfreev(connman_settings.tethering_technologies);
g_free(option_debug);
return 0;
}
int main(int argc, char **argv)
{
GOptionContext *context;
LSError lserror;
GError *err = NULL;
guint signal;
struct telephony_service *service;
g_message("Telephony Interface Layer Daemon %s", VERSION);
g_log_set_handler (NULL, G_LOG_LEVEL_DEBUG, debug_handler, NULL);
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (g_option_context_parse(context, &argc, &argv, &err) == FALSE) {
if (err != NULL) {
g_printerr("%s\n", err->message);
g_error_free(err);
exit(1);
}
g_printerr("An unknown error occurred\n");
exit(1);
}
g_option_context_free(context);
if (option_version == TRUE) {
printf("%s\n", VERSION);
exit(0);
}
if (option_detach == TRUE) {
if (daemon(0, 0)) {
perror("Can't start daemon");
return 1;
}
}
signal = setup_signalfd();
event_loop = g_main_loop_new(NULL, FALSE);
LSErrorInit(&lserror);
if (!LSRegisterPalmService("com.palm.telephony", &palm_serivce_handle, &lserror)) {
g_error("Failed to initialize the Luna Palm service: %s", lserror.message);
LSErrorFree(&lserror);
goto cleanup;
}
if (!LSGmainAttachPalmService(palm_serivce_handle, event_loop, &lserror)) {
g_error("Failed to attach to glib mainloop for palm service: %s", lserror.message);
LSErrorFree(&lserror);
goto cleanup;
}
private_service_handle = LSPalmServiceGetPrivateConnection(palm_serivce_handle);
service = telephony_service_create(palm_serivce_handle);
/* FIXME this should be done as part of a plugin mechanism */
ofono_init(service);
g_main_loop_run(event_loop);
cleanup:
/* FIXME this should be done as part of a plugin mechanism */
ofono_exit(service);
telephony_service_free(service);
if (palm_serivce_handle != NULL && LSUnregisterPalmService(palm_serivce_handle, &lserror) < 0) {
g_error("Could not unregister palm service: %s", lserror.message);
LSErrorFree(&lserror);
}
g_source_remove(signal);
g_main_loop_unref(event_loop);
return 0;
}