Example #1
0
        private int ReadStruct(Udbus.Serialization.UdbusMessageReader reader, out Udbus.Containers.dbus_union variantStruct)
        {
            int result = 0;

            if (this.objectDelegate == null) // If no fields
            {
                variantStruct = null;
            }    // Ends if no fields
            else // Else fields
            {
                object[] structFields;
                result = this.ReadStruct(reader, out structFields);

                if (result == 0) // If started struct
                {
                    // Todo - instantiate the thing which holds onto the field types.
                    // Basically this is our existing container but with object[] instead of dbus_union[]
                    variantStruct = Udbus.Containers.dbus_union.CreateStruct(structFields, this.parent.Types.ToArray());
                }    // Ends if started struct
                else // Else failed to start struct
                {
                    variantStruct = null;
                } // Ends else failed to start struct
            }     // Ends else fields

            return(result);
        }
Example #2
0
        private int ReadDictionaryObject(Udbus.Serialization.UdbusMessageReader reader, out object objDict)
        {
            Dictionary <object, object> dict;
            int result = this.ReadDictionary(reader, out dict);

            objDict = dict;
            return(result);
        }
Example #3
0
        private int ReadDictionary(Udbus.Serialization.UdbusMessageReader reader, out Udbus.Containers.dbus_union variantDict)
        {
            Dictionary <object, object> dict;
            int result = this.ReadDictionary(reader, out dict);

            variantDict = Udbus.Containers.dbus_union.Create(dict, this.owner.Types.ToArray());
            return(result);
        }
Example #4
0
        private int ReadDictionary(Udbus.Serialization.UdbusMessageReader reader, out Dictionary <object, object> dict)
        {
            IDictionary <object, object> idict;
            int result = reader.MarshalDict(this.ObjectDelegateKey, this.ObjectDelegateValue, out idict);

            dict = new Dictionary <object, object>(idict);
            return(result);
        }
Example #5
0
        private int ReadArrayObject(Udbus.Serialization.UdbusMessageReader reader, out Udbus.Containers.dbus_union variantArray)
        {
            object[] output;
            int      result = reader.MarshalEnumerable(this.ObjectDelegate, this.Type, out output);

            variantArray = Udbus.Containers.dbus_union.Create(output, this.owner.Types.ToArray());
            return(result);
        }
Example #6
0
        private int ReadArrayObject(Udbus.Serialization.UdbusMessageReader reader, out object objDict)
        {
            object[] output;
            int      result = reader.MarshalEnumerable(this.ObjectDelegate, this.Type, out output);

            objDict = output;
            return(result);
        }
Example #7
0
        private int ReadStruct(Udbus.Serialization.UdbusMessageReader reader, out object[] structFields)
        {
            int result = 0;

            if (this.objectDelegate == null) // If no fields
            {
                structFields = null;
            }    // Ends if no fields
            else // Else fields
            {
                result = reader.ReadStructureStart();

                if (result == 0) // If started struct
                {
                    // Yay casting something to what we already know it is because, yeah, that's how this works...
                    System.Delegate[] delegates = this.objectDelegate.GetInvocationList();
                    object[]          fields    = new object[delegates.Length];

                    int i = 0;
                    foreach (MarshalReadDelegate <object> fn in delegates)
                    {
                        result = fn(reader, out fields[i]);

                        if (result != 0) // If failed to read result
                        {
                            break;
                        } // Ends if failed to read result

                        ++i;
                    } // Ends loop over delegates

                    if (result == 0) // If read fields
                    {
                        result = reader.ReadStructureEnd();

                        if (result != 0) // If struct end failed
                        {
                            structFields = null;
                        }    // Ends if struct end failed
                        else // Else struct end ok
                        {
                            structFields = fields;
                        } // Ends else struct end ok
                    }     // Ends if read read fields
                    else  // Else failed to read fields
                    {
                        structFields = null;
                    } // Ends if failed to read fields
                }     // Ends if started struct
                else  // Else failed to start struct
                {
                    structFields = null;
                } // Ends else failed to start struct
            }     // Ends else fields

            return(result);
        }
Example #8
0
        //public delegate int HelloRecvDelegate(out string name, uint serial, Udbus.Serialization.DbusConnectionParameters connectionParametersDbus);

        public static Udbus.Serialization.UdbusConnector.HelloRecvDelegate MakeHelloRecvDelegate(DbusMessageReceiverPool receiverPool)
        {
            return((out string name, Udbus.Serialization.UdbusConnector connector, uint serial, Udbus.Serialization.DbusConnectionParameters connectionParametersDbus) =>
            {
                name = default(string);

                int result;
                Udbus.Core.UdbusMessagePair msgResp = default(Udbus.Core.UdbusMessagePair);
                try
                {
                    msgResp = receiverPool.ReceiveMessageData(connector, serial, out result);
                    if (((result == 0) &&
                         (msgResp.QuEmpty == false)))
                    {
                        if ((msgResp.Data.typefield.type == Udbus.Types.dbus_msg_type.DBUS_TYPE_ERROR))
                        {
                            throw Udbus.Serialization.Exceptions.UdbusMessageMethodErrorException.Create("Hello", connectionParametersDbus, msgResp.Data);
                        }
                        else
                        {
                            Udbus.Serialization.UdbusMessageReader reader = new Udbus.Serialization.UdbusMessageReader(msgResp.Handle);
                            if ((result == 0))
                            {
                                string nameResult;
                                result = Udbus.Serialization.UdbusMessageReader.ReadString(reader, out nameResult);
                                if ((result == 0))
                                {
                                    name = nameResult;
                                }
                                else
                                {
                                    throw Udbus.Serialization.Exceptions.UdbusMessageMethodArgumentOutException.Create(1, "name", typeof(string), result, "Hello", connectionParametersDbus, msgResp.Data);
                                }
                            }
                            else
                            {
                                throw Udbus.Serialization.Exceptions.UdbusMessageMethodArgumentOutException.Create(0, "UnknownParameters", typeof(Udbus.Serialization.Exceptions.UdbusMessageMethodArgumentException.UnknownParameters), result, "Hello", connectionParametersDbus, msgResp.Data);
                            }
                        }
                    }
                    else
                    {
                        throw Udbus.Serialization.Exceptions.UdbusMethodReceiveException.Create("Hello", result, connectionParametersDbus);
                    }
                }
                finally
                {
                    if ((msgResp.QuEmpty == false))
                    {
                        msgResp.Dispose();
                    }
                }

                return result;
            });
        }
Example #9
0
        // The object returned from a struct read is always a variant...
        private int ReadStructObject(Udbus.Serialization.UdbusMessageReader reader, out object objStruct)
        {
            //Udbus.Containers.dbus_union variantStruct;
            //int result = this.ReadStruct(reader, out variantStruct);
            object[] structFields;
            int      result = this.ReadStruct(reader, out structFields);

            if (result != 0) // If failed to read struct
            {
                objStruct = null;
            }    // Ends if failed to read struct
            else // Else read struct
            {
                //objStruct = variantStruct;
                objStruct = structFields;
            } // Ends else read struct

            return(result);
        }
        static void Foo()
        {
            //public delegate int MarshalReadDelegate<T>(Udbus.Serialization.UdbusMessageReader reader, out T t); // This would actually probably be better, despite sample code.
            //public delegate T MarshalReadResultDelegate<T>(Udbus.Serialization.UdbusMessageReader reader, out int result);
            //public static int ReadString(UdbusMessageReader reader, out string value)
            Udbus.Serialization.MarshalReadDelegate<string> ds = Udbus.Serialization.UdbusMessageReader.ReadString;
            Udbus.Serialization.MarshalReadDelegate<Udbus.Containers.dbus_union> dvbool = Udbus.Serialization.UdbusMessageReader.ReadVariantBoolean;
            Udbus.Serialization.MarshalReadDelegate<Udbus.Containers.dbus_union> dvbyte = Udbus.Serialization.UdbusMessageReader.ReadVariantByte;
            //Udbus.Core.MarshalReadDelegate<Udbus.Containers.dbus_union> dvmulti = new Udbus.Core.MarshalReadDelegate<Udbus.Containers.dbus_union>();
            //dvmulti += dvbool;
            //dvmulti += dvbyte;

            Udbus.Serialization.UdbusMessageReader reader = new Udbus.Serialization.UdbusMessageReader(null);
            Udbus.Containers.dbus_union u1 = new Udbus.Containers.dbus_union();
            reader.ReadVariantByte(u1);
            reader.ReadVariantByte(out u1);

            MarshalEventTest met = new MarshalEventTest();
            met.foo += dvbool;
            met.foo += dvbyte;
            met.Dude(reader, out u1);
        }
        public override void onSignal(UdbusMessagePair messageData)
        {
            const string StorageSpaceLow = "storage_space_low";

            if (messageData.Data.method.StartsWith(StorageSpaceLow))
            {
                Udbus.Serialization.UdbusMessageReader reader = new Udbus.Serialization.UdbusMessageReader(messageData.Handle);
                Int32 percentage = 0;
                int   result     = reader.ReadInt32(out percentage);
                if (result != 0)
                {
                    this.dumpError(messageData, "Reading percentage from storage space low signal");
                }
                else
                {
                    this.dumpStuff(messageData, string.Format("Signal. Left {0}%", percentage));
                }
            }
            else
            {
                base.onSignal(messageData);
            }
        }
        static void TestVariantSubArrays()
        {
            //Udbus.Containers.dbus_union uTop = null;

            Udbus.Serialization.UdbusMessageReader reader = new Udbus.Serialization.UdbusMessageReader(null);
            //object o;
            //reader.ReadString(out o);
        }
        static void TestReadWriteVariantStruct()
        {
            using (Udbus.Core.MockStoreUdbusTransport transport = new Udbus.Core.MockStoreUdbusTransport())
            {
                //Udbus.Serialization.UdbusConnector connector = Udbus.Serialization.UdbusConnector.CreateAuthorised(transport);
                Udbus.Serialization.UdbusConnector connector = new Udbus.Serialization.UdbusConnector(transport);
                Udbus.Serialization.UdbusMessageBuilderTracker builder = new Udbus.Serialization.UdbusMessageBuilderTracker();

                Udbus.Core.IUdbusMessageVisitor visitor = new Udbus.Core.UdbusMessageVisitorDumpXen();
                Udbus.Core.IUdbusMessageVisitor visitorTrack = new Udbus.Core.UdbusMessageVisitorFind(builder);
                Udbus.Core.IUdbusMessageVisitor visitors = new Udbus.Core.UdbusMessageVisitorMulti(visitor, visitorTrack);

                int result;
                using (var msg = builder.UdbusMethodMessage(
                                    "org.freedesktop.DBus", "/org/freedesktop/DBus",
                                    "org.freedesktop.DBus", "VariantStructMessage").Message)
                {
                    Udbus.Types.dbus_sig signature = Udbus.Types.dbus_sig.Initialiser;
                    signature.a[0] = Udbus.Types.dbus_type.DBUS_SIGNATURE;
                    signature.a[1] = Udbus.Types.dbus_type.DBUS_INVALID;
                    // As it happens these struct fields will double as dictionary entries...
                    object[] structFields = new object[] { 1, new object[] {"one", true } };

                    Udbus.Containers.dbus_union variantStruct = Udbus.Containers.dbus_union.CreateStruct(structFields,
                        new Udbus.Types.dbus_type[] {
                            Udbus.Types.dbus_type.DBUS_STRUCT_BEGIN,
                            Udbus.Types.dbus_type.DBUS_INT32,
                            Udbus.Types.dbus_type.DBUS_STRUCT_BEGIN,
                            Udbus.Types.dbus_type.DBUS_STRING,
                            Udbus.Types.dbus_type.DBUS_BOOLEAN,
                            Udbus.Types.dbus_type.DBUS_STRUCT_END,
                            Udbus.Types.dbus_type.DBUS_STRUCT_END,
                            Udbus.Types.dbus_type.DBUS_INVALID
                        }
                    );

                    builder.SetSignature(ref signature)
                        .BodyAdd(4096);
                    builder
                        .BodyAdd_Variant(variantStruct)
                    ;
                    result = connector.Send(msg);
                    Console.WriteLine("VariantStructMessage send result: {0}", result);
                }

                using (var msg = connector.ReceiveHandle(out result))
                {
                    Console.WriteLine("VariantStructMessage recv result: {0}. msg: {1}", result, msg);
                    if (result == 0) // If got message ok
                    {
                        Udbus.Core.UdbusMessagePair messageData = new Udbus.Core.UdbusMessagePair(msg);
                        Udbus.Serialization.UdbusMessageReader reader = new Udbus.Serialization.UdbusMessageReader(msg);

                        Udbus.Core.UdbusVisitorFunctions.Visit(result, msg, visitor);
                        Udbus.Containers.dbus_union variantReadStruct = reader.ReadVariant();
                        Console.WriteLine(string.Format("variantReadStruct: {0}", variantReadStruct.ToString()));

                    } // Ends if message ok
                } // Ends using receive message
            } // Ends using transport
        }
        static void TestReadWriteString()
        {
            using (Udbus.Core.MockStoreUdbusTransport transport = new Udbus.Core.MockStoreUdbusTransport())
            {
                //Udbus.Serialization.UdbusConnector connector = Udbus.Serialization.UdbusConnector.CreateAuthorised(transport);
                Udbus.Serialization.UdbusConnector connector = new Udbus.Serialization.UdbusConnector(transport);
                Udbus.Serialization.UdbusMessageBuilderTracker builder = new Udbus.Serialization.UdbusMessageBuilderTracker();

                Udbus.Core.IUdbusMessageVisitor visitor = new Udbus.Core.UdbusMessageVisitorDumpXen();
                Udbus.Core.IUdbusMessageVisitor visitorTrack = new Udbus.Core.UdbusMessageVisitorFind(builder);
                Udbus.Core.IUdbusMessageVisitor visitors = new Udbus.Core.UdbusMessageVisitorMulti(visitor, visitorTrack);

                int result;
                using (var msg = builder.UdbusMethodMessage(
                                    "org.freedesktop.DBus", "/org/freedesktop/DBus",
                                    "org.freedesktop.DBus", "NotARealMessage").Message)
                {
                    Udbus.Types.dbus_sig signature = Udbus.Types.dbus_sig.Initialiser;
                    signature.a[0] = Udbus.Types.dbus_type.DBUS_STRING;
                    signature.a[1] = Udbus.Types.dbus_type.DBUS_INVALID;
                    builder.SetSignature(ref signature)
                        .BodyAdd(4096)
                        .BodyAdd_String("param1")
                    ;
                    result = connector.Send(msg);
                    Console.WriteLine("NotARealMessagesend result: {0}", result);
                }

                using (var msg = connector.ReceiveHandle(out result))
                {
                    Console.WriteLine("NotARealMessage recv result: {0}. msg: {1}", result, msg);
                    if (result == 0) // If got message ok
                    {
                        Udbus.Core.UdbusMessagePair messageData = new Udbus.Core.UdbusMessagePair(msg);
                        Udbus.Serialization.UdbusMessageReader reader = new Udbus.Serialization.UdbusMessageReader(msg);

                        Udbus.Core.UdbusVisitorFunctions.Visit(result, msg, visitor);
                        //Udbus.Core.UdbusVisitorFunctions.Visit(result, msg, visitor);
                        string param1 = reader.ReadString();
                        Console.WriteLine(string.Format("Param1: {0}", param1));

                    } // Ends if message ok
                } // Ends using receive message
            } // Ends using transport
        }
        static void TestDbusReadIcon(Udbus.Serialization.UdbusMessageBuilderTracker builder, Udbus.Core.IUdbusMessageVisitor visitor, Udbus.Serialization.UdbusConnector connector,
            System.Threading.ManualResetEvent stop, PreNextActionDelegate preNextAction)
        {
            int result = -1;
            //Udbus.v4v.v4vConnection connection = new Udbus.v4v.v4vConnection(Console_io_debug);
            //Udbus.Serialization.ManagedDbusIo dbio;
            //connection.PopulateDbio(ref dbio);

            //Udbus.Core.UdbusFunctions.dbus_auth(ref dbio, "Dude");
            //Udbus.Serialization.UdbusConnector connector = Udbus.Serialization.UdbusConnector.CreateAuthorised(connection);

            // Visitors
            preNextAction("readicon");

            // list_vms.
            using (var msg = builder.UdbusMethodMessage(
                "com.citrix.xenclient.xenmgr", "/",
                "com.citrix.xenclient.xenmgr",
                "list_vms").Message)
            {
                result = connector.Send(msg);
                Console.WriteLine("list_vms send result: {0}", result);
            }
            Udbus.Serialization.NMessageStruct.UdbusMessageHandle recv;
            using (var msg = Udbus.Core.UdbusVisitorFunctions.LoopUdbusFind(connector, visitor, Console.Out, stop).Handle)
            {
                msg.HandleToStructure(out recv);
                Console.WriteLine("list_vms recv result: {0}. msg: {1}", result, recv);

                Udbus.Serialization.UdbusMessageReader reader = new Udbus.Serialization.UdbusMessageReader(msg);
                uint counter = 0;

                foreach (Udbus.Serialization.UdbusMessageReader subreader in reader.ArrayReader(Udbus.Types.dbus_type.DBUS_OBJECTPATH))
                {
                    Udbus.Types.UdbusObjectPath op;
                    result = subreader.ReadObjectPath(out op);
                    if (result != 0)
                    {
                        Console.WriteLine("Error ! {0:d}/0x{0:x8}", result);
                    }
                    else
                    {
                        Console.WriteLine(" {0}", op);

                        using (var msgVm = builder.UdbusMethodMessage(
                            "com.citrix.xenclient.xenmgr", op.Path,
                            "com.citrix.xenclient.xenmgr.vm",
                            "read_icon").Message)
                        {
                            result = connector.Send(msgVm);
                            Console.WriteLine("read_icon send result: {0}", result);

                        }
                        if (result == 0)
                        {
                            Udbus.Serialization.NMessageStruct.UdbusMessageHandle recvVm;
                            using (var msgVm = Udbus.Core.UdbusVisitorFunctions.LoopUdbusFind(connector, visitor, Console.Out, stop).Handle)
                            {
                                if (msgVm == null)
                                {
                                    Console.WriteLine("read_icon failed");
                                }
                                else
                                {
                                    msgVm.HandleToStructure(out recvVm);
                                    Console.WriteLine("read_icon result: {0}. msg: {1}", result, recvVm);

                                    Udbus.Serialization.UdbusMessageReader readerVm = new Udbus.Serialization.UdbusMessageReader(msgVm);
                                    Console.WriteLine("Icon bytes:");
                                    uint byteCounter = 0;

                                    foreach (Udbus.Serialization.UdbusMessageReader subreaderIcon in readerVm.ArrayReader(Udbus.Types.dbus_type.DBUS_BYTE))
                                    {
                                        byte b;
                                        result = subreaderIcon.ReadByte(out b);
                                        if (result != 0)
                                        {
                                            Console.WriteLine("Error ! {0:d}/0x{0:x8}", result);
                                            break;
                                        }
                                        else
                                        {
                                            //Console.Write(b);
                                            ++byteCounter;
                                        }
                                    }
                                    Console.WriteLine("Total: {0} bytes", byteCounter);
                                    Console.WriteLine();

                                } // Ends else read_icon succeeded
                            } // Ends read_icon response
                        }
                    }
                    Console.WriteLine("Entry {0:d2}: {1}", counter++, op);
                }
            } // Ends using ListVms response
        }
        static void TestDbusGetPropertyImpl(Udbus.Serialization.UdbusMessageBuilderTracker builder, Udbus.Core.IUdbusMessageVisitor visitor, Udbus.Serialization.UdbusConnector connector,
            System.Threading.ManualResetEvent stop, PreNextActionDelegate preNextAction)
        {
            preNextAction("GetProperty");
            int result;
            Udbus.Serialization.NMessageStruct.UdbusMessageHandle recv;

            using (var msg = builder.UdbusMethodMessage(
                "com.citrix.xenclient.xenmgr", "/",
                "org.freedesktop.DBus.Properties", "Get").Message)
            {
                Udbus.Types.dbus_sig signature = Udbus.Types.dbus_sig.Initialiser;
                signature.a[0] = Udbus.Types.dbus_type.DBUS_STRING;
                signature.a[1] = Udbus.Types.dbus_type.DBUS_STRING;
                signature.a[2] = Udbus.Types.dbus_type.DBUS_INVALID;
                builder.SetSignature(ref signature)
                    .BodyAdd(4096)
                    .BodyAdd_String("com.citrix.xenclient.xenmgr.config")
                    .BodyAdd_String("iso-path")
                ;
                result = connector.Send(msg);
                Console.WriteLine("GetProperty send result: {0}", result);
                Udbus.Core.UdbusVisitorFunctions.Visit(result, msg, new Udbus.Core.UdbusMessageVisitorDumpConsole());
            }
            try
            {
                Udbus.Core.UdbusMessagePair recvData = Udbus.Core.UdbusVisitorFunctions.LoopUdbusFind(connector, visitor, Console.Out, stop);
                if (!recvData.QuEmpty)
                {
                    recv = recvData.Data;
                    if (recv.typefield.type != Udbus.Types.dbus_msg_type.DBUS_TYPE_ERROR)
                    {
                        Udbus.Serialization.UdbusMessageReader reader = new Udbus.Serialization.UdbusMessageReader(recvData.Handle);
                        do
                        {
            #if !READASVARIANT
                            var variant = reader.ReadVariantValue(out result);
                            Console.WriteLine("iso_path: {0}", variant.ToString());
                            //Udbus.Parsing.BuildContext context = new Udbus.Parsing.BuildContext(new Udbus.Parsing.CodeTypeNoOpHolder());
                            //Udbus.Serialization.Variant.UdbusVariantIn variantIn = new Udbus.Serialization.Variant.UdbusVariantIn(reader);
                            //Udbus.Parsing.IDLArgumentTypeNameBuilderBase nameBuilder = new Udbus.Parsing.IDLArgumentTypeNameBuilderNoOp();
                            //Udbus.Types.dbus_sig sig = Udbus.Types.dbus_sig.Initialiser;
                            //result = reader.ReadSignature(ref sig);
                            //Udbus.Parsing.CodeBuilderHelper.BuildCodeParamType(variantIn, nameBuilder, sig.a, context);
                            //Console.WriteLine("iso_path: {0}", variantIn.Variant.ToString());

            #else // !READASVARIANT
                        Udbus.Types.dbus_sig sig = Udbus.Types.dbus_sig.Initialiser;
                        result = reader.ReadSignature(ref sig);
                        if (result != 0)
                        {
                            Console.WriteLine("Error reading property variant signature: {0}", result);
                            break;
                        }
                        string isopath;
                        result = reader.ReadString(out isopath);
                        if (result != 0)
                        {
                            Console.WriteLine("Error reading property variant string: {0}", result);
                            break;
                        }

                        Console.WriteLine("iso_path: {0}", isopath);
            #endif // READASVARIANT
                        } while (false);
                    }
                }
                else
                {
                    Console.WriteLine("Getting the property failed. Boooooo ");
                }
            }
            catch (System.Runtime.InteropServices.SEHException seh)
            {
                Console.WriteLine("Error: " + seh.ToString());
            }
        }
        static Udbus.Serialization.UdbusConnector TestDbusCalls(Udbus.Serialization.IUdbusTransport connection, PreNextActionDelegate preNextAction)
        {
            //int result = -1;
            System.Threading.ManualResetEvent stop = new System.Threading.ManualResetEvent(false);
            //Udbus.v4v.v4vConnection connection = new Udbus.v4v.v4vConnection(Console_io_debug);
            //Udbus.Serialization.ManagedDbusIo dbio;
            //connection.PopulateDbio(ref dbio);

            //Udbus.Core.UdbusFunctions.dbus_auth(ref dbio, "Dude");
            Udbus.Serialization.UdbusConnector connector = Udbus.Serialization.UdbusConnector.CreateAuthorised(connection);

            Udbus.Serialization.UdbusMessageBuilderTracker builder = new Udbus.Serialization.UdbusMessageBuilderTracker();

            // Visitors
            Udbus.Core.IUdbusMessageVisitor visitor = new Udbus.Core.UdbusMessageVisitorDumpXen();
            Udbus.Core.IUdbusMessageVisitor visitorTrack = new Udbus.Core.UdbusMessageVisitorFind(builder);
            Udbus.Core.IUdbusMessageVisitor visitors = new Udbus.Core.UdbusMessageVisitorMulti(visitor, visitorTrack);

            // Udbus.Serialization.NMessageStruct.UdbusMessageHandle recv;

            //preNextAction("Hello");

            //// Hello.
            //using (var msg = builder.UdbusMethodMessage(
            //                    "org.freedesktop.DBus", "/org/freedesktop/DBus",
            //                    "org.freedesktop.DBus", "Hello").Message)
            //{
            //    result = connector.Send(msg);
            //    Console.WriteLine("Hello send result: {0}", result);
            //}
            ////var recv = connector.Receive(out result);
            //result = connector.ReceiveStruct(out recv);
            //Console.WriteLine("Hello recv result: {0}. msg: {1}", result, recv);
            TestDbusHelloImpl(builder, visitors, connector, stop, preNextAction);

            // Get property.
            //TestDbusGetPropertyImpl(builder, visitors, connector, stop, preNextAction);

            #if _LISTVMS
            preNextAction("List VMs");

            using (var msg = builder.UdbusMethodMessage(
                "com.citrix.xenclient.xenmgr", "/",
                "com.citrix.xenclient.xenmgr",
                "list_vms").Message)
            {
                result = connector.Send(msg);
                Console.WriteLine("list_vms send result: {0}", result);
            }
            using (var msg = Udbus.Core.UdbusVisitorFunctions.LoopUdbusFind(connector, visitors, Console.Out, stop).Handle)
            {
                msg.HandleToStructure(out recv);
                Console.WriteLine("list_vms recv result: {0}. msg: {1}", result, recv);

                Udbus.Serialization.UdbusMessageReader reader = new Udbus.Serialization.UdbusMessageReader(msg);
                uint counter = 0;

                foreach (Udbus.Serialization.UdbusMessageReader subreader in reader.ArrayReader(Udbus.Types.dbus_type.DBUS_OBJECTPATH))
                {
                    Udbus.Types.UdbusObjectPath op;
                    result = subreader.ReadObjectPath(out op);
                    if (result != 0)
                    {
                        Console.WriteLine("Error ! {0:d}/0x{0:x8}", result);
                    }
                    Console.WriteLine("Entry {0:d2}: {1}", counter++, op);
                }
            } // Ends using ListNames response

            #endif // _LISTVMS

            // These days GetAllProperties tends to be blocked by firewall
            #if _GETALLPROPERTIES
            preNextAction("GetAllProperties");
            using (var msg = builder.UdbusMethodMessage(
                "com.citrix.xenclient.xenmgr", "/",
                "org.freedesktop.DBus.Properties", "GetAll").Message)
            {
                Udbus.Types.dbus_sig signature = Udbus.Types.dbus_sig.Initialiser;
                signature.a[0] = Udbus.Types.dbus_type.DBUS_STRING;
                signature.a[1] = Udbus.Types.dbus_type.DBUS_INVALID;
                builder.SetSignature(ref signature)
                    .BodyAdd(4096)
                    .BodyAdd_String("com.citrix.xenclient.xenmgr.config")
                ;
                result = connector.Send(msg);
                Console.WriteLine("GetAllProperties send result: {0}", result);
            }
            try
            {
                Udbus.Core.UdbusMessagePair recvData = Udbus.Core.UdbusVisitorFunctions.LoopUdbusFind(connector, visitors, Console.Out, stop);
                recv = recvData.Data;
                if (recv.typefield.type != Udbus.Types.dbus_msg_type.DBUS_TYPE_ERROR)
                {
                    Udbus.Serialization.UdbusMessageReader reader = new Udbus.Serialization.UdbusMessageReader(recvData.Handle);
                    do
                    {
            #if !READASVARIANT
                        Udbus.Parsing.BuildContext context = new Udbus.Parsing.BuildContext(new Udbus.Parsing.CodeTypeNoOpHolder());
                        Udbus.Serialization.Variant.UdbusVariantIn variantIn = new Udbus.Serialization.Variant.UdbusVariantIn();
                        Udbus.Parsing.IDLArgumentTypeNameBuilderBase nameBuilder = new Udbus.Parsing.IDLArgumentTypeNameBuilderNoOp();
                        // It's a dictionary of strings -> variants.
                        //IDictionary<string, Udbus.Containers.dbus_union> properties;
                        IEnumerable<KeyValuePair<string, Udbus.Containers.dbus_union>> properties;
                        reader.MarshalDict(Udbus.Serialization.UdbusMessageReader.ReadString,
                            Udbus.Serialization.UdbusMessageReader.ReadVariant,
                            out properties);
                        //Udbus.Types.dbus_sig sig = Udbus.Types.dbus_sig.Initialiser;
                        //result = reader.ReadSignature(ref sig);
                        //Udbus.Parsing.CodeBuilderHelper.BuildCodeParamType(variantIn, nameBuilder, sig.a, context);
                        foreach (KeyValuePair<string, Udbus.Containers.dbus_union> entry in properties)
                        {
                            Console.WriteLine("{0} => {1}", entry.Key, entry.Value.ToString());
                        }

            #else // !READASVARIANT
                        Udbus.Types.dbus_sig sig = Udbus.Types.dbus_sig.Initialiser;
                        result = reader.ReadSignature(ref sig);
                        if (result != 0)
                        {
                            Console.WriteLine("Error reading property variant signature: {0}", result);
                            break;
                        }
                        string isopath;
                        result = reader.ReadString(out isopath);
                        if (result != 0)
                        {
                            Console.WriteLine("Error reading property variant string: {0}", result);
                            break;
                        }

                        Console.WriteLine("iso_path: {0}", isopath);
            #endif // READASVARIANT
                    } while (false);
                }
                else
                {
                    Console.WriteLine("Getting the property failed. Boooooo ");
                }
            }
            catch (System.Runtime.InteropServices.SEHException seh)
            {
                Console.WriteLine("Error: " + seh.ToString());
            }
            #endif //_GETALLPROPERTIES

            #if _LISTNAMES
            preNextAction("ListNames");

            // List Names.
            using (var msg = builder.UdbusMethodMessage(
                "org.freedesktop.DBus", "/org/freedesktop/DBus",
                "org.freedesktop.DBus", "ListNames").Message)
            {
                result = connector.Send(msg);
                Console.WriteLine("ListNames send result: {0}", result);
            }

            //result = connector.ReceiveStruct(out recv);
            //Console.WriteLine("ListNames recv result: {0}. msg: {1}", result, recv);

            //using (var msg = connector.ReceiveHandle(out result))
            using(var msg = Udbus.Core.UdbusVisitorFunctions.LoopUdbusFind(connector, visitors, Console.Out, stop).Handle)
            {
                //result = connector.ReceiveStruct(out recv);
                msg.HandleToStructure(out recv);
                Console.WriteLine("ListNames recv result: {0}. msg: {1}", result, recv);

                Udbus.Serialization.UdbusMessageReader reader = new Udbus.Serialization.UdbusMessageReader(msg);
                uint counter = 0;

                foreach (Udbus.Serialization.UdbusMessageReader subreader in reader.ArrayReader(Udbus.Types.dbus_type.DBUS_STRING))
                {
                    string name = subreader.ReadStringValue(out result);
                    if (result != 0)
                    {
                        Console.WriteLine("Error ! {0:d}/0x{0:x8}", result);
                    }
                    Console.WriteLine("Entry {0:d2}: {1}", counter++, name);
                }
            } // Ends using ListNames response
            #endif // _LISTNAMES

            // read_icon
            TestDbusReadIcon(builder, visitors, connector, stop, preNextAction);

            #if _GETSIGNAL
            preNextAction("AddMatch");

            // AddMatch for signal.
            using (var msg = builder.UdbusMethodMessage(
                "org.freedesktop.DBus", "/org/freedesktop/DBus",
                "org.freedesktop.DBus", "AddMatch").Message)
            {
                Udbus.Types.dbus_sig signature = Udbus.Types.dbus_sig.Initialiser;
                signature.a[0] = Udbus.Types.dbus_type.DBUS_STRING;
                signature.a[1] = Udbus.Types.dbus_type.DBUS_INVALID;
                builder.SetSignature(ref signature)
                    .BodyAdd(4096)
                    .BodyAdd_String("type='signal',interface='com.citrix.xenclient.xenmgr.host',member='storage_space_low'")
                    //.BodyAdd_String("type='signal',interface='com.citrix.xenclient.xenmgr.host'")
                ;
                result = connector.Send(msg);
                Console.WriteLine("AddMatch send result: {0}", result);

            }

            preNextAction("LoopSignals");

            // Handle signals and other bits of magic.
            //Console.TreatControlCAsInput = true;
            Console.CancelKeyPress += delegate(Object sender, ConsoleCancelEventArgs consoleargs)
            {
                consoleargs.Cancel = true;
                Console.WriteLine("Setting stop event...");
                stop.Set();
                connection.Cancel();
            };

            try
            {
                Udbus.Core.UdbusVisitorFunctions.LoopUdbus(connector, visitor, Console.Out, stop);
            }
            catch (System.Runtime.InteropServices.SEHException seh)
            {
                Console.WriteLine("Error: " + seh.ToString());
            }
            #endif // _GETSIGNAL

            #if HAVESOMECCODE
            r = 0;
            msg = NULL;
            msg = dbus_msg_new_method_call(serial++,
            "org.freedesktop.DBus", "/org/freedesktop/DBus",
            "org.freedesktop.DBus", "AddMatch");
            if (!msg) {
            dio.io_debug(dio.logpriv, "Unable to create method message for AddMatch\n");
            exit(1);
            }
            MessageInfo::dumpMethodSend(&io_debug, msg);
            dbus_sig signature;
            signature.a[0] = DBUS_STRING;
            signature.a[1] = DBUS_INVALID;
            dbus_msg_set_signature(msg, &signature);
            dbus_msg_body_add(msg, 4096);
            //r |= dbus_msg_body_add_string(msg, "type='signal',interface='com.citrix.xenclient.xenmgr.host'");
            //r |= dbus_msg_body_add_string(msg, "type='method_call'");
            r |= dbus_msg_body_add_string(msg, "type='signal',interface='com.citrix.xenclient.xenmgr.host'");
            r |= dbus_msg_send(&dio, msg);

            loop_dbus(dio, visitor);
            #endif // HAVESOMECCODE
            Console.WriteLine("Press <ENTER> to end connection");
            Console.ReadLine();

            return connector;
        }