private ErlAbstractConnection(ErlLocalNode home, ErlRemoteNode peer, TcpClient s, ErlAtom? cookie = null)
 {
   m_Peer = peer;
   m_Home = home;
   m_TcpClient = s;
   m_Cookie = !cookie.HasValue || cookie.Value == ErlAtom.Null
       ? (peer.Cookie == ErlAtom.Null ? home.Cookie : peer.Cookie) : cookie.Value;
   m_SentBytes = 0;
   m_ReceivedBytes = 0;
   m_MaxPayloadLength = DEFAULT_MAX_PAYLOAD_LENGTH;
 }

 public static ErlType complexAnalyse(ByteBuffer data)
 {
     int position = data.position;
     int num2 = data.readByte();
     data.position = position;
     if ((num2 == ErlArray.TAG[0]) || (num2 == ErlArray.TAG[1]))
     {
         ErlArray array = new ErlArray(null);
         array.bytesRead(data);
         return array;
     }
     switch (num2)
     {
     case 0x6a:
         {
             ErlNullList list = new ErlNullList();
             list.bytesRead(data);
             return list;
         }
     case 0x6c:
         {
             ErlList list2 = new ErlList(null);
             list2.bytesRead(data);
             return list2;
         }
     case 100:
         {
             ErlAtom atom = new ErlAtom(null);
             atom.bytesRead(data);
             return atom;
         }
     case 0x6b:
         {
             ErlString str = new ErlString(null);
             str.sampleBytesRead(data);
             return str;
         }
     case 110:
         {
             ErlLong @long = new ErlLong();
             @long.bytesRead(data);
             return @long;
         }
     case 0x6d:
         {
             ErlByteArray array2 = new ErlByteArray(null);
             array2.bytesRead(data);
             return array2;
         }
     }
     return null;
 }

 private ErlAbstractConnection(ErlLocalNode home, ErlRemoteNode peer, IErlTransport s, ErlAtom? cookie = null)
 {
   m_Peer = peer;
   m_Home = home;
   m_Transport = s;
   m_Cookie = !cookie.HasValue || cookie.Value == ErlAtom.Null
       ? (peer.Cookie == ErlAtom.Null ? home.Cookie : peer.Cookie) : cookie.Value;
   m_SentBytes = 0;
   m_ReceivedBytes = 0;
   m_MaxPayloadLength = DEFAULT_MAX_PAYLOAD_LENGTH;
   if (m_Transport != null)
     m_Transport.Trace += (o, t, d, msg) => home.OnTrace(t, d, msg);
 }

        public void AtomTableTest()
        {
            Assert.AreEqual(0, AtomTable.Instance[string.Empty]);

              Assert.AreEqual(1, AtomTable.Instance["true"]);

              Assert.AreEqual(2, AtomTable.Instance["false"]);

              Assert.AreEqual(1, ErlAtom.True.Index);
              Assert.AreEqual(2, ErlAtom.False.Index);

              bool found = AtomTable.Instance.IndexOf("ok") != -1;
              int count = AtomTable.Instance.Count;

              var am_ok = new ErlAtom("ok");

              Assert.AreEqual(found ? am_ok.Index : AtomTable.Instance.Count - 1, am_ok.Index);
              Assert.AreEqual(found ? count : count + 1, AtomTable.Instance.Count);
        }

        public void ErlAtomTest()
        {
            var am_test = new ErlAtom("test");
              Assert.IsTrue(am_test.Equals(new ErlAtom("test")));
              Assert.AreEqual(am_test, new ErlAtom("test"));
              Assert.AreEqual("test", am_test.Value);
              Assert.AreEqual("test", am_test.ToString());
              Assert.IsTrue(am_test.IsScalar);
              Assert.AreEqual(ErlTypeOrder.ErlAtom, am_test.TypeOrder);

              Assert.IsTrue(am_test.Matches(new ErlAtom("test")));
              Assert.AreEqual(new ErlVarBind(), am_test.Match(new ErlAtom("test")));

              var am_Test = new ErlAtom("Test");
              Assert.AreEqual("'Test'", am_Test.ToString());
              Assert.AreEqual(4, am_Test.Length);
              Assert.AreNotEqual(am_test, am_Test);

              IErlObject temp = null;
              Assert.IsFalse(am_test.Subst(ref temp, new ErlVarBind()));

              Assert.IsTrue(am_Test.Visit(true, (acc, o) => acc));

              Assert.DoesNotThrow(() => { var x = am_test.ValueAsObject; });
              Assert.Throws<ErlIncompatibleTypesException>(() => { var x = am_test.ValueAsInt; });
              Assert.Throws<ErlIncompatibleTypesException>(() => { var x = am_test.ValueAsLong; });
              Assert.Throws<ErlIncompatibleTypesException>(() => { var x = am_test.ValueAsDecimal; });
              Assert.Throws<ErlIncompatibleTypesException>(() => { var x = am_test.ValueAsDateTime; });
              Assert.Throws<ErlIncompatibleTypesException>(() => { var x = am_test.ValueAsTimeSpan; });
              Assert.Throws<ErlIncompatibleTypesException>(() => { var x = am_test.ValueAsDouble; });
              Assert.DoesNotThrow(() => { var x = am_test.ValueAsString; });
              Assert.DoesNotThrow(() => { var x = am_test.ValueAsBool; });
              Assert.AreEqual('a', new ErlAtom("a").ValueAsChar);
              Assert.Throws<ErlIncompatibleTypesException>(() => { var x = am_test.ValueAsByteArray; });

              string s = am_test;  // Implicit conversion
              Assert.AreEqual("test", s);

              ErlAtom a = "abc";   // Implicit conversion
              Assert.AreEqual("abc", a.Value);
        }

        private byte[] genDigest(int challenge, ErlAtom cookie)
        {
            long ch2 = challenge < 0
              ? 1L << 31 | (long)(challenge & 0x7FFFFFFFL)
              : (long)challenge;

              return new MD5CryptoServiceProvider().ComputeHash(
              Encoding.UTF8.GetBytes(cookie.Value + Convert.ToString(ch2)));
        }

 internal ErlMbox(ErlLocalNode home, ErlPid self, ErlAtom name)
 {
   m_Self = self;
   m_Node = home;
   m_RegName = name;
   m_Queue = new ErlBlockingQueue<IQueable>();
   m_Links = new ErlLinks();
   m_Monitors = new ErlMonitors(this);
 }

    /// <summary>
    /// Used to break all known links to this mbox
    /// </summary>
    internal void BreakLinks(ErlAtom fromNode, IErlObject reason)
    {
      var links = m_Links.Remove(fromNode);

      foreach (var link in links)
        if (link.HasPid)
          m_Node.Deliver(ErlMsg.Exit(m_Self, link.Pid, reason));
        else
          m_Node.Deliver(new ErlConnectionException(fromNode, reason));

      foreach (var m in m_Monitors.Where(o => o.Value.Node == fromNode)
                                  .Where(m => m_Monitors.Remove(m.Key)))
        Deliver(new ErlConnectionException(fromNode, reason));
    }

 public void Down(ErlRef eref, ErlPid pid, ErlAtom reason)
 {
   // TODO
   throw new NotImplementedException();
 }

 public void RPCcast(ErlAtom node, ErlAtom mod, ErlAtom fun, ErlList args)
 {
   RPCcast(node, mod, fun, args, ConstAtoms.User);
 }

 public void AsyncRPC(ErlAtom node, ErlAtom mod, ErlAtom fun, ErlList args, ErlAtom? remoteCookie = null)
 {
   AsyncRPC(node, mod, fun, args, (IErlObject)m_Node.GroupLeader.Self, remoteCookie);
 }

    private IErlObject rpcCall(ErlPid from, ErlRef eref,
        ErlAtom mod, ErlAtom fun, ErlList args, IErlObject groupLeader)
    {
      // We spawn a new task, so that RPC calls wouldn't block the RPC server thread
      Task.Factory.StartNew(() =>
      {
        var type = Type.GetType(mod);

        if (type == null)
        {
          sendRpcReply(from, eref,
              ErlTuple.Create(ConstAtoms.Error, "unknown type: {0}".Args(mod)));
          return;
        }

        // TODO: add LRU caching
        //var method = type.GetMethod(fun.Value, BindingFlags.Static | BindingFlags.Public);

        string methodName = fun.Value;

        if (args.Count == 0)
        {
          var pi = type.GetProperty(fun, BindingFlags.Static | BindingFlags.Public);
          if (pi != null)
          {
            try
            {
              var result = pi.GetValue(null, null);
              sendRpcReply(from, eref,
                  ErlTuple.Create(ConstAtoms.Ok, result.ToErlObject()));
            }
            catch (Exception e)
            {
              sendRpcReply(from, eref,
                  ErlTuple.Create(ConstAtoms.Error, new ErlString(e.Message)));
            };
            return;
          }
        }

        var mi = type.GetMethods(BindingFlags.Static | BindingFlags.Public)
                     .Where(m => m.Name == methodName && m.GetParameters().Count() == args.Count)
                     .FirstOrDefault();

        if (mi == null)
        {
          sendRpcReply(from, eref,
              ErlTuple.Create(ConstAtoms.Error, "unknown method: {0}".Args(fun)));
          return;
        }

        var pars = mi.GetParameters();

        var margs = new object[pars.Length];

        for (int i = 0; i < pars.Length; i++)
        {
          var par = pars[i];
          var val = args[i];
          margs[i] = val.AsType(par.ParameterType);
        }

        try
        {
          var result = mi.Invoke(type, margs);
          sendRpcReply(from, eref, ErlTuple.Create(ConstAtoms.Ok, result.ToErlObject()));
        }
        catch (Exception e)
        {
          sendRpcReply(from, eref, ErlTuple.Create(ConstAtoms.Error, new ErlString(e.Message)));
        }
      });
      return (IErlObject)null;
    }

 internal static ErlTuple EncodeRPCcast(
     ErlPid from, ErlAtom mod, ErlAtom fun, ErlList args, IErlObject gleader)
 {
   /*{'$gen_cast', { cast, Mod, Fun, Args, GroupLeader}} */
   return new ErlTuple(
           ConstAtoms.GenCast,
           new ErlTuple(ConstAtoms.Cast, mod, fun, args, gleader));
 }

 /// <summary>
 /// Create a peer node
 /// </summary>
 public ErlRemoteNode(ErlLocalNode home, ErlAtom toNode, ErlAtom? cookie = null)
     : base(toNode, cookie ?? home.Cookie, home.UseShortName)
 {
   ctor(home);
 }

 private IErlObject ioProcessPutChars(ErlAtom encoding,
     ErlAtom mod, ErlAtom fun, ErlList args, IErlObject replyAs)
 {
   string term;
   if (mod == ConstAtoms.Io_Lib && fun == ConstAtoms.Format && args.Count == 2)
     try { term = ErlObject.Format(args); }
     catch { term = "{0}:{1}({2})".Args(mod, fun, args.ToString(true)); }
   else
     term = "{0}:{1}({2})".Args(mod, fun, args.ToString(true));
   Node.OnIoOutput(encoding, new ErlString(term));
   return s_ReplyPattern.Subst(
       new ErlVarBind { { RA, replyAs }, { R, ConstAtoms.Ok } });
 }

 public IErlObject RPC(ErlAtom node, ErlAtom mod, ErlAtom fun, ErlList args, int timeout, ErlAtom? remoteCookie = null)
 {
   AsyncRPC(node, mod, fun, args, remoteCookie);
   var r = m_Monitors.Add(node);
   using (Scope.OnExit(() => m_Monitors.Remove(r)))
   {
     return ReceiveRPC(timeout);
   }
 }

 internal static ErlTuple EncodeRPC(
     ErlPid from, ErlAtom mod, ErlAtom fun, ErlList args, IErlObject gleader)
 {
   /*{Self, {call, Mod, Fun, Args, GroupLeader}} */
   return new ErlTuple(from, new ErlTuple(ConstAtoms.Call, mod, fun, args, gleader));
 }

    /// <summary>
    /// Send an auth error to peer because he sent a bad cookie
    /// The auth error uses his cookie (not revealing ours).
    /// This is just like send_reg otherwise
    /// </summary>
    private void cookieError(ErlLocalNode local, ErlAtom cookie)
    {
      var header = new ErlOutputStream(writeVersion: false, capacity: HEADER_LEN);

      // preamble: 4 byte length + "PASS_THROUGH" tag + version
      header.Write4BE(0); // reserve space for length
      header.Write1(PASS_THROUGH);
      header.Write1((byte)ErlExternalTag.Version);

      header.WriteTupleHead(4);
      header.WriteLong((long)ErlMsg.Tag.RegSend);
      header.WritePid(local.CreatePid()); // disposable pid
      header.WriteAtom(cookie); // important: his cookie, not mine...
      header.WriteAtom("auth");

      // version for payload written later by the payload stream
      //header.Write1((byte)ErlExternalTag.Version);

      // the payload

      // the no_auth message (copied from Erlang) Don't change this (Erlang will crash)
      // {$gen_cast, {print, "~n** Unauthorized cookie ~w **~n", [[email protected]]}}

      var msg = ErlObject.Parse(
          "{'$gen_cast', {print, \"\n** Unauthorized cookie ~w **\n\", [" + local.NodeName.Value + "]}}");

      var payload = new ErlOutputStream(msg, writeVersion: true);

      // fix up length in preamble
      header.Poke4BE(0, (int)(header.Length + payload.Length - 4));

      try
      {
        DoSend(header, payload);
      }
      catch (Exception e)
      {
        Close();
        throw new ErlException(StringConsts.ERL_CONN_UNAUTH_COOKIE_ERROR.Args(cookie.Value), e);
      }
    }

 /*
 * send to remote name
 * dest is recipient's registered name, the nodename is implied by
 * the choice of connection.
 */
 public void Send(ErlPid from, ErlAtom dest, IErlObject msg)
 {
   // encode and send the message
   base.Send(ErlMsg.RegSend(from, dest, msg, SendCookie));
 }

 /// <summary>
 /// Close this mailbox
 /// </summary>
 /// <remarks>
 /// After this operation, the mailbox will no longer be able to
 /// receive messages. Any delivered but as yet unretrieved messages
 /// can still be retrieved however.
 ///
 /// If there are links from this mailbox to other <see cref="ErlPid"/>
 /// pids they will be broken when this method is
 /// called and exit signals will be sent.
 /// </remarks>
 internal void Close()
 {
   // Notify all registered monitors that this pid is closing
   foreach (var monitor in m_Monitors)
   {
     var msg = ErlMsg.MonitorPexit(m_Self, monitor.Value, monitor.Key, ErlAtom.Normal);
     m_Node.Deliver(monitor.Value.Node, msg);
   }
   m_Node.CloseMbox(this);
   m_RegName = ErlAtom.Null;
 }