/// <summary>
 /// Сохраняет файл новых уникальных сигнатур, добавленных функцией AddNewHtSign ДО (!!!) добавления их в общую хеш-таблицу
 /// </summary>
 /// <param name="db_update">Путь к файлу новых уникальных сигнатур</param>
 /// <param name="pb">ProgressBar</param>
 /// <returns>Успех/Отказ</returns>
 public bool SaveNewHtSighToDB_upd(string db_update, ProgressBar pb)
 {
     try
     {
         using (FileStream fStream = File.Open(db_update, FileMode.Create, FileAccess.Write))
         {
             BinaryFormatter bf = new BinaryFormatter();
             bf.Serialize(fStream, ht_new);
         }
         new Pack(pb).PackingFile(db_update, db_update + ext, true);
         if (OK != null)
         {
             OK.Invoke("Файл обновления создан", "ОК. Записей: " + ht_new.Count.ToString());
         }
         return(true);
     }
     catch (Exception ex)
     {
         error_transaction = true;
         if (MakeError != null)
         {
             MakeError.Invoke(ex.Message);
         }
         return(false);
     }
 }
 /// <summary>
 /// Добавляет все временные сигнатуры в хеш-таблицу базы данных
 /// </summary>
 public void AddNewHtSignsToHtBase(int prev_cnt)
 {
     try
     {
         foreach (object key in ht_new.Keys)
         {
             if (!ht_base.ContainsKey(key))
             {
                 ht_base.Add(key, string.Empty);
             }
         }
         if (OK != null)
         {
             int div = ht_base.Count - prev_cnt;
             OK.Invoke("Сигнатуры добавлены в базу", "Новые сигнатуры отобраны и добавлены в базу (всего: " + div.ToString() + ")");
         }
     }
     catch (Exception ex)
     {
         error_transaction = true;
         if (MakeError != null)
         {
             MakeError.Invoke(ex.Message);
         }
     }
 }
 /// <summary>
 /// Сохраняет файл базы данных с последней версией хеш-таблицы
 /// </summary>
 /// <param name="db_hash">Путь к файлу базы данных</param>
 /// <returns>Успех/Отказ</returns>
 public bool SaveHtSighToDB(string db_hash)
 {
     try
     {
         using (FileStream fStream = File.Open(db_hash, FileMode.Create, FileAccess.Write))
         {
             BinaryFormatter bf = new BinaryFormatter();
             bf.Serialize(fStream, ht_base);
         }
         if (OK != null)
         {
             OK.Invoke("База сохранена", "Хеш-таблица сохранена в базу данных (записей: " + ht_base.Count.ToString() + ")");
         }
         return(true);
     }
     catch (Exception ex)
     {
         error_transaction = true;
         if (MakeError != null)
         {
             MakeError.Invoke(ex.Message);
         }
         return(false);
     }
 }
 /// <summary>
 /// Создает файл основного хранилища БД и загружает в основную хеш-таблицу.
 /// </summary>
 /// <param name="db_hash">Путь к файлу базы данных</param>
 public void CreateDBAndLoadHTB(string db_hash)
 {
     try
     {
         using (FileStream fStream = File.Open(db_hash, FileMode.CreateNew, FileAccess.ReadWrite))
         {
             Hashtable       ht_tmp = new Hashtable(300000);
             BinaryFormatter bf     = new BinaryFormatter();
             bf.Serialize(fStream, ht_tmp);
         }
         using (FileStream fStream = File.Open(db_hash, FileMode.Open, FileAccess.Read))
         {
             BinaryFormatter outFormatter = new BinaryFormatter();
             ht_base = (Hashtable)outFormatter.Deserialize(fStream);
         }
         if (OK != null)
         {
             OK.Invoke("База создана", "Общая база создана. Хеш-таблица сформирована");
         }
     }
     catch (Exception ex)
     {
         error_transaction = true;
         if (MakeError != null)
         {
             MakeError.Invoke(ex.Message);
         }
     }
 }
Beispiel #5
0
 private void ExtractFileInfo(FileInfo[] fi)
 {
     if (!_is_scanning)
     {
         return;
     }
     foreach (FileInfo nm in fi)
     {
         if (!_is_scanning)
         {
             return;
         }
         try
         {
             if (nm.Length >= _file_size_min && nm.Length <= _file_size_max)
             {
                 if (FindFile != null)
                 {
                     FindFile.Invoke(nm);
                 }
             }
         }
         catch (Exception ex)
         {
             if (MakeError != null)
             {
                 MakeError.Invoke(ex.Message + " | " + ex.TargetSite);
             }
         }
     }
 }
Beispiel #6
0
 /// <summary>
 /// Старт поиска файлов. В Keys Hashtable - полные пути диреторий для поиска
 /// </summary>
 /// <param name="ht"></param>
 public void ScanFiles(Hashtable ht)
 {
     try
     {
         _is_scanning = true;
         foreach (object folder_to_scan in ht.Keys)
         {
             try
             {
                 DirectoryInfo dir = new DirectoryInfo(folder_to_scan.ToString());
                 ExtractFileInfo(dir.GetFiles("*", SearchOption.TopDirectoryOnly));
                 ExtractDirInfo(dir);
             }
             catch (Exception ex)
             {
                 if (MakeError != null)
                 {
                     MakeError.Invoke(ex.Message + " | " + ex.TargetSite);
                 }
             }
         }
     }
     catch (Exception ex)
     {
         _is_scanning = false;
         if (MakeError != null)
         {
             MakeError.Invoke(ex.Message + " | " + ex.TargetSite);
         }
     }
 }
Beispiel #7
0
        public bool Insert(Hashtable ht, string db, string tbl)
        {
            string field   = string.Empty;
            string param   = string.Empty;
            string content = string.Empty;

            if (conn != null)
            {
                conn.Close();
            }

            string connStr = String.Format("server={0};user id={1}; password={2}; database={3}; pooling=false",
                                           _server, _user_id, _password, db);

            try
            {
                conn = new MySqlConnection(connStr);
                conn.Open();

                MySqlCommand cmd = new MySqlCommand();
                cmd.Connection = conn;

                foreach (string key in ht.Keys)
                {
                    field += key + ", ";
                    param += "?" + key + ", ";
                    cmd.Parameters.AddWithValue("?" + key, ht[key]);
                }

                field = field.Remove(field.Length - 2);
                param = param.Remove(param.Length - 2);

                cmd.CommandText = "INSERT INTO " + tbl + " (" + field + ") VALUES (" + param + ")";

                cmd.Prepare();
                cmd.ExecuteNonQuery();

                //cmd.Parameters[0].Value = 20;
                //cmd.ExecuteNonQuery();
            }
            catch (MySqlException ex)
            {
                if (MakeError != null)
                {
                    MakeError.Invoke(ex.Message);
                }
            }
            return(true);
        }
Beispiel #8
0
        private void ExtractDirInfo(DirectoryInfo root_dir)
        {
            DirectoryInfo[] dirs = root_dir.GetDirectories("*", SearchOption.TopDirectoryOnly);

            foreach (DirectoryInfo dirx in dirs)
            {
                try
                {
                    FileInfo[] fi = dirx.GetFiles("*", SearchOption.TopDirectoryOnly);
                    ExtractFileInfo(fi);
                    ExtractDirInfo(dirx);
                }
                catch (Exception ex)
                {
                    if (MakeError != null)
                    {
                        MakeError.Invoke(ex.Message + " | " + ex.TargetSite);
                    }
                }
            }
        }
        /// <summary>
        /// Добавляет новую уникальную сигнатуру к временной хеш-таблице базы данных. Не сохраняет БД.
        /// </summary>
        /// <param name="signature">Сигнатура</param>
        /// <returns>Успех/Отказ (сигнатура уже есть или ошибка)</returns>
        public bool AddNewHtSign(string signature, bool write_ok_evnt)
        {
            bool return_val = false;

            try
            {
                counter_new_ht++;
                if (counter_new_ht == 1)
                {
                    prev_new_cnt = ht_new.Count;
                }

                if (!ht_base.ContainsKey(signature) &&
                    !ht_new.ContainsKey(signature))
                {
                    ht_new.Add(signature, string.Empty);
                    return_val = true;
                }
                else
                {
                    return_val = false;
                }
                if (OK != null && write_ok_evnt)
                {
                    int div = ht_new.Count - prev_new_cnt;
                    OK.Invoke("Новая сигнатура принята", "Проверено за сессию: " + counter_new_ht.ToString()
                              + ", новых: " + div.ToString() + ", всего новых: " + ht_new.Count.ToString());
                }
            }
            catch (Exception ex)
            {
                error_transaction = true;
                if (MakeError != null)
                {
                    MakeError.Invoke(ex.Message);
                }
            }

            return(return_val);
        }
        /// <summary>
        /// Добавляет в основную хеш-таблицу базы данных новые уникальные сигнатуы из файла
        /// (прежде сохраненные функцией SaveNewHtSighToDB_upd)
        /// </summary>
        /// <param name="db_update">Путь к файлу новых уникальных сигнатур</param>
        /// <param name="pb">ProgressBar</param>
        /// <returns>Успех/Отказ</returns>
        public bool LoadNewHtSighInDB_upd(string db_update, ProgressBar pb)
        {
            try
            {
                int       first_cnt = ht_base.Count;
                Hashtable ht_update;
                new UnPack(pb).UnPackingFile(db_update, db_update + ext, false);
                using (FileStream fStream = File.Open(db_update + ext, FileMode.Open, FileAccess.Read))
                {
                    BinaryFormatter outFormatter = new BinaryFormatter();
                    ht_update = (Hashtable)outFormatter.Deserialize(fStream);
                }

                foreach (object key in ht_update.Keys)
                {
                    if (!ht_base.ContainsKey(key))
                    {
                        ht_base.Add(key, string.Empty);
                    }
                }
                File.Delete(db_update + ext);
                if (OK != null)
                {
                    int div = ht_base.Count - first_cnt;
                    OK.Invoke("Обновление", "Новые сигнатуры добавлены в хеш-таблицу (всего: " + div.ToString() + ")");
                }
                return(true);
            }
            catch (Exception ex)
            {
                File.Delete(db_update + ext);
                error_transaction = true;
                if (MakeError != null)
                {
                    MakeError.Invoke(ex.Message);
                }
                return(false);
            }
        }
 /// <summary>
 /// Конструктор. Создает хеш-таблицу базы данных из файла
 /// </summary>
 /// <param name="db_hash">Путь к файлу базы данных</param>
 public void LoadBases(string db_hash)
 {
     try
     {
         using (FileStream fStream = File.Open(db_hash, FileMode.Open, FileAccess.Read))
         {
             BinaryFormatter outFormatter = new BinaryFormatter();
             ht_base = (Hashtable)outFormatter.Deserialize(fStream);
         }
         if (OK != null)
         {
             OK.Invoke("Базы проверены", "ОК. Записей: " + ht_base.Count.ToString());
         }
     }
     catch (Exception ex)
     {
         error_transaction = true;
         if (MakeError != null)
         {
             MakeError.Invoke(ex.Message);
         }
     }
 }
 /// <summary>
 /// Создает файл основного хранилища БД.
 /// </summary>
 /// <param name="db_hash">Путь к файлу базы данных</param>
 public void CreateDB(string db_hash)
 {
     try
     {
         using (FileStream fStream = File.Open(db_hash, FileMode.CreateNew, FileAccess.ReadWrite))
         {
             Hashtable       ht_tmp = new Hashtable(300000);
             BinaryFormatter bf     = new BinaryFormatter();
             bf.Serialize(fStream, ht_tmp);
         }
         if (OK != null)
         {
             OK.Invoke("База создана", "Новая глобальная база создана");
         }
     }
     catch (Exception ex)
     {
         error_transaction = true;
         if (MakeError != null)
         {
             MakeError.Invoke(ex.Message);
         }
     }
 }
        /// <summary>
        /// Используется пока только при инсерте записей в онлайн-бд
        /// </summary>
        /// <param name="hash"></param>
        /// <param name="path"></param>
        /// <param name="is_accept_file"></param>
        /// <param name="CheckedDate"></param>
        /// <returns></returns>
        public Hashtable LoadFInfo(string hash, string path, bool is_accept_file, DateTime CheckedDate)
        {
            Hashtable ht = new Hashtable(50);

            try
            {
                FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(path);
                FileInfo        fi  = new FileInfo(path);

                ht.Add("isChecked", is_accept_file);
                ht.Add("CheckedDate", CheckedDate);

                if (fi != null)
                {
                    ht.Add("ShortName", fi.Name);
                    ht.Add("CreationTime", fi.CreationTime);
                    ht.Add("CreationTimeUtc", fi.CreationTimeUtc);
                    ht.Add("Directory", fi.Directory);
                    ht.Add("DirectoryName", fi.DirectoryName);
                    ht.Add("Extension", fi.Extension);
                    ht.Add("FullName", fi.FullName);
                    ht.Add("IsReadOnly", fi.IsReadOnly);
                    ht.Add("LastAccessTime", fi.LastAccessTime);
                    ht.Add("LastAccessTimeUtc", fi.LastAccessTimeUtc);
                    ht.Add("LastWriteTime", fi.LastWriteTime);
                    ht.Add("LastWriteTimeUtc", fi.LastWriteTimeUtc);
                    ht.Add("Length", fi.Length);
                    ht.Add("Attributes", fi.Attributes.ToString());
                }

                ht.Add("Hash", hash);

                if (fvi != null)
                {
                    ht.Add("Comments", fvi.Comments);
                    ht.Add("CompanyName", fvi.CompanyName);
                    ht.Add("FileBuildPart", fvi.FileBuildPart);
                    ht.Add("FileDescription", fvi.FileDescription);
                    ht.Add("FileMajorPart", fvi.FileMajorPart);
                    ht.Add("FileMinorPart", fvi.FileMinorPart);
                    ht.Add("FileName", fvi.FileName);
                    ht.Add("FilePrivatePart", fvi.FilePrivatePart);
                    ht.Add("FileVersion", fvi.FileVersion);
                    ht.Add("InternalName", fvi.InternalName);
                    ht.Add("IsDebug", fvi.IsDebug);
                    ht.Add("IsPatched", fvi.IsPatched);
                    ht.Add("IsPreRelease", fvi.IsPreRelease);
                    ht.Add("IsPrivateBuild", fvi.IsPrivateBuild);
                    ht.Add("IsSpecialBuild", fvi.IsSpecialBuild);
                    ht.Add("Language", fvi.Language);
                    ht.Add("LegalCopyright", fvi.LegalCopyright);
                    ht.Add("LegalTrademarks", fvi.LegalTrademarks);
                    ht.Add("OriginalFilename", fvi.OriginalFilename);
                    ht.Add("PrivateBuild", fvi.PrivateBuild);
                    ht.Add("ProductBuildPart", fvi.ProductBuildPart);
                    ht.Add("ProductMajorPart", fvi.ProductMajorPart);
                    ht.Add("ProductMinorPart", fvi.ProductMinorPart);
                    ht.Add("ProductName", fvi.ProductName);
                    ht.Add("ProductPrivatePart", fvi.ProductPrivatePart);
                    ht.Add("ProductVersion", fvi.ProductVersion);
                    ht.Add("SpecialBuild", fvi.SpecialBuild);
                }
            }
            catch (Exception ex)
            {
                if (MakeError != null)
                {
                    MakeError.Invoke(ex.Message);
                }
            }
            return(ht);
        }