static int connect_eloop(struct kmscon_vt *vt, struct ev_eloop *eloop)
{
int ret;
if (!vt || !eloop || vt->fd < 0)
return -EINVAL;
ret = ev_eloop_register_signal_cb(eloop, SIGUSR1, vt_leave, vt);
if (ret)
return ret;
ret = ev_eloop_register_signal_cb(eloop, SIGUSR2, vt_enter, vt);
if (ret)
goto err_sig1;
ret = ev_eloop_new_fd(eloop, &vt->efd, vt->fd, EV_READABLE,
vt_input, vt);
if (ret)
goto err_sig2;
vt->eloop = eloop;
ev_eloop_ref(vt->eloop);
return 0;
err_sig2:
ev_eloop_unregister_signal_cb(vt->eloop, SIGUSR2, vt_enter, vt);
err_sig1:
ev_eloop_unregister_signal_cb(vt->eloop, SIGUSR1, vt_leave, vt);
return ret;
}
void uterm_vt_deallocate(struct uterm_vt *vt)
{
unsigned int mode;
if (!vt || !vt->vtm || vt->mode == UTERM_VT_DEAD)
return;
mode = vt->mode;
vt->mode = UTERM_VT_DEAD;
if (mode == UTERM_VT_REAL) {
real_close(vt);
} else if (mode == UTERM_VT_FAKE) {
ev_eloop_unregister_idle_cb(vt->vtm->eloop, vt_idle_event,
vt);
vt_call(vt, UTERM_VT_DEACTIVATE);
}
ev_eloop_unregister_signal_cb(vt->vtm->eloop, SIGUSR2, vt_sigusr2, vt);
ev_eloop_unregister_signal_cb(vt->vtm->eloop, SIGUSR1, vt_sigusr1, vt);
kmscon_dlist_unlink(&vt->list);
uterm_input_sleep(vt->input);
uterm_input_unref(vt->input);
vt->vtm = NULL;
uterm_vt_unref(vt);
}
static void destroy_app(struct kmscon_app *app)
{
kmscon_ui_free(app->ui);
kmscon_input_unref(app->input);
uterm_video_unref(app->video);
kmscon_vt_unref(app->vt);
ev_eloop_unregister_signal_cb(app->eloop, SIGINT, sig_generic, app);
ev_eloop_unregister_signal_cb(app->eloop, SIGTERM, sig_generic, app);
ev_eloop_rm_eloop(app->vt_eloop);
ev_eloop_unref(app->eloop);
}
static void disconnect_eloop(struct kmscon_vt *vt)
{
if (!vt)
return;
ev_eloop_rm_fd(vt->efd);
ev_eloop_unregister_signal_cb(vt->eloop, SIGUSR2, vt_enter, vt);
ev_eloop_unregister_signal_cb(vt->eloop, SIGUSR1, vt_leave, vt);
ev_eloop_unref(vt->eloop);
vt->efd = NULL;
vt->eloop = NULL;
}
static void destroy_app(struct uvtd_app *app)
{
ev_eloop_rm_fd(app->ctx_fd);
uvt_ctx_unref(app->ctx);
uterm_monitor_unref(app->mon);
ev_eloop_unregister_signal_cb(app->eloop, SIGPIPE, app_sig_ignore,
app);
ev_eloop_unregister_signal_cb(app->eloop, SIGINT, app_sig_generic,
app);
ev_eloop_unregister_signal_cb(app->eloop, SIGTERM, app_sig_generic,
app);
ev_eloop_unref(app->eloop);
}
int kmscon_pty_open(struct kmscon_pty *pty, unsigned short width,
unsigned short height)
{
int ret;
int master;
if (!pty)
return -EINVAL;
if (pty_is_open(pty))
return -EALREADY;
master = posix_openpt(O_RDWR | O_NOCTTY | O_CLOEXEC | O_NONBLOCK);
if (master < 0) {
log_err("cannot open master: %m");
return -errno;
}
ret = ev_eloop_new_fd(pty->eloop, &pty->efd, master,
EV_READABLE, pty_input, pty);
if (ret)
goto err_master;
ret = ev_eloop_register_signal_cb(pty->eloop, SIGCHLD, sig_child, pty);
if (ret)
goto err_fd;
ret = pty_spawn(pty, master, width, height);
if (ret)
goto err_sig;
return 0;
err_sig:
ev_eloop_unregister_signal_cb(pty->eloop, SIGCHLD, sig_child, pty);
err_fd:
ev_eloop_rm_fd(pty->efd);
pty->efd = NULL;
err_master:
close(master);
return ret;
}
int main(int argc, char **argv)
{
int ret;
struct uterm_monitor *mon;
size_t onum;
onum = sizeof(options) / sizeof(*options);
ret = test_prepare(options, onum, argc, argv, &eloop);
if (ret)
goto err_fail;
if (!setlocale(LC_ALL, "")) {
log_err("Cannot set locale: %m");
ret = -EFAULT;
goto err_exit;
}
ret = uterm_monitor_new(&mon, eloop, monitor_event, NULL);
if (ret)
goto err_exit;
ret = ev_eloop_register_signal_cb(eloop, SIGQUIT, sig_quit, NULL);
if (ret)
goto err_mon;
system("stty -echo");
uterm_monitor_scan(mon);
ev_eloop_run(eloop, -1);
system("stty echo");
ev_eloop_unregister_signal_cb(eloop, SIGQUIT, sig_quit, NULL);
err_mon:
uterm_monitor_unref(mon);
err_exit:
test_exit(options, onum, eloop);
err_fail:
if (ret != -ECANCELED)
test_fail(ret);
return abs(ret);
}
static void pty_close(struct kmscon_pty *pty, bool user)
{
bool called = true;
if (!pty || !pty_is_open(pty))
return;
if (pty->efd) {
called = false;
ev_eloop_rm_fd(pty->efd);
pty->efd = NULL;
}
if (!user) {
if (!called)
pty->input_cb(pty, NULL, 0, pty->data);
return;
}
ev_eloop_unregister_signal_cb(pty->eloop, SIGCHLD, sig_child, pty);
close(pty->fd);
pty->fd = -1;
}
int uterm_vt_allocate(struct uterm_vt_master *vtm,
struct uterm_vt **out,
const char *seat,
struct uterm_input *input,
uterm_vt_cb cb,
void *data)
{
struct uterm_vt *vt;
int ret;
if (!vtm || !out)
return -EINVAL;
if (!seat)
seat = "seat0";
vt = malloc(sizeof(*vt));
if (!vt)
return -ENOMEM;
memset(vt, 0, sizeof(*vt));
vt->ref = 1;
vt->vtm = vtm;
vt->cb = cb;
vt->data = data;
vt->real_fd = -1;
vt->real_num = -1;
vt->real_saved_num = -1;
ret = ev_eloop_register_signal_cb(vtm->eloop, SIGUSR1, vt_sigusr1, vt);
if (ret)
goto err_free;
ret = ev_eloop_register_signal_cb(vtm->eloop, SIGUSR2, vt_sigusr2, vt);
if (ret)
goto err_sig1;
if (!strcmp(seat, "seat0") && vtm->vt_support) {
vt->mode = UTERM_VT_REAL;
ret = real_open(vt);
if (ret)
goto err_sig2;
} else {
vt->mode = UTERM_VT_FAKE;
vt->input = input;
ret = uterm_input_register_cb(vt->input, vt_input, vt);
if (ret)
goto err_sig2;
ret = ev_eloop_register_idle_cb(vtm->eloop, vt_idle_event, vt);
if (ret)
goto err_input;
uterm_input_ref(vt->input);
uterm_input_wake_up(vt->input);
}
kmscon_dlist_link(&vtm->vts, &vt->list);
*out = vt;
return 0;
err_input:
uterm_input_unregister_cb(vt->input, vt_input, vt);
err_sig2:
ev_eloop_unregister_signal_cb(vtm->eloop, SIGUSR2, vt_sigusr2, vt);
err_sig1:
ev_eloop_unregister_signal_cb(vtm->eloop, SIGUSR1, vt_sigusr1, vt);
err_free:
free(vt);
return ret;
}
