//------------------------------------------------------------------------
bool StringParser::LoadStringItems( const string& fileList, const string& directory, bool isEncrypt )
{
TiXmlDocument doc;
if( !FileLoader::LoadFile( &doc, fileList, isEncrypt ) )
{
Assert(0);
_LogError( string("StringParser::LoadStringItems : ") + fileList + "¼ÓÔØʧ°Ü." );
return false;
}
TiXmlElement* root = doc.FirstChildElement( "StringList" );
if( root == 0 )
{
doc.Clear();
Assert(0);
_LogError( string("StringParser::LoadStringItems : ") + fileList + "¼ÓÔØʧ°Ü." );
return false;
}
TiXmlElement* entityNode = root->FirstChildElement( "StringFile" );
for( entityNode; entityNode; entityNode=entityNode->NextSiblingElement("StringFile") )
{
const char* fileName = entityNode->Attribute( "File" );
LoadStringItem( directory + "\\" + fileName, isEncrypt );
}
return true;
}
bool StringParser::LoadStringItem( const string& file, bool isEncrypt )
{
TiXmlDocument doc;
if( !FileLoader::LoadFile( &doc, file, isEncrypt ) )
{
Assert(0);
_LogError( string("StringParser::LoadStringItem : ") + file + "¼ÓÔØʧ°Ü." );
return false;
}
TiXmlElement* root = doc.FirstChildElement( "Strings" );
if( root == 0 )
{
doc.Clear();
Assert(0);
_LogError( string("StringParser::LoadStringItem : ") + file + "¼ÓÔØʧ°Ü." );
return false;
}
TiXmlElement* entityNode = root->FirstChildElement();
for( entityNode; entityNode; entityNode=entityNode->NextSiblingElement() )
{
const char* key = entityNode->Value();
const char* text = entityNode->Attribute( "Text" );
if( text == 0 )
{
_LogError( string("StringParser::LoadStringItem Error: ") + key + " ȱÉÙTextÊôÐÔ" );
continue;
}
if( m_StringItems.GetStringItemById( key ) != 0 )
{
_LogError( string("StringParser::LoadStringItem Error: ") + key + " ÒÑ´æÔÚ" );
continue;
}
string theText = text;
int len = ::strlen( text );
int start = 0;
int replaceCount = 0;
for( int i=0; i<len; ++i )
{
/// Find "\n"
if( text[i] == '\\' && i+1<len && text[i+1] == 'n' )
{
theText.erase( theText.begin()+(i-replaceCount),theText.begin()+(i-replaceCount+2));
string strEnter = "\n";
theText.insert( theText.begin()+(i-replaceCount), strEnter.begin(), strEnter.begin()+strEnter.length() );
++i;
++replaceCount;
}
}
StringParser::StringItem* item = new StringParser::StringItem;
Parse( key, We::Type::ToWstring( theText ), item );
m_StringItems.Add( item );
}
return true;
}
static void UI_post_notice(const char *title,const char *statement,...) {
va_list ap;
va_start(ap,statement);
if ( no_windowing_ui ) {
_LogError(statement,ap);
} else {
if ( GWidgetPostNoticeActive8(title))
_LogError(statement,ap);
else
_GWidgetPostNotice8(title,statement,ap,40);
}
va_end(ap);
}
static void UI_LogError(const char *format,...) {
va_list ap;
va_start(ap,format);
_LogError(format,ap);
va_end(ap);
}
void CMiscDlg::OnBnClicked_bnCountryCode()
{
//update country code
int iCheck = ((CButton*)GetDlgItem (IDC_chCountry))->GetCheck ();
TCHAR szCountryCode[3];
if(BST_CHECKED == iCheck)
{
int iCurSel = ((CComboBox*)GetDlgItem (IDC_cbCountry))->GetCurSel ();
((CComboBox*)GetDlgItem (IDC_cbCountry))->GetLBText(iCurSel, szCountryCode);
}
else
_tcscpy(szCountryCode, _T(WMI_DISABLE_REGULATORY_CODE));
if (0 == _tcscmp (m_pConfig->m_szCountryCode, szCountryCode))
{
return;//no change in country code
}
_LogStatus (_T ("Updating Country code... please wait"));
if (FALSE == m_pConfig->SetCountryCode (szCountryCode))
{
_LogError (_T ("Country code update failed"));
return;
}
else
{
_LogStatus (_T ("Country code updated"));
}
}
//------------------------------------------------------------------------
wstring StringParser::GetString( const string& key, const Var& arg, bool returnKeyIfFailed/*=true*/ )
{
StringParser::StringItem* item = m_StringItems.GetStringItemById( key );
if( item == 0 )
{
_LogError( string("StringParser::GetString Error : ") + key + " ²»´æÔÚ" );
if( returnKeyIfFailed )
return We::Type::ToWstring( key );
return L"";
}
if( item->m_Texts.size() != 2 )
{
_LogError( string("StringParser::GetString Error : ") + key + " ²ÎÊý¸öÊý²»Æ¥Åä" );
if( returnKeyIfFailed )
return We::Type::ToWstring( key );
return L"";
}
return item->m_Texts[0] + arg.ForceToWstring() + item->m_Texts[1];
}
void CMiscDlg::OnBnClicked_bnDelMac()
{
TCHAR szMAC[MAX_PATH];
char szDelMAC[MAX_PATH];
int nDelIndex = MAX_PATH;
memset(szMAC, NULL, sizeof (szMAC));
if (0 == ((CComboBox*)GetDlgItem (IDC_cbMACFilter))->GetCount ())
{
_LogStatus (_T ("MAC filters not present to delete"));
AfxMessageBox(_T("MAC filters not present to delete."));
return;
}
GetDlgItemText(IDC_cbMACFilter, szMAC, MAX_PATH);
int nCurSel = ((CComboBox*)GetDlgItem (IDC_cbMACFilter))->GetCurSel ();
memset(szDelMAC, NULL, sizeof (szDelMAC));
wcstombs(szDelMAC, szMAC, _tcslen (szMAC));
szDelMAC[_tcslen (szMAC)] = NULL;
for (int i = 0; i < AP_ACL_SIZE; i++)
{
if (! strcmp (szDelMAC, m_pConfig->m_szACLList[i]))
{
nDelIndex = i;
break;
}
}
if (MAX_PATH == nDelIndex)
{
_LogStatus (_T ("MAC not found in list"));
AfxMessageBox (_T ("MAC not found in list."));
RefreshMacFilter(FALSE);
return;
}
_stprintf(szMAC, _T("%u"), nDelIndex);
_LogStatus (_T ("Deleting MAC filter... please wait"));
if (FALSE == m_pConfig->UpdateACL (szMAC, DEL_MAC_ADDR))
{
_LogError (_T ("MAC filter delete failed"));
}
else
{
_LogStatus (_T ("MAC filter deleted"));
}
RefreshMacFilter(TRUE);
}
//------------------------------------------------------------------------
wstring StringParser::GetString( const string& key, bool returnKeyIfFailed/*=true*/ )
{
StringParser::StringItem* item = m_StringItems.GetStringItemById( key );
if( item == 0 )
{
_LogError( string("StringParser::GetString Error : ") + key + " ²»´æÔÚ" );
if( returnKeyIfFailed )
return We::Type::ToWstring( key );
return L"";
}
return item->m_Text;
}
//------------------------------------------------------------------------
wstring StringParser::GetString( const string& key, const VarList& args, bool returnKeyIfFailed/*=true*/ )
{
StringParser::StringItem* item = m_StringItems.GetStringItemById( key );
if( item == 0 )
{
_LogError( string("StringParser::GetString Error : ") + key + " ²»´æÔÚ" );
if( returnKeyIfFailed )
return We::Type::ToWstring( key );
return L"";
}
if( item->m_Texts.size() != args.Size() + 1 )
{
_LogError( string("StringParser::GetString Error : ") + key + " ²ÎÊý¸öÊý²»Æ¥Åä" );
if( returnKeyIfFailed )
return We::Type::ToWstring( key );
return L"";
}
wstring ret = item->m_Texts[0];
for( int i=0; i<args.Size(); ++i )
ret += args.GetValue( item->m_Indexes[i]-1 ).ForceToWstring() + item->m_Texts[i+1];
return ret;
}
int main(int argc, char** argv)
{
// Setup globals.
programName = argv[0];
if (argc < 2) {
_LogError("You must pass an argument to startw.exe telling it what file to start.\nUsage: startw <filename> [<args>...]");
return 1;
}
// Parse argv.
char* file = argv[1];
char params[BUF_LENGTH];
params[0] = '\0';
for (int i = 2; i < argc; ++i) {
strncat(params, argv[i], BUF_LENGTH-strlen(params));
strncat(params, " ", BUF_LENGTH-strlen(params));
}
// Call ShellExecuteEx with the given arguments.
SHELLEXECUTEINFO execInfo;
memset(&execInfo, 0, sizeof(execInfo));
execInfo.cbSize = sizeof(execInfo);
execInfo.fMask = NULL;
execInfo.lpVerb = NULL;
execInfo.lpFile = file;
execInfo.lpParameters = params;
//execInfo.lpDirectory = XXX necessary for what I want?
execInfo.nShow = SW_SHOW;
int success = ShellExecuteEx(&execInfo);
if (!success) {
_LogError("ShellExecuteEx failed: %d, %d",
(int)execInfo.hInstApp, GetLastError());
return 1;
}
return 0;
}
void CMiscDlg::OnBnClicked_bnAclpolicy()
{
int iCurSel = ((CComboBox*)GetDlgItem (IDC_cbACLPolicy))->GetCurSel ();
_LogStatus (_T ("Updating ACL policy.. please wait"));
if (FALSE == m_pConfig->SetAclPolicy (iCurSel))
{
_LogError (_T ("ACL policy update failed"));
return;
}
else
{
RefreshMacFilter (TRUE);
_LogStatus (_T ("ACL policy updated"));
}
}
void CMiscDlg::OnBnClicked_bnAddMac()
{
TCHAR szMAC[MAX_PATH];
char szBuffer[MAX_PATH];
A_UINT8 szMACFilter[ATH_MAC_LEN], cWildcard;
memset(szMAC, NULL, sizeof (szMAC));
GetDlgItemText(IDC_cbMACFilter, szMAC, MAX_PATH);
if (! _tcscmp(szMAC, _T("00:00:00:00:00:00")) ||//When passed this mac addr, ar6k ioctl fails
(FALSE == m_pConfig->wmic_ether_aton_wild(szMAC, szMACFilter, &cWildcard)))
{
_LogStatus (_T ("Please enter a valid MAC"));
AfxMessageBox(_T("Please enter a valid MAC."));
RefreshMacFilter(FALSE);
return;
}
memset(szBuffer, NULL, sizeof (szBuffer));
wcstombs(szBuffer, szMAC, _tcslen (szMAC));
szBuffer[_tcslen (szMAC)] = NULL;
for (int i = 0; i < AP_ACL_SIZE; i++)
{
if (! strcmp (szBuffer, m_pConfig->m_szACLList[i]))
{
_LogStatus (_T ("MAC already exists in filter list"));
AfxMessageBox(_T("MAC already exists in filter list."));
RefreshMacFilter(FALSE);
return;
}
}
_LogStatus (_T ("Adding MAC filter... please wait"));
if (FALSE == m_pConfig->UpdateACL (szMAC, ADD_MAC_ADDR))
{
_LogError (_T ("MAC filter add failed"));
}
else
{
_LogStatus (_T ("MAC filter added"));
}
RefreshMacFilter(TRUE);
}
static char* _GetProgramPath(void)
{
//XXX this is ugly but I didn't want to use malloc, no reason
static char progPath[MAXPATHLEN+1];
// get absolute path to module
if (!GetModuleFileName(NULL, progPath, MAXPATHLEN)) {
_LogError("could not get absolute program name from "\
"GetModuleFileName\n");
exit(1);
}
// just need dirname
for (char* p = progPath+strlen(progPath);
*p != SEP && *p != ALTSEP;
--p)
{
*p = '\0';
}
*p = '\0'; // remove the trailing SEP as well
return progPath;
}
void CMiscDlg::OnBnClicked_bnRefresh()
{
//clear all mac-strings from combo box
((CComboBox*)GetDlgItem (IDC_cbStattions))->ResetContent ();
if (FALSE == m_pConfig->GetStations ())
{
_LogError (_T("Get station list failed"));
}
else
{
_LogStatus (_T("Station list refreshed"));
int nStaCount = 0;
for (int i = 0; i < (int)m_pConfig->m_nMaxStationLimit; i++)
{
TCHAR szSta[MAX_PATH];
if (strlen (m_pConfig->m_szStaList[i]))
{
memset (szSta, NULL, sizeof (szSta));
mbstowcs (szSta, m_pConfig->m_szStaList[i], strlen(m_pConfig->m_szStaList[i]));
szSta[18] = NULL;
((CComboBox*)GetDlgItem (IDC_cbStattions))->AddString (szSta);
nStaCount++;
if(m_pConfig->m_nStaCount <= nStaCount)
break;
}
}
if (m_pConfig->m_nStaCount)
((CComboBox*)GetDlgItem (IDC_cbStattions))->SetCurSel (0);
else
_LogStatus (_T("Station list is empty"));
}
}
void CMiscDlg::OnBnClicked_bnMaxStation()
{
//update the station limit
TCHAR szMaxStations[MAX_PATH] = {0, };
GetDlgItemText (IDC_txtMaxStations, szMaxStations, MAX_PATH);
if (m_pConfig->m_nStationLimit == _ttoi (szMaxStations))
{
return;//no change in station limit
}
_LogStatus (_T ("Updating station limit... please wait"));
if (FALSE == m_pConfig->SetStationLimit (szMaxStations))
{
_LogError (_T ("Station limit update failed"));
return;
}
else
{
_LogStatus (_T ("Station limit updated"));
}
}
void StringParser::Parse( const string& key, const wstring& text, StringParser::StringItem* item )
{
item->m_Key = key;
item->m_Text = text;
int i = 0;
int j = 0;
int k = 0;
bool hasError = false;
while( true )
{
for( int x=i; x<text.length(); ++x )
{
if( text[x] == L'{' && x < text.length()-1 && text[x+1] == L'%' )
{
i = x;
break;
}
}
//i = text.find_first_of( L"{%", i );
if( i < 0 )
break;
/// 0123{%s1}
/// 012345678
if( text.length() < i+5 )
break;
wchar_t typeChar = text.at( i+2 );
/// 0123{%{%s1}
if( typeChar != L's'
&& typeChar != L'S'
&& typeChar != L'd'
&& typeChar != L'D'
&& typeChar != L'i'
&& typeChar != L'I'
&& typeChar != L'f'
&& typeChar != L'F' )
{
i += 2;
continue;
}
j = text.find_first_of( L"}", i+4 );
if( j < 0 )
break;
int indexLen = j - i - 3;
/// 0123{%s}8
if( indexLen < 1 )
{
i = j + 1;
continue;
}
/// Ö»Ö§³Ö1-99µÄÐòºÅ
/// 0123{%s100}
if( indexLen > 2 )
{
i = j + 1;
continue;
}
wstring indexStr = text.substr( i+3, indexLen );
/// ÅжÏÊÇ·ñÊÇÊý×Ö
if( indexStr < L"0" || indexStr > L"99" )
{
break;
}
int index = We::Type::ToInt( indexStr );
if( index <= 0 )
{
_LogError( string("StringParser::Parse Error : ") + key );
hasError = true;
break;
}
item->m_Indexes.push_back( index );
item->m_Texts.push_back( text.substr( k, i-k ) );
k = j + 1;
i = j + 1;
}
item->m_Texts.push_back( text.substr( k, text.length()-k ) );
/// ¼ì²éÐòºÅÊÇ·ñÓÐÎó
for( int i=0; i<item->m_Indexes.size(); ++i )
{
/// ÐòºÅ³¬³ö·¶Î§
if( item->m_Indexes[i] > item->m_Indexes.size() )
{
_LogError( string("StringParser::Parse Error : ") + key );
hasError = true;
break;
}
/// ÐòºÅÖظ´
for( int j=i+1; j<item->m_Indexes.size(); ++j )
{
if( item->m_Indexes[i] == item->m_Indexes[j] )
{
_LogError( string("StringParser::Parse Error : ") + key );
hasError = true;
break;
}
}
}
if( hasError )
{
item->m_Texts.clear();
item->m_Indexes.clear();
}
}
bool DecompressLZOCompressedPackage(UPKReader *Package)
{
if (!Package->IsCompressed())
{
_LogError("Package is not compressed!", "DecompressLZO");
return false;
}
if (!Package->IsLZOCompressed() && !Package->IsFullyCompressed())
{
_LogError("Cannot decompress non-LZO compressed packages!", "DecompressLZO");
return false;
}
/// init lzo library
int lzo_err;
lzo_uint in_len;
lzo_uint out_len;
lzo_uint new_len;
if (lzo_init() != LZO_E_OK)
{
_LogError("LZO library internal error: lzo_init() failed!", "DecompressLZO");
return false;
}
lzo_memset(in, 0, IN_LEN);
std::stringstream decompressed_stream;
unsigned int NumCompressedChunks = Package->Summary.NumCompressedChunks;
if (Package->IsFullyCompressed())
{
NumCompressedChunks = 1;
}
else
{
_LogDebug("Resetting package compression flags...", "DecompressLZO");
/// reset compression flags
Package->Summary.CompressionFlags = 0;
Package->Summary.PackageFlags ^= (uint32_t)UPackageFlags::Compressed;
Package->Summary.NumCompressedChunks = 0;
/// serialize package summary
std::vector<char> sVect = Package->SerializeSummary();
decompressed_stream.write(sVect.data(), sVect.size());
}
_LogDebug("Decompressing...", "DecompressLZO");
for (unsigned int i = 0; i < NumCompressedChunks; ++i)
{
if (Package->IsFullyCompressed())
{
Package->UPKStream.seekg(0);
}
else
{
Package->UPKStream.seekg(Package->Summary.CompressedChunks[i].CompressedOffset);
}
_LogDebug("Decompressing chunk #" + ToString(i), "DecompressLZO");
uint32_t tag = 0;
Package->UPKStream.read(reinterpret_cast<char*>(&tag), 4);
if (tag != 0x9E2A83C1)
{
_LogError("Missing 0x9E2A83C1 signature!", "DecompressLZO");
return false;
}
uint32_t blockSize = 0;
Package->UPKStream.read(reinterpret_cast<char*>(&blockSize), 4);
if (blockSize != IN_LEN)
{
_LogError("Incorrect max block size!", "DecompressLZO");
return false;
}
std::vector<uint32_t> sizes(2); /// compressed/uncompressed pairs
Package->UPKStream.read(reinterpret_cast<char*>(sizes.data()), 4 * sizes.size());
size_t dataSize = sizes[1]; /// uncompressed data chunk size
unsigned numBlocks = (dataSize + blockSize - 1) / blockSize;
_LogDebug("numBlocks = " + ToString(numBlocks), "DecompressLZO");
if (numBlocks < 1)
{
_LogError("Bad data!", "DecompressLZO");
return false;
}
sizes.resize((numBlocks + 1)*2);
Package->UPKStream.read(reinterpret_cast<char*>(sizes.data()) + 8, 4 * sizes.size() - 8);
for (unsigned i = 0; i <= numBlocks; ++i)
{
_LogDebug("Compressed size = " + ToString(sizes[i * 2]) +
+ "\tUncompressed size = " + ToString(sizes[i * 2 + 1]), "DecompressLZO");
}
std::vector<unsigned char> dataChunk(dataSize);
std::vector<unsigned char> compressedData(sizes[0]);
Package->UPKStream.read(reinterpret_cast<char*>(compressedData.data()), compressedData.size());
size_t blockOffset = 0;
size_t dataOffset = 0;
for (unsigned i = 1; i <= numBlocks; ++i)
{
out_len = sizes[i * 2]; /// compressed size
lzo_memcpy(out, compressedData.data() + blockOffset, out_len);
in_len = sizes[i * 2 + 1]; /// uncompressed size
new_len = in_len;
lzo_err = lzo1x_decompress(out, out_len, in, &new_len, NULL);
if (lzo_err == LZO_E_OK && new_len == in_len)
{
_LogDebug("Decompressed " + ToString(out_len) + " bytes back into "
+ ToString(in_len), "DecompressLZO");
}
else
{
_LogError("LZO library internal error: decompression failed!", "DecompressLZO");
return false;
}
lzo_memcpy(dataChunk.data() + dataOffset, in, in_len);
blockOffset += out_len;
dataOffset += in_len;
}
decompressed_stream.write(reinterpret_cast<char*>(dataChunk.data()), dataSize);
}
_LogDebug("Package decompressed successfully.", "DecompressLZO");
Package->UPKStream.str(decompressed_stream.str());
return Package->ReadPackageHeader();
}
