示例#1
2
    static Boolean TestKnownEnc(Aes aes, Byte[] Key, Byte[] IV, Byte[] Plain, Byte[] Cipher)
    {

        Byte[]  CipherCalculated;
        
        Console.WriteLine("Encrypting the following bytes:");
        PrintByteArray(Plain);
        Console.WriteLine("With the following Key:");
        PrintByteArray(Key);
        Console.WriteLine("and IV:");
        PrintByteArray(IV);
 		Console.WriteLine("Expecting this ciphertext:");
		PrintByteArray(Cipher);        
        
        ICryptoTransform sse = aes.CreateEncryptor(Key, IV);
        MemoryStream 	ms = new MemoryStream();
        CryptoStream    cs = new CryptoStream(ms, sse, CryptoStreamMode.Write);
        cs.Write(Plain,0,Plain.Length);
        cs.FlushFinalBlock();
        CipherCalculated = ms.ToArray();
        cs.Close();

		Console.WriteLine("Computed this cyphertext:");
        PrintByteArray(CipherCalculated);
        

        if (!Compare(Cipher, CipherCalculated)) {
        	Console.WriteLine("ERROR: result is different from the expected");
        	return false;
        }
        
        Console.WriteLine("OK");
        return true;
    }
示例#2
0
    //you need to provide the correct select statement for whatever doc you are trying to recieve
    public void DownloadFile(string selectStatement)
    {
        byte[] fileData;

        string connection = ConfigurationManager.ConnectionStrings["testDB"].ConnectionString;
        SqlConnection conn = new SqlConnection(connection);
        SqlCommand cmd = new SqlCommand(selectStatement, conn);
        conn.Open();
        SqlDataReader dr = cmd.ExecuteReader();

        while (dr.Read())
        {
            fileData = (byte[])dr[0];
            using ( MemoryStream stream = new MemoryStream(fileData))
            {
                HttpContext.Current.Response.AppendHeader("Content-Disposition", "attachment; filename=weserveuFile.pdf");
                HttpContext.Current.Response.ContentType = "application/pdf";
                HttpContext.Current.Response.BinaryWrite(stream.ToArray());
                HttpContext.Current.Response.End();
            }

        }
        dr.Close();
        conn.Close();
    }
    // gets the image's sizes
    private void GetWidthHeight(string filename, out string width, out string height)
    {
        width = "";
        height = "";
        System.Drawing.Image objImage;
        MemoryStream objStream;

        FileStream binStream = File.OpenRead(filename);
        byte[] buf = new byte[binStream.Length];

        System.Drawing.Image.GetThumbnailImageAbort myCallback = new System.Drawing.Image.GetThumbnailImageAbort(ThumbnailCallback);

        binStream.Read(buf, 0, (int)binStream.Length);
        binStream.Close();

        objStream = new MemoryStream(buf);
        objStream.Position = 0;
        try
        {
            objImage = System.Drawing.Image.FromStream(objStream);
            width = objImage.Width.ToString();
            height = objImage.Height.ToString();
            objImage.Dispose();
        }
        catch { }
        objStream.Close();
    }
示例#4
0
    public static void Main() {
        byte[] bytes;

        var values = new long[] {
            0, 1, 0xFFFF, 0xFF00FF00FF00L, 12345678901234L, -0xFFFF, -0xFF00FF00FF00L
        };

        long length;

        using (var ms = new MemoryStream())
        using (var bw = new BinaryWriter(ms)) {
            foreach (var value in values) {
                bw.Write(value);
                Console.WriteLine(value);
            }

            bw.Flush();
            length = ms.Position;

            bytes = ms.GetBuffer();
        }

        Util.PrintByteArray(bytes, (int)length);

        using (var ms = new MemoryStream(bytes, false))
        using (var br = new BinaryReader(ms)) {
            for (int i = 0; i < values.Length; i++) {
                var value = br.ReadInt64();
                Console.WriteLine(value);
            }
        }
    }
 public void OnMsgConstellationLevelup(MemoryStream stream)
 {
     MS2C_ConstellationLevelup mS2C_ConstellationLevelup = Serializer.NonGeneric.Deserialize(typeof(MS2C_ConstellationLevelup), stream) as MS2C_ConstellationLevelup;
     if (mS2C_ConstellationLevelup.Result != 0)
     {
         GameUIManager.mInstance.ShowMessageTip("PlayerR", mS2C_ConstellationLevelup.Result);
         return;
     }
     this.mconLv = Globals.Instance.Player.Data.ConstellationLevel;
     GameUIManager.mInstance.ShowFadeBG(5900, 3000);
     this.mGUIXingZuoPage.mUIXingZuoItem.mWaitTimeToHide = 1.1f;
     this.mGUIXingZuoPage.mUIXingZuoItem.RefreshShowIcon();
     this.mGUIRightInfo.Refresh(this.mconLv);
     this.mGUIXingZuoPage.mUIXingZuoItem.RefreshEffect();
     base.StartCoroutine(this.WaitShowAttribute());
     if (Globals.Instance.Player.ItemSystem.GetItemCount(GameConst.GetInt32(103)) >= GUIRightInfo.GetCost())
     {
         base.StartCoroutine(this.EffectSound());
     }
     int constellationLevel = Globals.Instance.Player.Data.ConstellationLevel;
     if (constellationLevel == 10 || constellationLevel == 30)
     {
         GameUIManager.mInstance.ShowPetQualityUp(constellationLevel);
     }
     if (constellationLevel > 0 && constellationLevel % 5 == 0 && (constellationLevel != 10 & constellationLevel != 30))
     {
         base.StartCoroutine(this.WaitShowBaoXiang());
     }
     Globals.Instance.TutorialMgr.InitializationCompleted(this, null);
 }
	public override void LoadTable(string _path)
	{		
		if ((null != AssetbundleManager.Instance && true == AssetbundleManager.Instance.useAssetbundle) || true == AsTableManager.Instance.useReadBinary) 
		{
			// Ready Binary
			TextAsset textAsset = ResourceLoad.LoadTextAsset (_path);
			MemoryStream stream = new MemoryStream (textAsset.bytes);
			BinaryReader br = new BinaryReader (stream);

			int nCount = br.ReadInt32 ();

			for (int i = 0; i < nCount; i++) {
				Tbl_SynDisassemble_Record record = new Tbl_SynDisassemble_Record (br);
					m_recordList.Add (record);		
			}

			br.Close ();
			stream.Close ();				
		} 
		else 
		{
			XmlElement root = GetXmlRootElement(_path);
			XmlNodeList nodes = root.ChildNodes;
			
			foreach(XmlNode node in nodes)
			{
				Tbl_SynDisassemble_Record record = new Tbl_SynDisassemble_Record((XmlElement)node);			
				m_recordList.Add( record );
			}		
		}
	}		 
示例#7
0
    public bool NegTest2() 
    {
        bool retVal = true;
        TestLibrary.TestFramework.BeginScenario("Verify InvalidOperationException is thrown when set ReadTimeOut property...");

        try
        {
            Stream s = new MemoryStream();
            for (int i = 0; i < 100; i++)
                s.WriteByte((byte)i);
            s.Position = 0;

            s.ReadTimeout = 10;

            TestLibrary.TestFramework.LogError("001", "No exception occurs!");
            retVal = false;
        }
        catch (InvalidOperationException)
        {
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("002", "Unexpected exception occurs: " + e);
            retVal = false;
        }

        return retVal;
    }
示例#8
0
        // Creates a memory stream with the first 4K bytes of the record.
        private void CreateMemoryStream()
        {
            byte[] pData;
            int cbData = INITIAL_READ;
            int totalSize;

            log.ReadRecordPrefix(this.recordSequenceNumber, out pData, ref cbData, out totalSize, out this.prevSeqNum, out this.nextSeqNum);

            if (cbData < FileLogRecordHeader.Size)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.LogCorrupt());

            this.header = new FileLogRecordHeader(pData);
            this.recordSize = totalSize - FileLogRecordHeader.Size;

            int streamSize = Math.Min(this.recordSize,
                                      INITIAL_READ - FileLogRecordHeader.Size);

            this.stream = new MemoryStream(
                pData,
                FileLogRecordHeader.Size,
                streamSize,
                false);

            if (totalSize <= INITIAL_READ)
            {
                // Record is smaller than 4K.  We have read the entire record.
                this.entireRecordRead = true;
            }
        }
示例#9
0
文件: rtest.cs 项目: nobled/mono
	static void Main (string [] args)
	{
		int i = 0;

		while (args [i].StartsWith ("-")){
			if (args [i] == "-debug")
				debug = true;
			if (args [i] == "-headers")
				headers = true;
			if (args [i] == "-header")
				header = args [++i];
			i++;
		}
		
		c = new TcpClient (args [i], Int32.Parse (args [i+1]));
		c.ReceiveTimeout = 1000;
		ns = c.GetStream ();
		
		sw = new StreamWriter (ns);
		sr = new StreamReader (ns);

		string host = args [i];
		if (args [i+1] != "80")
			host += ":" + args [i+1];
		send (String.Format ("GET {0} HTTP/1.1\r\nHost: {1}\r\n\r\n", args [i+2], host));

		MemoryStream ms = new MemoryStream ();
		
		try {
			byte [] buf = new byte [1024];
			int n;
			
			while ((n = ns.Read (buf, 0, 1024)) != 0){
				ms.Write (buf, 0, n);
			}
		} catch {}

		ms.Position = 0;
		sr = new StreamReader (ms);

		string s;
		
		while ((s = sr.ReadLine ()) != null){
			if (s == ""){
				if (headers)
					return;
				
				string x = sr.ReadToEnd ();
				Console.Write (x);
				break;
			}  else {
				if (debug || headers)
					Console.WriteLine (s);
				if (header != null && s.StartsWith (header)){
					Console.WriteLine (s);
					return;
				}
			}
		}
	}
 public void LoadFromFile()
 {
     TextAsset textAsset = Res.Load("Attribute/AchievementInfo") as TextAsset;
     if (textAsset == null)
     {
         global::Debug.LogError(new object[]
         {
             "Res.Load error, Name = AchievementInfo"
         });
         return;
     }
     try
     {
         this.infos.Clear();
         MemoryStream source = new MemoryStream(textAsset.bytes, 0, textAsset.bytes.Length);
         AchievementInfoDict achievementInfoDict = Serializer.NonGeneric.Deserialize(typeof(AchievementInfoDict), source) as AchievementInfoDict;
         for (int i = 0; i < achievementInfoDict.Data.Count; i++)
         {
             this.infos.Add(achievementInfoDict.Data[i].ID, achievementInfoDict.Data[i]);
         }
     }
     catch (Exception ex)
     {
         global::Debug.LogError(new object[]
         {
             "Load AchievementInfo.bytes Error, Exception = " + ex.Message
         });
     }
 }
示例#11
0
 public static string Serialize(object obj)
 {
     MemoryStream memoryStream = new MemoryStream ();
     binaryFormatter.Serialize (memoryStream, obj);
     string serialized = System.Convert.ToBase64String (memoryStream.ToArray ());
     return serialized;
 }
示例#12
0
    private void Start()
    {
        string imgFile = folderName + FileUpload1.FileName;
        Stream inputStream = new MemoryStream();
        System.Drawing.Image img = System.Drawing.Image.FromFile(Server.MapPath(imgFile));

        img.Save(inputStream, System.Drawing.Imaging.ImageFormat.Jpeg);

        Stream outputStream;
        int diameter;
        if (int.TryParse(tbDiameter.Text.Trim(), out diameter))
        {
            outputStream = CircleImageCreater.CreateCircleImageStream(inputStream, diameter);
        }
        else
        {
            outputStream = CircleImageCreater.CreateCircleImageStream(inputStream);
        }

        saveImage(outputStream, FileUpload1.FileName + ".png");

        oldImage.ImageUrl = imgFile;
        newImage.ImageUrl = folderName + FileUpload1.FileName + ".png";

        //dispose
        inputStream.Dispose();
        outputStream.Dispose();
    }
 public override void Serialize(MemoryStream stream)
 {
     header.Serialize(stream);
     System.Byte[] height_bytes = BitConverter.GetBytes(height);
     stream.Write(height_bytes, 0, height_bytes.Length);
     System.Byte[] width_bytes = BitConverter.GetBytes(width);
     stream.Write(width_bytes, 0, width_bytes.Length);
     System.Byte[] fields_len_bytes = BitConverter.GetBytes((System.UInt32)fields.Count);
     stream.Write(fields_len_bytes, 0, fields_len_bytes.Length);
     foreach(sensor_msgs.PointField element in fields)
     {
         element.Serialize(stream);
     }
     System.Byte[] is_bigendian_bytes = BitConverter.GetBytes(is_bigendian);
     stream.Write(is_bigendian_bytes, 0, is_bigendian_bytes.Length);
     System.Byte[] point_step_bytes = BitConverter.GetBytes(point_step);
     stream.Write(point_step_bytes, 0, point_step_bytes.Length);
     System.Byte[] row_step_bytes = BitConverter.GetBytes(row_step);
     stream.Write(row_step_bytes, 0, row_step_bytes.Length);
     System.Byte[] compression_type_bytes = new System.Byte[] {compression_type};
     stream.Write(compression_type_bytes, 0, compression_type_bytes.Length);
     System.Byte[] compressed_data_bytes = compressed_data.ToArray();
     System.Byte[] compressed_data_len_bytes = BitConverter.GetBytes((System.UInt32)compressed_data_bytes.Length);
     stream.Write(compressed_data_len_bytes, 0, compressed_data_len_bytes.Length);
     stream.Write(compressed_data_bytes, 0, compressed_data_bytes.Length);
     System.Byte[] is_dense_bytes = BitConverter.GetBytes(is_dense);
     stream.Write(is_dense_bytes, 0, is_dense_bytes.Length);
 }
    public static void Main() {
        string PlainText = "Titan";
        byte[] PlainBytes = new byte[5];
        PlainBytes = Encoding.ASCII.GetBytes(PlainText.ToCharArray());
        PrintByteArray(PlainBytes);
        byte[] CipherBytes = new byte[8];
        PasswordDeriveBytes pdb = new PasswordDeriveBytes("Titan", null);
        byte[] IV = new byte[8];
        byte[] Key = pdb.CryptDeriveKey("RC2", "SHA1", 40, IV);
        PrintByteArray(Key);
        PrintByteArray(IV);

        // Now use the data to encrypt something
        RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider();
        Console.WriteLine(rc2.Padding);
        Console.WriteLine(rc2.Mode);
        ICryptoTransform sse = rc2.CreateEncryptor(Key, IV);
        MemoryStream ms = new MemoryStream();
        CryptoStream cs1 = new CryptoStream(ms, sse, CryptoStreamMode.Write);
        cs1.Write(PlainBytes, 0, PlainBytes.Length);
        cs1.FlushFinalBlock();
        CipherBytes = ms.ToArray();
        cs1.Close();
        Console.WriteLine(Encoding.ASCII.GetString(CipherBytes));
        PrintByteArray(CipherBytes);

        ICryptoTransform ssd = rc2.CreateDecryptor(Key, IV);
        CryptoStream cs2 = new CryptoStream(new MemoryStream(CipherBytes), ssd, CryptoStreamMode.Read);
        byte[] InitialText = new byte[5];
        cs2.Read(InitialText, 0, 5);
        Console.WriteLine(Encoding.ASCII.GetString(InitialText));
    	PrintByteArray(InitialText);
    }
示例#15
0
 public static byte[] GetBytes(Level data)
 {
     IFormatter formatter = new BinaryFormatter();
     MemoryStream stream = new MemoryStream();
     formatter.Serialize(stream, data);
     return stream.ToArray();
 }
 public override void Serialize(MemoryStream stream)
 {
     header.Serialize(stream);
     System.Byte[] angle_min_bytes = BitConverter.GetBytes(angle_min);
     stream.Write(angle_min_bytes, 0, angle_min_bytes.Length);
     System.Byte[] angle_max_bytes = BitConverter.GetBytes(angle_max);
     stream.Write(angle_max_bytes, 0, angle_max_bytes.Length);
     System.Byte[] angle_increment_bytes = BitConverter.GetBytes(angle_increment);
     stream.Write(angle_increment_bytes, 0, angle_increment_bytes.Length);
     System.Byte[] time_increment_bytes = BitConverter.GetBytes(time_increment);
     stream.Write(time_increment_bytes, 0, time_increment_bytes.Length);
     System.Byte[] scan_time_bytes = BitConverter.GetBytes(scan_time);
     stream.Write(scan_time_bytes, 0, scan_time_bytes.Length);
     System.Byte[] range_min_bytes = BitConverter.GetBytes(range_min);
     stream.Write(range_min_bytes, 0, range_min_bytes.Length);
     System.Byte[] range_max_bytes = BitConverter.GetBytes(range_max);
     stream.Write(range_max_bytes, 0, range_max_bytes.Length);
     System.Byte[] ranges_len_bytes = BitConverter.GetBytes((System.UInt32)ranges.Count);
     stream.Write(ranges_len_bytes, 0, ranges_len_bytes.Length);
     foreach(sensor_msgs.LaserEcho element in ranges)
     {
         element.Serialize(stream);
     }
     System.Byte[] intensities_len_bytes = BitConverter.GetBytes((System.UInt32)intensities.Count);
     stream.Write(intensities_len_bytes, 0, intensities_len_bytes.Length);
     foreach(sensor_msgs.LaserEcho element in intensities)
     {
         element.Serialize(stream);
     }
 }
    public static NetworkResponse Parse(MemoryStream dataStream)
    {
        ResponseNoWaitForGame response = new ResponseNoWaitForGame();
        response.status = DataReader.ReadInt(dataStream);

        return response;
    }
示例#18
0
    Messages Deserialize(byte[] bytes)
    {
        MemoryStream stream = new MemoryStream(bytes);
        BinaryFormatter b = new BinaryFormatter();

        return (Messages)b.Deserialize(stream);
    }
示例#19
0
 public static void saveFunction(string saveTag, object obj)
 {
     MemoryStream memoryStream = new MemoryStream ();
     binaryFormatter.Serialize (memoryStream, obj);
     string temp = System.Convert.ToBase64String (memoryStream.ToArray ());
     PlayerPrefs.SetString (saveTag, temp);
 }
示例#20
0
    protected void Page_Load(object sender, EventArgs e)
    {
        string mode = Request["mode"];
        int node = 0;
        int.TryParse(Request["nid"], out node);
        Super2d3dGraph oGraph = null;

        if (mode == "links") {
            if (WAFContext.Session.ContentExists(node)) {
                NewsletterDelivery delivery = WAFContext.Session.GetContent<NewsletterDelivery>(node,WAFContext.Session.LCID);
                oGraph = NewsletterCharts.GetDeliveryLinksBarChart(delivery);
            }
        } else if (mode == "clicksvssent") {
            if (WAFContext.Session.ContentExists(node)) {
                NewsletterDelivery delivery = WAFContext.Session.GetContent<NewsletterDelivery>(node,WAFContext.Session.LCID);
                oGraph = NewsletterCharts.GetDeliveryReadsVsClicksBarChart(delivery);
            }
        }
        if (oGraph != null) {

            oGraph.RefreshChart();
            // Save image in a temporary buffer (PNG format for best quality)
            MemoryStream io = new MemoryStream();
            oGraph.Image.Save(io, ImageFormat.Png);

            // Output the content of the buffer to the browser
            Response.Clear();
            Response.ContentType = "image/png";
            Response.BinaryWrite(io.GetBuffer());
        }
    }
    /// <summary>
    /// Builds and in memory stream containing the binary data in a multi-part MIME that is ready for upload
    /// </summary>
    /// <returns></returns>
    public override byte [] GenerateMimeEncodedChunk()
    {
        var inMemoryStream = new MemoryStream();
        using (inMemoryStream)
        {
            WriteBoundaryLine(inMemoryStream);
//            WriteAsciiLine(inMemoryStream, "Content-Disposition: name=\"request_payload\"");
            WriteAsciiLine(inMemoryStream, "Content-Disposition: form-data; name=\"request_payload\"");  //Server v9.2 is stricter about request syntax
            WriteAsciiLine(inMemoryStream, "Content-Type: text/xml");
            WriteAsciiLine(inMemoryStream);
            WriteAsciiLine(inMemoryStream); //[2015-10-17] Extra line to meet expectations for 2 empty lines after content

            WriteBoundaryLine(inMemoryStream);
//            WriteAsciiLine(inMemoryStream, "Content-Disposition: name=\"tableau_file\"; filename=\"FILE-NAME\"");
            WriteAsciiLine(inMemoryStream, "Content-Disposition: form-data; name=\"tableau_file\"; filename=\"FILE-NAME\"");  //Server v9.2 is stricter about request syntax
            WriteAsciiLine(inMemoryStream, "Content-Type: application/octet-stream");
            WriteAsciiLine(inMemoryStream);

            //Write the raw binary data
            inMemoryStream.Write(_uploadData, 0, _numberBytes);
            WriteAsciiLine(inMemoryStream);
            WriteBoundaryLine(inMemoryStream, true);

            //Go to the beginning
            inMemoryStream.Seek(0, SeekOrigin.Begin);
            return inMemoryStream.ToArray();
        }
    }
示例#22
0
    public MemoryStream GET_PRESTATIONS_GROUPE(MemoryStream xml)
    {
        Dictionary<object, Object> param = null;
        MemoryStream mresult = null;
        bool demo = false;
        List<PRESTATIONS_GROUPE> result = null;

        OperationContext.Current.OperationCompleted += new EventHandler(delegate(object sender, EventArgs args)
        {
            if (mresult != null)
                mresult.Dispose();
        });

        try
        {
            param = Serializer.READC<Dictionary<object, object>>(xml);

            demo = ((param.Keys.Any(x => x.Equals("DEMO"))) && (param["DEMO"] != null)) ? Convert.ToBoolean(param["DEMO"]) : false;

            using (var CONTEXT = new dbAbisEntities((!demo) ? CS : CS_DEMO))
            {
                result =
                    CONTEXT.EXECUTE_ENTITY_STORED_PROCEDURE<PRESTATIONS_GROUPE>("PRESTATIONS_GROUPEget", param, new List<string> { "DEMO" });
            }

            mresult = Serializer.WRITEC<List<PRESTATIONS_GROUPE>>(result);

            return mresult;
        }
        catch (Exception ex)
        {
            throw new ApplicationException(String.Empty, ex);
        }
    }
示例#23
0
	//public static string Unscramble(string text ) {
	//	byte[] clear = Encoding.UTF8.GetBytes (text);
	//	return Encoding.UTF8.GetString( Xor( clear) );
	//}

	public static byte[] Xor(byte[] clearTextBytes )
	{

		byte[] key = GenKey (clearTextBytes.Length);

		//Debug.Log ("KEY : " + Encoding.Unicode.GetString (key));

		MemoryStream ms = new MemoryStream();
	
		for (int i = 0; i < clearTextBytes.Length; i++) {

			byte b = (byte)(  (clearTextBytes [i] ^ key [i]) );

			//if (b == 0 ) {
			//	b = key [i];
				//Debug.Log ("GOt NULL BYTE FROM KEY: " + key [i] + ", BYTE: " + clearTextBytes [i]);
			//}

			ms.WriteByte ( b );
		}

		byte[] output =  ms.ToArray();
		//Debug.Log ("SCRAM OUT: " + output.Length);
		return output;

	}
示例#24
0
    public static byte[] AES_Encrypt(byte[] bytesToBeEncrypted, byte[] passwordBytes)
    {
        byte[] encryptedBytes = null;

        // Set your salt here, change it to meet your flavor:
        // The salt bytes must be at least 8 bytes.
        byte[] saltBytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };

        using (MemoryStream ms = new MemoryStream())
        {
          using (RijndaelManaged AES = new RijndaelManaged())
          {
        AES.KeySize = 256;
        AES.BlockSize = 128;

        var key = new Rfc2898DeriveBytes(passwordBytes, saltBytes, 1000);
        AES.Key = key.GetBytes(AES.KeySize / 8);
        AES.IV = key.GetBytes(AES.BlockSize / 8);

        AES.Mode = CipherMode.CBC;

        using (var cs = new CryptoStream(ms, AES.CreateEncryptor(), CryptoStreamMode.Write))
        {
          cs.Write(bytesToBeEncrypted, 0, bytesToBeEncrypted.Length);
          cs.Close();
        }
        encryptedBytes = ms.ToArray();
          }
        }

        return encryptedBytes;
        //end public byte[] AES_Encrypt
    }
    public static ActionPayload Decode(byte[] payload)
    {
        MemoryStream stream = new MemoryStream(payload);
        BinaryReader reader = new BinaryReader(stream);

        byte op = reader.ReadByte ();

        ActionPayload action = new ActionPayload();

        switch (op) {

            case ActionPayload.OP_MOVEMENT:

                action.op = op;
                action.time = reader.ReadSingle ();

                action.position = new Vector3();
                action.position.x = reader.ReadSingle ();
                action.position.y = reader.ReadSingle ();
                action.position.z = reader.ReadSingle ();

                action.rot = reader.ReadSingle ();
                action.state = (int)reader.ReadSingle ();

            break;
        }

        return action;
    }
示例#26
0
 public static object Load(string saveTag)
 {
     string temp = PlayerPrefs.GetString (saveTag);
     if (temp == string.Empty) {return null;}
     MemoryStream memoryStream = new MemoryStream (System.Convert.FromBase64String (temp));
     return binaryFormatter.Deserialize(memoryStream);
 }
 public WrappedMemoryStream(bool canRead, bool canWrite, bool canSeek, byte[] data)
 {
     wrapped = data != null ? new MemoryStream(data) : new MemoryStream();
     _canWrite = canWrite;
     _canRead = canRead;
     _canSeek = canSeek;
 }
示例#28
0
    // Decrypt a byte array into a byte array using a key and an IV
    public static byte[] Decrypt(byte[] cipherData, byte[] Key, byte[] IV)
    {
        // Create a MemoryStream that is going to accept the decrypted bytes

        MemoryStream ms = new MemoryStream();

        // Create a symmetric algorithm.

        // We are going to use Rijndael because it is strong and available on all platforms.

        // You can use other algorithms, to do so substitute the next line with something like

        //                      TripleDES alg = TripleDES.Create();

        Rijndael alg = Rijndael.Create();

        // Now set the key and the IV.

        // We need the IV (Initialization Vector) because the algorithm is operating in its default

        // mode called CBC (Cipher Block Chaining). The IV is XORed with the first block (8 byte)

        // of the data after it is decrypted, and then each decrypted block is XORed with the previous

        // cipher block. This is done to make encryption more secure.

        // There is also a mode called ECB which does not need an IV, but it is much less secure.

        alg.Key = Key;

        alg.IV = IV;

        // Create a CryptoStream through which we are going to be pumping our data.

        // CryptoStreamMode.Write means that we are going to be writing data to the stream

        // and the output will be written in the MemoryStream we have provided.

        CryptoStream cs = new CryptoStream(ms, alg.CreateDecryptor(), CryptoStreamMode.Write);

        // Write the data and make it do the decryption

        cs.Write(cipherData, 0, cipherData.Length);

        // Close the crypto stream (or do FlushFinalBlock).

        // This will tell it that we have done our decryption and there is no more data coming in,

        // and it is now a good time to remove the padding and finalize the decryption process.

        cs.Close();

        // Now get the decrypted data from the MemoryStream.

        // Some people make a mistake of using GetBuffer() here, which is not the right way.

        byte[] decryptedData = ms.ToArray();

        return decryptedData;
    }
示例#29
0
文件: render.cs 项目: vbatz258/manos
    public static int Main(string [] args)
    {
        if (args.Length < 2)
            return Usage ();

        Dictionary<string,object> targs = new Dictionary<string,object> ();

        Assembly asm = Assembly.LoadFrom (args [0]);
        Type template_type = asm.GetType (args [1]);

        for (int i = 2; i + 1 < args.Length; i += 2) {
            targs.Add (args [i], args [i + 1]);
        }

        targs ["test_enumerable"] = new List<string> () { "one", "two", "three", "four" };

        Console.WriteLine ("TEMPLATE TYPE:  {0}", template_type);
        MethodInfo meth = template_type.GetMethod ("RenderToStream");
        object template = Activator.CreateInstance (template_type);

        MemoryStream stream = new MemoryStream ();
        StreamWriter writer = new StreamWriter (stream);

        meth.Invoke (template, new object [] { Console.Out, targs });

        return 0;
    }
示例#30
0
	public object DeserializeObject(string pXmlizedString , System.Type ty)
	{
		XmlSerializer xs  = new XmlSerializer(ty);
		MemoryStream memoryStream  = new MemoryStream(StringToUTF8ByteArray(pXmlizedString));
		XmlTextWriter xmlTextWriter   = new XmlTextWriter(memoryStream, Encoding.UTF8);
		return xs.Deserialize(memoryStream);
	}
示例#31
0
    static void Main(string[] args)
    {
        var data = new DataTable();

        using (var csvReader = new CsvReader(new StreamReader(System.IO.File.OpenRead(@"data.csv")), false, ',')) {
            data.Load(csvReader);
        }

        object[] headers = (object[])data.Rows[0].ItemArray.Clone();
        //foreach(var item in headers.ItemArray) Write(item + "   "); WriteLine();

        data.Rows[0].Delete();
        data.AcceptChanges();

        bool runprog = true;

        var drillaggregates = new List <int>();

        headermenu(headers);
        Console.Write("Enter initial aggregate column # (must be numeric values only): ");
        var initagg = Convert.ToInt32(Console.ReadLine());

        drillaggregates.Add(initagg);
        var filters    = new List <int>();
        var filterdata = new List <object>();

        do
        {
            try {
                WriteLine("Menu options:\n\t0. Display Fact Table\n\t1. Display Aggregated Table\n\t2. Reinitialize Aggregate\n\t3. Drill-down\n\t4. Filter\n\t5. View\n\t6. Quit\n\t7. Reset Drill Aggregates\n\t8. Reset Filters\n\t9. Remove Drill Aggregate\n\t10.Remove Filter");
                // also remove aggregate on website
                Write("Enter menu choice #: ");
                int menuoption = Convert.ToInt32(Console.ReadLine());

                if (menuoption == 0)            // Display Fact Table
                {
                    var watch = Stopwatch.StartNew();
                    WriteLine(string.Join(",", headers));
                    for (int i = 0; i < data.Rows.Count; i++)
                    {
                        WriteLine(string.Join(", ", data.Rows[i].ItemArray));
                    }
                    watch.Stop();
                    WriteLine("Execution time in seconds: {0}", watch.Elapsed.TotalSeconds);
                }
                else if (menuoption == 1)       // Display Aggregated Table
                {
                    var watch = Stopwatch.StartNew();
                    displayaggregatetable(data, headers, drillaggregates.ToArray(), filters.ToArray(), filterdata.ToArray());
                    watch.Stop();
                    WriteLine("Execution time in seconds: {0}", watch.Elapsed.TotalSeconds);
                }
                else if (menuoption == 2)       // Reinitialize Aggregate
                {
                    var watch = Stopwatch.StartNew();
                    headermenu(headers);
                    Write("Enter initial aggregate column # (must be numeric values only): ");
                    initagg = Convert.ToInt32(Console.ReadLine());

                    if (drillaggregates.Count == 0)
                    {
                        drillaggregates.Add(initagg);
                    }
                    else
                    {
                        drillaggregates[0] = initagg;
                    }
                    watch.Stop();
                    WriteLine("Execution time in seconds: {0}", watch.Elapsed.TotalSeconds);
                }
                else if (menuoption == 3)       // Drill-down
                {
                    var watch = Stopwatch.StartNew();
                    headermenu(headers);
                    Write("Enter drill-down aggregate choice #: ");
                    int drillagg = Convert.ToInt32(Console.ReadLine());

                    if (!drillaggregates.Contains(drillagg))
                    {
                        drillaggregates.Add(drillagg);
                    }

                    displayaggregatetable(data, headers, drillaggregates.ToArray(), filters.ToArray(), filterdata.ToArray());
                    watch.Stop();
                    WriteLine("Execution time in seconds: {0}", watch.Elapsed.TotalSeconds);
                }
                else if (menuoption == 4)       // Filter
                {
                    var watch = Stopwatch.StartNew();
                    headermenu(headers);
                    Write("Enter filter header choice #: ");
                    int filterheader  = Convert.ToInt32(Console.ReadLine());
                    var filteroptions = new List <object>();

                    for (int i = 0; i < data.Rows.Count; i++)
                    {
                        filteroptions.Add(data.Rows[i][filterheader]);
                    }
                    filteroptions = filteroptions.Distinct().ToList();

                    WriteLine("Filter options: ");
                    for (int i = 0; i < filteroptions.Count; i++)
                    {
                        WriteLine("\t{0}. {1}", i, filteroptions[i]);
                    }

                    Write("Enter filter option choice #: ");
                    int filterby = Convert.ToInt32(Console.ReadLine());
                    var filter   = filteroptions[filterby];

                    if (!filters.Contains(filterheader))
                    {
                        filters.Add(filterheader);
                        filterdata.Add(filter);
                    }

                    if (drillaggregates.Count > 1 || filters.Count > 0)
                    {
                        displayaggregatetable(data, headers, drillaggregates.ToArray(), filters.ToArray(), filterdata.ToArray());
                    }
                    else
                    {
                        if (filters.Count == 0 && drillaggregates.Count == 1)
                        {
                            var filtertable = data.Clone();
                            for (int i = 0; i < filtertable.Rows.Count; i++)
                            {
                                if (filtertable.Rows[i][filterheader] != filter)
                                {
                                    filtertable.Rows[i].Delete();
                                }
                            }
                            filtertable.AcceptChanges();
                            WriteLine(string.Join(",", headers));
                            for (int i = 0; i < filtertable.Rows.Count; i++)
                            {
                                WriteLine(string.Join(", ", filtertable.Rows[i].ItemArray));
                            }
                        }
                    }
                    watch.Stop();
                    WriteLine("Execution time in seconds: {0}", watch.Elapsed.TotalSeconds);
                }
                else if (menuoption == 5)       // View
                {
                    var       watch = Stopwatch.StartNew();
                    DataTable x, y;
                    int       xhead, yhead;

                    if (filters.Count == 0 && drillaggregates.Count == 1)
                    {
                        headermenu(headers);
                        Write("Enter x header column #: ");
                        xhead = Convert.ToInt32(Console.ReadLine());
                        Write("Enter y header column #: ");
                        yhead = Convert.ToInt32(Console.ReadLine());

                        x = data.Copy();
                        y = data.Copy();

                        for (int i = data.Columns.Count; i-- > 0;)
                        {
                            if (i != xhead)
                            {
                                x.Columns.RemoveAt(i);
                            }
                            if (i != yhead)
                            {
                                y.Columns.RemoveAt(i);
                            }
                        }
                    }
                    else
                    {
                        WriteLine("Header options (remove drill aggregates to display more options):");
                        for (int i = 0; i < drillaggregates.Count; i++)
                        {
                            WriteLine("{0}. {1}", drillaggregates[i], headers[drillaggregates[i]]);
                        }

                        Write("Enter x header column #: ");
                        xhead = Convert.ToInt32(Console.ReadLine());
                        Write("Enter y header column #: ");
                        yhead = Convert.ToInt32(Console.ReadLine());

                        var sorteddrillagg = drillaggregates.ToArray();
                        Array.Sort(sorteddrillagg);
                        int xheadind = Array.IndexOf(sorteddrillagg, xhead);
                        int yheadind = Array.IndexOf(sorteddrillagg, yhead);

                        x = getaggregatetable(data, drillaggregates.ToArray(), filters.ToArray(), filterdata.ToArray());
                        for (int i = x.Columns.Count; i-- > 0;)
                        {
                            if (i != xheadind)
                            {
                                x.Columns.RemoveAt(i);
                            }
                        }

                        y = getaggregatetable(data, drillaggregates.ToArray(), filters.ToArray(), filterdata.ToArray());
                        for (int i = y.Columns.Count; i-- > 0;)
                        {
                            if (i != yheadind)
                            {
                                y.Columns.RemoveAt(i);
                            }
                        }
                    }

                    WriteLine("Graph options:\n\t1. Bar\n\t2. Line\n\t3. Line with Marker\n\t4. Scatter\n\t5. Pie");
                    Write("Enter graph choice #: ");
                    int graphtype = Convert.ToInt32(Console.ReadLine());

                    var xlist = new List <object>();
                    var ylist = new List <object>();

                    for (int i = 0; i < x.Rows.Count; i++)
                    {
                        xlist.Add(x.Rows[i][0]);
                        ylist.Add(y.Rows[i][0]);
                    }

                    var myModel = new PlotModel {
                        Title      = $"Data from the CSV File: {headers[xhead]} and {headers[yhead]}",
                        Background = OxyColors.White
                    };

                    var linearAxis1 = new LinearAxis();
                    linearAxis1.Position = AxisPosition.Bottom;
                    var linearAxis2 = new LinearAxis();
                    linearAxis2.Position = AxisPosition.Left;

                    if (graphtype != 5 || graphtype != 1)
                    {
                        linearAxis1.Title = headers[xhead].ToString();
                        linearAxis2.Title = headers[yhead].ToString();
                    } // else { linearAxis1.Title = headers[xhead].ToString(); }

                    if (graphtype != 1)
                    {
                        myModel.Axes.Add(linearAxis1);
                    }
                    if (graphtype != 1)
                    {
                        myModel.Axes.Add(linearAxis2);
                    }

                    if (graphtype == 1)             // Bar
                    {
                        var barSource = new List <BarItem>();
                        for (int i = 0; i < xlist.Count; i++)
                        {
                            barSource.Add(new BarItem {
                                Value = Convert.ToDouble(ylist[i])
                            });
                        }

                        var barSeries = new BarSeries {
                            ItemsSource    = barSource,
                            LabelPlacement = LabelPlacement.Inside,
                        };

                        var catSource = new List <string>();
                        for (int i = 0; i < xlist.Count; i++)
                        {
                            catSource.Add(xlist[i].ToString());
                        }


                        linearAxis1.Title = headers[yhead].ToString();
                        myModel.Series.Add(barSeries);
                        myModel.Axes.Add(new CategoryAxis {
                            Position    = AxisPosition.Left,
                            Key         = "X_Axis",
                            Title       = headers[xhead].ToString(),
                            ItemsSource = catSource.ToArray()
                        });
                        myModel.Axes.Add(linearAxis1);
                    }
                    else if (graphtype == 2)        // Line
                    {
                        var lineSeries = new LineSeries();
                        for (int i = 0; i < xlist.Count; i++)
                        {
                            lineSeries.Points.Add(new DataPoint(Convert.ToDouble(xlist[i]), Convert.ToDouble(ylist[i])));
                        }
                        myModel.Series.Add(lineSeries);
                    }
                    else if (graphtype == 3)        // Line with Marker
                    {
                        var lineSeries = new LineSeries();
                        lineSeries.MarkerType            = MarkerType.Circle;
                        lineSeries.MarkerSize            = 5;
                        lineSeries.MarkerStroke          = OxyColors.Black;
                        lineSeries.MarkerFill            = OxyColors.SkyBlue;
                        lineSeries.MarkerStrokeThickness = 1.5;
                        for (int i = 0; i < xlist.Count; i++)
                        {
                            lineSeries.Points.Add(new DataPoint(Convert.ToDouble(xlist[i]), Convert.ToDouble(ylist[i])));
                        }
                        myModel.Series.Add(lineSeries);
                    }
                    else if (graphtype == 4)        // Scatter
                    {
                        var scatterSeries = new ScatterSeries();
                        for (int i = 0; i < xlist.Count; i++)
                        {
                            scatterSeries.Points.Add(new ScatterPoint(Convert.ToDouble(xlist[i]), Convert.ToDouble(ylist[i])));
                        }
                        myModel.Series.Add(scatterSeries);
                    }
                    else if (graphtype == 5)        // Pie
                    {
                        var aggr_x = xlist.Distinct().ToList();
                        //plt.pie(aggr_x, labels=aggr_x)
                        var pieSeries = new PieSeries {
                            StrokeThickness = 2.0, InsideLabelPosition = 0.8, AngleSpan = 360, StartAngle = 0
                        };
                        for (int i = 0; i < xlist.Count; i++)
                        {
                            pieSeries.Slices.Add(new PieSlice(xlist[i].ToString(), Convert.ToDouble(ylist[i]))
                            {
                                IsExploded = false
                            });
                        }
                        myModel.Series.Add(pieSeries);
                        //https://oxyplot.readthedocs.io/en/latest/models/series/PieSeries.html
                    }

                    var form = new Form1(myModel);
                    Application.EnableVisualStyles();
                    Application.Run(form);


                    var stream      = new MemoryStream();
                    var pngExporter = new PngExporter {
                        Width = 600, Height = 400
                    };                                                              //, Background = OxyColors.White };
                    pngExporter.Export(myModel, stream);

                    var bytes = new Byte[(int)stream.Length];
                    stream.Seek(0, SeekOrigin.Begin);
                    stream.Read(bytes, 0, (int)stream.Length);

                    string b64  = Convert.ToBase64String(bytes);
                    string uri  = "data:image/png;base64," + b64;
                    string html = $"<img src = \"{uri}\"/>";

                    watch.Stop();
                    WriteLine("Execution time in seconds: {0}", watch.Elapsed.TotalSeconds);
                }
                else if (menuoption == 6)       // Quit
                {
                    runprog = false;
                    return;
                }
                else if (menuoption == 7)       // Reset Drill Aggregates
                {
                    var watch = Stopwatch.StartNew();
                    drillaggregates.Clear();
                    watch.Stop();
                    WriteLine("Execution time in seconds: {0}", watch.Elapsed.TotalSeconds);
                }
                else if (menuoption == 8)       // Reset Filters
                {
                    var watch = Stopwatch.StartNew();
                    filters.Clear();
                    filterdata.Clear();
                    watch.Stop();
                    WriteLine("Execution time in seconds: {0}", watch.Elapsed.TotalSeconds);
                }
                else if (menuoption == 9)       // Remove Drill Aggregate
                {
                    var watch = Stopwatch.StartNew();
                    WriteLine("Current drill aggregates:");
                    for (int i = 0; i < drillaggregates.Count; i++)
                    {
                        WriteLine("{0}. {1}", i, headers[drillaggregates[i]]);
                    }

                    Write("Enter choice # to remove: ");
                    int removechoice = Convert.ToInt32(Console.ReadLine());
                    drillaggregates.RemoveAt(removechoice);
                    watch.Stop();
                    WriteLine("Execution time in seconds: {0}", watch.Elapsed.TotalSeconds);
                }
                else if (menuoption == 10)      // Remove Filter
                {
                    var watch = Stopwatch.StartNew();
                    WriteLine("Current filters:");
                    for (int i = 0; i < filters.Count; i++)
                    {
                        WriteLine("{0}. {1}", i, headers[filters[i]]);
                    }

                    Write("Enter choice # to remove: ");
                    int removechoice = Convert.ToInt32(Console.ReadLine());
                    filters.RemoveAt(removechoice);
                    filterdata.RemoveAt(removechoice);
                    watch.Stop();
                    WriteLine("Execution time in seconds: {0}", watch.Elapsed.TotalSeconds);
                }
            } catch (Exception ex) {
                WriteLine(ex.StackTrace);
            }
        } while (runprog);
    }
示例#32
0
        /// <summary>
        /// Saves the local Avatar
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
        protected void UploadUpdate_Click([NotNull] object sender, [NotNull] EventArgs e)
        {
            if (this.File.PostedFile == null || this.File.PostedFile.FileName.Trim().Length <= 0 ||
                this.File.PostedFile.ContentLength <= 0)
            {
                return;
            }

            long x          = this.Get <YafBoardSettings>().AvatarWidth;
            long y          = this.Get <YafBoardSettings>().AvatarHeight;
            var  avatarSize = this.Get <YafBoardSettings>().AvatarSize;

            Stream resized = null;

            try
            {
                using (var img = Image.FromStream(this.File.PostedFile.InputStream))
                {
                    if (img.Width > x || img.Height > y)
                    {
                        this.PageContext.AddLoadMessage(
                            $"{this.GetTextFormatted("WARN_TOOBIG", x, y)} {this.GetTextFormatted("WARN_SIZE", img.Width, img.Height)} {this.GetText("CP_EDITAVATAR", "WARN_RESIZED")}");

                        resized = ImageHelper.GetResizedImageStreamFromImage(img, x, y);
                    }
                }

                // Delete old first...
                this.GetRepository <User>().DeleteAvatar(this.currentUserId);

                if (this.Get <YafBoardSettings>().UseFileTable)
                {
                    var image = Image.FromStream(resized ?? this.File.PostedFile.InputStream);

                    var memoryStream = new MemoryStream();
                    image.Save(memoryStream, image.RawFormat);
                    memoryStream.Position = 0;

                    this.GetRepository <User>().SaveAvatar(
                        this.currentUserId,
                        null,
                        memoryStream,
                        this.File.PostedFile.ContentType);
                }
                else
                {
                    var uploadFolderPath = this.Get <HttpRequestBase>().MapPath(
                        string.Concat(BaseUrlBuilder.ServerFileRoot, YafBoardFolders.Current.Uploads));

                    // check if Uploads folder exists
                    if (!Directory.Exists(uploadFolderPath))
                    {
                        Directory.CreateDirectory(uploadFolderPath);
                    }

                    var fileName = this.File.PostedFile.FileName;

                    var pos = fileName.LastIndexOfAny(new[] { '/', '\\' });

                    if (pos >= 0)
                    {
                        fileName = fileName.Substring(pos + 1);
                    }

                    // filename can be only 255 characters long (due to table column)
                    if (fileName.Length > 255)
                    {
                        fileName = fileName.Substring(fileName.Length - 255);
                    }

                    var newFileName = $"{this.currentUserId}{Path.GetExtension(fileName)}";

                    var filePath = Path.Combine(uploadFolderPath, newFileName);

                    // Delete old avatar
                    if (System.IO.File.Exists(filePath))
                    {
                        System.IO.File.Delete(filePath);
                    }

                    var avatarImage = Image.FromStream(resized ?? this.File.PostedFile.InputStream);

                    using (var memory = new MemoryStream())
                    {
                        using (var fs = new FileStream(filePath, FileMode.Create, FileAccess.ReadWrite))
                        {
                            avatarImage.Save(memory, avatarImage.RawFormat);
                            var bytes = memory.ToArray();
                            fs.Write(bytes, 0, bytes.Length);
                        }
                    }

                    this.GetRepository <User>().SaveAvatar(
                        this.currentUserId,
                        $"{YafForumInfo.ForumBaseUrl}{YafBoardFolders.Current.Uploads}/{newFileName}",
                        null,
                        null);
                }

                // clear the cache for this user...
                this.Get <IRaiseEvent>().Raise(new UpdateUserEvent(this.currentUserId));

                if (avatarSize > 0 && this.File.PostedFile.ContentLength >= avatarSize && resized == null)
                {
                    this.PageContext.AddLoadMessage(
                        $"{this.GetTextFormatted("WARN_BIGFILE", avatarSize)} {this.GetTextFormatted("WARN_FILESIZE", this.File.PostedFile.ContentLength)}",
                        MessageTypes.warning);
                }

                this.BindData();
            }
            catch (Exception exception)
            {
                this.Logger.Log(
                    exception.Message,
                    EventLogTypes.Error,
                    this.PageContext.CurrentUserData.UserName,
                    string.Empty,
                    exception);

                // image is probably invalid...
                this.PageContext.AddLoadMessage(this.GetText("CP_EDITAVATAR", "INVALID_FILE"), MessageTypes.danger);
            }
        }
示例#33
0
        public void Process(Map map, MapInfo info)
        {
            Grid <byte> heightMap = new Grid <byte>(map.HeightMap.MapWidth, map.HeightMap.MapHeight);

            if (AddObjects)
            {
                foreach (var o in map.Objects)
                {
                    if (!o.IsWaypoint && o.RoadOptions == RoadOptions.None)
                    {
                        var coordinates = map.PositionToCoordinates(o.GetPosition());

                        if (info.Tiles[coordinates.X, coordinates.Y].HasFlag(TileInfo.Structure))
                        {
                            heightMap[coordinates.X - map.HeightMap.Border, coordinates.Y - map.HeightMap.Border] = 255;
                        }
                    }
                }
            }

            using (MemoryStream tga = new MemoryStream())
            {
                BinaryWriter writer = new BinaryWriter(tga);
                writer.Write((byte)0);                                   // Id Length
                writer.Write((byte)0);                                   // Cmap Type
                writer.Write((byte)10);                                  // Image Type (TGA_RLERGB 10)

                writer.Write((UInt16)0);                                 // Cmap Index
                writer.Write((UInt16)0);                                 // Cmap Length
                writer.Write((byte)0);                                   // Cmap Entry Size

                writer.Write((UInt16)0);                                 // X Origin
                writer.Write((UInt16)0);                                 // Y Origin
                writer.Write(Convert.ToUInt16(map.HeightMap.MapWidth));  // Image Width
                writer.Write(Convert.ToUInt16(map.HeightMap.MapHeight)); // Image Height
                writer.Write((byte)32);                                  // Pixel Depth
                writer.Write((byte)0);                                   // Imag Desc

                List <System.Drawing.Color> tgaPacket = new List <System.Drawing.Color>();

                for (int j = 0; j < heightMap.Height; j++)
                {
                    for (int i = 0; i < heightMap.Width; i++)
                    {
                        byte height = map.HeightMap[i + map.HeightMap.Border, j + map.HeightMap.Border];

                        if (height > heightMap[i, j])
                        {
                            heightMap[i, j] = height;
                        }

                        Color pixel = Color.FromArgb(height, height, height);
                        tgaPacket.Add(pixel);
                        if (tgaPacket.Count == 128)
                        {
                            WriteTgaPacket(writer, tgaPacket);
                        }
                    }
                }
                WriteTgaPacket(writer, tgaPacket);

                lock (Lock)
                {
                    BmpPreview = heightMap.ToArray();
                    TgaPreview = tga.ToArray();
                }
            }
        }
示例#34
0
 public IProjectItemModel CreateProjectItem(string path, byte[] content, bool overwrite)
 {
     var contentStream = new MemoryStream(content);
     return CreateProjectItem(path, contentStream, overwrite);
 }
        internal WebHeaderCollection WriteHeadersTo(MemoryStream destination)
        {
            var headers = new WebHeaderCollection(HttpHeaderType.Response, true);

            if (_headers != null)
            {
                headers.Add(_headers);
            }

            if (_contentType != null)
            {
                var type = _contentType.IndexOf("charset=", StringComparison.Ordinal) == -1 &&
                           _contentEncoding != null
                   ? String.Format("{0}; charset={1}", _contentType, _contentEncoding.WebName)
                   : _contentType;

                headers.InternalSet("Content-Type", type, true);
            }

            if (headers.GetOne("Server") == null)
            {
                headers.InternalSet("Server", "websocket-sharp/1.0", true);
            }

            var prov = CultureInfo.InvariantCulture;

            if (headers.GetOne("Date") == null)
            {
                headers.InternalSet("Date", DateTime.UtcNow.ToString("r", prov), true);
            }

            if (!_sendChunked)
            {
                headers.InternalSet("Content-Length", _contentLength.ToString(prov), true);
            }
            else
            {
                headers.InternalSet("Transfer-Encoding", "chunked", true);
            }

            /*
             * Apache forces closing the connection for these status codes:
             * - 400 Bad Request
             * - 408 Request Timeout
             * - 411 Length Required
             * - 413 Request Entity Too Large
             * - 414 Request-Uri Too Long
             * - 500 Internal Server Error
             * - 503 Service Unavailable
             */
            var closeConn = !_context.Request.KeepAlive ||
                            !_keepAlive ||
                            _statusCode == 400 ||
                            _statusCode == 408 ||
                            _statusCode == 411 ||
                            _statusCode == 413 ||
                            _statusCode == 414 ||
                            _statusCode == 500 ||
                            _statusCode == 503;

            var reuses = _context.Connection.Reuses;

            if (closeConn || reuses >= 100)
            {
                headers.InternalSet("Connection", "close", true);
            }
            else
            {
                headers.InternalSet(
                    "Keep-Alive", String.Format("timeout=15,max={0}", 100 - reuses), true);

                if (_context.Request.ProtocolVersion < HttpVersion.Version11)
                {
                    headers.InternalSet("Connection", "keep-alive", true);
                }
            }

            if (_location != null)
            {
                headers.InternalSet("Location", _location, true);
            }

            if (_cookies != null)
            {
                foreach (Cookie cookie in _cookies)
                {
                    headers.InternalSet("Set-Cookie", cookie.ToResponseString(), true);
                }
            }

            var enc    = _contentEncoding ?? Encoding.Default;
            var writer = new StreamWriter(destination, enc, 256);

            writer.Write("HTTP/{0} {1} {2}\r\n", _version, _statusCode, _statusDescription);
            writer.Write(headers.ToStringMultiValue(true));
            writer.Flush();

            // Assumes that the destination was at position 0.
            destination.Position = enc.GetPreamble().Length;

            return(headers);
        }
示例#36
0
        public ActionResult LogoFoto(int ContratanteId, HttpPostedFileBase file)
        {
            ViewBag.ContratanteID = ContratanteId;
            int grupoId   = (int)Geral.PegaAuthTicket("Grupo");
            int usuarioId = (int)Geral.PegaAuthTicket("UsuarioId");

            if (file == null)
            {
                ModelState.AddModelError("", "Escolha uma Imagem!");
            }
            else
            {
                MemoryStream target = new MemoryStream();
                file.InputStream.CopyTo(target);

                Bitmap imagem1 = (Bitmap)Image.FromStream(target);
                Bitmap imagemRedimensionada = ScaleImage(imagem1, 220, 130);

                MemoryStream novaImagem = new MemoryStream();
                imagemRedimensionada.Save(novaImagem, System.Drawing.Imaging.ImageFormat.Png);

                Contratante contratante = Db.Contratante.FirstOrDefault(c => c.WFD_GRUPO.Any(g => g.ID == grupoId));
                if (contratante != null)
                {
                    contratante.LOGO_FOTO = novaImagem.ToArray();

                    //string extensao = (file.FileName.IndexOf(".") >= 0) ? file.FileName.Substring(file.FileName.IndexOf(".")) : "";
                    contratante.EXTENSAO_IMAGEM = ".png";

                    Db.Entry(contratante).State = EntityState.Modified;
                }
                Db.SaveChanges();

                string caminhoFisico   = Server.MapPath("/ImagensUsuarios");
                string arquivo         = "ImagemContratante" + contratante.ID + ".png";
                string caminhoCompleto = caminhoFisico + "\\" + arquivo;
                System.IO.File.WriteAllBytes(caminhoCompleto, novaImagem.ToArray());

                string dados = User.Identity.Name;
                dados = dados.Replace("semfoto.png", arquivo).Replace("semlogo.png", arquivo);

                var usuario = Db.WFD_USUARIO
                              .Include("WAC_PERFIL.WAC_FUNCAO")
                              .FirstOrDefault(u => u.ID == usuarioId);

                string roles = string.Empty;
                foreach (var perfil in usuario.WAC_PERFIL)
                {
                    foreach (var funcao in perfil.WAC_FUNCAO)
                    {
                        if (!roles.Contains(funcao.CODIGO))
                        {
                            roles += funcao.CODIGO + ",";
                        }
                    }
                }

                _metodosGerais.CriarAuthTicket(dados, roles);
                _metodosGerais.AuthenticateRequest();

                ViewBag.MensagemSucesso = "Imagem Salva com sucesso!";
            }
            return(View());
        }
示例#37
0
    public void OnSaveDialog(Notification notification)
    {
        KeyValuePair <string, string> results = (KeyValuePair <string, string>)notification.data;
        String bot_transcript  = results.Value;
        String user_transcript = results.Key;

        DateTime today = System.DateTime.Now;
        string   key   = today.ToString("yyyy-MM-dd") + "/" + PlayerPrefs.GetString("guid") + ".txt";

        string dialogue = "{\"actor\": \"human\", \"msg\": \"" + user_transcript + "\", \"timestamp\": \"" + today.ToString() + "\"}\n" +
                          "{\"actor\": \"bot\", \"msg\": \"" + bot_transcript + "\", \"timestamp\": \"" + today.ToString() + "\"}\n";

        byte[] dialogueData = System.Text.Encoding.UTF8.GetBytes(dialogue);

        Stream stream   = new MemoryStream();
        int    position = 0;

        try {
            s3Client.GetObjectAsync("unitychat", key, (responseObj) => {
                if (responseObj.Response != null)
                {
                    var response = responseObj.Response;
                    if (response.ResponseStream != null)
                    {
                        Stream inputStream = response.ResponseStream;
                        byte[] buffer      = new byte[16 * 1024];
                        int read;
                        while ((read = inputStream.Read(buffer, 0, buffer.Length)) > 0)
                        {
                            stream.Write(buffer, 0, read);
                        }
                        position = (int)inputStream.Length;
                    }
                }
                TextWriter writer = new StreamWriter(stream);
                writer.Write(dialogue);
                writer.Flush();
                stream.Position = 0L;

                var request = new PostObjectRequest()
                {
                    Region      = RegionEndpoint.USEast1,
                    Bucket      = "unitychat",
                    Key         = key,
                    InputStream = stream,
                    CannedACL   = S3CannedACL.PublicReadWrite
                };

                try {
                    s3Client.PostObjectAsync(request, (postResponseObj) => {
                        if (postResponseObj.Exception == null)
                        {
                            Debug.Log(string.Format("object {0} posted to bucket", postResponseObj.Request.Key));
                        }
                        else
                        {
                            Debug.Log(string.Format("receieved error {0}", postResponseObj.Exception.StackTrace));
                        }
                    });
                } catch (Exception e) {
                    Debug.Log("exception: " + e.ToString());
                }
            });
        } catch (Exception ex) {
            Debug.Log("Amazon died trying to run:" + ex.Message);
        }
    }
示例#38
0
 public void InitBuffers()
 {
     _stream = new MemoryStream();
     _writer = new EndianBinaryWriter(EndianBitConverter.Little, _stream);
 }
示例#39
0
 public BinaryWriter CreateStaticDictionaryCache()
 {
     staticDictionaryStream = new MemoryStream();
     var writer = new BinaryWriter(staticDictionaryStream);
     return writer;
 }
示例#40
0
 public bool runTest()
 {
     Console.WriteLine(s_strTFPath + " " + s_strTFName + " , for " + s_strClassMethod + " , Source ver : " + s_strDtTmVer);
     int iCountErrors = 0;
     int iCountTestcases = 0;
     String strLoc = "Loc_000oo";
     Hashtable hsh1;
     String strValue;
     Thread[] workers;
     ThreadStart ts1;
     Int32 iNumberOfWorkers = 15;
     Boolean fLoopExit;
     DictionaryEntry[] strValueArr;
     String[] strKeyArr;
     Hashtable hsh3;
     Hashtable hsh4;
     IDictionaryEnumerator idic;
     MemoryStream ms1;
     Boolean fPass;
     Object oValue;
     try 
     {
         do
         {
             hsh1 = new Hashtable();
             for(int i=0; i<iNumberOfElements; i++)
             {
                 hsh1.Add("Key_" + i, "Value_" + i);
             }
             hsh2 = Hashtable.Synchronized(hsh1);
             fPass = true;
             iCountTestcases++;
             if(hsh2.Count != hsh1.Count) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_742dsf! Expected value not returned, " + hsh2.Count);
             }
             for(int i=0; i<iNumberOfElements; i++)
             {
                 if(!((String)hsh2["Key_" + i]).Equals("Value_" + i))
                 {
                     Console.WriteLine(hsh2["Key_" + i]);
                     fPass = false;
                 }
             }
             try
             {
                 oValue = hsh2[null];
                 fPass = false;
             }
             catch(ArgumentNullException)
             {
             }
             catch(Exception)
             {
                 fPass = false;
             }
             hsh2.Clear();
             for(int i=0; i<iNumberOfElements; i++)
             {
                 hsh2["Key_" + i] =  "Value_" + i;
             }
             if(!fPass)
             {
                 iCountErrors++;
                 Console.WriteLine("Err_752dsgf! Oh man! This is busted!!!!");
             }
             strValueArr = new DictionaryEntry[hsh2.Count];
             hsh2.CopyTo(strValueArr, 0);
             hsh3 = new Hashtable();
             for(int i=0; i<iNumberOfElements; i++)
             {
                 if(!hsh2.Contains("Key_" + i)) 
                 {
                     iCountErrors++;
                     Console.WriteLine("Err_742ds8f! Expected value not returned, " + hsh2.Contains("Key_" + i));
                 }				
                 if(!hsh2.ContainsKey("Key_" + i)) 
                 {
                     iCountErrors++;
                     Console.WriteLine("Err_742389dsaf! Expected value not returned, " + hsh2.ContainsKey("Key_" + i));
                 }				
                 if(!hsh2.ContainsValue("Value_" + i)) 
                 {
                     iCountErrors++;
                     Console.WriteLine("Err_563fgd! Expected value not returned, " + hsh2.ContainsValue("Value_" + i));
                 }				
                 if(!hsh1.ContainsValue(((DictionaryEntry)strValueArr[i]).Value)) 
                 {
                     iCountErrors++;
                     Console.WriteLine("Err_87429dsfd! Expected value not returned, " + ((DictionaryEntry)strValueArr[i]).Value);
                 }				
                 try
                 {
                     hsh3.Add(strValueArr[i], null);
                 }
                 catch(Exception)
                 {
                     iCountErrors++;
                     Console.WriteLine("Err_74298dsd! Exception thrown for  " + strValueArr[i]);
                 }
             }
             hsh4 = (Hashtable)hsh2.Clone();
             if(hsh4.Count != hsh1.Count) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_342342! Expected value not returned, " + hsh4.Count);
             }				
             strValueArr = new DictionaryEntry[hsh4.Count];
             hsh4.CopyTo(strValueArr, 0);
             hsh3 = new Hashtable();
             for(int i=0; i<iNumberOfElements; i++)
             {
                 if(!hsh4.Contains("Key_" + i)) 
                 {
                     iCountErrors++;
                     Console.WriteLine("Err_742ds8f! Expected value not returned, " + hsh4.Contains("Key_" + i));
                 }				
                 if(!hsh4.ContainsKey("Key_" + i)) 
                 {
                     iCountErrors++;
                     Console.WriteLine("Err_742389dsaf! Expected value not returned, " + hsh4.ContainsKey("Key_" + i));
                 }				
                 if(!hsh4.ContainsValue("Value_" + i)) 
                 {
                     iCountErrors++;
                     Console.WriteLine("Err_6-4142dsf! Expected value not returned, " + hsh4.ContainsValue("Value_" + i));
                 }				
                 if(!hsh1.ContainsValue(((DictionaryEntry)strValueArr[i]).Value)) 
                 {
                     iCountErrors++;
                     Console.WriteLine("Err_87429dsfd! Expected value not returned, " + ((DictionaryEntry)strValueArr[i]).Value);
                 }				
                 try
                 {
                     hsh3.Add(((DictionaryEntry)strValueArr[i]).Value, null);
                 }
                 catch(Exception)
                 {
                     iCountErrors++;
                     Console.WriteLine("Err_74298dsd! Exception thrown for  " + ((DictionaryEntry)strValueArr[i]).Value);
                 }
             }
             if(hsh4.IsReadOnly) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_723sadf! Expected value not returned, " + hsh4.IsReadOnly);
             }
             if(!hsh4.IsSynchronized) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_723sadf! Expected value not returned, " + hsh4.IsSynchronized);
             }
             idic = hsh2.GetEnumerator();
             hsh3 = new Hashtable();
             hsh4 = new Hashtable();
         while(idic.MoveNext())
         {
             if(!hsh2.ContainsKey(idic.Key)) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_4532sfds! Expected value not returned");
             }				
             if(!hsh2.ContainsValue(idic.Value)) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_682wm! Expected value not returned");
             }				
             try
             {
                 hsh3.Add(idic.Key, null);
             }
             catch(Exception)
             {
                 iCountErrors++;
                 Console.WriteLine("Err_5243sfd! Exception thrown for  " + idic.Key);
             }
             try
             {
                 hsh4.Add(idic.Value, null);
             }
             catch(Exception)
             {
                 iCountErrors++;
                 Console.WriteLine("Err_25sfs! Exception thrown for  " + idic.Value);
             }
         }
             BinaryFormatter formatter = new BinaryFormatter();
             ms1 = new MemoryStream();
             formatter.Serialize(ms1, hsh2);
             ms1.Position = 0;
             hsh4 = (Hashtable)formatter.Deserialize(ms1);
             if(hsh4.Count != hsh1.Count) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_072xsf! Expected value not returned, " + hsh4.Count);
             }				
             strValueArr = new DictionaryEntry[hsh4.Count];
             hsh4.CopyTo(strValueArr, 0);
             hsh3 = new Hashtable();
             for(int i=0; i<iNumberOfElements; i++)
             {
                 if(!hsh4.Contains("Key_" + i)) 
                 {
                     iCountErrors++;
                     Console.WriteLine("Err_742ds8f! Expected value not returned, " + hsh4.Contains("Key_" + i));
                 }				
                 if(!hsh4.ContainsKey("Key_" + i)) 
                 {
                     iCountErrors++;
                     Console.WriteLine("Err_742389dsaf! Expected value not returned, " + hsh4.ContainsKey("Key_" + i));
                 }				
                 if(!hsh4.ContainsValue("Value_" + i)) 
                 {
                     iCountErrors++;
                     Console.WriteLine("Err_0672esfs! Expected value not returned, " + hsh4.ContainsValue("Value_" + i));
                 }				
                 if(!hsh1.ContainsValue(((DictionaryEntry)strValueArr[i]).Value)) 
                 {
                     iCountErrors++;
                     Console.WriteLine("Err_87429dsfd! Expected value not returned, " + ((DictionaryEntry)strValueArr[i]).Value);
                 }				
                 try
                 {
                     hsh3.Add(((DictionaryEntry)strValueArr[i]).Value, null);
                 }
                 catch(Exception)
                 {
                     iCountErrors++;
                     Console.WriteLine("Err_74298dsd! Exception thrown for  " + strValueArr[i]);
                 }
             }
             if(hsh4.IsReadOnly) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_723sadf! Expected value not returned, " + hsh4.IsReadOnly);
             }
             if(!hsh4.IsSynchronized) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_723sadf! Expected value not returned, " + hsh4.IsSynchronized);
             }
             if(hsh2.IsReadOnly) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_723sadf! Expected value not returned, " + hsh2.IsReadOnly);
             }
             if(!hsh2.IsSynchronized) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_723sadf! Expected value not returned, " + hsh2.IsSynchronized);
             }
             if(hsh2.SyncRoot != hsh1) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_7428dsafd! Expected value not returned, ");
             }
             String[] strValueArr11 = new String[hsh1.Count];
             strKeyArr = new String[hsh1.Count];
             hsh2.Keys.CopyTo(strKeyArr, 0);
             hsh2.Values.CopyTo(strValueArr11, 0);
             hsh3 = new Hashtable();
             hsh4 = new Hashtable();
             for(int i=0; i<iNumberOfElements; i++)
             {
                 if(!hsh2.ContainsKey(strKeyArr[i])) 
                 {
                     iCountErrors++;
                     Console.WriteLine("Err_4532sfds! Expected value not returned");
                 }				
                 if(!hsh2.ContainsValue(strValueArr11[i])) 
                 {
                     iCountErrors++;
                     Console.WriteLine("Err_074dsd! Expected value not returned, " + strValueArr11[i]);
                 }				
                 try
                 {
                     hsh3.Add(strKeyArr[i], null);
                 }
                 catch(Exception)
                 {
                     iCountErrors++;
                     Console.WriteLine("Err_5243sfd! Exception thrown for  " + idic.Key);
                 }
                 try
                 {
                     hsh4.Add(strValueArr11[i], null);
                 }
                 catch(Exception)
                 {
                     iCountErrors++;
                     Console.WriteLine("Err_25sfs! Exception thrown for  " + idic.Value);
                 }
             }
             hsh2.Remove("Key_1");
             if(hsh2.ContainsKey("Key_1")) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_423ewd! Expected value not returned, ");
             }				
             if(hsh2.ContainsValue("Value_1")) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_64q213d! Expected value not returned, ");
             }				
             hsh2.Add("Key_1", "Value_1");
             if(!hsh2.ContainsKey("Key_1")) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_423ewd! Expected value not returned, ");
             }				
             if(!hsh2.ContainsValue("Value_1")) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_74523esf! Expected value not returned, ");
             }				
             hsh2["Key_1"] = "Value_Modified_1";
             if(!hsh2.ContainsKey("Key_1")) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_423ewd! Expected value not returned, ");
             }				
             if(hsh2.ContainsValue("Value_1")) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_74523esf! Expected value not returned, ");
             }				
             if(!hsh2.ContainsValue("Value_Modified_1")) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_342fs! Expected value not returned, ");
             }		
             hsh3 = Hashtable.Synchronized(hsh2);
             if(hsh3.Count != hsh1.Count) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_742dsf! Expected value not returned, " + hsh3.Count);
             }				
             if(!hsh3.IsSynchronized) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_723sadf! Expected value not returned, " + hsh3.IsSynchronized);
             }
             hsh2.Clear();		
             if(hsh2.Count != 0) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_742dsf! Expected value not returned, " + hsh2.Count);
             }				
             strLoc = "Loc_8345vdfv";
             hsh1 = new Hashtable();
             hsh2 = Hashtable.Synchronized(hsh1);
             workers = new Thread[iNumberOfWorkers];
             ts1 = new ThreadStart(AddElements);
             for(int i=0; i<workers.Length; i++)
             {
                 workers[i] = new Thread(ts1);
                 workers[i].Name = "Thread worker " + i;
                 workers[i].Start();
             }
         while(true)
         {
             fLoopExit=false;
             for(int i=0; i<iNumberOfWorkers;i++)
             {
                 if(workers[i].IsAlive)
                     fLoopExit=true;
             }
             if(!fLoopExit)
                 break;
         }
             iCountTestcases++;
             if(hsh2.Count != iNumberOfElements*iNumberOfWorkers) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_75630fvbdf! Expected value not returned, " + hsh2.Count);
             }
             iCountTestcases++;
             for(int i=0; i<iNumberOfWorkers; i++)
             {
                 for(int j=0; j<iNumberOfElements; j++)
                 {
                     strValue = "Thread worker " + i + "_" + j;
                     if(!hsh2.Contains(strValue))
                     {
                         iCountErrors++;
                         Console.WriteLine("Err_452dvdf_" + i + "_" + j + "! Expected value not returned, " + strValue);
                     }
                 }
             }
             workers = new Thread[iNumberOfWorkers];
             ts1 = new ThreadStart(RemoveElements);
             for(int i=0; i<workers.Length; i++)
             {
                 workers[i] = new Thread(ts1);
                 workers[i].Name = "Thread worker " + i;
                 workers[i].Start();
             }
         while(true)
         {
             fLoopExit=false;
             for(int i=0; i<iNumberOfWorkers;i++)
             {
                 if(workers[i].IsAlive)
                     fLoopExit=true;
             }
             if(!fLoopExit)
                 break;
         }
             iCountTestcases++;
             if(hsh2.Count != 0) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_6720fvdg! Expected value not returned, " + hsh2.Count);
             }
             iCountTestcases++;
             if(hsh1.IsSynchronized) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_4820fdf! Expected value not returned, " + hsh1.IsSynchronized);
             }
             iCountTestcases++;
             if(!hsh2.IsSynchronized) 
             {
                 iCountErrors++;
                 Console.WriteLine("Err_4820fdf! Expected value not returned, " + hsh2.IsSynchronized);
             }
         } while (false);
     } 
     catch (Exception exc_general ) 
     {
         ++iCountErrors;
         Console.WriteLine (s_strTFAbbrev + " : Error Err_8888yyy!  strLoc=="+ strLoc +", exc_general==\n"+exc_general.ToString());
     }
     if ( iCountErrors == 0 )
     {
         Console.WriteLine( "paSs.   "+s_strTFPath +" "+s_strTFName+" ,iCountTestcases=="+iCountTestcases);
         return true;
     }
     else
     {
         Console.WriteLine("FAiL!   "+s_strTFPath+" "+s_strTFName+" ,iCountErrors=="+iCountErrors+" , BugNums?: "+s_strActiveBugNums );
         return false;
     }
 }
示例#41
0
 /// <summary>
 /// Reads the specified content.
 /// </summary>
 /// <param name="content">The content.</param>
 static public CSequence ReadContent(MemoryStream content)
 {
     CParser parser = new CParser(content);
     CSequence sequence = parser.ReadContent();
     return sequence;
 }
示例#42
0
 public BinaryWriter CreateDynamicDictionaryCache()
 {
     dynamicDictionaryStream = new MemoryStream();
     var writer = new BinaryWriter(dynamicDictionaryStream);
     return writer;
 }
示例#43
0
        public static object DeSerialize(byte[] bytes, SerializedType type)
        {
            switch (type)
            {
            case SerializedType.String:
                return(Encoding.UTF8.GetString(bytes));

            case SerializedType.Datetime:
                return(new DateTime(BitConverter.ToInt64(bytes, 0)));

            case SerializedType.Bool:
                return(bytes[0] == 1);

            case SerializedType.Byte:
                return(bytes[0]);

            case SerializedType.Short:
                return(BitConverter.ToInt16(bytes, 0));

            case SerializedType.UShort:
                return(BitConverter.ToUInt16(bytes, 0));

            case SerializedType.Int:
                return(BitConverter.ToInt32(bytes, 0));

            case SerializedType.UInt:
                return(BitConverter.ToUInt32(bytes, 0));

            case SerializedType.Long:
                return(BitConverter.ToInt64(bytes, 0));

            case SerializedType.ULong:
                return(BitConverter.ToUInt64(bytes, 0));

            case SerializedType.Float:
                return(BitConverter.ToSingle(bytes, 0));

            case SerializedType.Double:
                return(BitConverter.ToDouble(bytes, 0));

            case SerializedType.Object:
                using (MemoryStream ms = new MemoryStream(bytes))
                {
                    return(new BinaryFormatter().Deserialize(ms));
                }

            case SerializedType.ObjectJson:
                return(Encoding.UTF8.GetString(bytes));

            case SerializedType.CompressedByteArray:
                return(DeSerialize(decompress(bytes), SerializedType.ByteArray));

            case SerializedType.CompressedString:
                return(DeSerialize(decompress(bytes), SerializedType.String));

            case SerializedType.CompressedObject:
                return(DeSerialize(decompress(bytes), SerializedType.Object));

            case SerializedType.CompressedObjectJson:
                return(DeSerialize(decompress(bytes), SerializedType.ObjectJson));

            case SerializedType.ByteArray:
            default:
                return(bytes);
            }
        }
示例#44
0
 /// <summary>
 /// 序列化
 /// </summary>
 /// <param name="value">值</param>
 /// <param name="type">返回序列化类型</param>
 /// <param name="compressionThreshold">指定超过长度时启用压缩功能</param>
 /// <returns></returns>
 public static byte[] Serialize(object value, out SerializedType type, uint compressionThreshold)
 {
     byte[] bytes;
     if (value is byte[])
     {
         bytes = (byte[])value;
         type  = SerializedType.ByteArray;
         if (bytes.Length > compressionThreshold)
         {
             bytes = compress(bytes);
             type  = SerializedType.CompressedByteArray;
         }
     }
     else if (value is string)
     {
         bytes = Encoding.UTF8.GetBytes((string)value);
         type  = SerializedType.String;
         if (bytes.Length > compressionThreshold)
         {
             bytes = compress(bytes);
             type  = SerializedType.CompressedString;
         }
     }
     else if (value is DateTime)
     {
         bytes = BitConverter.GetBytes(((DateTime)value).Ticks);
         type  = SerializedType.Datetime;
     }
     else if (value is bool)
     {
         bytes = new byte[] { (byte)((bool)value ? 1 : 0) };
         type  = SerializedType.Bool;
     }
     else if (value is byte)
     {
         bytes = new byte[] { (byte)value };
         type  = SerializedType.Byte;
     }
     else if (value is short)
     {
         bytes = BitConverter.GetBytes((short)value);
         type  = SerializedType.Short;
     }
     else if (value is ushort)
     {
         bytes = BitConverter.GetBytes((ushort)value);
         type  = SerializedType.UShort;
     }
     else if (value is int)
     {
         bytes = BitConverter.GetBytes((int)value);
         type  = SerializedType.Int;
     }
     else if (value is uint)
     {
         bytes = BitConverter.GetBytes((uint)value);
         type  = SerializedType.UInt;
     }
     else if (value is long)
     {
         bytes = BitConverter.GetBytes((long)value);
         type  = SerializedType.Long;
     }
     else if (value is ulong)
     {
         bytes = BitConverter.GetBytes((ulong)value);
         type  = SerializedType.ULong;
     }
     else if (value is float)
     {
         bytes = BitConverter.GetBytes((float)value);
         type  = SerializedType.Float;
     }
     else if (value is double)
     {
         bytes = BitConverter.GetBytes((double)value);
         type  = SerializedType.Double;
     }
     else
     {
         type = SerializedType.ObjectJson;
         Type t = value.GetType();
         switch (StaticTool.GetSystemType(ref t))
         {
         case SysType.Base:
         case SysType.Enum:
         case SysType.Custom:
             if (t.GetCustomAttributes(typeof(SerializableAttribute), false).Length > 0)
             {
                 type = SerializedType.Object;
             }
             break;
         }
         if (type == SerializedType.Object)
         {
             //可序列化 List<object> 如果 object 不支持序列化,会挂。
             using (MemoryStream ms = new MemoryStream())
             {
                 new BinaryFormatter().Serialize(ms, value);
                 bytes = ms.ToArray();
                 if (bytes.Length > compressionThreshold)
                 {
                     bytes = compress(bytes);
                     type  = SerializedType.CompressedObject;
                 }
             }
         }
         else
         {
             string json = JsonHelper.ToJson(value);
             bytes = Encoding.UTF8.GetBytes(json);
             if (bytes.Length > compressionThreshold)
             {
                 bytes = compress(bytes);
                 type  = SerializedType.CompressedObjectJson;
             }
         }
     }
     return(bytes);
 }
示例#45
0
文件: Session.cs 项目: xujiangbeer/ET
 public void Send(MemoryStream stream)
 {
     channel.Send(stream);
 }
示例#46
0
        /// <inheritdoc />
        public virtual IDictionary<string, object> LoadTempData(HttpContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

            // Accessing Session property will throw if the session middleware is not enabled.
            var session = context.Session;

            var tempDataDictionary = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
            byte[] value;

            if (session.TryGetValue(TempDataSessionStateKey, out value))
            {
                using (var memoryStream = new MemoryStream(value))
                using (var writer = new BsonReader(memoryStream))
                {
                    tempDataDictionary = _jsonSerializer.Deserialize<Dictionary<string, object>>(writer);
                }

                var convertedDictionary = new Dictionary<string, object>(
                    tempDataDictionary,
                    StringComparer.OrdinalIgnoreCase);
                foreach (var item in tempDataDictionary)
                {
                    var jArrayValue = item.Value as JArray;
                    var jObjectValue = item.Value as JObject;
                    if (jArrayValue != null && jArrayValue.Count > 0)
                    {
                        var arrayType = jArrayValue[0].Type;
                        Type returnType;
                        if (_tokenTypeLookup.TryGetValue(arrayType, out returnType))
                        {
                            var arrayConverter = _arrayConverters.GetOrAdd(returnType, type =>
                            {
                                return (Func<JArray, object>)_convertArrayMethodInfo
                                    .MakeGenericMethod(type)
                                    .CreateDelegate(typeof(Func<JArray, object>));
                            });
                            var result = arrayConverter(jArrayValue);

                            convertedDictionary[item.Key] = result;
                        }
                        else
                        {
                            var message = Resources.FormatTempData_CannotDeserializeToken(nameof(JToken), arrayType);
                            throw new InvalidOperationException(message);
                        }
                    }
                    else if (jObjectValue != null)
                    {
                        if (!jObjectValue.HasValues)
                        {
                            convertedDictionary[item.Key] = null;
                            continue;
                        }

                        var jTokenType = jObjectValue.Properties().First().Value.Type;
                        Type valueType;
                        if (_tokenTypeLookup.TryGetValue(jTokenType, out valueType))
                        {
                            var dictionaryConverter = _dictionaryConverters.GetOrAdd(valueType, type =>
                            {
                                return (Func<JObject, object>)_convertDictMethodInfo
                                    .MakeGenericMethod(type)
                                    .CreateDelegate(typeof(Func<JObject, object>));
                            });
                            var result = dictionaryConverter(jObjectValue);

                            convertedDictionary[item.Key] = result;
                        }
                        else
                        {
                            var message = Resources.FormatTempData_CannotDeserializeToken(nameof(JToken), jTokenType);
                            throw new InvalidOperationException(message);
                        }
                    }
                    else if (item.Value is long)
                    {
                        var longValue = (long)item.Value;
                        if (longValue < int.MaxValue)
                        {
                            // BsonReader casts all ints to longs. We'll attempt to work around this by force converting
                            // longs to ints when there's no loss of precision.
                            convertedDictionary[item.Key] = (int)longValue;
                        }
                    }
                }

                tempDataDictionary = convertedDictionary;

                // If we got it from Session, remove it so that no other request gets it
                session.Remove(TempDataSessionStateKey);
            }
            else
            {
                // Since we call Save() after the response has been sent, we need to initialize an empty session
                // so that it is established before the headers are sent.
                session.Set(TempDataSessionStateKey, new byte[] { });
            }

            return tempDataDictionary;
        }
示例#47
0
 static void Initialise()
 {
     LocalEvents = new SceneTriggerSet();
     Checkpoint = new MemoryStream();
     GlobalEvents = new HashSet<int>();
 }
示例#48
0
        //public CompositeType GetDataUsingDataContract(CompositeType composite)
        //{
        //    if (composite == null)
        //    {
        //        throw new ArgumentNullException("composite");
        //    }
        //    if (composite.BoolValue)
        //    {
        //        composite.StringValue += "Suffix";
        //    }
        //    return composite;
        //}

        public int CreateSession(int serviceCategoryID, Guid userID, byte[] parameters, Decimal PeasCount, Decimal PeasValue)
        {
            //Where Magic happens
            Utils.Helper_Trace("MANAGER SERVICE", "Entering CreateSession()");
            
            Utils.Helper_Trace("MANAGER SERVICE", string.Format("ServiceCategoryID = {0}", serviceCategoryID));
            Utils.Helper_Trace("MANAGER SERVICE", string.Format("UserID            = {0}", userID.ToString()));

            Dictionary<string, object> dicoParameters;

            try
            {
                MemoryStream ms;
                ms = new MemoryStream(parameters);

                BinaryFormatter bf;
                bf = new BinaryFormatter();

                dicoParameters = (Dictionary<string, object>)bf.Deserialize(ms);
            }
            catch (Exception e)
            {
                Utils.Helper_Trace("MANAGER SERVICE", string.Format("Exception while deserializing parameters : {0}", e.Message));
                return -1;
            }

            Utils.Helper_Trace("MANAGER SERVICE", string.Format("Size of parameters = {0} bytes", parameters.Length));

            int[] tabAssetID        = null;
            int MaxPages;
            string FileName         = string.Empty;
            string nmapAddress      = string.Empty;
            string cronExpression   = string.Empty;
            string sip              = string.Empty;
            string extrange         = string.Empty;
            string policy           = string.Empty;
            string strategie        = string.Empty;
           
            switch (serviceCategoryID)  //TODO Hardcoded
            {
                case 1:             // Vulnerability Assessment
                    tabAssetID      = (int[])dicoParameters["ASSETS"];
                    cronExpression  = (string)dicoParameters["CRONEXPRESSION"];
                    policy          = (string)dicoParameters["POLICY"];
                    strategie       = (string)dicoParameters["STRATEGY"];

                    Utils.Helper_Trace("MANAGER SERVICE", string.Format("Number of assets  = {0}", tabAssetID.Length));
                    Utils.Helper_Trace("MANAGER SERVICE", string.Format("Cron Expression   = {0}", cronExpression));

                    break;

                case 2:             //WAS   (Web Application Scanning)
                    tabAssetID      = (int[])dicoParameters["ASSETS"];
                    cronExpression  = (string)dicoParameters["CRONEXPRESSION"];
                    policy          = (string)dicoParameters["POLICY"];
                    strategie       = (string)dicoParameters["STRATEGY"];

                    Utils.Helper_Trace("MANAGER SERVICE", string.Format("Number of assets  = {0}", tabAssetID.Length));
                    Utils.Helper_Trace("MANAGER SERVICE", string.Format("Cron Expression   = {0}", cronExpression));

                    break;
                case 3:
                    Utils.Helper_Trace("MANAGER SERVICE", "NO parameters defined in XManagerService Service1.cs for service category 3");

                    break;
                case 4:             //PCI DSS
                    tabAssetID      = (int[])dicoParameters["ASSETS"];
                    cronExpression  = (string)dicoParameters["CRONEXPRESSION"];
                    policy          = "PCI DSS";
                    strategie       = "Compliance PCI DSS"; //(string)dicoParameters["STRATEGY"];

                    Utils.Helper_Trace("MANAGER SERVICE", string.Format("Number of assets  = {0}", tabAssetID.Length));
                    Utils.Helper_Trace("MANAGER SERVICE", string.Format("Cron Expression   = {0}", cronExpression));

                    break;
                case 5:
                    Utils.Helper_Trace("MANAGER SERVICE", "NO parameters defined in XManagerService Service1.cs for service category 5");
                    
                    break;
                case 6:             // VOIP Scanner
                    tabAssetID = (int[])dicoParameters["ASSETS"];
                    sip = (string)dicoParameters["SIP"];
                    extrange = (string)dicoParameters["EXTRANGE"];
                    Utils.Helper_Trace("MANAGER SERVICE", string.Format("Number of assets  = {0}", tabAssetID.Length));
                    break;

                case 7:             // Web Anti-malware Monitoring
                    tabAssetID = (int[])dicoParameters["ASSETS"];
                    cronExpression = (string)dicoParameters["CRONEXPRESSION"];
                    MaxPages = (int)dicoParameters["MaxPages"];
                    Utils.Helper_Trace("MANAGER SERVICE", string.Format("Service Malware Monitoring:Number of assets  = {0}", tabAssetID.Length));
                    Utils.Helper_Trace("MANAGER SERVICE", string.Format("Cron Expression   = {0}", cronExpression));
                    Utils.Helper_Trace("MANAGER SERVICE", string.Format("Service Malware Monitoring:MaxPages  = {0}", MaxPages));
                    break;

                case 8:             // Web Site Monitoring
                    tabAssetID = (int[])dicoParameters["ASSETS"];
                    Utils.Helper_Trace("MANAGER SERVICE", string.Format("Number of assets  = {0}", tabAssetID.Length));
                    break;

                case 9:
                    Utils.Helper_Trace("MANAGER SERVICE", "NO parameters defined in XManagerService Service1.cs for service category 9");

                    break;
                case 10:            // Discovery

                    nmapAddress = (string)dicoParameters["TARGET"];
                    Utils.Helper_Trace("MANAGER SERVICE", string.Format("Target = {0}", nmapAddress));
                    break;

                case 11:
                case 12:
                case 13:             // Import
                case 14:
                case 15:
                    FileName = (string)dicoParameters["FILENAME"];
                    Utils.Helper_Trace("MANAGER SERVICE", string.Format("Import File : Filename = {0}", FileName));
                    break;

                case 16:             //Information Gathering (OSINT)
                    tabAssetID = (int[])dicoParameters["ASSETS"];
                    cronExpression = (string)dicoParameters["CRONEXPRESSION"];
                    policy = (string)dicoParameters["POLICY"];
                    strategie = (string)dicoParameters["STRATEGY"];

                    Utils.Helper_Trace("MANAGER SERVICE", string.Format("Number of assets  = {0}", tabAssetID.Length));
                    Utils.Helper_Trace("MANAGER SERVICE", string.Format("Cron Expression   = {0}", cronExpression));

                    break;
                
            }

            XORCISMEntities context = new XORCISMEntities();

            // ===============================================
            // Add a new entry in table SESSION or SESSIONCRON
            // ===============================================

            int id;

            if (cronExpression == "")
            {
                // ================================
                // Add a new entry in table SESSION
                // ================================

                Utils.Helper_Trace("MANAGER SERVICE", string.Format("Adding an entry in table SESSION"));

                SESSION tmpSession = new SESSION();
                //Price
                try
                {
                    tmpSession.UserID               = userID;
                    tmpSession.Status = XCommon.STATUS.IDLE.ToString();
                    tmpSession.ServiceCategoryID    = serviceCategoryID;
                    tmpSession.DateEnd              = null;
                    tmpSession.DateStart            = DateTimeOffset.Now;
                    tmpSession.Parameters           = parameters;
                    //Price

                    context.SESSION.Add(tmpSession);

                    context.SaveChanges();
                    //Price
                }
                catch (Exception ex)
                {
                    /*
                    USER user;
                    user = context.USERS.SingleOrDefault(u => u.UserId == userID);
                    ACCOUNT userAccount;
                    userAccount = context.USERACCOUNT.SingleOrDefault(o => o.UserID == user.UserId).ACCOUNT;

                    //Price
                    */
                    Utils.Helper_Trace("MANAGER SERVICE", string.Format("Error adding entry in table SESSION : Exception = {0} - {1}", ex.Message, ex.InnerException.Message));
                    throw ex;
                }

                Utils.Helper_Trace("MANAGER SERVICE", string.Format("SessionID = {0}", tmpSession.SessionID));
                //Random random = new Random();                
                try
                {
                //    tmpSession.SessionID = tmpSession.SessionID + random.Next(20, 200);
                //    context.SaveChanges();
                }
                catch (Exception ex)
                {
                    Utils.Helper_Trace("MANAGER SERVICE", string.Format("Error random SESSION : Exception = {0} - {1}", ex.Message, ex.InnerException.Message));
                }
                Utils.Helper_Trace("MANAGER SERVICE", string.Format("NewRandomSessionID = {0}", tmpSession.SessionID));

                id = tmpSession.SessionID;

                // ============================================
                // Add several entries in table ASSETSESSION
                // ============================================

                if (tabAssetID != null)
                {
                    Utils.Helper_Trace("MANAGER SERVICE", string.Format("Adding {0} entries in table ASSETSESSION", tabAssetID.Count()));

                    try
                    {
                        foreach (int assetID in tabAssetID)
                        {
                            ASSETSESSION tmpAinS = new ASSETSESSION();
                            tmpAinS.SESSION = tmpSession;
                            tmpAinS.AssetID = assetID;
                            context.ASSETSESSION.Add(tmpAinS);
                        }
                        context.SaveChanges();
                    }
                    catch (Exception ex)
                    {
                        Utils.Helper_Trace("MANAGER SERVICE", string.Format("Error adding entries in table ASSETSESSION : Exception = {0}", ex.Message));
                        throw ex;
                    }
                }
            }
            else
            {
                Utils.Helper_Trace("MANAGER SERVICE", string.Format("Adding an entry in table SESSIONCRON"));

                SESSIONCRON tmpSessionCron = new SESSIONCRON();
                //Price
                try
                {
                    tmpSessionCron.UserID               = userID;
                    tmpSessionCron.CronExpression       = cronExpression;
                    tmpSessionCron.Parameters           = parameters;
                    tmpSessionCron.Status = XCommon.STATUS.IDLE.ToString();
                    tmpSessionCron.ServiceCategoryID    = serviceCategoryID;
                    tmpSessionCron.DateStart            = DateTimeOffset.Now;         //TODO Non il faut que ce soit les dates de start/end du cron A VOIR TODO
                    tmpSessionCron.DateEnd              = null;
                    //Price
                    
                    context.SESSIONCRON.Add(tmpSessionCron);

                    context.SaveChanges();
                }
                catch (Exception ex)
                {
                    Utils.Helper_Trace("MANAGER SERVICE", string.Format("Error adding entry in table SESSIONCRON : Exception = {0} - {1}", ex.Message, ex.InnerException.Message));
                    throw ex;
                }

                Utils.Helper_Trace("MANAGER SERVICE", string.Format("SessionCronID = {0}", tmpSessionCron.SessionCronID));

                id = tmpSessionCron.SessionCronID;
            }

            Utils.Helper_Trace("MANAGER SERVICE", "Leaving CreateSession()");

            // Finished
            return id;
        }
示例#49
0
        public bool Open(IFilter imageFilter)
        {
            Stream stream = imageFilter.GetDataForkStream();
            stream.Seek(0, SeekOrigin.Begin);

            if(stream.Length < 512) return false;

            byte[] vhdxIdB = new byte[Marshal.SizeOf(vhdxId)];
            stream.Read(vhdxIdB, 0, Marshal.SizeOf(vhdxId));
            vhdxId = new VhdxIdentifier();
            IntPtr idPtr = Marshal.AllocHGlobal(Marshal.SizeOf(vhdxId));
            Marshal.Copy(vhdxIdB, 0, idPtr, Marshal.SizeOf(vhdxId));
            vhdxId = (VhdxIdentifier)Marshal.PtrToStructure(idPtr, typeof(VhdxIdentifier));
            Marshal.FreeHGlobal(idPtr);

            if(vhdxId.signature != VHDX_SIGNATURE) return false;

            imageInfo.Application = Encoding.Unicode.GetString(vhdxId.creator);

            stream.Seek(64 * 1024, SeekOrigin.Begin);
            byte[] vHdrB = new byte[Marshal.SizeOf(vHdr)];
            stream.Read(vHdrB, 0, Marshal.SizeOf(vHdr));
            vHdr = new VhdxHeader();
            IntPtr headerPtr = Marshal.AllocHGlobal(Marshal.SizeOf(vHdr));
            Marshal.Copy(vHdrB, 0, headerPtr, Marshal.SizeOf(vHdr));
            vHdr = (VhdxHeader)Marshal.PtrToStructure(headerPtr, typeof(VhdxHeader));
            Marshal.FreeHGlobal(headerPtr);

            if(vHdr.Signature != VHDX_HEADER_SIG)
            {
                stream.Seek(128 * 1024, SeekOrigin.Begin);
                vHdrB = new byte[Marshal.SizeOf(vHdr)];
                stream.Read(vHdrB, 0, Marshal.SizeOf(vHdr));
                vHdr      = new VhdxHeader();
                headerPtr = Marshal.AllocHGlobal(Marshal.SizeOf(vHdr));
                Marshal.Copy(vHdrB, 0, headerPtr, Marshal.SizeOf(vHdr));
                vHdr = (VhdxHeader)Marshal.PtrToStructure(headerPtr, typeof(VhdxHeader));
                Marshal.FreeHGlobal(headerPtr);

                if(vHdr.Signature != VHDX_HEADER_SIG) throw new ImageNotSupportedException("VHDX header not found");
            }

            stream.Seek(192 * 1024, SeekOrigin.Begin);
            byte[] vRegTableB = new byte[Marshal.SizeOf(vRegHdr)];
            stream.Read(vRegTableB, 0, Marshal.SizeOf(vRegHdr));
            vRegHdr = new VhdxRegionTableHeader();
            IntPtr vRegTabPtr = Marshal.AllocHGlobal(Marshal.SizeOf(vRegHdr));
            Marshal.Copy(vRegTableB, 0, vRegTabPtr, Marshal.SizeOf(vRegHdr));
            vRegHdr = (VhdxRegionTableHeader)Marshal.PtrToStructure(vRegTabPtr, typeof(VhdxRegionTableHeader));
            Marshal.FreeHGlobal(vRegTabPtr);

            if(vRegHdr.signature != VHDX_REGION_SIG)
            {
                stream.Seek(256 * 1024, SeekOrigin.Begin);
                vRegTableB = new byte[Marshal.SizeOf(vRegHdr)];
                stream.Read(vRegTableB, 0, Marshal.SizeOf(vRegHdr));
                vRegHdr    = new VhdxRegionTableHeader();
                vRegTabPtr = Marshal.AllocHGlobal(Marshal.SizeOf(vRegHdr));
                Marshal.Copy(vRegTableB, 0, vRegTabPtr, Marshal.SizeOf(vRegHdr));
                vRegHdr = (VhdxRegionTableHeader)Marshal.PtrToStructure(vRegTabPtr, typeof(VhdxRegionTableHeader));
                Marshal.FreeHGlobal(vRegTabPtr);

                if(vRegHdr.signature != VHDX_REGION_SIG)
                    throw new ImageNotSupportedException("VHDX region table not found");
            }

            vRegs = new VhdxRegionTableEntry[vRegHdr.entries];
            for(int i = 0; i < vRegs.Length; i++)
            {
                byte[] vRegB = new byte[Marshal.SizeOf(vRegs[i])];
                stream.Read(vRegB, 0, Marshal.SizeOf(vRegs[i]));
                vRegs[i] = new VhdxRegionTableEntry();
                IntPtr vRegPtr = Marshal.AllocHGlobal(Marshal.SizeOf(vRegs[i]));
                Marshal.Copy(vRegB, 0, vRegPtr, Marshal.SizeOf(vRegs[i]));
                vRegs[i] = (VhdxRegionTableEntry)Marshal.PtrToStructure(vRegPtr, typeof(VhdxRegionTableEntry));
                Marshal.FreeHGlobal(vRegPtr);

                if(vRegs[i].guid == batGuid)
                    batOffset = (long)vRegs[i].offset;
                else if(vRegs[i].guid == metadataGuid)
                    metadataOffset = (long)vRegs[i].offset;
                else if((vRegs[i].flags & REGION_FLAGS_REQUIRED) == REGION_FLAGS_REQUIRED)
                    throw new
                        ImageNotSupportedException($"Found unsupported and required region Guid {vRegs[i].guid}, not proceeding with image.");
            }

            if(batOffset == 0) throw new Exception("BAT not found, cannot continue.");

            if(metadataOffset == 0) throw new Exception("Metadata not found, cannot continue.");

            uint fileParamsOff = 0, vdSizeOff = 0, p83Off = 0, logOff = 0, physOff = 0, parentOff = 0;

            stream.Seek(metadataOffset, SeekOrigin.Begin);
            byte[] metTableB = new byte[Marshal.SizeOf(vMetHdr)];
            stream.Read(metTableB, 0, Marshal.SizeOf(vMetHdr));
            vMetHdr = new VhdxMetadataTableHeader();
            IntPtr metTablePtr = Marshal.AllocHGlobal(Marshal.SizeOf(vMetHdr));
            Marshal.Copy(metTableB, 0, metTablePtr, Marshal.SizeOf(vMetHdr));
            vMetHdr = (VhdxMetadataTableHeader)Marshal.PtrToStructure(metTablePtr, typeof(VhdxMetadataTableHeader));
            Marshal.FreeHGlobal(metTablePtr);

            vMets = new VhdxMetadataTableEntry[vMetHdr.entries];
            for(int i = 0; i < vMets.Length; i++)
            {
                byte[] vMetB = new byte[Marshal.SizeOf(vMets[i])];
                stream.Read(vMetB, 0, Marshal.SizeOf(vMets[i]));
                vMets[i] = new VhdxMetadataTableEntry();
                IntPtr vMetPtr = Marshal.AllocHGlobal(Marshal.SizeOf(vMets[i]));
                Marshal.Copy(vMetB, 0, vMetPtr, Marshal.SizeOf(vMets[i]));
                vMets[i] = (VhdxMetadataTableEntry)Marshal.PtrToStructure(vMetPtr, typeof(VhdxMetadataTableEntry));
                Marshal.FreeHGlobal(vMetPtr);

                if(vMets[i].itemId == fileParametersGuid)
                    fileParamsOff = vMets[i].offset;
                else if(vMets[i].itemId == virtualDiskSizeGuid)
                    vdSizeOff = vMets[i].offset;
                else if(vMets[i].itemId == page83DataGuid)
                    p83Off = vMets[i].offset;
                else if(vMets[i].itemId == logicalSectorSizeGuid)
                    logOff = vMets[i].offset;
                else if(vMets[i].itemId == physicalSectorSizeGuid)
                    physOff = vMets[i].offset;
                else if(vMets[i].itemId == parentLocatorGuid)
                    parentOff = vMets[i].offset;
                else if((vMets[i].flags & METADATA_FLAGS_REQUIRED) == METADATA_FLAGS_REQUIRED)
                    throw new
                        ImageNotSupportedException($"Found unsupported and required metadata Guid {vMets[i].itemId}, not proceeding with image.");
            }

            byte[] tmp;

            if(fileParamsOff != 0)
            {
                stream.Seek(fileParamsOff + metadataOffset, SeekOrigin.Begin);
                tmp = new byte[8];
                stream.Read(tmp, 0, 8);
                vFileParms = new VhdxFileParameters
                {
                    blockSize = BitConverter.ToUInt32(tmp, 0),
                    flags     = BitConverter.ToUInt32(tmp, 4)
                };
            }
            else throw new Exception("File parameters not found.");

            if(vdSizeOff != 0)
            {
                stream.Seek(vdSizeOff + metadataOffset, SeekOrigin.Begin);
                tmp = new byte[8];
                stream.Read(tmp, 0, 8);
                virtualDiskSize = BitConverter.ToUInt64(tmp, 0);
            }
            else throw new Exception("Virtual disk size not found.");

            if(p83Off != 0)
            {
                stream.Seek(p83Off + metadataOffset, SeekOrigin.Begin);
                tmp = new byte[16];
                stream.Read(tmp, 0, 16);
                page83Data = new Guid(tmp);
            }

            if(logOff != 0)
            {
                stream.Seek(logOff + metadataOffset, SeekOrigin.Begin);
                tmp = new byte[4];
                stream.Read(tmp, 0, 4);
                logicalSectorSize = BitConverter.ToUInt32(tmp, 0);
            }
            else throw new Exception("Logical sector size not found.");

            if(physOff != 0)
            {
                stream.Seek(physOff + metadataOffset, SeekOrigin.Begin);
                tmp = new byte[4];
                stream.Read(tmp, 0, 4);
                physicalSectorSize = BitConverter.ToUInt32(tmp, 0);
            }
            else throw new Exception("Physical sector size not found.");

            if(parentOff != 0 && (vFileParms.flags & FILE_FLAGS_HAS_PARENT) == FILE_FLAGS_HAS_PARENT)
            {
                stream.Seek(parentOff + metadataOffset, SeekOrigin.Begin);
                byte[] vParHdrB = new byte[Marshal.SizeOf(vMetHdr)];
                stream.Read(vParHdrB, 0, Marshal.SizeOf(vMetHdr));
                vParHdr = new VhdxParentLocatorHeader();
                IntPtr vParHdrPtr = Marshal.AllocHGlobal(Marshal.SizeOf(vMetHdr));
                Marshal.Copy(vParHdrB, 0, vParHdrPtr, Marshal.SizeOf(vMetHdr));
                vParHdr = (VhdxParentLocatorHeader)Marshal.PtrToStructure(vParHdrPtr, typeof(VhdxParentLocatorHeader));
                Marshal.FreeHGlobal(vParHdrPtr);

                if(vParHdr.locatorType != parentTypeVhdxGuid)
                    throw new
                        ImageNotSupportedException($"Found unsupported and required parent locator type {vParHdr.locatorType}, not proceeding with image.");

                vPars = new VhdxParentLocatorEntry[vParHdr.keyValueCount];
                for(int i = 0; i < vPars.Length; i++)
                {
                    byte[] vParB = new byte[Marshal.SizeOf(vPars[i])];
                    stream.Read(vParB, 0, Marshal.SizeOf(vPars[i]));
                    vPars[i] = new VhdxParentLocatorEntry();
                    IntPtr vParPtr = Marshal.AllocHGlobal(Marshal.SizeOf(vPars[i]));
                    Marshal.Copy(vParB, 0, vParPtr, Marshal.SizeOf(vPars[i]));
                    vPars[i] = (VhdxParentLocatorEntry)Marshal.PtrToStructure(vParPtr, typeof(VhdxParentLocatorEntry));
                    Marshal.FreeHGlobal(vParPtr);
                }
            }
            else if((vFileParms.flags & FILE_FLAGS_HAS_PARENT) == FILE_FLAGS_HAS_PARENT)
                throw new Exception("Parent locator not found.");

            if((vFileParms.flags & FILE_FLAGS_HAS_PARENT) == FILE_FLAGS_HAS_PARENT &&
               vParHdr.locatorType                        == parentTypeVhdxGuid)
            {
                parentImage = new Vhdx();
                bool parentWorks = false;

                foreach(VhdxParentLocatorEntry parentEntry in vPars)
                {
                    stream.Seek(parentEntry.keyOffset + metadataOffset, SeekOrigin.Begin);
                    byte[] tmpKey = new byte[parentEntry.keyLength];
                    stream.Read(tmpKey, 0, tmpKey.Length);
                    string entryType = Encoding.Unicode.GetString(tmpKey);

                    IFilter parentFilter;
                    if(string.Compare(entryType, RELATIVE_PATH_KEY, StringComparison.OrdinalIgnoreCase) == 0)
                    {
                        stream.Seek(parentEntry.valueOffset + metadataOffset, SeekOrigin.Begin);
                        byte[] tmpVal = new byte[parentEntry.valueLength];
                        stream.Read(tmpVal, 0, tmpVal.Length);
                        string entryValue = Encoding.Unicode.GetString(tmpVal);

                        try
                        {
                            parentFilter =
                                new FiltersList().GetFilter(Path.Combine(imageFilter.GetParentFolder(), entryValue));
                            if(parentFilter != null && parentImage.Open(parentFilter))
                            {
                                parentWorks = true;
                                break;
                            }
                        }
                        catch { parentWorks = false; }

                        string relEntry = Path.Combine(Path.GetDirectoryName(imageFilter.GetPath()), entryValue);

                        try
                        {
                            parentFilter =
                                new FiltersList().GetFilter(Path.Combine(imageFilter.GetParentFolder(), relEntry));
                            if(parentFilter == null || !parentImage.Open(parentFilter)) continue;

                            parentWorks = true;
                            break;
                        }
                        catch
                        {
                            // ignored
                        }
                    }
                    else if(string.Compare(entryType, VOLUME_PATH_KEY, StringComparison.OrdinalIgnoreCase) ==
                            0 ||
                            string.Compare(entryType, ABSOLUTE_WIN32_PATH_KEY, StringComparison.OrdinalIgnoreCase) == 0)
                    {
                        stream.Seek(parentEntry.valueOffset + metadataOffset, SeekOrigin.Begin);
                        byte[] tmpVal = new byte[parentEntry.valueLength];
                        stream.Read(tmpVal, 0, tmpVal.Length);
                        string entryValue = Encoding.Unicode.GetString(tmpVal);

                        try
                        {
                            parentFilter =
                                new FiltersList().GetFilter(Path.Combine(imageFilter.GetParentFolder(), entryValue));
                            if(parentFilter == null || !parentImage.Open(parentFilter)) continue;

                            parentWorks = true;
                            break;
                        }
                        catch
                        {
                            // ignored
                        }
                    }
                }

                if(!parentWorks) throw new Exception("Image is differential but parent cannot be opened.");

                hasParent = true;
            }

            chunkRatio = (long)(Math.Pow(2, 23) * logicalSectorSize / vFileParms.blockSize);
            dataBlocks = virtualDiskSize / vFileParms.blockSize;
            if(virtualDiskSize           % vFileParms.blockSize > 0) dataBlocks++;

            long batEntries;
            if(hasParent)
            {
                long sectorBitmapBlocks = (long)dataBlocks / chunkRatio;
                if(dataBlocks % (ulong)chunkRatio > 0) sectorBitmapBlocks++;
                sectorBitmapPointers = new ulong[sectorBitmapBlocks];

                batEntries = sectorBitmapBlocks * (chunkRatio - 1);
            }
            else batEntries = (long)(dataBlocks + (dataBlocks - 1) / (ulong)chunkRatio);

            DicConsole.DebugWriteLine("VHDX plugin", "Reading BAT");

            long readChunks = 0;
            blockAllocationTable = new ulong[dataBlocks];
            byte[] batB = new byte[batEntries * 8];
            stream.Seek(batOffset, SeekOrigin.Begin);
            stream.Read(batB, 0, batB.Length);

            ulong skipSize = 0;
            for(ulong i = 0; i < dataBlocks; i++)
                if(readChunks == chunkRatio)
                {
                    if(hasParent)
                        sectorBitmapPointers[skipSize / 8] = BitConverter.ToUInt64(batB, (int)(i * 8 + skipSize));

                    readChunks =  0;
                    skipSize   += 8;
                }
                else
                {
                    blockAllocationTable[i] = BitConverter.ToUInt64(batB, (int)(i * 8 + skipSize));
                    readChunks++;
                }

            if(hasParent)
            {
                DicConsole.DebugWriteLine("VHDX plugin", "Reading Sector Bitmap");

                MemoryStream sectorBmpMs = new MemoryStream();
                foreach(ulong pt in sectorBitmapPointers)
                    switch(pt & BAT_FLAGS_MASK)
                    {
                        case SECTOR_BITMAP_NOT_PRESENT:
                            sectorBmpMs.Write(new byte[1048576], 0, 1048576);
                            break;
                        case SECTOR_BITMAP_PRESENT:
                            stream.Seek((long)((pt & BAT_FILE_OFFSET_MASK) * 1048576), SeekOrigin.Begin);
                            byte[] bmp = new byte[1048576];
                            stream.Read(bmp, 0, bmp.Length);
                            sectorBmpMs.Write(bmp, 0, bmp.Length);
                            break;
                        default:
                            if((pt & BAT_FLAGS_MASK) != 0)
                                throw new
                                    ImageNotSupportedException($"Unsupported sector bitmap block flags (0x{pt & BAT_FLAGS_MASK:X16}) found, not proceeding.");

                            break;
                    }

                sectorBitmap = sectorBmpMs.ToArray();
                sectorBmpMs.Close();
            }

            maxBlockCache  = (int)(MAX_CACHE_SIZE / vFileParms.blockSize);
            maxSectorCache = (int)(MAX_CACHE_SIZE / logicalSectorSize);

            imageStream = stream;

            sectorCache = new Dictionary<ulong, byte[]>();
            blockCache  = new Dictionary<ulong, byte[]>();

            imageInfo.CreationTime         = imageFilter.GetCreationTime();
            imageInfo.LastModificationTime = imageFilter.GetLastWriteTime();
            imageInfo.MediaTitle           = Path.GetFileNameWithoutExtension(imageFilter.GetFilename());
            imageInfo.SectorSize           = logicalSectorSize;
            imageInfo.XmlMediaType         = XmlMediaType.BlockMedia;
            imageInfo.MediaType            = MediaType.GENERIC_HDD;
            imageInfo.ImageSize            = virtualDiskSize;
            imageInfo.Sectors              = imageInfo.ImageSize / imageInfo.SectorSize;
            imageInfo.DriveSerialNumber    = page83Data.ToString();

            // TODO: Separate image application from version, need several samples.

            imageInfo.Cylinders       = (uint)(imageInfo.Sectors / 16 / 63);
            imageInfo.Heads           = 16;
            imageInfo.SectorsPerTrack = 63;

            return true;
        }
示例#50
0
 public static Image bytes2Image(byte[] bytes)
 {
     MemoryStream ms = new MemoryStream(bytes);
     return Image.FromStream(ms);
 }
 public void WriteThrowsForNullData()
 {
   using var stream = new MemoryStream();
   var cfgWriter = new XmlConfigurationWriter();
   cfgWriter.Write(stream, null);
 } /* End of Function - WriteThrowsForNullData */
示例#52
0
        public void TestUncompressThisRow()
        {
            var data = new byte[]
            {
                0x09,
                0x00,
                0x2e,
                0x07,
                0x00,
                0xad,
                0x03,
                0x00,
                0x2e,
                0x03,
                0x10,
                0xaf,
                0xf5,
                0x2f,
                0xaf,
                0xf5,
                0x03,

                0x0c,
                0xf5,
                0xaf,
                0x5f,
                0x5f,
                0x0b,
            };

            var data2 = new byte[]
            {
                0x09,
                0x00,
                0x2e,
                0x07,
                0x00,
                0xad,
                0x03,
                0x00,
                0x2e,
                0x03,
                0x10,
                0xaf,
                0xf5,
                0x2f,
                0xaf,
                0xf5,
                0x03,

                0x04,
                0xf5,
                0xaf,
                0x06,
                0x5f,
                0x0b,
            };

            var s = new MemoryStream();

            CompressedFrameReader.DecompressRow(data, s, 27, 9);
            var ss = s.ToArray();

            var s2 = new MemoryStream();

            CompressedFrameReader.DecompressRow(data2, s2, 27, 9);
            var ss2 = s.ToArray();

            CollectionAssert.AreEqual(ss, ss2);
        }
示例#53
0
        public virtual object WriteSampleObjectUsingFormatter(MediaTypeFormatter formatter, object value, Type type, MediaTypeHeaderValue mediaType)
        {
            if (formatter == null)
            {
                throw new ArgumentNullException("formatter");
            }
            if (mediaType == null)
            {
                throw new ArgumentNullException("mediaType");
            }

            object       sample  = String.Empty;
            MemoryStream ms      = null;
            HttpContent  content = null;

            try
            {
                if (formatter.CanWriteType(type))
                {
                    ms      = new MemoryStream();
                    content = new ObjectContent(type, value, formatter, mediaType);
                    formatter.WriteToStreamAsync(type, value, ms, content, null).Wait();
                    ms.Position = 0;
                    StreamReader reader = new StreamReader(ms);
                    string       serializedSampleString = reader.ReadToEnd();
                    if (mediaType.MediaType.ToUpperInvariant().Contains("XML"))
                    {
                        serializedSampleString = TryFormatXml(serializedSampleString);
                    }
                    else if (mediaType.MediaType.ToUpperInvariant().Contains("JSON"))
                    {
                        serializedSampleString = TryFormatJson(serializedSampleString);
                    }

                    sample = new TextSample(serializedSampleString);
                }
                else
                {
                    sample = new InvalidSample(String.Format(
                                                   CultureInfo.CurrentCulture,
                                                   "Failed to generate the sample for media type '{0}'. Cannot use formatter '{1}' to write type '{2}'.",
                                                   mediaType,
                                                   formatter.GetType().Name,
                                                   type.Name));
                }
            }
            catch (Exception e)
            {
                sample = new InvalidSample(String.Format(
                                               CultureInfo.CurrentCulture,
                                               "An exception has occurred while using the formatter '{0}' to generate sample for media type '{1}'. Exception message: {2}",
                                               formatter.GetType().Name,
                                               mediaType.MediaType,
                                               UnwrapException(e).Message));
            }
            finally
            {
                if (ms != null)
                {
                    ms.Dispose();
                }
                if (content != null)
                {
                    content.Dispose();
                }
            }

            return(sample);
        }
示例#54
0
        public async Task <IActionResult> FilePreview(IFormFileCollection files) //System.Web HttpPostedFileBase file)
        {
            var resImport = new ResultCrmDb();

            if ((Request.Form?.Files?.Count ?? 0) != 1)
            {
                resImport.AddError(Constant.ErrCodeImport, "Файла для импорта не передан!");
                return(Tools.CreateResult(true, "Файла не передан!", resImport));
            }

            var formfile = Request.Form.Files[0];

            if (formfile.Length > 500000)
            {
                resImport.AddError(Constant.ErrCodeImport, "Размер файла превышает 500кБ !");
                return(Tools.CreateResult(false, "Файл слшком длинный !", resImport));
            }

            var filename      = formfile.FileName;
            var fileextension = Path.GetExtension(filename).ToUpper();

            if (fileextension.Length < 4 || !allowedExtensions.Split(',').Any(x => fileextension.StartsWith(x.Trim())))
            {
                resImport.AddError(Constant.ErrCodeImport, "Файл с таким расширением не импортируется !");
                return(Tools.CreateResult(true, "Файла не передан!", resImport));
            }


            using (var memoryStream = new MemoryStream())
            {
                byte[] bytesUtf = null;
                await formfile.CopyToAsync(memoryStream);

                if (fileextension == ".XLSX")
                {
                    // Уже Utf
                    bytesUtf = memoryStream.ToArray();
                }
                else
                {
                    var enc       = CodePagesEncodingProvider.Instance.GetEncoding(1251);
                    var bytes1251 = memoryStream.ToArray();
                    //var txt1251 = enc.GetString(bytes1251, 0, bytes1251.Length);
                    bytesUtf = Encoding.Convert(enc, Encoding.UTF8, bytes1251);
                }
                //string txtUtf = Encoding.UTF8.GetString(bytesUtf);

                ImportParam importParam = new ImportParam()
                {
                    FileName    = filename,
                    FormatGroup = fileextension == ".XLSX" ? "MFXL" : "FKTX",
                    Format      = fileextension == ".XLSX" ? "VP" : fileextension.Substring(1, 2),
                    TypeImp     = ImportType.Preview,
                    CodeAte     = "004", // ГО Волоколамский
                    CodePos     = "00",
                    DaysToSkip  = 1
                };


                resImport = await _importAdapter.PreviewFile(bytesUtf, importParam);

                return(Tools.CreateResult(true, "", resImport));
            }
        }
示例#55
0
        /// <summary>
        /// Executes command buffers until we hit the next resultset
        /// </summary>
        /// <returns>CommandResult containing the next resultset when hit
        /// or null if no more resultsets were found</returns>
        internal CommandResult GetNextResultSet(MySqlDataReader reader)
        {
            // if  we are supposed to return only a single resultset and our reader
            // is calling us back again, then return null
            if (reader != null &&
                (reader.Behavior & CommandBehavior.SingleResult) != 0 &&
                lastResult != null)
            {
                return(null);
            }

            // if the last result we returned has more results
            if (lastResult != null && lastResult.ReadNextResult(false))
            {
                return(lastResult);
            }
            lastResult = null;

            CommandResult result = null;

            // if we haven't prepared a statement and don't have any sql buffers
            // to execute, we are done
            if (preparedStatement == null)
            {
                if (sqlBuffers == null || sqlBuffers.Count == 0)
                {
                    return(null);
                }
            }
            else if (preparedStatement.ExecutionCount > 0)
            {
                return(null);
            }


            // if we have a prepared statement, we execute it instead
            if (preparedStatement != null)
            {
                result = preparedStatement.Execute(parameters);

                if (!result.IsResultSet)
                {
                    if (updateCount == -1)
                    {
                        updateCount = 0;
                    }
                    updateCount += (long)result.AffectedRows;
                }
            }
            else
            {
                while (sqlBuffers.Count > 0)
                {
                    MemoryStream sqlStream = (MemoryStream)sqlBuffers[0];

                    using (sqlStream)
                    {
                        result = connection.driver.SendQuery(sqlStream.GetBuffer(), (int)sqlStream.Length, false);
                        sqlBuffers.RemoveAt(0);
                    }

                    if (result.AffectedRows != -1)
                    {
                        if (updateCount == -1)
                        {
                            updateCount = 0;
                        }
                        updateCount += (long)result.AffectedRows;
                    }

                    // if this is a resultset, then we break out of our execution loop
                    if (result.IsResultSet)
                    {
                        break;
                    }
                }
            }

            if (result.IsResultSet)
            {
                lastResult = result;
                return(result);
            }
            return(null);
        }
示例#56
0
        private static byte[] rsaEncrypt(byte[] buffer /*, string key*/)
        {
            RSAParameters rsaParameters;

            if (_cachedPublicKey is null)
            {
                _cachedPublicKey = ParsePublicKey(publicKey);
            }
            rsaParameters = _cachedPublicKey.Value;
            return(BigInteger.ModPow(GetBigIntegerBigEndian(buffer), GetBigIntegerBigEndian(rsaParameters.Exponent), GetBigIntegerBigEndian(rsaParameters.Modulus)).ToByteArray(true, true));

            RSAParameters ParsePublicKey(string _publicKey)
            {
                _publicKey = _publicKey.Replace("\n", string.Empty);
                _publicKey = _publicKey.Substring(26, _publicKey.Length - 50);
                using (MemoryStream _stream = new MemoryStream(Convert.FromBase64String(_publicKey))) {
                    using (BinaryReader _reader = new BinaryReader(_stream)) {
                        ushort _i16;
                        byte[] _oid;
                        byte   _i8;
                        byte   _low;
                        byte   _high;
                        int    _modulusLength;
                        byte[] _modulus;
                        int    _exponentLength;
                        byte[] _exponent;

                        _i16 = _reader.ReadUInt16();
                        if (_i16 == 0x8130)
                        {
                            _reader.ReadByte();
                        }
                        else if (_i16 == 0x8230)
                        {
                            _reader.ReadInt16();
                        }
                        else
                        {
                            throw new ArgumentException(nameof(_publicKey));
                        }
                        _oid = _reader.ReadBytes(15);
                        if (!_oid.SequenceEqual(new byte[] { 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00 }))
                        {
                            throw new ArgumentException(nameof(_publicKey));
                        }
                        _i16 = _reader.ReadUInt16();
                        if (_i16 == 0x8103)
                        {
                            _reader.ReadByte();
                        }
                        else if (_i16 == 0x8203)
                        {
                            _reader.ReadInt16();
                        }
                        else
                        {
                            throw new ArgumentException(nameof(_publicKey));
                        }
                        _i8 = _reader.ReadByte();
                        if (_i8 != 0x00)
                        {
                            throw new ArgumentException(nameof(_publicKey));
                        }
                        _i16 = _reader.ReadUInt16();
                        if (_i16 == 0x8130)
                        {
                            _reader.ReadByte();
                        }
                        else if (_i16 == 0x8230)
                        {
                            _reader.ReadInt16();
                        }
                        else
                        {
                            throw new ArgumentException(nameof(_publicKey));
                        }
                        _i16 = _reader.ReadUInt16();
                        if (_i16 == 0x8102)
                        {
                            _high = 0;
                            _low  = _reader.ReadByte();
                        }
                        else if (_i16 == 0x8202)
                        {
                            _high = _reader.ReadByte();
                            _low  = _reader.ReadByte();
                        }
                        else
                        {
                            throw new ArgumentException(nameof(_publicKey));
                        }
                        _modulusLength = BitConverter.ToInt32(new byte[] { _low, _high, 0x00, 0x00 }, 0);
                        if (_reader.PeekChar() == 0x00)
                        {
                            _reader.ReadByte();
                            _modulusLength -= 1;
                        }
                        _modulus = _reader.ReadBytes(_modulusLength);
                        if (_reader.ReadByte() != 0x02)
                        {
                            throw new ArgumentException(nameof(_publicKey));
                        }
                        _exponentLength = _reader.ReadByte();
                        _exponent       = _reader.ReadBytes(_exponentLength);
                        return(new RSAParameters {
                            Modulus = _modulus,
                            Exponent = _exponent
                        });
                    }
                }
            }

            BigInteger GetBigIntegerBigEndian(byte[] _value)
            {
                return(new BigInteger(new ReadOnlySpan <byte>(_value), true, true));
            }
        }
        /// <summary>
        /// Update the navigation property singleValueExtendedProperties in users
        /// </summary>
        public Command BuildPatchCommand()
        {
            var command = new Command("patch");

            command.Description = "Update the navigation property singleValueExtendedProperties in users";
            // Create options for all the parameters
            var userIdOption = new Option <string>("--user-id", description: "key: id of user")
            {
            };

            userIdOption.IsRequired = true;
            command.AddOption(userIdOption);
            var mailFolderIdOption = new Option <string>("--mail-folder-id", description: "key: id of mailFolder")
            {
            };

            mailFolderIdOption.IsRequired = true;
            command.AddOption(mailFolderIdOption);
            var messageIdOption = new Option <string>("--message-id", description: "key: id of message")
            {
            };

            messageIdOption.IsRequired = true;
            command.AddOption(messageIdOption);
            var singleValueLegacyExtendedPropertyIdOption = new Option <string>("--single-value-legacy-extended-property-id", description: "key: id of singleValueLegacyExtendedProperty")
            {
            };

            singleValueLegacyExtendedPropertyIdOption.IsRequired = true;
            command.AddOption(singleValueLegacyExtendedPropertyIdOption);
            var bodyOption = new Option <string>("--body")
            {
            };

            bodyOption.IsRequired = true;
            command.AddOption(bodyOption);
            command.SetHandler(async(object[] parameters) => {
                var userId       = (string)parameters[0];
                var mailFolderId = (string)parameters[1];
                var messageId    = (string)parameters[2];
                var singleValueLegacyExtendedPropertyId = (string)parameters[3];
                var body = (string)parameters[4];
                var cancellationToken = (CancellationToken)parameters[5];
                using var stream      = new MemoryStream(Encoding.UTF8.GetBytes(body));
                var parseNode         = ParseNodeFactoryRegistry.DefaultInstance.GetRootParseNode("application/json", stream);
                var model             = parseNode.GetObjectValue <SingleValueLegacyExtendedProperty>(SingleValueLegacyExtendedProperty.CreateFromDiscriminatorValue);
                var requestInfo       = CreatePatchRequestInformation(model, q => {
                });
                requestInfo.PathParameters.Add("user%2Did", userId);
                requestInfo.PathParameters.Add("mailFolder%2Did", mailFolderId);
                requestInfo.PathParameters.Add("message%2Did", messageId);
                requestInfo.PathParameters.Add("singleValueLegacyExtendedProperty%2Did", singleValueLegacyExtendedPropertyId);
                var errorMapping = new Dictionary <string, ParsableFactory <IParsable> > {
                    { "4XX", ODataError.CreateFromDiscriminatorValue },
                    { "5XX", ODataError.CreateFromDiscriminatorValue },
                };
                await RequestAdapter.SendNoContentAsync(requestInfo, errorMapping: errorMapping, cancellationToken: cancellationToken);
                Console.WriteLine("Success");
            }, new CollectionBinding(userIdOption, mailFolderIdOption, messageIdOption, singleValueLegacyExtendedPropertyIdOption, bodyOption, new TypeBinding(typeof(CancellationToken))));
            return(command);
        }
示例#58
0
 public MemoryStream RenderToBitmapStream(IViewport viewport, IEnumerable<ILayer> layers, Color background = null)
 {
     MemoryStream bitmapStream = null;
     RunMethodOnStaThread(() => bitmapStream = RenderToBitmapStreamStatic(viewport, layers, _symbolCache));
     return bitmapStream;
 }
示例#59
0
        public IEnumerator readAMFList(MemoryStream memoryStream, IConfigVODB configVodb)
        {
            AMFReader reader   = new AMFReader(memoryStream);
            byte      typeCode = reader.ReadByte();

            //DebugX.Log("typeCode:"+typeCode);
            if (typeCode != 9)
            {
                yield break;
            }
            Type type   = configVodb.dbInstanceType;
            int  handle = reader.ReadAMF3IntegerData();
            bool inline = ((handle & 1) != 0);

            handle = handle >> 1;
            if (inline)
            {
                hashtable = null;
                string key = reader.ReadAMF3String();
                object value;
                while (key != null && key != string.Empty)
                {
                    if (hashtable == null)
                    {
                        hashtable = new Dictionary <string, object>();
                        reader.AddAMF3ObjectReference(hashtable);
                    }
                    value = reader.ReadAMF3Data();
                    hashtable.Add(key, value);
                    key = reader.ReadAMF3String();
                }
                //Not an associative array
                if (hashtable == null)
                {
                    object[] array = new object[handle];
                    reader.AddAMF3ObjectReference(array);

                    //long startParserTime = DateTime.Now.Ticks;
                    FieldInfo[] fieldInfos = type.GetFields();
                    fieldInfosDic.Clear();

                    string fieldName;
                    for (int i = 0, len = fieldInfos.Length; i < len; i++)
                    {
                        fieldName = fieldInfos[i].Name;
                        if (fieldInfosDic.ContainsKey(fieldName) == false)
                        {
                            fieldInfosDic.Add(fieldName, fieldInfos[i]);
                        }
                    }

                    for (int i = 0; i < handle; i++)
                    {
                        typeCode = reader.ReadByte();
                        if (typeCode == 10)
                        {
                            array[i] = ReadAMF3Object(reader, configVodb);
                        }
                        else
                        {
                            array[i] = reader.ReadAMF3Data(typeCode);
                        }

                        if (i % 1000 == 0)
                        {
                            yield return(null);
                        }
                    }
                    //DebugX.Log("tt:" + (DateTime.Now.Ticks - startParserTime) / 10000);
                    result = array;
                }
                else
                {
                    for (int i = 0; i < handle; i++)
                    {
                        value = reader.ReadAMF3Data();
                        hashtable.Add(i.ToString(), value);
                    }
                    result = (IList)hashtable;
                }
            }
            else
            {
                result = (IList)reader.ReadAMF3ObjectReference(handle);
            }
        }
示例#60
0
        /// <summary>
        /// Prepares the necessary byte buffers from the given CommandText
        /// </summary>
        /// <returns>Array of byte buffers, one for each SQL command</returns>
        /// <remarks>
        /// Converts the CommandText into an array of tokens
        /// using TokenizeSql and then into one or more byte buffers that can be
        /// sent to the server.  If the server supports batching (and we  have enabled it),
        /// then all commands result in a single byte array, otherwise a single buffer
        /// is created for each SQL command (as separated by ';').
        /// The SQL text is converted to bytes using the active encoding for the server.
        /// </remarks>
        private ArrayList PrepareSqlBuffers(string sql)
        {
            ArrayList    buffers = new ArrayList();
            PacketWriter writer  = new PacketWriter();

            writer.Encoding = connection.Encoding;
            writer.Version  = connection.driver.Version;

            // if we are executing as a stored procedure, then we need to add the call
            // keyword.
            if (CommandType == CommandType.StoredProcedure)
            {
                if (storedProcedure == null)
                {
                    storedProcedure = new StoredProcedure(connection);
                }
                sql = storedProcedure.Prepare(this);
            }

            // tokenize the SQL
            sql = sql.TrimStart(';').TrimEnd(';');
            ArrayList tokens = TokenizeSql(sql);

            foreach (string token in tokens)
            {
                if (token.Trim().Length == 0)
                {
                    continue;
                }
                if (token == ";" && !connection.driver.SupportsBatch)
                {
                    MemoryStream ms = (MemoryStream)writer.Stream;
                    if (ms.Length > 0)
                    {
                        buffers.Add(ms);
                    }

                    writer          = new PacketWriter();
                    writer.Encoding = connection.Encoding;
                    writer.Version  = connection.driver.Version;
                    continue;
                }
                else if (token[0] == parameters.ParameterMarker)
                {
                    if (SerializeParameter(writer, token))
                    {
                        continue;
                    }
                }

                // our fall through case is to write the token to the byte stream
                writer.WriteStringNoNull(token);
            }

            // capture any buffer that is left over
            MemoryStream mStream = (MemoryStream)writer.Stream;

            if (mStream.Length > 0)
            {
                buffers.Add(mStream);
            }

            return(buffers);
        }