Beispiel #1
0
        /// <summary>
        /// Manage a profile image dowload of a remote user
        /// </summary>
        /// <param name="client">TCPClient</param>
        /// <param name="stream">NetworkStream of the client</param>
        /// <param name="ip">Remote Ip</param>
        /// <param name="fileOriginal">Original file name</param>
        /// <param name="dim">Lenght of the file (bytes)</param>
        async Task ServeReceiveProfileImage(TcpClient client, NetworkStream stream, string ip, string fileOriginal, long dim)
        {
            string filename = Utility.PathHost() + "\\" + fileOriginal;
            int    i        = 0;
            string hash_s   = "";

            byte[] bytes = new byte[32];

            if ((i = await stream.ReadAsync(bytes, 0, bytes.Length)) != 0)
            {
                try {
                    hash_s = BitConverter.ToString(bytes).Replace("-", string.Empty);
                }
                catch (Exception) {
                    throw new Exception("Pacchetto inviato non corretto");
                }
            }
            else
            {
                throw new Exception("Pacchetto inviato non corretto");
            };

            // Wait end asyncronous operation to check if a file already exists or not with the same name
            await semaphoreProfileImage.WaitAsync();

            if (_referenceData.GetRemoteUserHashImage(ip).Equals(hash_s))
            {
                semaphoreProfileImage.Release();
                return;
            }
            bytes = new byte[bufferSize * 64];

            if (File.Exists(filename))
            {
                string[] parts     = fileOriginal.Split('.');
                string   extension = parts[parts.Length - 1];
                parts = parts.Take(parts.Count() - 1).ToArray();
                string name = String.Join(".", parts);
                int    numb = Directory.GetFiles(Utility.PathHost(), name + "*" + extension).Length;
                filename = Utility.PathHost() + "\\" + name + "_(" + numb + ")." + extension;
            }
            FileStream fileImage = null;

            try {
                fileImage = File.Create(filename);
                Console.WriteLine($"{DateTime.Now.ToString()}\t - ProfileImage File Created on path {filename}");

                long dataReceived = dim;

                while (((i = await stream.ReadAsync(bytes, 0, bytes.Length)) != 0) && dataReceived >= 0)
                {
                    if (dataReceived > 0 && dataReceived < i)
                    {
                        await fileImage.WriteAsync(bytes, 0, Convert.ToInt32(dataReceived));
                    }
                    else
                    {
                        await fileImage.WriteAsync(bytes, 0, i);
                    }

                    dataReceived -= i;
                }
                fileImage.Close();

                using (SHA256 sha = SHA256.Create()) {
                    FileStream fs        = File.OpenRead(filename);
                    byte[]     hash      = sha.ComputeHash(fs);
                    string     hashimage = BitConverter.ToString(hash).Replace("-", string.Empty);
                    fs.Close();

                    if (!_referenceData.ProfileImageUpdate(hashimage, filename, ((IPEndPoint)client.Client.RemoteEndPoint).Address.ToString()))
                    {
                        File.Delete(filename);
                    }
                }

                semaphoreProfileImage.Release();
            }
            catch (Exception e) {
                Console.WriteLine($"{DateTime.Now.ToString()}\t - ServeReceiveProfileImage Exception - {e.GetType()} {e.Message}");
                semaphoreProfileImage.Release();

                if (fileImage != null)
                {
                    File.Delete(filename);
                }
            }
        }