dbus-sharp/MessageWriter.cs

   1 // Copyright 2006 Alp Toker <alp@atoker.com>
   2 // This software is made available under the MIT License
   3 // See COPYING for details
   4 //
   5 using System;
   6 using System.Collections;
   7 using System.Collections.Generic;
   8 using System.Text;
   9 using System.IO;
  10 using System.Reflection;
  11
  12 namespace Wv
  13 {
  14     public class MessageWriter
  15     {
  16         EndianFlag endianness;
  17         internal MemoryStream stream;
  18
  19         public Connection connection;
  20
  21         // a default constructor is a bad idea for now as we want to make
  22         // sure the header and content-type match
  23         public MessageWriter() : this (Connection.NativeEndianness) {}
  24
  25         public MessageWriter(EndianFlag endianness)
  26         {
  27             this.endianness = endianness;
  28             stream = new MemoryStream ();
  29         }
  30
  31         public byte[] ToArray()
  32         {
  33             //TODO: mark the writer locked or something here
  34             return stream.ToArray();
  35         }
  36
  37         public void Write(byte val)
  38         {
  39             stream.WriteByte(val);
  40         }
  41
  42         public void Write(bool val)
  43         {
  44             Write ((uint) (val ? 1 : 0));
  45         }
  46
  47         unsafe protected void MarshalUShort(byte *data)
  48         {
  49             WritePad(2);
  50             byte[] dst = new byte[2];
  51
  52             if (endianness == Connection.NativeEndianness) {
  53                 dst[0] = data[0];
  54                 dst[1] = data[1];
  55             }
  56             else {
  57                 dst[0] = data[1];
  58                 dst[1] = data[0];
  59             }
  60
  61             stream.Write(dst, 0, 2);
  62         }
  63
  64         unsafe public void Write(short val)
  65         {
  66             MarshalUShort((byte*)&val);
  67         }
  68
  69         unsafe public void Write(ushort val)
  70         {
  71             MarshalUShort((byte*)&val);
  72         }
  73
  74         unsafe protected void MarshalUInt(byte *data)
  75         {
  76             WritePad(4);
  77             byte[] dst = new byte[4];
  78
  79             if (endianness == Connection.NativeEndianness) {
  80                 dst[0] = data[0];
  81                 dst[1] = data[1];
  82                 dst[2] = data[2];
  83                 dst[3] = data[3];
  84             }
  85             else {
  86                 dst[0] = data[3];
  87                 dst[1] = data[2];
  88                 dst[2] = data[1];
  89                 dst[3] = data[0];
  90             }
  91
  92             stream.Write(dst, 0, 4);
  93         }
  94
  95         unsafe public void Write(int val)
  96         {
  97             MarshalUInt((byte*)&val);
  98         }
  99
 100         unsafe public void Write(uint val)
 101         {
 102             MarshalUInt((byte*)&val);
 103         }
 104
 105         unsafe protected void MarshalULong(byte *data)
 106         {
 107             WritePad (8);
 108             byte[] dst = new byte[8];
 109
 110             if (endianness == Connection.NativeEndianness) {
 111                 for (int i = 0; i < 8; ++i)
 112                     dst[i] = data[i];
 113             }
 114             else {
 115                 for (int i = 0; i < 8; ++i)
 116                     dst[i] = data[7 - i];
 117             }
 118
 119             stream.Write(dst, 0, 8);
 120         }
 121
 122         unsafe public void Write(long val)
 123         {
 124             MarshalULong((byte*)&val);
 125         }
 126
 127         unsafe public void Write (ulong val)
 128         {
 129             MarshalULong((byte*)&val);
 130         }
 131
 132         unsafe public void Write (float val)
 133         {
 134             MarshalUInt((byte*)&val);
 135         }
 136
 137         unsafe public void Write (double val)
 138         {
 139             MarshalULong((byte*)&val);
 140         }
 141
 142         public void Write(string val)
 143         {
 144             byte[] utf8_data = Encoding.UTF8.GetBytes (val);
 145             Write ((uint)utf8_data.Length);
 146             stream.Write (utf8_data, 0, utf8_data.Length);
 147             WriteNull ();
 148         }
 149
 150         public void Write(Signature val)
 151         {
 152             byte[] ascii_data = val.GetBuffer ();
 153
 154             if (ascii_data.Length > Protocol.MaxSignatureLength)
 155                 throw new Exception ("Signature length " + ascii_data.Length + " exceeds maximum allowed " + Protocol.MaxSignatureLength + " bytes");
 156
 157             Write ((byte)ascii_data.Length);
 158             stream.Write (ascii_data, 0, ascii_data.Length);
 159             WriteNull ();
 160         }
 161
 162         public void WriteComplex(object val, Type type)
 163         {
 164             if (type == typeof(void))
 165                 return;
 166
 167             if (type.IsArray) {
 168                 xWriteArray(val, type.GetElementType());
 169             }
 170             else if (type.IsGenericType && (type.GetGenericTypeDefinition () == typeof (IDictionary<,>) || type.GetGenericTypeDefinition () == typeof (Dictionary<,>))) {
 171                 Type[] genArgs = type.GetGenericArguments ();
 172                 System.Collections.IDictionary idict = (System.Collections.IDictionary)val;
 173                 WriteFromDict (genArgs[0], genArgs[1], idict);
 174             }
 175             else if (Mapper.IsPublic (type)) {
 176                 WriteObject (type, val);
 177             }
 178             else if (!type.IsPrimitive && !type.IsEnum) {
 179                 WriteValueType (val, type);
 180             }
 181             else {
 182                 throw new Exception ("Can't write");
 183             }
 184         }
 185
 186         public void Write(Type type, object val)
 187         {
 188             if (type == typeof(void))
 189                 return;
 190
 191             if (type.IsArray) {
 192                 xWriteArray(val, type.GetElementType());
 193             }
 194             else if (type == typeof(Signature)) {
 195                 Write((Signature)val);
 196             }
 197             else if (type == typeof(object)) {
 198                 Write(val);
 199             }
 200             else if (type == typeof(string)) {
 201                 Write((string)val);
 202             }
 203             else if (type.IsGenericType
 204                      && (type.GetGenericTypeDefinition()
 205                            == typeof(IDictionary<,>)
 206                          || type.GetGenericTypeDefinition()
 207                            == typeof(Dictionary<,>))) {
 208                 Type[] genArgs = type.GetGenericArguments();
 209                 IDictionary idict = (IDictionary)val;
 210                 WriteFromDict(genArgs[0], genArgs[1], idict);
 211             }
 212             else if (Mapper.IsPublic(type)) {
 213                 WriteObject(type, val);
 214             }
 215             else if (!type.IsPrimitive && !type.IsEnum) {
 216                 WriteValueType(val, type);
 217             }
 218             else {
 219                 Write(Signature.TypeToDType(type), val);
 220             }
 221         }
 222
 223         //helper method, should not be used as it boxes needlessly
 224         public void Write (DType dtype, object val)
 225         {
 226             switch (dtype)
 227             {
 228             case DType.Byte:
 229                 Write((byte)val);
 230                 break;
 231             case DType.Boolean:
 232                 Write((bool)val);
 233                 break;
 234             case DType.Int16:
 235                 Write((short)val);
 236                 break;
 237             case DType.UInt16:
 238                 Write((ushort)val);
 239                 break;
 240             case DType.Int32:
 241                 Write((int)val);
 242                 break;
 243             case DType.UInt32:
 244                 Write((uint)val);
 245                 break;
 246             case DType.Int64:
 247                 Write((long)val);
 248                 break;
 249             case DType.UInt64:
 250                 Write((ulong)val);
 251                 break;
 252             case DType.Single:
 253                 Write((float)val);
 254                 break;
 255             case DType.Double:
 256                 Write((double)val);
 257                 break;
 258             case DType.String:
 259                 Write((string)val);
 260                 break;
 261             case DType.ObjectPath:
 262                 Write((string)val);
 263                 break;
 264             case DType.Signature:
 265                 Write((Signature)val);
 266                 break;
 267             case DType.Variant:
 268                 Write((object)val);
 269                 break;
 270             default:
 271                 throw new Exception ("Unhandled D-Bus type: " + dtype);
 272             }
 273         }
 274
 275         public void WriteObject(Type type, object val)
 276         {
 277             string path;
 278
 279             BusObject bobj = val as BusObject;
 280
 281             if (bobj == null && val is MarshalByRefObject) {
 282                 bobj = ((MarshalByRefObject)val).GetLifetimeService () as BusObject;
 283             }
 284
 285             if (bobj == null)
 286                 throw new Exception ("No object reference to write");
 287
 288             path = bobj.Path;
 289
 290             Write (path);
 291         }
 292
 293         //variant
 294         public void Write(object val)
 295         {
 296             //TODO: maybe support sending null variants
 297
 298             if (val == null)
 299                 throw new NotSupportedException ("Cannot send null variant");
 300
 301             Type type = val.GetType();
 302
 303             WriteVariant(type, val);
 304         }
 305
 306         public void WriteVariant(Type type, object val)
 307         {
 308             Signature sig = Signature.GetSig(type);
 309             Write(sig);
 310             Write(type, val);
 311         }
 312
 313         //this requires a seekable stream for now
 314         public void xWriteArray(object obj, Type elemType)
 315         {
 316             Array val = (Array)obj;
 317
 318             //TODO: more fast paths for primitive arrays
 319             if (elemType == typeof (byte)) {
 320                 if (val.Length > Protocol.MaxArrayLength)
 321                     throw new Exception ("Array length " + val.Length + " exceeds maximum allowed " + Protocol.MaxArrayLength + " bytes");
 322
 323                 Write ((uint)val.Length);
 324                 stream.Write ((byte[])val, 0, val.Length);
 325                 return;
 326             }
 327
 328             long origPos = stream.Position;
 329             Write ((uint)0);
 330
 331             //advance to the alignment of the element
 332             WritePad(Protocol.GetAlignment (Signature.TypeToDType (elemType)));
 333
 334             long startPos = stream.Position;
 335
 336             foreach (object elem in val)
 337                 Write (elemType, elem);
 338
 339             long endPos = stream.Position;
 340             uint ln = (uint)(endPos - startPos);
 341             stream.Position = origPos;
 342
 343             if (ln > Protocol.MaxArrayLength)
 344                 throw new Exception ("Array length " + ln + " exceeds maximum allowed " + Protocol.MaxArrayLength + " bytes");
 345
 346             Write (ln);
 347             stream.Position = endPos;
 348         }
 349
 350         static byte[] zeroes = new byte[8] { 0,0,0,0,0,0,0,0 };
 351         public void WriteArray<T>(int align,
 352                                   IEnumerable<T> list,
 353                                   Action<MessageWriter,T> doelement)
 354         {
 355             var tmp = new MessageWriter(endianness);
 356
 357             // after the arraylength, we'll be aligned to size 4, but that
 358             // might not be enough, so maybe we need to fix it up.
 359             WritePad(4);
 360
 361             int startpad = (int)(stream.Position+4) % 8;
 362             tmp.stream.Write(zeroes, 0, startpad);
 363
 364             int first = -1;
 365             foreach (T i in list)
 366             {
 367                 tmp.WritePad(align);
 368                 if (first < 0)
 369                     first = (int)tmp.stream.Position;
 370                 doelement(tmp, i);
 371             }
 372
 373             byte[] a = tmp.ToArray();
 374             Write((uint)(a.Length - first));
 375             stream.Write(a, startpad, a.Length - startpad);
 376         }
 377
 378         // not used!
 379         public void WriteDict<K,V>(IDictionary<K,V> dict)
 380         {
 381             WriteArray(8, dict, (w2, i) => {
 382                 w2.Write(i.Key);
 383                 w2.Write(i.Value);
 384             });
 385         }
 386
 387         public void WriteFromDict(Type keyType, Type valType, IDictionary val)
 388         {
 389             long origPos = stream.Position;
 390             Write ((uint)0);
 391
 392             //advance to the alignment of the element
 393             //WritePad (Protocol.GetAlignment (Signature.TypeToDType (type)));
 394             WritePad (8);
 395
 396             long startPos = stream.Position;
 397
 398             foreach (System.Collections.DictionaryEntry entry in val)
 399             {
 400                 WritePad (8);
 401
 402                 Write (keyType, entry.Key);
 403                 Write (valType, entry.Value);
 404             }
 405
 406             long endPos = stream.Position;
 407             uint ln = (uint)(endPos - startPos);
 408             stream.Position = origPos;
 409
 410             if (ln > Protocol.MaxArrayLength)
 411                 throw new Exception ("Dict length " + ln + " exceeds maximum allowed " + Protocol.MaxArrayLength + " bytes");
 412
 413             Write (ln);
 414             stream.Position = endPos;
 415         }
 416
 417         public void WriteValueType(object val, Type type)
 418         {
 419             MethodInfo mi = TypeImplementer.GetWriteMethod (type);
 420             mi.Invoke (null, new object[] {this, val});
 421         }
 422
 423         public void WriteNull()
 424         {
 425             stream.WriteByte(0);
 426         }
 427
 428         public void WritePad(int alignment)
 429         {
 430             int needed = Protocol.PadNeeded ((int)stream.Position, alignment);
 431             for (int i = 0 ; i != needed ; i++)
 432                 stream.WriteByte (0);
 433         }
 434
 435         public delegate void WriterDelegate(MessageWriter w);
 436         public void WriteDelegatePrependSize(WriterDelegate wd, int alignment)
 437         {
 438             WritePad(4);
 439
 440             long sizepos = stream.Position;
 441
 442             Write((int)0);
 443
 444             WritePad(alignment);
 445
 446             long counter = stream.Position;
 447
 448             wd(this);
 449
 450             long endpos = stream.Position;
 451
 452             stream.Position = sizepos;
 453             Write((int)(endpos-counter));
 454
 455             stream.Position = endpos;
 456         }
 457     }
 458 }