config.c

一文件过滤与加密,系统监视以及控制的东东,自己看

	  aStringArrays[i].nBufferSize = dwSize ;
         
	  // count strings and get pointers
	  {
	    LPTSTR szBuffer ;
	    int j, n ;
	    
	    TRACE_INFO (TEXT("Counting string in array...\n")) ;
	    
	    szBuffer = (LPTSTR)aStringArrays[i].pBuffer ;
	    n = 0 ;
	    
	    for( j=1 ; j<dwSize/sizeof(TCHAR) ; j++ )
	      {
		if( szBuffer[j]==0 && szBuffer[j-1]!=0 )  n++ ;		
	      }
	    
	    TRACE_INFO (TEXT("Found %d strings.\n"), n) ;
	    
	    aStringArrays[i].nLength = n ;
	    aStringArrays[i].pszArray = malloc (aStringArrays[i].nLength*sizeof(LPTSTR)) ;
	    
	    n = 0 ;
	    aStringArrays[i].pszArray[n] = szBuffer ;
	    TRACE_INFO (TEXT("String %d is \"%s\"\n"), n, aStringArrays[i].pszArray[n]) ;
	    n++ ;
	    
	    for( j=1 ; j<dwSize/sizeof(TCHAR) ; j++ )
	      {
		if( szBuffer[j]!=0 && szBuffer[j-1]==0 )
		  {
		    aStringArrays[i].pszArray[n] = &szBuffer[j] ;
		    TRACE_INFO (TEXT("String %d is \"%s\"\n"), n, aStringArrays[i].pszArray[n]) ;
		    n++ ;
		  }
	      }
	    
	    TRACE_INFO (TEXT("Finished getting %d strings\n"), n) ;
	  }
      }
    }
  // for each config string array (end)
 
  return TRUE ;
}


/******************************************************************/
/* Exported function : Save                                       */
/******************************************************************/

BOOL Config_Save ()
{
  int		i ;

  TRACE ;

  // 1. Strings
  //
  for( i=0 ; i<_CFGSTR_COUNT ; i++ )
    Config_SaveString (i) ;

  //
  // 2. Integers
  //
  for( i=0 ; i<_CFGINT_COUNT ; i++ )
    Config_SaveInteger (i) ;

  //
  // 3. String arrays
  //
  for( i=0 ; i<_CFGSAR_COUNT ; i++ )
    Config_SaveStringArray (i) ;
 
  return TRUE ;
}

/******************************************************************/
/* Internal function                                              */
/******************************************************************/

void Config_SaveString (CONFIG_STRING_ID i) 
{
  LPCTSTR szValue ;
  
  TRACE ;

  szValue = aStrings[i].szValue ?: aStrings[i].szDefaultValue ;
  
  if( ! szValue ) return ;
  
  RegSetValueEx (g_hKey, aStrings[i].szName, 0, REG_SZ, 
		 (BYTE*)szValue, 
		 (_tcslen(szValue)+1)*sizeof(TCHAR)) ;
}


/******************************************************************/
/* Internal function                                              */
/******************************************************************/

void Config_SaveStringArray (CONFIG_STRING_ARRAY_ID i) 
{
  TRACE ;

  RegSetValueEx (g_hKey, aStringArrays[i].szName, 0, REG_MULTI_SZ, 
		 (BYTE*)aStringArrays[i].pBuffer, 
		 aStringArrays[i].nBufferSize) ; 
}

/******************************************************************/
/* Internal function                                              */
/******************************************************************/

void Config_SaveInteger (CONFIG_INTEGER_ID i) 
{
  DWORD		dwValue ;

  TRACE ;

  dwValue = aIntegers[i].iValue ;

  RegSetValueEx (g_hKey, aIntegers[i].szName, 0, REG_DWORD, 
		 (BYTE*)&dwValue, sizeof(dwValue)) ; 
}


/******************************************************************/
/* Exported function : GetInteger                                 */
/******************************************************************/

int Config_GetInteger (CONFIG_INTEGER_ID id)
{
  ASSERT (id>=0) ;
  ASSERT (id<_CFGINT_COUNT) ;

  return aIntegers[id].iValue ;
}


/******************************************************************/
/* Exported function : SetInteger                                 */
/******************************************************************/

void Config_SetInteger (CONFIG_INTEGER_ID id, int iValue)
{
  ASSERT (id>=0) ;
  ASSERT (id<_CFGINT_COUNT) ;

  aIntegers[id].iValue = iValue ;
}


/******************************************************************/
/* Exported function : GetString                                  */
/******************************************************************/

LPCTSTR Config_GetString (CONFIG_STRING_ID id)
{
  ASSERT (id>=0) ;
  ASSERT (id<_CFGSTR_COUNT) ;

  return aStrings[id].szValue ;
}


/******************************************************************/
/* Exported function : SetString                                  */
/******************************************************************/

void Config_SetString (CONFIG_STRING_ID id, LPCTSTR szValue)
{
  ASSERT (id>=0) ;
  ASSERT (id<_CFGSTR_COUNT) ;

  free (aStrings[id].szValue) ;
  aStrings[id].szValue = _tcsdup (szValue) ;
}




/******************************************************************/
/* Exported function                                              */
/******************************************************************/

VOID Config_SetStringArray (CONFIG_STRING_ARRAY_ID id, LPCTSTR* pszArray, UINT nLength) 
{
  ASSERT (id>=0) ;
  ASSERT (id<_CFGSAR_COUNT) ;

  if( aStringArrays[id].pBuffer!=NULL ) free (aStringArrays[id].pBuffer) ;
  if( aStringArrays[id].pszArray!=NULL ) free (aStringArrays[id].pszArray) ;
  
  if( nLength > 0 )
    {
      UINT i, n ;

      TRACE_INFO (TEXT("Calculating buffer size...\n")) ;
      
      n = 0 ;
      for( i=0 ; i<nLength ; i++ )
	n += (_tcslen(pszArray[i])+1)*sizeof(TCHAR) ;

      TRACE_INFO (TEXT("Buffer size is %u\n"), n) ;
      
      aStringArrays[id].nBufferSize = n ;
      aStringArrays[id].nLength = nLength ;
      aStringArrays[id].pBuffer = malloc (n) ;
      aStringArrays[id].pszArray = malloc (nLength*sizeof(LPCTSTR)) ;
      
      n = 0 ;
      for( i=0 ; i<nLength ; i++ )
	{	  
	  aStringArrays[id].pszArray[i] = (LPTSTR)&aStringArrays[id].pBuffer[n] ;
	  _tcscpy (aStringArrays[id].pszArray[i], pszArray[i]) ;
	  n += (_tcslen(pszArray[i])+1)*sizeof(TCHAR) ;
	  TRACE_INFO (TEXT("String %u = %s\n"), i, aStringArrays[id].pszArray[i]) ;
	}     
    }
  else
    {
      aStringArrays[id].pBuffer = NULL ;
      aStringArrays[id].pszArray = NULL ;
      aStringArrays[id].nBufferSize = 0 ;
      aStringArrays[id].nLength = 0 ;
    }
}


/******************************************************************/
/* Exported function                                              */
/******************************************************************/

LPCTSTR* Config_GetStringArray (CONFIG_STRING_ARRAY_ID id, UINT * pnLength) 
{
  ASSERT (id>=0) ;
  ASSERT (id<_CFGSAR_COUNT) ;
  ASSERT (pnLength!=0) ;
  
  *pnLength = aStringArrays[id].nLength ;

  return (LPCTSTR*)aStringArrays[id].pszArray ;
}


/******************************************************************/
/* Internal function                                              */
/******************************************************************/

VOID _Config_SetDefaultValues () 
{
  int i ;

  //
  // set deault values for each integer
  //
  for( i=0 ; i<_CFGINT_COUNT ; i++ )
    aIntegers[i].iValue = aIntegers[i].iDefaultValue ;

  //
  // Set default values for "Background scan folders"
  //
  {
    TCHAR szWindowsFolder[MAX_PATH] ;
    LPCTSTR szStringArray[1] ;
    
    SHGetSpecialFolderPath (NULL, szWindowsFolder, CSIDL_WINDOWS, FALSE) ;
    
    szStringArray[0] = szWindowsFolder ;

    Config_SetStringArray (CFGSAR_SCAN_FOLDERS, szStringArray, arraysize(szStringArray)) ;
  }

  //
  // Set default values for "Scan include filter"
  //
  {
    LPCTSTR szStringArray[] = 
      { TEXT("*.exe"), TEXT("*.com"), TEXT("*.dll"), TEXT("*.ocx"), 
	TEXT("*.scr"), TEXT("*.bin"), TEXT("*.dat"), TEXT("*.386"),
	TEXT("*.vxd"), TEXT("*.sys"), TEXT("*.wdm"), TEXT("*.cla"), 
	TEXT("*.class"), TEXT("*.ovl"), TEXT("*.ole"), TEXT("*.hlp"), 
	TEXT("*.doc"), TEXT("*.dot"), TEXT("*.xls"), TEXT("*.ppt"), 
	TEXT("*.wbk"), TEXT("*.wiz"), TEXT("*.pot"), TEXT("*.ppa"), 
	TEXT("*.xla"), TEXT("*.xlt"), TEXT("*.vbs"), TEXT("*.vbe"), 
	TEXT("*.mdb"), TEXT("*.rtf"), TEXT("*.htm"), TEXT("*.hta"), 
	TEXT("*.html"), TEXT("*.xml"), TEXT("*.xtp"), TEXT("*.php"),
	TEXT("*.asp"), TEXT("*.js"), TEXT("*.shs"), TEXT("*.chm"),
	TEXT("*.lnk"), TEXT("*.pif"), TEXT("*.prc"), TEXT("*.url"), 
	TEXT("*.smm"), TEXT("*.pfd"), TEXT("*.msi"), TEXT("*.ini"), 
	TEXT("*.csc"), TEXT("*.cmd"), TEXT("*.bas"), TEXT("*.nws") } ;

    Config_SetStringArray (CFGSAR_SCAN_PATTERNS, szStringArray, arraysize(szStringArray)) ;
  }
}