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; }