ROX-Filer/src/remote.c

   1 /*
   2  * $Id$
   3  *
   4  * ROX-Filer, filer for the ROX desktop project
   5  * Copyright (C) 2005, the ROX-Filer team.
   6  *
   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.
  11  *
  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.
  16  *
  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
  20  */
  21
  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.
  26  */
  27
  28 #include "config.h"
  29
  30 #include <string.h>
  31
  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>
  38
  39 #include "global.h"
  40
  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"
  54
  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 */
  58
  59 typedef struct _SOAP_call SOAP_call;
  60 typedef xmlNodePtr (*SOAP_func)(GList *args);
  61
  62 struct _SOAP_call {
  63         SOAP_func func;
  64         gchar **required_args;
  65         gchar **optional_args;
  66 };
  67
  68 static GHashTable *rpc_calls = NULL; /* MethodName -> Function */
  69
  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);
  82
  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);
  97
  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);
 104
 105 /****************************************************************
 106  *                      EXTERNAL INTERFACE                      *
 107  ****************************************************************/
 108
 109
 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.
 113  */
 114 gboolean remote_init(xmlDocPtr rpc, gboolean new_copy)
 115 {
 116         guchar          *unique_id;
 117         GdkWindow       *existing_ipc_window;
 118         GtkWidget       *ipc_window;
 119         Window          xwindow;
 120
 121         /* xmlDocDump(stdout, rpc); */
 122
 123         rpc_calls = g_hash_table_new(g_str_hash, g_str_equal);
 124
 125         soap_register("Version", rpc_Version, NULL, NULL);
 126
 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);
 133
 134         soap_register("Pinboard", rpc_Pinboard, NULL, "Name");
 135         soap_register("Panel", rpc_Panel, NULL, "Side,Name");
 136
 137         soap_register("FileType", rpc_FileType, "Filename", NULL);
 138
 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");
 144
 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");
 151
 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.
 155          */
 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);
 160
 161         xsoap = gdk_atom_intern("_XSOAP", FALSE);
 162
 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...
 168          */
 169         ipc_window = gtk_invisible_new();
 170         gtk_widget_realize(ipc_window);
 171
 172         XGrabServer(GDK_DISPLAY());
 173
 174         existing_ipc_window = new_copy ? NULL : get_existing_ipc_window();
 175         if (existing_ipc_window)
 176         {
 177                 xmlChar *mem;
 178                 int     size;
 179
 180                 XUngrabServer(GDK_DISPLAY());
 181
 182                 xmlDocDumpMemory(rpc, &mem, &size);
 183                 g_return_val_if_fail(size > 0, FALSE);
 184
 185                 /* Since Gtk might have selected this already, we'd
 186                  * better do it BEFORE changing the property.
 187                  */
 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));
 191
 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);
 196
 197                 soap_send(ipc_window, xsoap, existing_ipc_window);
 198
 199                 return TRUE;
 200         }
 201
 202         xwindow = GDK_WINDOW_XWINDOW(ipc_window->window);
 203
 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.
 207          */
 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);
 212
 213         /* Get notified when we get a message */
 214         g_signal_connect(ipc_window, "client-event",
 215                         G_CALLBACK(client_event), NULL);
 216
 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);
 222
 223         XUngrabServer(GDK_DISPLAY());
 224
 225         /* Also have a property without the version number, for programs
 226          * that are happy to talk to any version of the filer.
 227          */
 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);
 242
 243         return FALSE;
 244 }
 245
 246 /* Executes the RPC call(s) in the given SOAP message and returns
 247  * the reply.
 248  */
 249 xmlDocPtr run_soap(xmlDocPtr soap)
 250 {
 251         xmlNodePtr body, node, rep_body, reply;
 252         xmlDocPtr rep_doc = NULL;
 253
 254         g_return_val_if_fail(soap != NULL, NULL);
 255
 256         /* Make sure we don't quit before doing the whole list
 257          * (there's a command that closes windows)
 258          */
 259         number_of_windows++;
 260
 261         node = xmlDocGetRootElement(soap);
 262         if (!node->ns)
 263                 goto bad_soap;
 264
 265         if (strcmp(node->ns->href, SOAP_ENV_NS) != 0 &&
 266             strcmp(node->ns->href, SOAP_ENV_NS_OLD) != 0)
 267                 goto bad_soap;
 268
 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;
 274
 275         for (node = body->xmlChildrenNode; node; node = node->next)
 276         {
 277                 if (node->type != XML_ELEMENT_NODE)
 278                         continue;
 279
 280                 if (node->ns == NULL || strcmp(node->ns->href, ROX_NS) != 0)
 281                 {
 282                         g_warning("Unknown namespace %s",
 283                                         node->ns ? node->ns->href
 284                                                  : (xmlChar *) "(none)");
 285                         continue;
 286                 }
 287
 288                 reply = soap_invoke(node);
 289
 290                 if (reply)
 291                 {
 292                         if (!rep_doc)
 293                                 rep_doc = soap_new(&rep_body);
 294                         xmlAddChild(rep_body, reply);
 295                 }
 296         }
 297
 298         goto out;
 299
 300 bad_soap:
 301         g_warning("Bad SOAP message received!");
 302
 303 out:
 304         number_of_windows--;
 305
 306         return rep_doc;
 307 }
 308
 309
 310 /****************************************************************
 311  *                      INTERNAL FUNCTIONS                      *
 312  ****************************************************************/
 313
 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.
 319  */
 320 static void soap_register(char *name, SOAP_func func, char *req, char *opt)
 321 {
 322         SOAP_call *call;
 323
 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;
 328
 329         g_hash_table_insert(rpc_calls, g_strdup(name), call);
 330 }
 331
 332 /* Get the remote IPC window of the already-running filer if there
 333  * is one.
 334  */
 335 static GdkWindow *get_existing_ipc_window(void)
 336 {
 337         Window          xid, xid_confirm;
 338         GdkWindow       *window;
 339
 340         if (!get_ipc_property(gdk_get_default_root_window(), &xid))
 341                 return NULL;
 342
 343         if (gdk_window_lookup(xid))
 344                 return NULL;    /* Stale handle which we now own */
 345
 346         window = gdk_window_foreign_new(xid);
 347         if (!window)
 348                 return NULL;
 349
 350         if (!get_ipc_property(window, &xid_confirm) || xid_confirm != xid)
 351                 return NULL;
 352
 353         return window;
 354 }
 355
 356 /* Returns the 'rox_atom' property of 'window' */
 357 static gboolean get_ipc_property(GdkWindow *window, Window *r_xid)
 358 {
 359         guchar          *data;
 360         gint            format, length;
 361         gboolean        retval = FALSE;
 362
 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)
 366         {
 367                 /* Note: values with format=32 are stored as longs client-side,
 368                  * which may be more than 32 bits on some systems.
 369                  */
 370                 if (format == 32 && length == sizeof(long))
 371                 {
 372                         long windowID = *((long *) data);
 373                         retval = TRUE;
 374                         *r_xid = (Window) windowID;
 375                 }
 376                 g_free(data);
 377         }
 378
 379         return retval;
 380 }
 381
 382 static char *read_property(GdkWindow *window, GdkAtom prop, gint *out_length)
 383 {
 384         gint    grab_len = 4096;
 385         gint    length;
 386         guchar  *data;
 387         guchar  *retval = NULL;
 388
 389         gdk_error_trap_push();
 390
 391         while (!retval)
 392         {
 393                 if (!(gdk_property_get(window, prop,
 394                                 gdk_x11_xatom_to_atom(XA_STRING), 0, grab_len,
 395                                 FALSE, NULL, NULL,
 396                                 &length, &data) && data))
 397                         goto out;       /* Error? */
 398
 399                 if (length >= grab_len)
 400                 {
 401                         /* Didn't get all of it - try again */
 402                         grab_len <<= 1;
 403                         g_free(data);
 404                         continue;
 405                 }
 406
 407                 data = g_realloc(data, length + 1);
 408                 data[length] = '\0';    /* libxml seems to need this */
 409                 *out_length = length;
 410
 411                 retval = data;
 412         }
 413 out:
 414
 415         if (gdk_error_trap_pop() == Success)
 416                 return retval;
 417
 418         g_warning("Error reading %s property!", gdk_atom_name(prop));
 419
 420         g_free(retval);
 421         return NULL;
 422 }
 423
 424 static gboolean client_event(GtkWidget *window,
 425                                  GdkEventClient *event,
 426                                  gpointer user_data)
 427 {
 428         GdkWindow *src_window;
 429         GdkAtom prop;
 430         xmlDocPtr reply;
 431         guchar  *data;
 432         gint    length;
 433         xmlDocPtr doc;
 434
 435         if (event->message_type != xsoap)
 436                 return FALSE;
 437
 438         src_window = gdk_window_foreign_new(event->data.l[0]);
 439         if (!src_window)
 440         {
 441                 g_warning("SOAP message sender window was destroyed before I \n"
 442                           "could read it.");
 443                 return FALSE;
 444         }
 445         prop = gdk_x11_xatom_to_atom(event->data.l[1]);
 446
 447         data = read_property(src_window, prop, &length);
 448         if (!data)
 449                 return TRUE;
 450
 451         doc = xmlParseMemory(g_strndup(data, length), length);
 452         g_free(data);
 453
 454         reply = run_soap(doc);
 455         if (number_of_windows == 0)
 456                 gtk_main_quit();
 457
 458         xmlFreeDoc(doc);
 459
 460         if (reply)
 461         {
 462                 /* Send reply back... */
 463                 xmlChar *mem;
 464                 int     size;
 465
 466                 xmlDocDumpMemory(reply, &mem, &size);
 467                 g_return_val_if_fail(size > 0, TRUE);
 468
 469                 gdk_error_trap_push();
 470                 gdk_property_change(src_window, prop,
 471                         gdk_x11_xatom_to_atom(XA_STRING), 8,
 472                         GDK_PROP_MODE_REPLACE, mem, size);
 473                 g_free(mem);
 474                 gdk_flush();
 475                 if (gdk_error_trap_pop() != Success)
 476                         g_warning("Failed to send SOAP reply!");
 477         }
 478         else
 479         {
 480                 gdk_error_trap_push();
 481                 gdk_property_delete(src_window, prop);
 482                 gdk_flush();
 483                 if (gdk_error_trap_pop() != Success)
 484                         g_warning("Failed to send SOAP reply!");
 485         }
 486
 487         return TRUE;
 488 }
 489
 490 /* Some handy functions for processing SOAP RPC arguments... */
 491
 492 /* Returns TRUE, FALSE, or -1 (if argument is unspecified) */
 493 static int bool_value(xmlNode *arg)
 494 {
 495         int answer;
 496         char *optval;
 497
 498         if (!arg)
 499                 return -1;
 500
 501         optval = xmlNodeGetContent(arg);
 502         answer = text_to_boolean(optval, -1);   /* XXX: Report error? */
 503         g_free(optval);
 504
 505         return answer;
 506 }
 507
 508 /* Returns the text of this arg as a string, or NULL if the (optional)
 509  * argument wasn't supplied. Returns "" if the arg is empty.
 510  * g_free() the result.
 511  */
 512 static char *string_value(xmlNode *arg)
 513 {
 514         char *retval;
 515
 516         if (!arg)
 517                 return NULL;
 518
 519         retval = xmlNodeGetContent(arg);
 520
 521         return retval ? retval : g_strdup("");
 522 }
 523
 524 /* Returns the text of this arg as an int, or the default value if not
 525  * supplied or not an int.
 526  */
 527 static int int_value(xmlNode *arg, int def)
 528 {
 529         char *str, *end;
 530         int i;
 531
 532         if (!arg)
 533                 return def;
 534
 535         str = xmlNodeGetContent(arg);
 536         if (!str || !str[0])
 537                 return def;
 538
 539         i = (int) strtol(str, &end, 0);
 540
 541         return (end > str) ? i : def;
 542 }
 543
 544 /* Return a list of strings, one for each child node of arg.
 545  * g_list_free the list, and g_free each string.
 546  */
 547 static GList *list_value(xmlNode *arg)
 548 {
 549         GList *list = NULL;
 550         xmlNode *node;
 551
 552         for (node = arg->xmlChildrenNode; node; node = node->next)
 553         {
 554                 if (node->type != XML_ELEMENT_NODE)
 555                         continue;
 556
 557                 list = g_list_append(list, string_value(node));
 558         }
 559
 560         return list;
 561 }
 562
 563 #define ARG(n) ((xmlNode *) g_list_nth(args, n)->data)
 564
 565 /* The RPC handlers all work in the same way -- they get passed a list of
 566  * xmlNode arguments from the RPC call and they return the result node, or
 567  * NULL if there isn't a result.
 568  */
 569
 570 static xmlNodePtr rpc_Version(GList *args)
 571 {
 572         xmlNodePtr reply;
 573
 574         reply = xmlNewNode(NULL, "rox:VersionResponse");
 575         xmlNewNs(reply, SOAP_RPC_NS, "soap");
 576         xmlNewTextChild(reply, NULL, "soap:result", VERSION);
 577
 578         return reply;
 579 }
 580
 581 /* Args: Path, [Style, Details, Sort, Class, Window] */
 582 static xmlNodePtr rpc_OpenDir(GList *args)
 583 {
 584         char       *path;
 585         char       *style, *details, *sort, *class, *window;
 586         int         hidden=FALSE;
 587         char       *filter_string=NULL;
 588         FilerWindow *fwin = NULL;
 589
 590         path = string_value(ARG(0));
 591         class = string_value(ARG(4));
 592         window = string_value(ARG(5));
 593
 594         if (window)
 595                 fwin = filer_get_by_id(window);
 596
 597         if (!fwin)
 598         {
 599                 fwin = filer_opendir(path, NULL, class);
 600                 if (window)
 601                         filer_set_id(fwin, window);
 602         }
 603         else
 604                 filer_change_to(fwin, path, NULL);
 605
 606         g_free(path);
 607         g_free(class);
 608         g_free(window);
 609         if (!fwin)
 610                 return NULL;
 611
 612         style = string_value(ARG(1));
 613         details = string_value(ARG(2));
 614         sort = string_value(ARG(3));
 615         hidden = bool_value(ARG(6));
 616         filter_string = string_value(ARG(7));
 617
 618         if (style)
 619         {
 620                 DisplayStyle ds;
 621
 622                 ds = !g_strcasecmp(style, "Large") ? LARGE_ICONS :
 623                      !g_strcasecmp(style, "Small") ? SMALL_ICONS :
 624                      !g_strcasecmp(style, "Huge")  ? HUGE_ICONS :
 625                      !g_strcasecmp(style, "Automatic")  ? AUTO_SIZE_ICONS :
 626                                                      UNKNOWN_STYLE;
 627                 if (ds == UNKNOWN_STYLE)
 628                         delayed_error(_("Unknown style '%s'"), style);
 629                 else
 630                         display_set_layout(fwin, ds, fwin->details_type, TRUE);
 631
 632                 g_free(style);
 633         }
 634
 635         if (details)
 636         {
 637                 DetailsType dt;
 638                 ViewType view_type;
 639
 640                 dt = !g_strcasecmp(details, "None") ? DETAILS_NONE :
 641                      !g_strcasecmp(details, "ListView") ? DETAILS_NONE :
 642                      !g_strcasecmp(details, "Size") ? DETAILS_SIZE :
 643                      !g_strcasecmp(details, "Type") ? DETAILS_TYPE :
 644                      !g_strcasecmp(details, "Times") ? DETAILS_TIMES :
 645                      !g_strcasecmp(details, "Permissions")
 646                                                 ? DETAILS_PERMISSIONS :
 647                                                   DETAILS_UNKNOWN;
 648
 649                 if (dt == DETAILS_UNKNOWN)
 650                         delayed_error(_("Unknown details type '%s'"), details);
 651                 else
 652                         display_set_layout(fwin, fwin->display_style_wanted,
 653                                            dt, TRUE);
 654
 655                 if (g_strcasecmp(details, "ListView") == 0)
 656                         view_type = VIEW_TYPE_DETAILS;
 657                 else
 658                         view_type = VIEW_TYPE_COLLECTION;
 659
 660                 if (view_type != fwin->view_type)
 661                         filer_set_view_type(fwin, view_type);
 662
 663                 g_free(details);
 664         }
 665
 666         if (sort)
 667         {
 668                 SortType type;
 669
 670                 type = !g_strcasecmp(sort, "Name") ? SORT_NAME :
 671                        !g_strcasecmp(sort, "Type") ? SORT_TYPE :
 672                        !g_strcasecmp(sort, "Date") ? SORT_DATE :
 673                        !g_strcasecmp(sort, "Size") ? SORT_SIZE :
 674                        !g_strcasecmp(sort, "Owner") ? SORT_OWNER :
 675                        !g_strcasecmp(sort, "Group") ? SORT_GROUP :
 676                                                        -1;
 677                 if (type == -1)
 678                         delayed_error(_("Unknown sorting type '%s'"), sort);
 679                 else
 680                         display_set_sort_type(fwin, type, GTK_SORT_ASCENDING);
 681
 682                 g_free(sort);
 683         }
 684         if (hidden!=-1)
 685         {
 686                 display_set_hidden(fwin, hidden);
 687         }
 688
 689         if (filter_string)
 690                 display_set_filter(fwin, FILER_SHOW_GLOB, filter_string);
 691         else
 692                 display_set_filter(fwin, FILER_SHOW_ALL, NULL);
 693
 694         return NULL;
 695 }
 696
 697 static xmlNodePtr rpc_Run(GList *args)
 698 {
 699         char       *path;
 700
 701         path = string_value(ARG(0));
 702         run_by_path(path);
 703         g_free(path);
 704
 705         return NULL;
 706 }
 707
 708 static xmlNodePtr rpc_CloseDir(GList *args)
 709 {
 710         char       *path;
 711
 712         path = string_value(ARG(0));
 713         filer_close_recursive(path);
 714         g_free(path);
 715
 716         return NULL;
 717 }
 718
 719 static xmlNodePtr rpc_Examine(GList *args)
 720 {
 721         char       *path;
 722
 723         path = string_value(ARG(0));
 724         examine(path);
 725         g_free(path);
 726
 727         return NULL;
 728 }
 729
 730 static xmlNodePtr rpc_Show(GList *args)
 731 {
 732         char       *dir, *leaf;
 733
 734         dir = string_value(ARG(0));
 735         leaf = string_value(ARG(1));
 736
 737         /* XXX: Seems silly to join them only to split again later... */
 738         open_to_show(make_path(dir, leaf));
 739
 740         g_free(dir);
 741         g_free(leaf);
 742
 743         return NULL;
 744 }
 745
 746 static xmlNodePtr rpc_Pinboard(GList *args)
 747 {
 748         char *name = NULL;
 749
 750         name = string_value(ARG(0));
 751         pinboard_activate(name);
 752         g_free(name);
 753
 754         return NULL;
 755 }
 756
 757 /* args = Filename, Style */
 758 static xmlNodePtr rpc_SetBackdrop(GList *args)
 759 {
 760         char *file;
 761         char *style;
 762         BackdropStyle s;
 763
 764         file = string_value(ARG(0));
 765         style = string_value(ARG(1));
 766
 767         s = !g_strcasecmp(style, "Tile") ? BACKDROP_TILE :
 768             !g_strcasecmp(style, "Scale") ? BACKDROP_SCALE :
 769             !g_strcasecmp(style, "Stretch") ? BACKDROP_STRETCH :
 770             !g_strcasecmp(style, "Centre") ? BACKDROP_CENTRE :
 771                                              BACKDROP_NONE;
 772
 773         if (s == BACKDROP_NONE)
 774                 g_warning("Invalid style '%s' for backdrop", style);
 775         else
 776                 pinboard_set_backdrop(file, s);
 777
 778         g_free(file);
 779         g_free(style);
 780
 781         return NULL;
 782 }
 783
 784 /* args = App */
 785 static xmlNodePtr rpc_SetBackdropApp(GList *args)
 786 {
 787         char *app;
 788
 789         app = string_value(ARG(0));
 790
 791         pinboard_set_backdrop_app(app);
 792
 793         g_free(app);
 794
 795         return NULL;
 796 }
 797
 798 /* args = Path, X, Y, [Label] */
 799 static xmlNodePtr rpc_PinboardAdd(GList *args)
 800 {
 801         char *path = NULL;
 802         gchar *name, *shortcut, *xargs;
 803         int x, y;
 804
 805         path = string_value(ARG(0));
 806         x = int_value(ARG(1), 0);
 807         y = int_value(ARG(2), 0);
 808         name = string_value(ARG(3));
 809         shortcut = string_value(ARG(4));
 810         xargs = string_value(ARG(5));
 811
 812         pinboard_pin_with_args(path, name, x, y, shortcut, xargs);
 813
 814         g_free(path);
 815         g_free(name);
 816         g_free(shortcut);
 817         g_free(xargs);
 818
 819         return NULL;
 820 }
 821
 822 /* args = Path, [Label] */
 823 static xmlNodePtr rpc_PinboardRemove(GList *args)
 824 {
 825         char *path = NULL;
 826         gchar *name;
 827
 828         path = string_value(ARG(0));
 829         name = string_value(ARG(1));
 830
 831         pinboard_remove(path, name);
 832
 833         g_free(path);
 834         if(name)
 835                 g_free(name);
 836
 837         return NULL;
 838 }
 839
 840 /* args = Side, [Name] */
 841 static xmlNodePtr rpc_Panel(GList *args)
 842 {
 843         PanelSide side;
 844         char *name, *side_name;
 845
 846         side_name = string_value(ARG(0));
 847         if (side_name)
 848         {
 849                 side = panel_name_to_side(side_name);
 850                 g_free(side_name);
 851                 g_return_val_if_fail(side != PANEL_NUMBER_OF_SIDES, NULL);
 852         }
 853         else
 854                 side = PANEL_DEFAULT_SIDE;
 855
 856         name = string_value(ARG(1));
 857
 858         panel_new(name, side);
 859
 860         g_free(name);
 861
 862         return NULL;
 863 }
 864
 865 /* args = Side, Path, [Label, After] */
 866 static xmlNodePtr rpc_PanelAdd(GList *args)
 867 {
 868         PanelSide side;
 869         char *path, *side_name, *label, *shortcut, *arg;
 870         gboolean after = FALSE;
 871         int tmp;
 872
 873         side_name = string_value(ARG(0));
 874         side = panel_name_to_side(side_name);
 875         g_free(side_name);
 876         g_return_val_if_fail(side != PANEL_NUMBER_OF_SIDES, NULL);
 877
 878         path = string_value(ARG(1));
 879         label = string_value(ARG(2));
 880
 881         tmp = bool_value(ARG(3));
 882         after = (tmp == -1) ? FALSE : tmp;
 883
 884         shortcut = string_value(ARG(4));
 885         arg = string_value(ARG(5));
 886
 887         panel_add(side, path, label, after, shortcut, arg);
 888
 889         g_free(path);
 890         g_free(label);
 891         g_free(shortcut);
 892         g_free(arg);
 893
 894         return NULL;
 895 }
 896
 897 static xmlNodePtr rpc_PanelRemove(GList *args)
 898 {
 899         PanelSide side;
 900         char *path, *side_name, *label;
 901
 902         side_name = string_value(ARG(0));
 903         side = panel_name_to_side(side_name);
 904         g_free(side_name);
 905         g_return_val_if_fail(side != PANEL_NUMBER_OF_SIDES, NULL);
 906
 907         path = string_value(ARG(1));
 908         label = string_value(ARG(2));
 909
 910         if (path || label)
 911                 panel_remove_item(side, path, label);
 912         else
 913                 g_warning("Must specify either path or label");
 914
 915         g_free(path);
 916         g_free(label);
 917
 918         return NULL;
 919 }
 920
 921 static xmlNodePtr rpc_Copy(GList *args)
 922 {
 923         GList *from;
 924         char *to;
 925         char *leaf;
 926         int quiet;
 927
 928         from = list_value(ARG(0));
 929         to = string_value(ARG(1));
 930         leaf = string_value(ARG(2));
 931         quiet = bool_value(ARG(3));
 932
 933         if (from)
 934                 action_copy(from, to, leaf, quiet);
 935         else
 936                 g_warning("No files in SOAP request list");
 937
 938         destroy_glist(&from);
 939         g_free(to);
 940         g_free(leaf);
 941
 942         return NULL;
 943 }
 944
 945 static xmlNodePtr rpc_Move(GList *args)
 946 {
 947         GList *from;
 948         char *to;
 949         char *leaf;
 950         int quiet;
 951
 952         from = list_value(ARG(0));
 953         to = string_value(ARG(1));
 954         leaf = string_value(ARG(2));
 955         quiet = bool_value(ARG(3));
 956
 957         if (from)
 958                 action_move(from, to, leaf, quiet);
 959         else
 960                 g_warning("No files in SOAP request list");
 961
 962         destroy_glist(&from);
 963         g_free(to);
 964         g_free(leaf);
 965
 966         return NULL;
 967 }
 968
 969 static xmlNodePtr rpc_Link(GList *args)
 970 {
 971         GList *from;
 972         char *to;
 973         char *leaf;
 974
 975         from = list_value(ARG(0));
 976         to = string_value(ARG(1));
 977         leaf = string_value(ARG(2));
 978
 979         if (from)
 980                 action_link(from, to, leaf, TRUE);
 981         else
 982                 g_warning("No files in SOAP request list");
 983
 984         destroy_glist(&from);
 985         g_free(to);
 986         g_free(leaf);
 987
 988         return NULL;
 989 }
 990
 991 static xmlNodePtr rpc_FileType(GList *args)
 992 {
 993         MIME_type *type;
 994         char *path, *tname;
 995         xmlNodePtr reply;
 996
 997         path = string_value(ARG(0));
 998         type = type_get_type(path);
 999         g_free(path);
1000
1001         reply = xmlNewNode(NULL, "rox:FileTypeResponse");
1002         tname = g_strconcat(type->media_type, "/", type->subtype, NULL);
1003
1004         xmlNewNs(reply, SOAP_RPC_NS, "soap");
1005         xmlNewTextChild(reply, NULL, "soap:result", tname);
1006         g_free(tname);
1007
1008         return reply;
1009 }
1010
1011 static xmlNodePtr rpc_Mount(GList *args)
1012 {
1013         GList *paths;
1014         int     open_dir, quiet;
1015
1016         paths = list_value(ARG(0));
1017         open_dir = bool_value(ARG(1));
1018         quiet = bool_value(ARG(2));
1019
1020         if (open_dir == -1)
1021                 open_dir = TRUE;
1022
1023         if (paths)
1024                 action_mount(paths, open_dir, TRUE, quiet);
1025
1026         destroy_glist(&paths);
1027
1028         return NULL;
1029 }
1030
1031 static xmlNodePtr rpc_Unmount(GList *args)
1032 {
1033         GList *paths;
1034         int     quiet;
1035
1036         paths = list_value(ARG(0));
1037         quiet = bool_value(ARG(1));
1038
1039         if (paths)
1040                 action_mount(paths, FALSE, FALSE, quiet);
1041
1042         destroy_glist(&paths);
1043
1044         return NULL;
1045 }
1046
1047 /* The first time the property changes, do nothing (it's us setting the
1048  * property). The second time, get the result.
1049  * Don't call this function three times!
1050  */
1051 static void soap_done(GtkWidget *widget, GdkEventProperty *event, gpointer data)
1052 {
1053         static int times_called = 0;
1054         GdkAtom prop = (GdkAtom) data;
1055
1056         if (prop != event->atom)
1057                 return;
1058
1059         times_called++;
1060         g_return_if_fail(times_called < 3);
1061
1062         if (times_called == 1)
1063                 return;
1064
1065         /* If we got a reply, display it here */
1066         if (event->state == GDK_PROPERTY_NEW_VALUE)
1067         {
1068                 gint length;
1069
1070                 data = read_property(event->window, event->atom, &length);
1071
1072                 if (data)
1073                         puts(data);
1074         }
1075
1076         gtk_main_quit();
1077 }
1078
1079 static gboolean too_slow(gpointer data)
1080 {
1081         g_warning("Existing ROX-Filer process is not responding! Try with -n");
1082         gtk_main_quit();
1083
1084         return 0;
1085 }
1086
1087 /* Send the SOAP message in property 'prop' on 'from' to 'dest' */
1088 static void soap_send(GtkWidget *from, GdkAtom prop, GdkWindow *dest)
1089 {
1090         GdkEventClient event;
1091
1092         event.data.l[0] = GDK_WINDOW_XWINDOW(from->window);
1093         event.data.l[1] = gdk_x11_atom_to_xatom(prop);
1094         event.data_format = 32;
1095         event.message_type = xsoap;
1096
1097         gdk_event_send_client_message((GdkEvent *) &event,
1098                                       GDK_WINDOW_XWINDOW(dest));
1099
1100         g_timeout_add(10000, too_slow, NULL);
1101
1102         gtk_main();
1103 }
1104
1105 /* Lookup this method in rpc_calls and invoke it.
1106  * Returns the SOAP reply or fault, or NULL if this method
1107  * doesn't return anything.
1108  */
1109 static xmlNodePtr soap_invoke(xmlNode *method)
1110 {
1111         GList *args = NULL;
1112         SOAP_call *call;
1113         gchar **arg;
1114         xmlNodePtr retval = NULL;
1115         GHashTable *name_to_node;
1116         xmlNode *node;
1117
1118         call = g_hash_table_lookup(rpc_calls, method->name);
1119         if (!call)
1120         {
1121                 xmlNodePtr reply;
1122                 gchar *err;
1123
1124                 err = g_strdup_printf(_("Attempt to invoke unknown SOAP "
1125                                         "method '%s'"), method->name);
1126                 reply = xmlNewNode(NULL, "env:Fault");
1127                 xmlNewNs(reply, SOAP_RPC_NS, "rpc");
1128                 xmlNewNs(reply, SOAP_ENV_NS, "env");
1129                 xmlNewTextChild(reply, NULL, "faultcode",
1130                                                 "rpc:ProcedureNotPresent");
1131                 xmlNewTextChild(reply, NULL, "faultstring", err);
1132                 g_free(err);
1133                 return reply;
1134         }
1135
1136         name_to_node = g_hash_table_new(g_str_hash, g_str_equal);
1137         for (node = method->xmlChildrenNode; node; node = node->next)
1138         {
1139                 if (node->type != XML_ELEMENT_NODE)
1140                         continue;
1141
1142                 if (node->ns == NULL || strcmp(node->ns->href, ROX_NS) != 0)
1143                         continue;
1144
1145                 g_hash_table_insert(name_to_node, (gchar *) node->name, node);
1146         }
1147
1148         if (call->required_args)
1149         {
1150                 for (arg = call->required_args; *arg; arg++)
1151                 {
1152                         node = g_hash_table_lookup(name_to_node, *arg);
1153                         if (!node)
1154                         {
1155                                 g_warning("Missing required argument '%s' "
1156                                         "in call to method '%s'", *arg,
1157                                         method->name);
1158                                 goto out;
1159                         }
1160
1161                         args = g_list_append(args, node);
1162                 }
1163         }
1164
1165         if (call->optional_args)
1166         {
1167                 for (arg = call->optional_args; *arg; arg++)
1168                         args = g_list_append(args,
1169                                 g_hash_table_lookup(name_to_node, *arg));
1170         }
1171
1172         retval = call->func(args);
1173
1174 out:
1175         g_hash_table_destroy(name_to_node);
1176         g_list_free(args);
1177
1178         return retval;
1179 }