static void server_callback(int fd, uint32_t events, void *user_data)
{
union {
struct sockaddr common;
struct sockaddr_un sun;
struct sockaddr_in sin;
} addr;
socklen_t len;
int host_fd, dev_fd;
if (events & (EPOLLERR | EPOLLHUP)) {
mainloop_quit();
return;
}
memset(&addr, 0, sizeof(addr));
len = sizeof(addr);
if (getsockname(fd, &addr.common, &len) < 0) {
perror("Failed to get socket name");
return;
}
host_fd = accept(fd, &addr.common, &len);
if (host_fd < 0) {
perror("Failed to accept client socket");
return;
}
if (client_active) {
fprintf(stderr, "Active client already present\n");
close(host_fd);
return;
}
dev_fd = open_channel(hci_index);
if (dev_fd < 0) {
close(host_fd);
return;
}
printf("New client connected\n");
if (!setup_proxy(host_fd, true, dev_fd, false)) {
close(dev_fd);
close(host_fd);
return;
}
client_active = true;
}
static BIO *
make_ssl_bio(SSL_CTX *ctx)
{
BIO *con = NULL;
BIO *ssl = NULL;
if (!(con = BIO_new(BIO_s_connect())))
die("BIO_s_connect failed");
if (!(ssl = BIO_new_ssl(ctx, 1)))
die("BIO_new_ssl failed");
setup_proxy(ssl);
BIO_push(ssl, con);
return ssl;
}
static duk_ret_t test_delete2(duk_context *ctx, void *udata) {
duk_ret_t rc;
(void) udata;
setup_proxy(ctx);
printf("top: %ld\n", (long) duk_get_top(ctx));
rc = duk_del_prop_string(ctx, -1, "_deleteTest");
printf("delete result: rc=%d\n", (int) rc);
duk_pop(ctx);
printf("final top: %ld\n", (long) duk_get_top(ctx));
return 0;
}
static duk_ret_t test_set2(duk_context *ctx, void *udata) {
duk_ret_t rc;
(void) udata;
setup_proxy(ctx);
printf("top: %ld\n", (long) duk_get_top(ctx));
duk_push_string(ctx, "testValue");
rc = duk_put_prop_string(ctx, -2, "_setTest");
printf("set result: rc=%d\n", (int) rc);
duk_pop(ctx);
printf("final top: %ld\n", (long) duk_get_top(ctx));
return 0;
}
static duk_ret_t test_get2(duk_context *ctx, void *udata) {
duk_ret_t rc;
(void) udata;
setup_proxy(ctx);
printf("top: %ld\n", (long) duk_get_top(ctx));
rc = duk_get_prop_string(ctx, -1, "_getTest");
printf("get result: rc=%d, value=%s\n", (int) rc, duk_to_string(ctx, -1));
duk_pop(ctx);
duk_pop(ctx);
printf("final top: %ld\n", (long) duk_get_top(ctx));
return 0;
}
int main(int argc, char *argv[])
{
const char *connect_address = NULL;
const char *server_address = NULL;
const char *unix_path = NULL;
unsigned short tcp_port = 0xb1ee; /* 45550 */
const char *str;
sigset_t mask;
for (;;) {
int opt;
opt = getopt_long(argc, argv, "c:l::u::p:i:dvh",
main_options, NULL);
if (opt < 0)
break;
switch (opt) {
case 'c':
connect_address = optarg;
break;
case 'l':
if (optarg)
server_address = optarg;
else
server_address = "0.0.0.0";
break;
case 'u':
if (optarg)
unix_path = optarg;
else
unix_path = "/tmp/bt-server-bredr";
break;
case 'p':
tcp_port = atoi(optarg);
break;
case 'i':
if (strlen(optarg) > 3 && !strncmp(optarg, "hci", 3))
str = optarg + 3;
else
str = optarg;
if (!isdigit(*str)) {
usage();
return EXIT_FAILURE;
}
hci_index = atoi(str);
break;
case 'd':
debug_enabled = true;
break;
case 'v':
printf("%s\n", VERSION);
return EXIT_SUCCESS;
case 'h':
usage();
return EXIT_SUCCESS;
default:
return EXIT_FAILURE;
}
}
if (argc - optind > 0) {
fprintf(stderr, "Invalid command line parameters\n");
return EXIT_FAILURE;
}
if (unix_path && server_address) {
fprintf(stderr, "Invalid to specify TCP and Unix servers\n");
return EXIT_FAILURE;
}
if (connect_address && (unix_path || server_address)) {
fprintf(stderr, "Invalid to specify client and server mode\n");
return EXIT_FAILURE;
}
mainloop_init();
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);
mainloop_set_signal(&mask, signal_callback, NULL, NULL);
if (connect_address) {
int host_fd, dev_fd;
printf("Connecting to %s:%u\n", connect_address, tcp_port);
dev_fd = connect_tcp(connect_address, tcp_port);
if (dev_fd < 0)
return EXIT_FAILURE;
printf("Opening virtual device\n");
host_fd = open_vhci(0x00);
if (host_fd < 0) {
close(dev_fd);
return EXIT_FAILURE;
}
if (!setup_proxy(host_fd, false, dev_fd, true)) {
close(dev_fd);
close(host_fd);
return EXIT_FAILURE;
}
} else {
int server_fd;
if (unix_path) {
printf("Listening on %s\n", unix_path);
server_fd = open_unix(unix_path);
} else if (server_address) {
printf("Listening on %s:%u\n", server_address,
tcp_port);
server_fd = open_tcp(server_address, tcp_port);
} else {
fprintf(stderr, "Missing emulator device\n");
return EXIT_FAILURE;
}
if (server_fd < 0)
return EXIT_FAILURE;
mainloop_add_fd(server_fd, EPOLLIN, server_callback,
NULL, NULL);
}
return mainloop_run();
}
int
main (int argc, char *argv[])
{
char ** args;
int ret;
DBusServer * server;
struct stat sb;
nih_main_init (argv[0]);
nih_option_set_synopsis (_("Control group proxy"));
nih_option_set_help (_("The cgroup manager proxy"));
args = nih_option_parser (NULL, argc, argv, options, FALSE);
if (! args)
exit (1);
if (geteuid() != 0) {
nih_error("%s: Cgmanager proxy must be run as root", __func__);
exit(1);
}
/*
* If we are called with checkmaster, then only check whether
* cgmanager is running. This is used by the init script to
* determine whether to run cgmanager or cgproxy
*/
if (checkmaster) {
if (master_running())
exit(0);
exit(1);
}
if (setup_proxy() < 0) {
nih_fatal ("Failed to set up as proxy");
exit(1);
}
/* Setup the DBus server */
server = nih_dbus_server ( CGMANAGER_DBUS_PATH, client_connect,
client_disconnect);
nih_assert (server != NULL);
if (stat("/proc/self/ns/pid", &sb) == 0) {
mypidns = read_pid_ns_link(getpid());
setns_pid_supported = true;
}
if (stat("/proc/self/ns/user", &sb) == 0) {
myuserns = read_user_ns_link(getpid());
setns_user_supported = true;
}
/* Become daemon */
if (daemonise) {
if (nih_main_daemonise () < 0) {
NihError *err;
err = nih_error_get ();
nih_fatal ("%s: %s", _("Unable to become daemon"),
err->message);
nih_free (err);
exit (1);
}
}
/*
* We have to send a message to force fd passing over the dbus
* link to be negotiated. Else when we try to attach an fd we'll
* fail.
*/
if (!send_dummy_msg(server_conn)) {
nih_fatal("Failed to send opening ping to cgmanager");
exit(1);
}
if (sigstop)
raise(SIGSTOP);
ret = nih_main_loop ();
return ret;
}
