r4085: Updated French manual translation (Arnaud Calvo).
[rox-filer.git] / ROX-Filer / src / remote.c
blob0afd8a9f8a7d6161a6e8920095bbec21b6a47f3f
1 /*
2 * $Id$
4 * ROX-Filer, filer for the ROX desktop project
5 * Copyright (C) 2005, the ROX-Filer team.
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the Free
9 * Software Foundation; either version 2 of the License, or (at your option)
10 * any later version.
12 * This program is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * more details.
17 * You should have received a copy of the GNU General Public License along with
18 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
19 * Place, Suite 330, Boston, MA 02111-1307 USA
22 /* This code is used to communicate between two copies of the filer:
23 * If the filer is run and the same version of the filer is already
24 * running on the same machine then the new copy simply asks the old
25 * one deal with it and quits.
28 #include "config.h"
30 #include <string.h>
32 #include <gdk/gdkx.h>
33 #include <X11/X.h>
34 #include <X11/Xatom.h>
35 #include <gtk/gtk.h>
36 #include <gtk/gtkinvisible.h>
37 #include <libxml/parser.h>
39 #include "global.h"
41 #include "main.h"
42 #include "support.h"
43 #include "gui_support.h"
44 #include "run.h"
45 #include "remote.h"
46 #include "filer.h"
47 #include "pinboard.h"
48 #include "panel.h"
49 #include "action.h"
50 #include "type.h"
51 #include "display.h"
52 #include "xml.h"
53 #include "diritem.h"
55 static GdkAtom filer_atom; /* _ROX_FILER_EUID_VERSION_HOST */
56 static GdkAtom filer_atom_any; /* _ROX_FILER_EUID_HOST */
57 static GdkAtom xsoap; /* _XSOAP */
59 typedef struct _SOAP_call SOAP_call;
60 typedef xmlNodePtr (*SOAP_func)(GList *args);
62 struct _SOAP_call {
63 SOAP_func func;
64 gchar **required_args;
65 gchar **optional_args;
68 static GHashTable *rpc_calls = NULL; /* MethodName -> Function */
70 /* Static prototypes */
71 static GdkWindow *get_existing_ipc_window(void);
72 static gboolean get_ipc_property(GdkWindow *window, Window *r_xid);
73 static void soap_send(GtkWidget *from, GdkAtom prop, GdkWindow *dest);
74 static gboolean client_event(GtkWidget *window,
75 GdkEventClient *event,
76 gpointer data);
77 static void soap_done(GtkWidget *widget,
78 GdkEventProperty *event,
79 gpointer data);
80 static void soap_register(char *name, SOAP_func func, char *req, char *opt);
81 static xmlNodePtr soap_invoke(xmlNode *method);
83 static xmlNodePtr rpc_Version(GList *args);
84 static xmlNodePtr rpc_OpenDir(GList *args);
85 static xmlNodePtr rpc_CloseDir(GList *args);
86 static xmlNodePtr rpc_Examine(GList *args);
87 static xmlNodePtr rpc_Show(GList *args);
88 static xmlNodePtr rpc_Pinboard(GList *args);
89 static xmlNodePtr rpc_Panel(GList *args);
90 static xmlNodePtr rpc_Run(GList *args);
91 static xmlNodePtr rpc_Copy(GList *args);
92 static xmlNodePtr rpc_Move(GList *args);
93 static xmlNodePtr rpc_Link(GList *args);
94 static xmlNodePtr rpc_FileType(GList *args);
95 static xmlNodePtr rpc_Mount(GList *args);
96 static xmlNodePtr rpc_Unmount(GList *args);
98 static xmlNodePtr rpc_PanelAdd(GList *args);
99 static xmlNodePtr rpc_PanelRemove(GList *args);
100 static xmlNodePtr rpc_PinboardAdd(GList *args);
101 static xmlNodePtr rpc_PinboardRemove(GList *args);
102 static xmlNodePtr rpc_SetBackdrop(GList *args);
103 static xmlNodePtr rpc_SetBackdropApp(GList *args);
105 /****************************************************************
106 * EXTERNAL INTERFACE *
107 ****************************************************************/
110 /* Try to get an already-running filer to handle things (only if
111 * new_copy is FALSE); TRUE if we succeed.
112 * Create an IPC widget so that future filers can contact us.
114 gboolean remote_init(xmlDocPtr rpc, gboolean new_copy)
116 guchar *unique_id;
117 GdkWindow *existing_ipc_window;
118 GtkWidget *ipc_window;
119 Window xwindow;
121 /* xmlDocDump(stdout, rpc); */
123 rpc_calls = g_hash_table_new(g_str_hash, g_str_equal);
125 soap_register("Version", rpc_Version, NULL, NULL);
127 soap_register("Run", rpc_Run, "Filename", NULL);
128 soap_register("OpenDir", rpc_OpenDir, "Filename",
129 "Style,Details,Sort,Class,ID,Hidden,Filter");
130 soap_register("CloseDir", rpc_CloseDir, "Filename", NULL);
131 soap_register("Examine", rpc_Examine, "Filename", NULL);
132 soap_register("Show", rpc_Show, "Directory,Leafname", NULL);
134 soap_register("Pinboard", rpc_Pinboard, NULL, "Name");
135 soap_register("Panel", rpc_Panel, NULL, "Side,Name");
137 soap_register("FileType", rpc_FileType, "Filename", NULL);
139 soap_register("Copy", rpc_Copy, "From,To", "Leafname,Quiet");
140 soap_register("Move", rpc_Move, "From,To", "Leafname,Quiet");
141 soap_register("Link", rpc_Link, "From,To", "Leafname");
142 soap_register("Mount", rpc_Mount, "MountPoints", "OpenDir,Quiet");
143 soap_register("Unmount", rpc_Unmount, "MountPoints", "Quiet");
145 soap_register("SetBackdrop", rpc_SetBackdrop, "Filename,Style", NULL);
146 soap_register("SetBackdropApp", rpc_SetBackdropApp, "App", NULL);
147 soap_register("PinboardAdd", rpc_PinboardAdd, "Path,X,Y", "Label,Shortcut,Args");
148 soap_register("PinboardRemove", rpc_PinboardRemove, "Path", "Label");
149 soap_register("PanelAdd", rpc_PanelAdd, "Side,Path", "Label,After,Shortcut,Args");
150 soap_register("PanelRemove", rpc_PanelRemove, "Side,Path", "Label");
152 /* Look for a property on the root window giving the IPC window
153 * of an already-running copy of this version of the filer, running
154 * on the same machine and with the same euid.
156 unique_id = g_strdup_printf("_ROX_FILER_%d_%s_%s",
157 (int) euid, VERSION, our_host_name());
158 filer_atom = gdk_atom_intern(unique_id, FALSE);
159 g_free(unique_id);
161 xsoap = gdk_atom_intern("_XSOAP", FALSE);
163 /* If we find a running copy, we'll need a window to put the
164 * SOAP message in before sending.
165 * If there's no running copy, we'll need a window to receive
166 * future SOAP message events.
167 * Either way, we'll need a window for it...
169 ipc_window = gtk_invisible_new();
170 gtk_widget_realize(ipc_window);
172 XGrabServer(GDK_DISPLAY());
174 existing_ipc_window = new_copy ? NULL : get_existing_ipc_window();
175 if (existing_ipc_window)
177 xmlChar *mem;
178 int size;
180 XUngrabServer(GDK_DISPLAY());
182 xmlDocDumpMemory(rpc, &mem, &size);
183 g_return_val_if_fail(size > 0, FALSE);
185 /* Since Gtk might have selected this already, we'd
186 * better do it BEFORE changing the property.
188 gtk_widget_add_events(ipc_window, GDK_PROPERTY_CHANGE_MASK);
189 g_signal_connect(ipc_window, "property-notify-event",
190 G_CALLBACK(soap_done), GINT_TO_POINTER(xsoap));
192 gdk_property_change(ipc_window->window, xsoap,
193 gdk_x11_xatom_to_atom(XA_STRING), 8,
194 GDK_PROP_MODE_REPLACE, mem, size);
195 g_free(mem);
197 soap_send(ipc_window, xsoap, existing_ipc_window);
199 return TRUE;
202 xwindow = GDK_WINDOW_XWINDOW(ipc_window->window);
204 /* Make the IPC window contain a property pointing to
205 * itself - this can then be used to check that it really
206 * is an IPC window.
208 gdk_property_change(ipc_window->window, filer_atom,
209 gdk_x11_xatom_to_atom(XA_WINDOW), 32,
210 GDK_PROP_MODE_REPLACE,
211 (void *) &xwindow, 1);
213 /* Get notified when we get a message */
214 g_signal_connect(ipc_window, "client-event",
215 G_CALLBACK(client_event), NULL);
217 /* Make the root window contain a pointer to the IPC window */
218 gdk_property_change(gdk_get_default_root_window(), filer_atom,
219 gdk_x11_xatom_to_atom(XA_WINDOW), 32,
220 GDK_PROP_MODE_REPLACE,
221 (void *) &xwindow, 1);
223 XUngrabServer(GDK_DISPLAY());
225 /* Also have a property without the version number, for programs
226 * that are happy to talk to any version of the filer.
228 unique_id = g_strdup_printf("_ROX_FILER_%d_%s",
229 (int) euid, our_host_name());
230 filer_atom_any = gdk_atom_intern(unique_id, FALSE);
231 g_free(unique_id);
232 /* On the IPC window... */
233 gdk_property_change(ipc_window->window, filer_atom_any,
234 gdk_x11_xatom_to_atom(XA_WINDOW), 32,
235 GDK_PROP_MODE_REPLACE,
236 (void *) &xwindow, 1);
237 /* ... and on the root */
238 gdk_property_change(gdk_get_default_root_window(), filer_atom_any,
239 gdk_x11_xatom_to_atom(XA_WINDOW), 32,
240 GDK_PROP_MODE_REPLACE,
241 (void *) &xwindow, 1);
243 return FALSE;
246 /* Executes the RPC call(s) in the given SOAP message and returns
247 * the reply.
249 xmlDocPtr run_soap(xmlDocPtr soap)
251 xmlNodePtr body, node, rep_body, reply;
252 xmlDocPtr rep_doc = NULL;
254 g_return_val_if_fail(soap != NULL, NULL);
256 /* Make sure we don't quit before doing the whole list
257 * (there's a command that closes windows)
259 number_of_windows++;
261 node = xmlDocGetRootElement(soap);
262 if (!node->ns)
263 goto bad_soap;
265 if (strcmp(node->ns->href, SOAP_ENV_NS) != 0 &&
266 strcmp(node->ns->href, SOAP_ENV_NS_OLD) != 0)
267 goto bad_soap;
269 body = get_subnode(node, SOAP_ENV_NS, "Body");
270 if (!body)
271 body = get_subnode(node, SOAP_ENV_NS_OLD, "Body");
272 if (!body)
273 goto bad_soap;
275 for (node = body->xmlChildrenNode; node; node = node->next)
277 if (node->type != XML_ELEMENT_NODE)
278 continue;
280 if (node->ns == NULL || strcmp(node->ns->href, ROX_NS) != 0)
282 g_warning("Unknown namespace %s",
283 node->ns ? node->ns->href
284 : (xmlChar *) "(none)");
285 continue;
288 reply = soap_invoke(node);
290 if (reply)
292 if (!rep_doc)
293 rep_doc = soap_new(&rep_body);
294 xmlAddChild(rep_body, reply);
298 goto out;
300 bad_soap:
301 g_warning("Bad SOAP message received!");
303 out:
304 number_of_windows--;
306 return rep_doc;
310 /****************************************************************
311 * INTERNAL FUNCTIONS *
312 ****************************************************************/
314 /* Register this function to handle SOAP calls to method 'name'.
315 * 'req' and 'opt' are comma separated lists of argument names, in the order
316 * that they are to be delivered to the function.
317 * NULL will be passed for an opt argument if not given.
318 * Otherwise, the parameter is the xmlNode from the call.
320 static void soap_register(char *name, SOAP_func func, char *req, char *opt)
322 SOAP_call *call;
324 call = g_new(SOAP_call, 1);
325 call->func = func;
326 call->required_args = req ? g_strsplit(req, ",", 0) : NULL;
327 call->optional_args = opt ? g_strsplit(opt, ",", 0) : NULL;
329 g_hash_table_insert(rpc_calls, g_strdup(name), call);
332 /* Get the remote IPC window of the already-running filer if there
333 * is one.
335 static GdkWindow *get_existing_ipc_window(void)
337 Window xid, xid_confirm;
338 GdkWindow *window;
340 if (!get_ipc_property(gdk_get_default_root_window(), &xid))
341 return NULL;
343 if (gdk_window_lookup(xid))
344 return NULL; /* Stale handle which we now own */
346 window = gdk_window_foreign_new(xid);
347 if (!window)
348 return NULL;
350 if (!get_ipc_property(window, &xid_confirm) || xid_confirm != xid)
351 return NULL;
353 return window;
356 /* Returns the 'rox_atom' property of 'window' */
357 static gboolean get_ipc_property(GdkWindow *window, Window *r_xid)
359 guchar *data;
360 gint format, length;
361 gboolean retval = FALSE;
363 if (gdk_property_get(window, filer_atom,
364 gdk_x11_xatom_to_atom(XA_WINDOW), 0, 4,
365 FALSE, NULL, &format, &length, &data) && data)
367 if (format == 32 && length == 4)
369 retval = TRUE;
370 *r_xid = *((Window *) data);
372 g_free(data);
375 return retval;
378 static char *read_property(GdkWindow *window, GdkAtom prop, gint *out_length)
380 gint grab_len = 4096;
381 gint length;
382 guchar *data;
383 guchar *retval = NULL;
385 gdk_error_trap_push();
387 while (!retval)
389 if (!(gdk_property_get(window, prop,
390 gdk_x11_xatom_to_atom(XA_STRING), 0, grab_len,
391 FALSE, NULL, NULL,
392 &length, &data) && data))
393 goto out; /* Error? */
395 if (length >= grab_len)
397 /* Didn't get all of it - try again */
398 grab_len <<= 1;
399 g_free(data);
400 continue;
403 data = g_realloc(data, length + 1);
404 data[length] = '\0'; /* libxml seems to need this */
405 *out_length = length;
407 retval = data;
409 out:
411 if (gdk_error_trap_pop() == Success)
412 return retval;
414 g_warning("Error reading %s property!", gdk_atom_name(prop));
416 g_free(retval);
417 return NULL;
420 static gboolean client_event(GtkWidget *window,
421 GdkEventClient *event,
422 gpointer user_data)
424 GdkWindow *src_window;
425 GdkAtom prop;
426 xmlDocPtr reply;
427 guchar *data;
428 gint length;
429 xmlDocPtr doc;
431 if (event->message_type != xsoap)
432 return FALSE;
434 src_window = gdk_window_foreign_new(event->data.l[0]);
435 if (!src_window)
437 g_warning("SOAP message sender window was destroyed before I \n"
438 "could read it.");
439 return FALSE;
441 prop = gdk_x11_xatom_to_atom(event->data.l[1]);
443 data = read_property(src_window, prop, &length);
444 if (!data)
445 return TRUE;
447 doc = xmlParseMemory(g_strndup(data, length), length);
448 g_free(data);
450 reply = run_soap(doc);
451 if (number_of_windows == 0)
452 gtk_main_quit();
454 xmlFreeDoc(doc);
456 if (reply)
458 /* Send reply back... */
459 xmlChar *mem;
460 int size;
462 xmlDocDumpMemory(reply, &mem, &size);
463 g_return_val_if_fail(size > 0, TRUE);
465 gdk_error_trap_push();
466 gdk_property_change(src_window, prop,
467 gdk_x11_xatom_to_atom(XA_STRING), 8,
468 GDK_PROP_MODE_REPLACE, mem, size);
469 g_free(mem);
470 gdk_flush();
471 if (gdk_error_trap_pop() != Success)
472 g_warning("Failed to send SOAP reply!");
474 else
476 gdk_error_trap_push();
477 gdk_property_delete(src_window, prop);
478 gdk_flush();
479 if (gdk_error_trap_pop() != Success)
480 g_warning("Failed to send SOAP reply!");
483 return TRUE;
486 /* Some handy functions for processing SOAP RPC arguments... */
488 /* Returns TRUE, FALSE, or -1 (if argument is unspecified) */
489 static int bool_value(xmlNode *arg)
491 int answer;
492 char *optval;
494 if (!arg)
495 return -1;
497 optval = xmlNodeGetContent(arg);
498 answer = text_to_boolean(optval, -1); /* XXX: Report error? */
499 g_free(optval);
501 return answer;
504 /* Returns the text of this arg as a string, or NULL if the (optional)
505 * argument wasn't supplied. Returns "" if the arg is empty.
506 * g_free() the result.
508 static char *string_value(xmlNode *arg)
510 char *retval;
512 if (!arg)
513 return NULL;
515 retval = xmlNodeGetContent(arg);
517 return retval ? retval : g_strdup("");
520 /* Returns the text of this arg as an int, or the default value if not
521 * supplied or not an int.
523 static int int_value(xmlNode *arg, int def)
525 char *str, *end;
526 int i;
528 if (!arg)
529 return def;
531 str = xmlNodeGetContent(arg);
532 if (!str || !str[0])
533 return def;
535 i = (int) strtol(str, &end, 0);
537 return (end > str) ? i : def;
540 /* Return a list of strings, one for each child node of arg.
541 * g_list_free the list, and g_free each string.
543 static GList *list_value(xmlNode *arg)
545 GList *list = NULL;
546 xmlNode *node;
548 for (node = arg->xmlChildrenNode; node; node = node->next)
550 if (node->type != XML_ELEMENT_NODE)
551 continue;
553 list = g_list_append(list, string_value(node));
556 return list;
559 #define ARG(n) ((xmlNode *) g_list_nth(args, n)->data)
561 /* The RPC handlers all work in the same way -- they get passed a list of
562 * xmlNode arguments from the RPC call and they return the result node, or
563 * NULL if there isn't a result.
566 static xmlNodePtr rpc_Version(GList *args)
568 xmlNodePtr reply;
570 reply = xmlNewNode(NULL, "rox:VersionResponse");
571 xmlNewNs(reply, SOAP_RPC_NS, "soap");
572 xmlNewTextChild(reply, NULL, "soap:result", VERSION);
574 return reply;
577 /* Args: Path, [Style, Details, Sort, Class, Window] */
578 static xmlNodePtr rpc_OpenDir(GList *args)
580 char *path;
581 char *style, *details, *sort, *class, *window;
582 int hidden=FALSE;
583 char *filter_string=NULL;
584 FilerWindow *fwin = NULL;
586 path = string_value(ARG(0));
587 class = string_value(ARG(4));
588 window = string_value(ARG(5));
590 if (window)
591 fwin = filer_get_by_id(window);
593 if (!fwin)
595 fwin = filer_opendir(path, NULL, class);
596 if (window)
597 filer_set_id(fwin, window);
599 else
600 filer_change_to(fwin, path, NULL);
602 g_free(path);
603 g_free(class);
604 g_free(window);
605 if (!fwin)
606 return NULL;
608 style = string_value(ARG(1));
609 details = string_value(ARG(2));
610 sort = string_value(ARG(3));
611 hidden = bool_value(ARG(6));
612 filter_string = string_value(ARG(7));
614 if (style)
616 DisplayStyle ds;
618 ds = !g_strcasecmp(style, "Large") ? LARGE_ICONS :
619 !g_strcasecmp(style, "Small") ? SMALL_ICONS :
620 !g_strcasecmp(style, "Huge") ? HUGE_ICONS :
621 !g_strcasecmp(style, "Automatic") ? AUTO_SIZE_ICONS :
622 UNKNOWN_STYLE;
623 if (ds == UNKNOWN_STYLE)
624 delayed_error(_("Unknown style '%s'"), style);
625 else
626 display_set_layout(fwin, ds, fwin->details_type, TRUE);
628 g_free(style);
631 if (details)
633 DetailsType dt;
634 ViewType view_type;
636 dt = !g_strcasecmp(details, "None") ? DETAILS_NONE :
637 !g_strcasecmp(details, "ListView") ? DETAILS_NONE :
638 !g_strcasecmp(details, "Size") ? DETAILS_SIZE :
639 !g_strcasecmp(details, "Type") ? DETAILS_TYPE :
640 !g_strcasecmp(details, "Times") ? DETAILS_TIMES :
641 !g_strcasecmp(details, "Permissions")
642 ? DETAILS_PERMISSIONS :
643 DETAILS_UNKNOWN;
645 if (dt == DETAILS_UNKNOWN)
646 delayed_error(_("Unknown details type '%s'"), details);
647 else
648 display_set_layout(fwin, fwin->display_style_wanted,
649 dt, TRUE);
651 if (g_strcasecmp(details, "ListView") == 0)
652 view_type = VIEW_TYPE_DETAILS;
653 else
654 view_type = VIEW_TYPE_COLLECTION;
656 if (view_type != fwin->view_type)
657 filer_set_view_type(fwin, view_type);
659 g_free(details);
662 if (sort)
664 SortType type;
666 type = !g_strcasecmp(sort, "Name") ? SORT_NAME :
667 !g_strcasecmp(sort, "Type") ? SORT_TYPE :
668 !g_strcasecmp(sort, "Date") ? SORT_DATE :
669 !g_strcasecmp(sort, "Size") ? SORT_SIZE :
670 !g_strcasecmp(sort, "Owner") ? SORT_OWNER :
671 !g_strcasecmp(sort, "Group") ? SORT_GROUP :
673 if (type == -1)
674 delayed_error(_("Unknown sorting type '%s'"), sort);
675 else
676 display_set_sort_type(fwin, type, GTK_SORT_ASCENDING);
678 g_free(sort);
680 if (hidden!=-1)
682 display_set_hidden(fwin, hidden);
685 if (filter_string)
686 display_set_filter(fwin, FILER_SHOW_GLOB, filter_string);
687 else
688 display_set_filter(fwin, FILER_SHOW_ALL, NULL);
690 return NULL;
693 static xmlNodePtr rpc_Run(GList *args)
695 char *path;
697 path = string_value(ARG(0));
698 run_by_path(path);
699 g_free(path);
701 return NULL;
704 static xmlNodePtr rpc_CloseDir(GList *args)
706 char *path;
708 path = string_value(ARG(0));
709 filer_close_recursive(path);
710 g_free(path);
712 return NULL;
715 static xmlNodePtr rpc_Examine(GList *args)
717 char *path;
719 path = string_value(ARG(0));
720 examine(path);
721 g_free(path);
723 return NULL;
726 static xmlNodePtr rpc_Show(GList *args)
728 char *dir, *leaf;
730 dir = string_value(ARG(0));
731 leaf = string_value(ARG(1));
733 /* XXX: Seems silly to join them only to split again later... */
734 open_to_show(make_path(dir, leaf));
736 g_free(dir);
737 g_free(leaf);
739 return NULL;
742 static xmlNodePtr rpc_Pinboard(GList *args)
744 char *name = NULL;
746 name = string_value(ARG(0));
747 pinboard_activate(name);
748 g_free(name);
750 return NULL;
753 /* args = Filename, Style */
754 static xmlNodePtr rpc_SetBackdrop(GList *args)
756 char *file;
757 char *style;
758 BackdropStyle s;
760 file = string_value(ARG(0));
761 style = string_value(ARG(1));
763 s = !g_strcasecmp(style, "Tile") ? BACKDROP_TILE :
764 !g_strcasecmp(style, "Scale") ? BACKDROP_SCALE :
765 !g_strcasecmp(style, "Stretch") ? BACKDROP_STRETCH :
766 !g_strcasecmp(style, "Centre") ? BACKDROP_CENTRE :
767 BACKDROP_NONE;
769 if (s == BACKDROP_NONE)
770 g_warning("Invalid style '%s' for backdrop", style);
771 else
772 pinboard_set_backdrop(file, s);
774 g_free(file);
775 g_free(style);
777 return NULL;
780 /* args = App */
781 static xmlNodePtr rpc_SetBackdropApp(GList *args)
783 char *app;
785 app = string_value(ARG(0));
787 pinboard_set_backdrop_app(app);
789 g_free(app);
791 return NULL;
794 /* args = Path, X, Y, [Label] */
795 static xmlNodePtr rpc_PinboardAdd(GList *args)
797 char *path = NULL;
798 gchar *name, *shortcut, *xargs;
799 int x, y;
801 path = string_value(ARG(0));
802 x = int_value(ARG(1), 0);
803 y = int_value(ARG(2), 0);
804 name = string_value(ARG(3));
805 shortcut = string_value(ARG(4));
806 xargs = string_value(ARG(5));
808 pinboard_pin_with_args(path, name, x, y, shortcut, xargs);
810 g_free(path);
811 g_free(name);
812 g_free(shortcut);
813 g_free(xargs);
815 return NULL;
818 /* args = Path, [Label] */
819 static xmlNodePtr rpc_PinboardRemove(GList *args)
821 char *path = NULL;
822 gchar *name;
824 path = string_value(ARG(0));
825 name = string_value(ARG(1));
827 pinboard_remove(path, name);
829 g_free(path);
830 if(name)
831 g_free(name);
833 return NULL;
836 /* args = Side, [Name] */
837 static xmlNodePtr rpc_Panel(GList *args)
839 PanelSide side;
840 char *name, *side_name;
842 side_name = string_value(ARG(0));
843 if (side_name)
845 side = panel_name_to_side(side_name);
846 g_free(side_name);
847 g_return_val_if_fail(side != PANEL_NUMBER_OF_SIDES, NULL);
849 else
850 side = PANEL_DEFAULT_SIDE;
852 name = string_value(ARG(1));
854 panel_new(name, side);
856 g_free(name);
858 return NULL;
861 /* args = Side, Path, [Label, After] */
862 static xmlNodePtr rpc_PanelAdd(GList *args)
864 PanelSide side;
865 char *path, *side_name, *label, *shortcut, *arg;
866 gboolean after = FALSE;
867 int tmp;
869 side_name = string_value(ARG(0));
870 side = panel_name_to_side(side_name);
871 g_free(side_name);
872 g_return_val_if_fail(side != PANEL_NUMBER_OF_SIDES, NULL);
874 path = string_value(ARG(1));
875 label = string_value(ARG(2));
877 tmp = bool_value(ARG(3));
878 after = (tmp == -1) ? FALSE : tmp;
880 shortcut = string_value(ARG(4));
881 arg = string_value(ARG(5));
883 panel_add(side, path, label, after, shortcut, arg);
885 g_free(path);
886 g_free(label);
887 g_free(shortcut);
888 g_free(arg);
890 return NULL;
893 static xmlNodePtr rpc_PanelRemove(GList *args)
895 PanelSide side;
896 char *path, *side_name, *label;
898 side_name = string_value(ARG(0));
899 side = panel_name_to_side(side_name);
900 g_free(side_name);
901 g_return_val_if_fail(side != PANEL_NUMBER_OF_SIDES, NULL);
903 path = string_value(ARG(1));
904 label = string_value(ARG(2));
906 panel_remove_item(side, path, label);
908 g_free(path);
909 g_free(label);
911 return NULL;
914 static xmlNodePtr rpc_Copy(GList *args)
916 GList *from;
917 char *to;
918 char *leaf;
919 int quiet;
921 from = list_value(ARG(0));
922 to = string_value(ARG(1));
923 leaf = string_value(ARG(2));
924 quiet = bool_value(ARG(3));
926 if (from)
927 action_copy(from, to, leaf, quiet);
928 else
929 g_warning("No files in SOAP request list");
931 destroy_glist(&from);
932 g_free(to);
933 g_free(leaf);
935 return NULL;
938 static xmlNodePtr rpc_Move(GList *args)
940 GList *from;
941 char *to;
942 char *leaf;
943 int quiet;
945 from = list_value(ARG(0));
946 to = string_value(ARG(1));
947 leaf = string_value(ARG(2));
948 quiet = bool_value(ARG(3));
950 if (from)
951 action_move(from, to, leaf, quiet);
952 else
953 g_warning("No files in SOAP request list");
955 destroy_glist(&from);
956 g_free(to);
957 g_free(leaf);
959 return NULL;
962 static xmlNodePtr rpc_Link(GList *args)
964 GList *from;
965 char *to;
966 char *leaf;
968 from = list_value(ARG(0));
969 to = string_value(ARG(1));
970 leaf = string_value(ARG(2));
972 if (from)
973 action_link(from, to, leaf, TRUE);
974 else
975 g_warning("No files in SOAP request list");
977 destroy_glist(&from);
978 g_free(to);
979 g_free(leaf);
981 return NULL;
984 static xmlNodePtr rpc_FileType(GList *args)
986 MIME_type *type;
987 char *path, *tname;
988 xmlNodePtr reply;
990 path = string_value(ARG(0));
991 type = type_get_type(path);
992 g_free(path);
994 reply = xmlNewNode(NULL, "rox:FileTypeResponse");
995 tname = g_strconcat(type->media_type, "/", type->subtype, NULL);
997 xmlNewNs(reply, SOAP_RPC_NS, "soap");
998 xmlNewTextChild(reply, NULL, "soap:result", tname);
999 g_free(tname);
1001 return reply;
1004 static xmlNodePtr rpc_Mount(GList *args)
1006 GList *paths;
1007 int open_dir, quiet;
1009 paths = list_value(ARG(0));
1010 open_dir = bool_value(ARG(1));
1011 quiet = bool_value(ARG(2));
1013 if (open_dir == -1)
1014 open_dir = TRUE;
1016 if (paths)
1017 action_mount(paths, open_dir, TRUE, quiet);
1019 destroy_glist(&paths);
1021 return NULL;
1024 static xmlNodePtr rpc_Unmount(GList *args)
1026 GList *paths;
1027 int quiet;
1029 paths = list_value(ARG(0));
1030 quiet = bool_value(ARG(1));
1032 if (paths)
1033 action_mount(paths, FALSE, FALSE, quiet);
1035 destroy_glist(&paths);
1037 return NULL;
1040 /* The first time the property changes, do nothing (it's us setting the
1041 * property). The second time, get the result.
1042 * Don't call this function three times!
1044 static void soap_done(GtkWidget *widget, GdkEventProperty *event, gpointer data)
1046 static int times_called = 0;
1047 GdkAtom prop = (GdkAtom) data;
1049 if (prop != event->atom)
1050 return;
1052 times_called++;
1053 g_return_if_fail(times_called < 3);
1055 if (times_called == 1)
1056 return;
1058 /* If we got a reply, display it here */
1059 if (event->state == GDK_PROPERTY_NEW_VALUE)
1061 gint length;
1063 data = read_property(event->window, event->atom, &length);
1065 if (data)
1066 puts(data);
1069 gtk_main_quit();
1072 static gboolean too_slow(gpointer data)
1074 g_warning("Existing ROX-Filer process is not responding! Try with -n");
1075 gtk_main_quit();
1077 return 0;
1080 /* Send the SOAP message in property 'prop' on 'from' to 'dest' */
1081 static void soap_send(GtkWidget *from, GdkAtom prop, GdkWindow *dest)
1083 GdkEventClient event;
1085 event.data.l[0] = GDK_WINDOW_XWINDOW(from->window);
1086 event.data.l[1] = gdk_x11_atom_to_xatom(prop);
1087 event.data_format = 32;
1088 event.message_type = xsoap;
1090 gdk_event_send_client_message((GdkEvent *) &event,
1091 GDK_WINDOW_XWINDOW(dest));
1093 g_timeout_add(10000, too_slow, NULL);
1095 gtk_main();
1098 /* Lookup this method in rpc_calls and invoke it.
1099 * Returns the SOAP reply or fault, or NULL if this method
1100 * doesn't return anything.
1102 static xmlNodePtr soap_invoke(xmlNode *method)
1104 GList *args = NULL;
1105 SOAP_call *call;
1106 gchar **arg;
1107 xmlNodePtr retval = NULL;
1108 GHashTable *name_to_node;
1109 xmlNode *node;
1111 call = g_hash_table_lookup(rpc_calls, method->name);
1112 if (!call)
1114 xmlNodePtr reply;
1115 gchar *err;
1117 err = g_strdup_printf(_("Attempt to invoke unknown SOAP "
1118 "method '%s'"), method->name);
1119 reply = xmlNewNode(NULL, "env:Fault");
1120 xmlNewNs(reply, SOAP_RPC_NS, "rpc");
1121 xmlNewNs(reply, SOAP_ENV_NS, "env");
1122 xmlNewTextChild(reply, NULL, "faultcode",
1123 "rpc:ProcedureNotPresent");
1124 xmlNewTextChild(reply, NULL, "faultstring", err);
1125 g_free(err);
1126 return reply;
1129 name_to_node = g_hash_table_new(g_str_hash, g_str_equal);
1130 for (node = method->xmlChildrenNode; node; node = node->next)
1132 if (node->type != XML_ELEMENT_NODE)
1133 continue;
1135 if (node->ns == NULL || strcmp(node->ns->href, ROX_NS) != 0)
1136 continue;
1138 g_hash_table_insert(name_to_node, (gchar *) node->name, node);
1141 if (call->required_args)
1143 for (arg = call->required_args; *arg; arg++)
1145 node = g_hash_table_lookup(name_to_node, *arg);
1146 if (!node)
1148 g_warning("Missing required argument '%s' "
1149 "in call to method '%s'", *arg,
1150 method->name);
1151 goto out;
1154 args = g_list_append(args, node);
1158 if (call->optional_args)
1160 for (arg = call->optional_args; *arg; arg++)
1161 args = g_list_append(args,
1162 g_hash_table_lookup(name_to_node, *arg));
1165 retval = call->func(args);
1167 out:
1168 g_hash_table_destroy(name_to_node);
1169 g_list_free(args);
1171 return retval;