void _fcitx_wizard_im_dialog_connect(FcitxWizardImDialog* self)
{
int i;
GError* error = NULL;
if (self->owner->im_dialog_array == NULL) {
self->improxy = fcitx_input_method_new(G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE,
fcitx_utils_get_display_number(),
NULL,
&error
);
if (self->improxy == NULL) {
g_error_free(error);
return;
}
self->owner->im_dialog_array = fcitx_input_method_get_imlist(self->improxy);
if (self->owner->im_dialog_array_del != NULL) {
for (i = 0; i < self->owner->im_dialog_array_del->len; i += 1) {
g_ptr_array_add(self->owner->im_dialog_array,
g_ptr_array_index(self->owner->im_dialog_array_del, i));
}
}
}
_fcitx_wizard_im_dialog_load(self);
}
FcitxIMPage::Private::Private(QObject* parent)
: QObject(parent),
availIMModel(0),
m_connection(QDBusConnection::sessionBus())
{
m_inputmethod = new org::fcitx::Fcitx::InputMethod(
QString("%1-%2").arg(FCITX_DBUS_SERVICE).arg(fcitx_utils_get_display_number()),
FCITX_IM_DBUS_PATH,
m_connection,
this
);
}
char*
_fcitx_get_socket_path()
{
char* addressFile = NULL;
char* machineId = dbus_get_local_machine_id();
asprintf(&addressFile, "%s-%d", machineId, fcitx_utils_get_display_number());
dbus_free(machineId);
char* file = NULL;
FcitxXDGGetFileUserWithPrefix("dbus", addressFile, NULL, &file);
return file;
}
static void
fcitx_client_init(FcitxClient *self)
{
self->priv = FCITX_CLIENT_GET_PRIVATE(self);
sprintf(self->priv->servicename, "%s-%d", FCITX_DBUS_SERVICE, fcitx_utils_get_display_number());
self->priv->connection = NULL;
self->priv->cancellable = NULL;
self->priv->improxy = NULL;
self->priv->icproxy = NULL;
self->priv->connection = fcitx_connection_new();
g_signal_connect (self->priv->connection, "connected", (GCallback) _fcitx_client_create_ic, self);
g_signal_connect (self->priv->connection, "disconnected", (GCallback) _fcitx_client_disconnect, self);
}
int fcitxIsNotRunning()
{
char* servicename = NULL;
asprintf(&servicename, "%s-%d", FCITX_DBUS_SERVICE,
fcitx_utils_get_display_number());
QDBusConnection conn = QDBusConnection::sessionBus();
if (!conn.isConnected())
return -1;
// ?? Always return false...
//QDBusReply<boolean> reply = conn.interface()->call("NameHasOwner", servicename);
QDBusReply<QString> reply = conn.interface()->call("GetNameOwner", servicename);
qDebug() << "reply.value():" << reply.value();
return reply.value() == "";
}
void _fcitx_im_dialog_connect(FcitxImDialog* self)
{
GError* error = NULL;
self->improxy = fcitx_input_method_new(G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE,
fcitx_utils_get_display_number(),
NULL,
&error
);
if (self->improxy == NULL) {
g_error_free(error);
return;
}
g_signal_connect(self->improxy, "imlist-changed", G_CALLBACK(_fcitx_im_dialog_imlist_changed_cb), self);
_fcitx_im_dialog_load(self);
}
static void
fcitx_client_init(FcitxClient *self)
{
self->priv = FCITX_CLIENT_GET_PRIVATE(self);
sprintf(self->priv->servicename, "%s-%d", FCITX_DBUS_SERVICE, fcitx_utils_get_display_number());
self->priv->watch_id = g_bus_watch_name(
G_BUS_TYPE_SESSION,
self->priv->servicename,
G_BUS_NAME_WATCHER_FLAGS_NONE,
_fcitx_client_appear,
_fcitx_client_vanish,
self,
NULL
);
self->priv->improxy = NULL;
self->priv->icproxy = NULL;
}
void fcitx_ui_widget_connect(FcitxUIWidget* self)
{
GError* error = NULL;
self->improxy = fcitx_input_method_new(G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
fcitx_utils_get_display_number(),
NULL,
&error
);
if (self->improxy == NULL) {
g_error_free(error);
return;
}
gchar* uiname = fcitx_input_method_get_current_ui(self->improxy);
if (uiname) {
_fcitx_ui_widget_load(self, uiname);
g_free(uiname);
}
}
void* RemoteCreate(FcitxInstance* instance)
{
FcitxRemote* remote = fcitx_utils_malloc0(sizeof(FcitxRemote));
remote->owner = instance;
char *socketfile;
asprintf(&socketfile, "/tmp/fcitx-socket-:%d", fcitx_utils_get_display_number());
remote->socket_fd = CreateSocket(socketfile);
if (remote->socket_fd < 0) {
FcitxLog(ERROR, _("Can't open socket %s: %s"), socketfile, strerror(errno));
free(remote);
free(socketfile);
return NULL;
}
fcntl(remote->socket_fd, F_SETFD, FD_CLOEXEC);
fcntl(remote->socket_fd, F_SETFL, O_NONBLOCK);
chmod(socketfile, 0600);
free(socketfile);
return remote;
}
int FcitxQtConnectionPrivate::displayNumber() {
if (m_displayNumber >= 0)
return m_displayNumber;
Display * dpy = QX11Info::display();
int displayNumber = 0;
if (dpy) {
char* display = XDisplayString(dpy);
if (display) {
char* strDisplayNumber = NULL;
display = strdup(display);
char* p = display;
for (; *p != ':' && *p != '\0'; p++);
if (*p == ':') {
*p = '\0';
p++;
strDisplayNumber = p;
}
for (; *p != '.' && *p != '\0'; p++);
if (*p == '.') {
*p = '\0';
}
if (strDisplayNumber) {
displayNumber = atoi(strDisplayNumber);
}
free(display);
}
}
else
displayNumber = fcitx_utils_get_display_number();
m_displayNumber = displayNumber;
return displayNumber;
}
int main (int argc, char* argv[])
{
char *servicename = NULL;
char *address = NULL;
DBusMessage* message = NULL;
DBusConnection* conn = NULL;
int c;
int ret = 1;
int messageType = FCITX_DBUS_GET_CURRENT_STATE;
char *imname = NULL;
while ((c = getopt(argc, argv, "chortTeam:")) != -1) {
switch (c) {
case 'o':
messageType = FCITX_DBUS_ACTIVATE;
break;
case 'c':
messageType = FCITX_DBUS_INACTIVATE;
break;
case 'r':
messageType = FCITX_DBUS_RELOAD_CONFIG;
break;
case 't':
case 'T':
messageType = FCITX_DBUS_TOGGLE;
break;
case 'e':
messageType = FCITX_DBUS_EXIT;
break;
case 'm':
messageType = FCITX_DBUS_GET_IM_ADDON;
imname = strdup(optarg);
break;
case 'a':
address = _fcitx_get_address();
if (address) {
printf("%s\n", address);
return 0;
}
else
return 1;
break;
case 'h':
usage(stdout);
return 0;
default:
usage(stderr);
return 1;
break;
}
}
#define CASE(ENUMNAME, MESSAGENAME) \
case FCITX_DBUS_##ENUMNAME: \
message = dbus_message_new_method_call(servicename, FCITX_IM_DBUS_PATH, FCITX_IM_DBUS_INTERFACE, #MESSAGENAME); \
break;
asprintf(&servicename, "%s-%d", FCITX_DBUS_SERVICE, fcitx_utils_get_display_number());
switch(messageType) {
CASE(ACTIVATE, ActivateIM);
CASE(INACTIVATE, InactivateIM);
CASE(RELOAD_CONFIG, ReloadConfig);
CASE(EXIT, Exit);
CASE(TOGGLE, ToggleIM);
CASE(GET_CURRENT_STATE, GetCurrentState);
CASE(GET_IM_ADDON, GetIMAddon);
default:
goto some_error;
};
if (!message) {
goto some_error;
}
address = _fcitx_get_address();
do {
if (!address)
break;
conn = dbus_connection_open(address, NULL);
if (!conn)
break;
if (!dbus_bus_register(conn, NULL)) {
dbus_connection_unref(conn);
conn = NULL;
break;
}
} while(0);
if (!conn) {
conn = dbus_bus_get(DBUS_BUS_SESSION, NULL);
if (!conn) {
goto some_error;
}
dbus_connection_set_exit_on_disconnect(conn, FALSE);
}
if (messageType == FCITX_DBUS_GET_CURRENT_STATE) {
DBusMessage* reply = dbus_connection_send_with_reply_and_block(conn, message, 1000, NULL);
int result = 0;
if (reply && dbus_message_get_args(reply, NULL, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID)) {
printf("%d\n", result);
ret = 0;
} else {
fprintf(stderr, "Not get reply\n");
}
}
else if (messageType == FCITX_DBUS_GET_IM_ADDON) {
do {
if (!fcitx_utf8_check_string(imname))
break;
dbus_message_append_args(message, DBUS_TYPE_STRING, &imname, DBUS_TYPE_INVALID);
DBusMessage* reply = dbus_connection_send_with_reply_and_block(conn, message, 1000, NULL);
char *result = NULL;
if (reply && dbus_message_get_args(reply, NULL, DBUS_TYPE_STRING, &result, DBUS_TYPE_INVALID)) {
printf("%s\n", result);
ret = 0;
} else {
fprintf(stderr, "Not get reply\n");
}
} while(0);
} else {
dbus_connection_send(conn, message, NULL);
dbus_connection_flush(conn);
ret = 0;
}
some_error:
if (message)
dbus_message_unref(message);
if (conn)
dbus_connection_unref(conn);
fcitx_utils_free(address);
fcitx_utils_free(servicename);
fcitx_utils_free(imname);
return ret;
}
void* DBusCreate(FcitxInstance* instance)
{
FcitxDBus *dbusmodule = (FcitxDBus*) fcitx_utils_malloc0(sizeof(FcitxDBus));
FcitxAddon* dbusaddon = FcitxAddonsGetAddonByName(FcitxInstanceGetAddons(instance), FCITX_DBUS_NAME);
dbusmodule->owner = instance;
DBusError err;
if (FcitxInstanceIsTryReplace(instance)) {
fcitx_utils_launch_tool("fcitx-remote", "-e");
sleep(1);
}
dbus_threads_init_default();
// first init dbus
dbus_error_init(&err);
int retry = 0;
DBusConnection* conn = NULL;
char* servicename = NULL;
asprintf(&servicename, "%s-%d", FCITX_DBUS_SERVICE,
fcitx_utils_get_display_number());
/* do session dbus initialize */
do {
if (!getenv("DISPLAY") && !getenv("DBUS_SESSION_BUS_ADDRESS")) {
FcitxLog(WARNING, "Without DISPLAY or DBUS_SESSION_BUS_ADDRESS session bus will not work");
break;
}
/* try to get session dbus */
while (1) {
conn = dbus_bus_get(DBUS_BUS_SESSION, &err);
if (dbus_error_is_set(&err)) {
FcitxLog(WARNING, "Connection Error (%s)", err.message);
dbus_error_free(&err);
dbus_error_init(&err);
}
if (NULL == conn && retry < MAX_RETRY_TIMES) {
retry ++;
sleep(RETRY_INTERVAL * retry);
} else {
break;
}
}
if (NULL == conn) {
break;
}
if (!dbus_connection_add_filter(conn, DBusModuleFilter, dbusmodule, NULL))
break;
if (!dbus_connection_set_watch_functions(conn, DBusAddWatch, DBusRemoveWatch,
NULL, &dbusmodule->watches, NULL)) {
FcitxLog(WARNING, "Add Watch Function Error");
dbus_error_free(&err);
dbus_error_init(&err);
dbus_connection_unref(conn);
conn = NULL;
break;
}
/* from here we know dbus connection is successful, now we need to register the service */
dbus_connection_set_exit_on_disconnect(conn, FALSE);
dbusmodule->conn = conn;
boolean request_retry = false;
int replaceCountdown = FcitxInstanceIsTryReplace(instance) ? 3 : 0;
FcitxInstanceResetTryReplace(instance);
do {
request_retry = false;
// request a name on the bus
int ret = dbus_bus_request_name(conn, servicename,
DBUS_NAME_FLAG_DO_NOT_QUEUE,
&err);
if (dbus_error_is_set(&err)) {
FcitxLog(WARNING, "Name Error (%s)", err.message);
goto dbus_init_failed;
}
if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
FcitxLog(WARNING, "DBus Service Already Exists");
if (replaceCountdown > 0) {
replaceCountdown --;
fcitx_utils_launch_tool("fcitx-remote", "-e");
/* sleep for a while and retry */
sleep(1);
request_retry = true;
continue;
}
/* if we know fcitx exists, we should exit. */
dbus_error_free(&err);
free(servicename);
free(dbusmodule);
FcitxInstanceEnd(instance);
return NULL;
}
} while (request_retry);
dbus_connection_flush(dbusmodule->conn);
} while(0);
DBusConnection* privconn = NULL;
do {
int noPrivateDBus = fcitx_utils_get_boolean_env("FCITX_NO_PRIVATE_DBUS", false);
if (noPrivateDBus)
break;
char* file;
FILE* dbusfp = FcitxXDGGetFileWithPrefix("dbus", "daemon.conf", "r", &file);
if (dbusfp) {
fclose(dbusfp);
}
else {
free(file);
file = NULL;
}
dbusmodule->daemon = DBusLaunch(file);
fcitx_utils_free(file);
if (dbusmodule->daemon.pid == 0)
break;
privconn = dbus_connection_open(dbusmodule->daemon.address, &err);
if (dbus_error_is_set(&err)) {
FcitxLog(ERROR, "Private dbus daemon connection error (%s)",
err.message);
break;
}
dbus_bus_register(privconn, &err);
if (dbus_error_is_set(&err)) {
FcitxLog(ERROR, "Private dbus bus register error (%s)", err.message);
break;
}
int ret = dbus_bus_request_name(privconn, servicename,
DBUS_NAME_FLAG_DO_NOT_QUEUE,
&err);
if (dbus_error_is_set(&err)) {
FcitxLog(WARNING, "Private Name Error (%s)", err.message);
break;
}
if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
FcitxLog(ERROR, "Private DBus Service Already Exists, fcitx being hacked?");
break;
}
if (!dbus_connection_add_filter(privconn, DBusModuleFilter, dbusmodule, NULL))
break;
if (!dbus_connection_set_watch_functions(privconn, DBusAddWatch, DBusRemoveWatch,
NULL, &dbusmodule->watches, NULL)) {
FcitxLog(WARNING, "Add Watch Function Error");
break;
}
char* addressFile = NULL;
char* localMachineId = dbus_get_local_machine_id();
asprintf(&addressFile, "%s-%d", localMachineId,
fcitx_utils_get_display_number());
dbus_free(localMachineId);
FILE* fp = FcitxXDGGetFileUserWithPrefix("dbus", addressFile, "w", NULL);
free(addressFile);
if (!fp)
break;
fprintf(fp, "%s", dbusmodule->daemon.address);
fwrite("\0", sizeof(char), 1, fp);
pid_t curPid = getpid();
fwrite(&dbusmodule->daemon.pid, sizeof(pid_t), 1, fp);
fwrite(&curPid, sizeof(pid_t), 1, fp);
fclose(fp);
dbusmodule->privconn = privconn;
char* command = fcitx_utils_get_fcitx_path_with_filename("bindir", "/fcitx-dbus-watcher");
char* pidstring = NULL;
asprintf(&pidstring, "%d", dbusmodule->daemon.pid);
char* args[] = {
command,
dbusmodule->daemon.address,
pidstring,
NULL
};
fcitx_utils_start_process(args);
free(command);
free(pidstring);
} while(0);
if (!dbusmodule->privconn) {
if (privconn) {
dbus_connection_unref(privconn);
DBusKill(&dbusmodule->daemon);
}
}
FcitxModuleAddFunction(dbusaddon, DBusGetConnection);
FcitxModuleAddFunction(dbusaddon, DBusGetPrivateConnection);
dbus_error_free(&err);
dbusmodule->serviceName = servicename;
return dbusmodule;
dbus_init_failed:
dbus_error_free(&err);
fcitx_utils_free(servicename);
if (conn)
dbus_connection_unref(conn);
DBusKill(&dbusmodule->daemon);
fcitx_utils_free(dbusmodule);
return NULL;
}
int main(int argc, char *argv[])
{
char *socketfile = NULL;
int socket_fd;
int o = 0;
char c;
char* imname = 0;
while ((c = getopt(argc, argv, "chortTs:w:")) != -1) {
switch (c) {
case 'o':
o = 1;
o |= (1 << 16);
break;
case 'c':
o = 1;
break;
case 'r':
o = 2;
break;
case 't':
case 'T':
o = 3;
break;
case 's':
o = 4;
imname = optarg;
break;
case 'w':
o = 5;
imname = optarg;
break;
case 'h':
usage(stderr);
return 0;
default:
usage(stderr);
return 1;
break;
}
}
asprintf(&socketfile, "/tmp/fcitx-socket-:%d", fcitx_utils_get_display_number());
socket_fd = create_socket(socketfile);
if (socket_fd < 0) {
fprintf(stderr, "Can't open socket %s: %s\n", socketfile, strerror(errno));
free(socketfile);
return 1;
}
free(socketfile);
write(socket_fd, &o, sizeof(o));
if (o == 0) {
int buf;
read(socket_fd, &buf, sizeof(buf));
printf("%d\n", buf);
} else if (o == 4 || o == 5) {
write(socket_fd, imname, strlen(imname));
}
close(socket_fd);
return 0;
} /* ---------- end of function main ---------- */
int main (int argc, char* argv[])
{
if (argc != 3)
return 1;
pid_t pid = atoi(argv[2]);
if (pid <= 0)
return 1;
fcitx_utils_init_as_daemon();
asprintf(&servicename, "%s-%d", FCITX_DBUS_SERVICE, fcitx_utils_get_display_number());
DBusError err;
dbus_error_init(&err);
DBusConnection* conn = dbus_connection_open(argv[1], NULL);
if (!conn)
goto some_error;
FcitxDBusWatch* watches = NULL;
if (!dbus_connection_set_watch_functions(conn, DBusAddWatch, DBusRemoveWatch, NULL, &watches, NULL)) {
goto some_error;
}
dbus_connection_set_exit_on_disconnect(conn, TRUE);
if (!dbus_bus_register(conn, NULL))
goto some_error;
dbus_bus_add_match(conn,
"type='signal',"
"interface='" DBUS_INTERFACE_DBUS "',"
"path='" DBUS_PATH_DBUS "',"
"member='NameOwnerChanged'",
&err);
if (dbus_error_is_set(&err))
goto some_error;
if (!dbus_connection_add_filter(conn, WatcherDBusFilter, NULL, NULL))
goto some_error;
#ifndef NZERO
#define NZERO 20
#endif
nice(NZERO - 1);
fd_set rfds, wfds, efds;
FD_ZERO(&rfds);
FD_ZERO(&wfds);
FD_ZERO(&efds);
do {
DBusProcessEventForWatches(watches, &rfds, &wfds, &efds);
DBusProcessEventForConnection(conn);
if (status != WATCHER_WAITING)
break;
FD_ZERO(&rfds);
FD_ZERO(&wfds);
FD_ZERO(&efds);
int maxfd = DBusUpdateFDSet(watches, &rfds, &wfds, &efds);
if (maxfd == 0)
break;
select(maxfd + 1, &rfds, &wfds, &efds, NULL);
} while(1);
if (status == FCITX_DIE) {
kill(pid, SIGTERM);
}
some_error:
if (conn)
dbus_connection_unref(conn);
dbus_error_free(&err);
fcitx_utils_free(servicename);
return 1;
}
