wvdbus-sharp/conn.cs

   1 // Copyright 2006 Alp Toker <alp@atoker.com>
   2 // Copyright 2007 Versabanq (Adrian Dewhurst <adewhurst@versabanq.com>)
   3 // This software is made available under the MIT License
   4 // See COPYING for details
   5 //
   6 using System;
   7 using System.Collections.Generic;
   8 using System.IO;
   9 using System.Reflection;
  10 using Wv.Extensions;
  11
  12 namespace Wv
  13 {
  14     [Flags]
  15     public enum NameFlag : uint
  16     {
  17         None = 0,
  18         AllowReplacement = 0x1,
  19         ReplaceExisting = 0x2,
  20         DoNotQueue = 0x4,
  21     }
  22
  23     public enum RequestNameReply : uint
  24     {
  25         PrimaryOwner = 1,
  26         InQueue,
  27         Exists,
  28         AlreadyOwner,
  29     }
  30
  31     public enum ReleaseNameReply : uint
  32     {
  33         Released = 1,
  34         NonExistent,
  35         NotOwner,
  36     }
  37
  38     public enum StartReply : uint
  39     {
  40         Success = 1,    // service was successfully started
  41         AlreadyRunning, // connection already owns the given name
  42     }
  43
  44     public class WvDbus : IDisposable
  45     {
  46         static readonly string DBusName = "org.freedesktop.DBus";
  47         static readonly string DBusPath = "/org/freedesktop/DBus";
  48
  49         WvLog log = new WvLog("DBus");
  50         public WvBufStream stream { get; private set; }
  51         public bool ok { get { return stream.ok; } }
  52
  53         public WvDbus(string address)
  54         {
  55             handlers = new List<Func<WvDbusMsg,bool>>();
  56             handlers.Add(default_handler);
  57             stream = make_stream(address);
  58             stream.onreadable += () => {
  59                 handlemessages(0);
  60             };
  61
  62             // write the credential byte (needed for passing unix uids over
  63             // the unix domain socket, but anyway, part of the protocol
  64             // spec).
  65             stream.write(new byte[] { 0 });
  66
  67             if (stream.err != null)
  68                 throw stream.err;
  69
  70             // Run the authentication phase
  71             var auth = new Dbus.ExternalAuthClient(this, stream);
  72             auth.Run();
  73
  74             unique_name = CallDBusMethod("Hello");
  75         }
  76
  77         public void Dispose()
  78         {
  79             using (stream)
  80             {
  81                 stream = null;
  82             }
  83         }
  84
  85         static WvBufStream make_stream(string address)
  86         {
  87             WvStream s;
  88             WvUrl url = address_to_url(address);
  89             if (url.method == "unix")
  90             {
  91                 if (url.path.ne())
  92                     s = new WvUnix(url.path);
  93                 else
  94                     throw new Exception("No path specified for UNIX transport");
  95             }
  96             else if (url.method == "tcp")
  97             {
  98                 string host = url.host.or("127.0.0.1");
  99                 int port = url.port.or(5555);
 100                 s = new WvTcp(host, (ushort)port);
 101             }
 102             else
 103                 throw new Exception(wv.fmt("Unknown connection method {0}",
 104                                            url.method));
 105             return new WvBufStream(s);
 106         }
 107
 108         uint serial = 0;
 109         uint GenerateSerial()
 110         {
 111             return ++serial;
 112         }
 113
 114         public WvDbusMsg send_and_wait(WvDbusMsg msg)
 115         {
 116             WvDbusMsg reply = null;
 117
 118             send(msg, (r) => { reply = r; });
 119             stream.flush(-1);
 120
 121             while (reply == null && ok)
 122                 handlemessage(-1);
 123
 124             return reply;
 125         }
 126
 127         public uint send(WvDbusMsg msg, Action<WvDbusMsg> replyaction)
 128         {
 129             msg.ReplyExpected = true;
 130             msg.serial = send(msg);
 131             rserial_to_action[msg.serial] = replyaction;
 132             return msg.serial;
 133         }
 134
 135         void printmsg(string prefix, WvBytes hdata, WvDbusMsg msg)
 136         {
 137             log.print(WvLog.L.Debug3,
 138                       "{0} {1}#{2} ->{3} '{4}'.'{5}' ({6} bytes)\n",
 139                       prefix, msg.type, msg.serial, msg.dest,
 140                       msg.ifc, msg.method,
 141                       msg.Body==null ? 0 : msg.Body.Length);
 142             log.print(WvLog.L.Debug4, "Header:\n{0}", wv.hexdump(hdata));
 143             log.print(WvLog.L.Debug5, "Body:\n{0}", wv.hexdump(msg.Body));
 144         }
 145
 146         public uint send(WvDbusMsg msg)
 147         {
 148             msg.serial = GenerateSerial();
 149             var hdata = msg.GetHeaderData();
 150
 151             long len = hdata.Length + (msg.Body != null ? msg.Body.Length : 0);
 152             if (len > Dbus.Protocol.MaxMessageLength)
 153                 throw new Exception(
 154                   wv.fmt("Message length {0} > max {1}",
 155                          len, Dbus.Protocol.MaxMessageLength));
 156
 157             printmsg(" >>", hdata, msg);
 158             stream.write(hdata);
 159             if (msg.Body != null && msg.Body.Length != 0)
 160                 stream.write(msg.Body);
 161
 162             return msg.serial;
 163         }
 164
 165         WvBuf inbuf = new WvBuf();
 166
 167         int entrycount = 0;
 168         void readbytes(int max, int msec_timeout)
 169         {
 170             entrycount++;
 171             wv.assert(entrycount == 1);
 172
 173             log.print(WvLog.L.Debug5, "Reading: have {0} of needed {1}\n",
 174                       inbuf.used, max);
 175             int needed = max - inbuf.used;
 176             if (needed > 0)
 177             {
 178                 if (stream.wait(msec_timeout, true, false))
 179                 {
 180                     WvBytes b = inbuf.alloc(needed);
 181                     int got = stream.read(b);
 182                     inbuf.unalloc(needed-got);
 183                 }
 184             }
 185             entrycount--;
 186         }
 187
 188         /**
 189          * You shouldn't use this, as it bypasses normal message processing.
 190          * Add a message handler instead.
 191          *
 192          * It exists because it's useful in our unit tests.
 193          */
 194         public WvDbusMsg readmessage(int msec_timeout)
 195         {
 196             foreach (int remain in wv.until(msec_timeout))
 197             {
 198                 readbytes(16, remain);
 199                 if (inbuf.used < 16)
 200                     continue;
 201
 202                 int needed = WvDbusMsg.bytes_needed(inbuf.peek(16));
 203                 readbytes(needed, remain);
 204                 if (inbuf.used < needed)
 205                     continue;
 206
 207                 var msg = new WvDbusMsg(inbuf.get(needed));
 208                 printmsg("<< ", msg.GetHeaderData(), msg);
 209                 return msg;
 210             }
 211
 212             return null;
 213         }
 214
 215         bool handlemessage(int msec_timeout)
 216         {
 217             var m = readmessage(msec_timeout);
 218             if (m != null)
 219             {
 220                 // use ToArray() here in case the list changes while
 221                 // we're iterating
 222                 foreach (var handler in handlers.ToArray())
 223                     if (handler(m))
 224                         return true;
 225
 226                 // if we get here, there was a message but nobody could
 227                 // handle it.  That's weird because our default handler
 228                 // should handle *everything*.
 229                 wv.assert(false, "No default message handler?!");
 230                 return true;
 231             }
 232             return false;
 233         }
 234
 235         public void handlemessages(int msec_timeout)
 236         {
 237             while (handlemessage(msec_timeout) && ok)
 238                 ;
 239         }
 240
 241         public List<Func<WvDbusMsg,bool>> handlers { get; private set; }
 242
 243         bool default_handler(WvDbusMsg msg)
 244         {
 245             if (msg == null)
 246                 return false;
 247
 248             if (msg.rserial.HasValue)
 249             {
 250                 Action<WvDbusMsg> raction
 251                     = rserial_to_action.tryget(msg.rserial.Value);
 252                 if (raction != null)
 253                 {
 254                     raction(msg);
 255                     return true;
 256                 }
 257             }
 258
 259             switch (msg.type)
 260             {
 261             case Dbus.MType.Error:
 262                 //TODO: better exception handling
 263                 string errMsg = String.Empty;
 264                 if (msg.signature.StartsWith("s")) {
 265                     errMsg = msg.iter().pop();
 266                 }
 267                 Console.Error.WriteLine
 268                     ("Remote Error: Signature='" + msg.signature
 269                      + "' " + msg.err + ": " + errMsg);
 270                 return true;
 271             case Dbus.MType.Signal:
 272             case Dbus.MType.MethodCall:
 273                 // nothing to do with these by default, so give an error
 274                 if (msg.ReplyExpected)
 275                 {
 276                     var r = msg.err_reply
 277                         ("org.freedesktop.DBus.Error.UnknownMethod",
 278                          "Unknown dbus method '{0}'.'{1}'",
 279                          msg.ifc, msg.method);
 280                     send(r);
 281                 }
 282                 return true;
 283             case Dbus.MType.Invalid:
 284             default:
 285                 throw new Exception("Invalid message received: Dbus.MType='" + msg.type + "'");
 286             }
 287         }
 288
 289         Dictionary<uint,Action<WvDbusMsg>> rserial_to_action
 290             = new Dictionary<uint,Action<WvDbusMsg>>();
 291
 292         // Standard D-Bus monikers:
 293         //   unix:path=whatever,guid=whatever
 294         //   unix:abstract=whatever,guid=whatever
 295         //   tcp:host=whatever,port=whatever
 296         // Non-standard:
 297         //   wv:wvstreams_moniker
 298         internal static WvUrl address_to_url(string s)
 299         {
 300             string[] parts = s.Split(new char[] { ':' }, 2);
 301
 302             if (parts.Length < 2)
 303                 throw new Exception(wv.fmt("No colon found in '{0}'", s));
 304
 305             string method = parts[0];
 306             string user = null, pass = null, host = null, path = null;
 307             int port = 0;
 308
 309             if (method == "wv")
 310                 path = parts[1];
 311             else
 312             {
 313                 foreach (string prop in parts[1].Split(new char[] { ',' }, 2))
 314                 {
 315                     string[] propa = prop.Split(new char[] { '=' }, 2);
 316
 317                     if (propa.Length < 2)
 318                         throw new Exception(wv.fmt("No '=' found in '{0}'",
 319                                                    prop));
 320
 321                     string name = propa[0];
 322                     string value = propa[1];
 323
 324                     if (name == "path")
 325                         path = value;
 326                     else if (name == "abstract")
 327                         path = "@" + value;
 328                     else if (name == "guid")
 329                         pass = value;
 330                     else if (name == "host")
 331                         host = value;
 332                     else if (name == "port")
 333                         port = value.atoi();
 334                     // else ignore it silently; extra properties might be used
 335                     // in newer versions for backward compatibility
 336                 }
 337             }
 338
 339             return new WvUrl(method, user, pass, host, port, path);
 340         }
 341
 342         const string SYSTEM_BUS_ADDRESS
 343             = "unix:path=/var/run/dbus/system_bus_socket";
 344         public static string system_bus_address
 345         {
 346             get {
 347                 string addr = wv.getenv("DBUS_SYSTEM_BUS_ADDRESS");
 348
 349                 if (addr.e())
 350                     addr = SYSTEM_BUS_ADDRESS;
 351
 352                 return addr;
 353             }
 354         }
 355
 356         public static string session_bus_address
 357         {
 358             get {
 359                 return wv.getenv("DBUS_SESSION_BUS_ADDRESS");
 360             }
 361         }
 362
 363         // FIXME: might as well cache this
 364         public static WvDbus session_bus {
 365             get {
 366                 if (session_bus_address.e())
 367                     throw new Exception("DBUS_SESSION_BUS_ADDRESS not set");
 368                 return new WvDbus(session_bus_address);
 369             }
 370         }
 371
 372         WvAutoCast CallDBusMethod(string method)
 373         {
 374             return CallDBusMethod(method, "", new byte[0]);
 375         }
 376
 377         WvAutoCast CallDBusMethod(string method, string param)
 378         {
 379             WvDbusWriter w = new WvDbusWriter();
 380             w.Write(param);
 381
 382             return CallDBusMethod(method, "s", w.ToArray());
 383         }
 384
 385         WvAutoCast CallDBusMethod(string method, string p1, uint p2)
 386         {
 387             WvDbusWriter w = new WvDbusWriter();
 388             w.Write(p1);
 389             w.Write(p2);
 390
 391             return CallDBusMethod(method, "su", w.ToArray());
 392         }
 393
 394         WvAutoCast CallDBusMethod(string method, string sig,
 395                                   byte[] body)
 396         {
 397             var call = new WvDbusCall(DBusName, DBusPath,
 398                                        DBusName, method, sig);
 399             call.Body = body;
 400             var reply = send_and_wait(call);
 401             if (reply.err.ne())
 402             {
 403                 reply.check("IGNORED"); // we know it's an error
 404                 return default(WvAutoCast);
 405             }
 406             else
 407                 return reply.iter().pop();
 408         }
 409
 410         public string GetUnixUserName(string name)
 411         {
 412             return CallDBusMethod("GetConnectionUnixUserName", name);
 413         }
 414
 415         public ulong GetUnixUser(string name)
 416         {
 417             return CallDBusMethod("GetConnectionUnixUser", name);
 418         }
 419
 420         public string GetCert(string name)
 421         {
 422             return CallDBusMethod("GetCert", name);
 423         }
 424
 425         public string GetCertFingerprint(string name)
 426         {
 427             return CallDBusMethod("GetCertFingerprint", name);
 428         }
 429
 430         public RequestNameReply RequestName(string name)
 431         {
 432             return RequestName(name, NameFlag.None);
 433         }
 434
 435         public RequestNameReply RequestName(string name, NameFlag flags)
 436         {
 437             WvAutoCast reply = CallDBusMethod("RequestName", name, (uint)flags);
 438             return (RequestNameReply)(uint)reply;
 439         }
 440
 441         public ReleaseNameReply ReleaseName(string name)
 442         {
 443             return (ReleaseNameReply)(uint)CallDBusMethod("ReleaseName", name);
 444         }
 445
 446         public bool NameHasOwner(string name)
 447         {
 448             return CallDBusMethod("NameHasOwner", name);
 449         }
 450
 451         public StartReply StartServiceByName(string name)
 452         {
 453             return StartServiceByName(name, 0);
 454         }
 455
 456         public StartReply StartServiceByName(string name, uint flags)
 457         {
 458             var retval = CallDBusMethod("StartServiceByName", name, flags);
 459             return (StartReply)(uint)retval;
 460         }
 461
 462         public void AddMatch(string rule)
 463         {
 464             CallDBusMethod("AddMatch", rule);
 465         }
 466
 467         public void RemoveMatch(string rule)
 468         {
 469             CallDBusMethod("RemoveMatch", rule);
 470         }
 471
 472         public string unique_name { get; private set; }
 473     }
 474
 475     // These are here rather than in WvDbusMsg itself so that WvDbusMsg
 476     // can be compiled entirely without knowing about connections.
 477     public static class WvDbusHelpers
 478     {
 479         public static uint send(this WvDbusMsg msg, WvDbus conn)
 480         {
 481             return conn.send(msg);
 482         }
 483
 484         public static uint send(this WvDbusMsg msg, WvDbus conn,
 485                                 Action<WvDbusMsg> replyaction)
 486         {
 487             return conn.send(msg, replyaction);
 488         }
 489
 490         public static WvDbusMsg send_and_wait(this WvDbusMsg msg,
 491                                                  WvDbus conn)
 492         {
 493             return conn.send_and_wait(msg);
 494         }
 495     }
 496 }