static string hexbyte(WvBytes b, int ofs)
{
if (ofs >= b.start && ofs < b.start+b.len)
return b.bytes[ofs].ToString("x2");
else
return " ";
}
public override int read(WvBytes b)
{
if (!ok)
return 0;
try
{
int ret = sock.Receive(b.bytes, b.start, b.len, 0);
if (ret <= 0) // EOF
{
nowrite();
noread();
return 0;
}
else
return ret;
}
catch (SocketException e)
{
if (e.ErrorCode == 10004) // EINTR is normal when non-blocking
return 0;
else if (e.ErrorCode == 10035) // EWOULDBLOCK too
return 0;
else
{
err = e;
// err = new Exception(wv.fmt("Error code {0}\n", e.ErrorCode));
}
return 0;
}
}
public override int write(WvBytes b)
{
if (!ok)
return 0;
try
{
int ret = sock.Send(b.bytes, b.start, b.len, 0);
if (ret < 0) // Unexpected error
{
err = new Exception(wv.fmt("Write error #{0}", ret));
return 0;
}
else
return ret;
}
catch (SocketException e)
{
if (e.ErrorCode == 10004) // EINTR is normal when non-blocking
return 0;
else if (e.ErrorCode == 10035) // EWOULDBLOCK too
return 0;
else
{
err = e;
// err = new Exception(wv.fmt("Error code {0}\n", e.ErrorCode));
}
return 0;
}
}
public WvDbusMsg(WvBytes b)
{
int hlen, blen;
_bytes_needed(b, out hlen, out blen);
wv.assert(b.len == hlen+blen);
SetHeaderData(b);
Body = b.sub(hlen, blen).ToArray();
}
static char printable(WvBytes b, int ofs)
{
if (ofs >= b.start && ofs < b.start+b.len)
{
byte n = b.bytes[ofs];
if (31 < n && n < 127)
return (char)n;
else
return '.';
}
else
return ' ';
}
public static string _hexdump(WvBytes b)
{
if (b.bytes == null)
return "(nil)";
var sb = new StringBuilder();
// This is overly complicated so that the body and header of
// the same buffer can be printed separately yet still show the
// proper alignment
int rowoffset = b.start & (~0xf);
// Note: it's important to set the right capacity when dealing
// with large quantities of data. Assume about 80 chars per line.
sb.EnsureCapacity((b.len / 16 + 2) * 80);
for (int i = rowoffset; i < b.len; i += 16)
{
sb.Append('[').Append(i.ToString("x4")).Append("]");
for (int j = 0; j < 16; j++)
{
if ((j % 4)==0)
sb.Append(' ');
sb.Append(hexbyte(b, i+j));
}
sb.Append(' ');
for (int j = 0; j < 16; j++)
{
if ((j % 4)==0)
sb.Append(' ');
sb.Append(printable(b, i+j));
}
sb.Append('\n');
}
return sb.ToString();
}
public override int read(WvBytes b)
{
lock (readlock)
{
if (in_left > 0)
{
int max = in_left <= b.len ? in_left : b.len;
b.put(0, inbuf.sub(in_ofs, max));
in_ofs += max;
in_left -= max;
if (in_left > 0)
post_readable();
else
start_reading();
return max;
}
else
{
start_reading();
return 0;
}
}
}
protected override void w(WvBytes b)
{
outstr.write(b);
}
public override int read(WvBytes b)
{
if (hasinner)
return inner.read(b);
else
return 0; // 0 bytes read
}
public override int write(WvBytes b)
{
if (!ok) return 0;
try {
inner.BeginWrite(b.bytes, b.start, b.len,
delegate(IAsyncResult ar) {
inner.EndWrite(ar);
inner.Flush();
post_writable();
},
null);
} catch (Exception e) {
err = e;
return 0;
}
return b.len;
}
public override int write(WvBytes b)
{
if (hasinner)
return inner.write(b);
else
return 0; // 0 bytes written
}
public void SetHeaderData(WvBytes data)
{
var it = new WvDbusIter((Dbus.Endian)data[0], "yyyyuua{yv}", data)
.GetEnumerator();
endian = (Dbus.Endian)(byte)it.pop();
type = (Dbus.MType)(byte)it.pop();
flags = (Dbus.MFlag)(byte)it.pop();
it.pop(); // version
it.pop(); // length
serial = it.pop();
foreach (var _f in it.pop())
{
var f = _f.GetEnumerator();
Dbus.Field c = (Dbus.Field)(byte)f.pop();
var v = f.pop();
switch (c)
{
case Dbus.Field.Sender:
sender = v;
break;
case Dbus.Field.Destination:
dest = v;
break;
case Dbus.Field.ReplySerial:
rserial = v;
break;
case Dbus.Field.Signature:
signature = v;
break;
case Dbus.Field.Path:
path = v;
break;
case Dbus.Field.Interface:
ifc = v;
break;
case Dbus.Field.Member:
method = v;
break;
case Dbus.Field.ErrorName:
err = v;
break;
default:
break; // unknown field code, ignore
}
}
}
public virtual int write(WvBytes b)
{
return b.len; // lie: we "wrote" all the bytes to nowhere
}
public override int read(WvBytes b)
{
if (inbuf.used > 0)
{
int max = inbuf.used > b.len ? b.len : inbuf.used;
b.put(0, inbuf.get(max));
post_readable();
return max;
}
else
return base.read(b);
}
protected override void w(WvBytes b)
{
outstr.Write(b.bytes, b.start, b.len);
}
protected abstract void w(WvBytes b);
public override int write(WvBytes b)
{
if (level > maxlevel)
return b.len; // pretend it's written
WvBuf outbuf = new WvBuf();
outbuf.put(b);
recv.writelines(wv.fmt("{0}<{1}>: ", name, levelstr(level)),
outbuf);
return b.len;
}
public override int write(WvBytes b)
{
outbuf.put(b);
flush(0);
// always succeed
return b.len;
}
// Tries to guess how many bytes you'll need into inbuf before you can
// read an entire message. The buffer needs to have at least 16
// bytes before you can start.
static void _bytes_needed(WvBytes b, out int hlen, out int blen)
{
wv.assert(b.len >= 16);
// the real header signature is: yyyyuua{yv}
// However, we only care about the first 16 bytes, and we know
// that the a{yv} starts with an unsigned int that's the number
// of bytes in the array, which is what we *really* want to know.
// So we lie about the signature here.
var it = new WvDbusIter((Dbus.Endian)b[0], "yyyyuuu", b.sub(0,16))
.GetEnumerator();
it.pop();
it.pop();
it.pop();
byte version = it.pop();
if (version < Dbus.Protocol.MinVersion || version > Dbus.Protocol.MaxVersion)
throw new NotSupportedException
("Dbus.Protocol version '"
+ version.ToString() + "' is not supported");
uint _blen = it.pop(); // body length
it.pop(); // serial
uint _hlen = it.pop(); // remaining header length
if (_blen > Int32.MaxValue || _hlen > Int32.MaxValue)
throw new NotImplementedException
("Long messages are not yet supported");
hlen = 16 + Dbus.Protocol.Padded((int)_hlen, 8);
blen = (int)_blen;
}
public static int bytes_needed(WvBytes b)
{
int hlen, blen;
_bytes_needed(b, out hlen, out blen);
return hlen + blen;
}
public static object hexdump(WvBytes b)
{
return new WvDelayedString(() => _hexdump(b));
}
public virtual int read(WvBytes b)
{
return 0;
}
