C# MemBlock.CopyTo方法代码示例

    public void HandleData(MemBlock packet, ISender from, object node)
    {
      _message_count++;

      long stop_time, rt_ticks = -10000;

      if ( !from.Equals(node)) {
        if (packet[0] == 0) {
        //log.Debug("Echo Response:");
	  stop_time = System.DateTime.Now.Ticks;
	  int received_uid = NumberSerializer.ReadInt(packet, 1);
          if(uid_starttime.ContainsKey(received_uid)){
		rt_ticks = stop_time - (long)EchoTester.uid_starttime[received_uid];
	  }
	  double rt_ms = (double) rt_ticks/10000.0;
	  uid_brunetpingtime.Add(received_uid, rt_ms);
	  Console.WriteLine("Packet ID = {0}, Round-trip = {1}", received_uid, rt_ms); 	  
        }
        else {
        //log.Debug("Echo Request:");
        }

        //log.Debug(packet.ToString());

        //System.Console.WriteLine("{0}", packet.ToString());

        if (packet[0] > 0) {
          //Send a reply back, this is a request  
	  byte[] new_payload = new byte[ packet.Length ];
	  packet.CopyTo(new_payload, 0);
          new_payload[0] = (byte) 0;
          from.Send(new CopyList(PType.Protocol.Echo, MemBlock.Reference(new_payload)));
        }
      }
    }

        public static RpcDHCPServer GetRpcDHCPServer(MemBlock ip, MemBlock netmask)
        {
            DHCPConfig config = new DHCPConfig();
              config.LeaseTime = 3200;
              config.Netmask = Utils.MemBlockToString(netmask, '.');
              config.IPBase = Utils.MemBlockToString(ip, '.');

              config.ReservedIPs = new DHCPConfig.ReservedIP[1];
              config.ReservedIPs[0] = new DHCPConfig.ReservedIP();

              byte[] local_ip = new byte[4];
              ip.CopyTo(local_ip, 0);
              local_ip[3] = 2;

              config.ReservedIPs[0].IPBase = Utils.BytesToString(local_ip, '.');
              config.ReservedIPs[0].Mask = "255.255.255.255";

              return new RpcDHCPServer(config);
        }

        public DHCPPacket(byte op, MemBlock xid, MemBlock ciaddr, MemBlock yiaddr,
                     MemBlock siaddr, MemBlock chaddr, Dictionary<OptionTypes, MemBlock> Options)
        {
            this.op = op;
              this.xid = xid;
              this.ciaddr = ciaddr;
              this.yiaddr = yiaddr;
              this.siaddr = siaddr;
              this.chaddr = chaddr;
              this.Options = Options;

              byte[] header = new byte[240];
              header[0] = op;
              header[1] = 1;
              header[2] = (byte) chaddr.Length;
              header[3] = 0;

              xid.CopyTo(header, 4);
              for(int i = 8; i < 12; i++) {
            header[i] = 0;
              }
              ciaddr.CopyTo(header, 12);
              yiaddr.CopyTo(header, 16);
              siaddr.CopyTo(header, 20);
              for(int i = 24; i < 28; i++) {
            header[i] = 0;
              }
              chaddr.CopyTo(header, 28);
              for(int i = 34; i < 236; i++) {
            header[i] = 0;
              }
              magic_key.CopyTo(header, 236);

              _icpacket = new CopyList(MemBlock.Reference(header));
              foreach(KeyValuePair<OptionTypes, MemBlock> kvp in Options) {
            MemBlock value = kvp.Value;

            byte[] tmp = new byte[2];
            tmp[0] = (byte) kvp.Key;
            tmp[1] = (byte) value.Length;

            _icpacket = new CopyList(_icpacket, MemBlock.Reference(tmp), value);
              }
              byte []end = new byte[1]{255}; /* End of Options */
              _icpacket = new CopyList(_icpacket, MemBlock.Reference(end));
        }

 protected byte[] GenToken(MemBlock key) {
   RNGCryptoServiceProvider provider = new RNGCryptoServiceProvider();
   byte[] token = new byte[20];
   provider.GetBytes(token);
   byte[] res = new byte[40];
   key.CopyTo(res, 0);
   token.CopyTo(res, 20);
   return res;
 }

 public static MemBlock MakePseudoHeader(MemBlock SourceIP,
                                         MemBlock DestinationIP,
                                         byte Protocol,
                                         int Length) {
   byte[] pseudoheader = new byte[12];
   SourceIP.CopyTo(pseudoheader, 0);
   DestinationIP.CopyTo(pseudoheader, 4);
   pseudoheader[9] = Protocol;
   pseudoheader[10] = (byte) ((Length >> 8) & 0xFF);
   pseudoheader[11] = (byte) (Length & 0xFF);
   return MemBlock.Reference(pseudoheader);
 }

    /**
    <summary>If we're not creating a packet from scratch, this will keep its
    integrity and transform UDP and TCP headers as well (due to their checksums
    being dependent on source and destination ip addresses.</summary>
    <param name="Packet">The packet to translate.</param>
    <param name="SourceIP">The new source ip.</param>
    <param name="DestinationIP">The new destination ip.</param>
    */
    public static MemBlock Translate(MemBlock Packet, MemBlock SourceIP,
                                     MemBlock DestinationIP) {
      byte[] new_packet = new byte[Packet.Length];
      Packet.CopyTo(new_packet, 0);
      int length = (Packet[0] & 0xF) * 4;
      SourceIP.CopyTo(new_packet, 12);
      // Do not copy over multicast addresses!
      if(new_packet[16] < 224 || new_packet[16] > 239) {
        DestinationIP.CopyTo(new_packet, 16);
      }
      // Zero out the checksum so we don't use it in our future calculations
      new_packet[10] = 0;
      new_packet[11] = 0;
      MemBlock header = MemBlock.Reference(new_packet, 0, length);
      int checksum = GenerateChecksum(header);
      new_packet[10] = (byte) ((checksum >> 8) & 0xFF);
      new_packet[11] = (byte) (checksum & 0xFF);
      Protocols p = (Protocols) Packet[9];

      bool fragment = ((Packet[6] & 0x1F) | Packet[7]) != 0;

      if(p == Protocols.UDP && !fragment) {
        // Zero out the checksum to disable it
        new_packet[length + 6] = 0;
        new_packet[length + 7] = 0;
      }
      else if(p == Protocols.TCP && !fragment) {
        // Zero out the checksum so we don't use it in our future calculations
        new_packet[length + 16] = 0;
        new_packet[length + 17] = 0;
        MemBlock payload = MemBlock.Reference(new_packet).Slice(length);
        MemBlock pseudoheader = IPPacket.MakePseudoHeader(SourceIP,
            DestinationIP, (byte) Protocols.TCP, Packet.Length - 20);
        checksum = IPPacket.GenerateChecksum(payload, pseudoheader);
        new_packet[length + 16] = (byte) ((checksum >> 8) & 0xFF);
        new_packet[length + 17] = (byte) (checksum & 0xFF);
      }
      return MemBlock.Reference(new_packet);
    }

 public static double ReadDouble(MemBlock mb)
 {
   byte[] bin = new byte[8];
   mb.CopyTo(bin,0);
   return ReadDouble(bin, 0);
 }

 public static float ReadFloat(MemBlock mb)
 {
   byte[] bin = new byte[4];
   mb.CopyTo(bin,0);
   return ReadFloat(bin, 0);
 }

 public static MemBlock MakePseudoHeader(MemBlock source_address,
     MemBlock destination_address, byte protocol, ushort length)
 {
   byte[] pseudoheader = new byte[source_address.Length + destination_address.Length + 4];
   int pos = 0;
   source_address.CopyTo(pseudoheader, pos);
   pos += source_address.Length;
   destination_address.CopyTo(pseudoheader, pos);
   pos += destination_address.Length;
   pseudoheader[++pos] = protocol;
   NumberSerializer.WriteUShort(length, pseudoheader, ++pos);
   return MemBlock.Reference(pseudoheader);
 }