220 lines
6.6 KiB
C++
220 lines
6.6 KiB
C++
/**********************************************************************
|
|
|
|
Audacity: A Digital Audio Editor
|
|
|
|
XMLTagHandler.cpp
|
|
|
|
Dominic Mazzoni
|
|
Vaughan Johnson
|
|
|
|
|
|
*//****************************************************************//**
|
|
|
|
\class XMLTagHandler
|
|
\brief This class is an interface which should be implemented by
|
|
classes which wish to be able to load and save themselves
|
|
using XML files.
|
|
|
|
\class XMLValueChecker
|
|
\brief XMLValueChecker implements static bool methods for checking
|
|
input values from XML files.
|
|
|
|
*//*******************************************************************/
|
|
|
|
#include "../Audacity.h"
|
|
#include "XMLTagHandler.h"
|
|
|
|
#include "../MemoryX.h"
|
|
#include "../Internat.h"
|
|
|
|
#ifdef _WIN32
|
|
#include <windows.h>
|
|
#include <wx/msw/winundef.h>
|
|
#endif
|
|
|
|
#include <wx/defs.h>
|
|
#include <wx/arrstr.h>
|
|
#include <wx/filename.h>
|
|
|
|
#include "../SampleFormat.h"
|
|
#include "../Track.h"
|
|
|
|
bool XMLValueChecker::IsGoodString(const wxString & str)
|
|
{
|
|
size_t len = str.Length();
|
|
int nullIndex = str.Find('\0', false);
|
|
if ((len <= PLATFORM_MAX_PATH) && // Shouldn't be any reason for longer strings, except intentional file corruption.
|
|
(nullIndex == -1)) // No null characters except terminator.
|
|
return true;
|
|
else
|
|
return false; // good place for a breakpoint
|
|
}
|
|
|
|
// "Good" means the name is well-formed and names an existing file or folder.
|
|
bool XMLValueChecker::IsGoodFileName(const wxString & strFileName, const wxString & strDirName /* = "" */)
|
|
{
|
|
// Test strFileName.
|
|
if (!IsGoodFileString(strFileName) ||
|
|
(strDirName.Length() + 1 + strFileName.Length() > PLATFORM_MAX_PATH))
|
|
return false;
|
|
|
|
// Test the corresponding wxFileName.
|
|
wxFileName fileName(strDirName, strFileName);
|
|
return (fileName.IsOk() && fileName.FileExists());
|
|
}
|
|
|
|
bool XMLValueChecker::IsGoodFileString(const wxString &str)
|
|
{
|
|
return (IsGoodString(str) &&
|
|
!str.IsEmpty() &&
|
|
|
|
// FILENAME_MAX is 260 in MSVC, but inconsistent across platforms,
|
|
// sometimes huge, but we use 260 for all platforms.
|
|
(str.Length() <= 260) &&
|
|
|
|
(str.Find(wxFileName::GetPathSeparator()) == -1)); // No path separator characters.
|
|
}
|
|
|
|
bool XMLValueChecker::IsGoodSubdirName(const wxString & strSubdirName, const wxString & strDirName /* = "" */)
|
|
{
|
|
// Test strSubdirName.
|
|
// Note this prevents path separators, and relative path to parents (strDirName),
|
|
// so fixes vulnerability #3 in the NGS report for UmixIt,
|
|
// where an attacker could craft an AUP file with relative pathnames to get to system files, for example.
|
|
if (!IsGoodFileString(strSubdirName) ||
|
|
(strSubdirName == wxT(".")) || (strSubdirName == wxT("..")) ||
|
|
(strDirName.Length() + 1 + strSubdirName.Length() > PLATFORM_MAX_PATH))
|
|
return false;
|
|
|
|
// Test the corresponding wxFileName.
|
|
wxFileName fileName(strDirName, strSubdirName);
|
|
return (fileName.IsOk() && fileName.DirExists());
|
|
}
|
|
|
|
bool XMLValueChecker::IsGoodPathName(const wxString & strPathName)
|
|
{
|
|
// Test the corresponding wxFileName.
|
|
wxFileName fileName(strPathName);
|
|
return XMLValueChecker::IsGoodFileName(fileName.GetFullName(), fileName.GetPath(wxPATH_GET_VOLUME));
|
|
}
|
|
|
|
bool XMLValueChecker::IsGoodPathString(const wxString &str)
|
|
{
|
|
return (IsGoodString(str) &&
|
|
!str.IsEmpty() &&
|
|
(str.Length() <= PLATFORM_MAX_PATH));
|
|
}
|
|
|
|
|
|
bool XMLValueChecker::IsGoodIntForRange(const wxString & strInt, const wxString & strMAXABS)
|
|
{
|
|
if (!IsGoodString(strInt))
|
|
return false;
|
|
|
|
// Check that the value won't overflow.
|
|
// Must lie between -Range and +Range-1
|
|
// We're strict about disallowing spaces and commas, and requiring minus sign to be first
|
|
// char for negative. No + sign for positive numbers. It's disallowed, not optional.
|
|
|
|
const size_t lenMAXABS = strMAXABS.Length();
|
|
const size_t lenStrInt = strInt.Length();
|
|
|
|
if( lenStrInt < 1 )
|
|
return false;
|
|
size_t offset = (strInt[0] == '-') ?1:0;
|
|
if( lenStrInt <= offset )
|
|
return false;// string too short, no digits in it.
|
|
|
|
if (lenStrInt > (lenMAXABS + offset))
|
|
return false;
|
|
|
|
unsigned int i;
|
|
for (i = offset; i < lenStrInt; i++)
|
|
if (strInt[i] < '0' || strInt[i] > '9' )
|
|
return false; // not a digit
|
|
|
|
// All chars were digits.
|
|
if( lenStrInt < (lenMAXABS + offset) )
|
|
return true; // too few digits to overflow.
|
|
|
|
// Numerical part is same length as strMAXABS
|
|
for (i = 0; i < lenMAXABS; i++)
|
|
if (strInt[i+offset] < strMAXABS[i])
|
|
return true; // number is small enough
|
|
else if (strInt[i+offset] > strMAXABS[i])
|
|
return false; // number is too big.
|
|
|
|
// Digits were textually equal to strMAXABS
|
|
// That's OK if negative, but not OK if positive.
|
|
return (strInt[0] == '-');
|
|
}
|
|
|
|
|
|
bool XMLValueChecker::IsGoodInt(const wxString & strInt)
|
|
{
|
|
// Signed long: -2,147,483,648 to +2,147,483,647, i.e., -2^31 to 2^31-1
|
|
return IsGoodIntForRange( strInt, "2147483648" );
|
|
}
|
|
|
|
bool XMLValueChecker::IsGoodInt64(const wxString & strInt)
|
|
{
|
|
// Signed 64-bit: -9,223,372,036,854,775,808 to +9,223,372,036,854,775,807, i.e., -2^63 to 2^63-1
|
|
return IsGoodIntForRange( strInt, "9223372036854775808" );
|
|
}
|
|
|
|
bool XMLValueChecker::IsValidChannel(const int nValue)
|
|
{
|
|
return (nValue >= Track::LeftChannel) && (nValue <= Track::MonoChannel);
|
|
}
|
|
|
|
#ifdef USE_MIDI
|
|
bool XMLValueChecker::IsValidVisibleChannels(const int nValue)
|
|
{
|
|
return (nValue >= 0 && nValue < (1 << 16));
|
|
}
|
|
#endif
|
|
|
|
bool XMLValueChecker::IsValidSampleFormat(const int nValue)
|
|
{
|
|
return (nValue == int16Sample) || (nValue == int24Sample) || (nValue == floatSample);
|
|
}
|
|
|
|
bool XMLTagHandler::ReadXMLTag(const char *tag, const char **attrs)
|
|
{
|
|
wxArrayString tmp_attrs;
|
|
|
|
while (*attrs) {
|
|
const char *s = *attrs++;
|
|
tmp_attrs.Add(UTF8CTOWX(s));
|
|
}
|
|
|
|
// JKC: Previously the next line was:
|
|
// const char **out_attrs = NEW char (const char *)[tmp_attrs.GetCount()+1];
|
|
// however MSVC doesn't like the constness in this position, so this is now
|
|
// added by a cast after creating the array of pointers-to-non-const chars.
|
|
auto out_attrs = std::make_unique<const wxChar *[]>(tmp_attrs.GetCount() + 1);
|
|
for (size_t i=0; i<tmp_attrs.GetCount(); i++) {
|
|
out_attrs[i] = tmp_attrs[i];
|
|
}
|
|
out_attrs[tmp_attrs.GetCount()] = 0;
|
|
|
|
bool result = HandleXMLTag(UTF8CTOWX(tag), out_attrs.get());
|
|
|
|
return result;
|
|
}
|
|
|
|
void XMLTagHandler::ReadXMLEndTag(const char *tag)
|
|
{
|
|
HandleXMLEndTag(UTF8CTOWX(tag));
|
|
}
|
|
|
|
void XMLTagHandler::ReadXMLContent(const char *s, int len)
|
|
{
|
|
HandleXMLContent(wxString(s, wxConvUTF8, len));
|
|
}
|
|
|
|
XMLTagHandler *XMLTagHandler::ReadXMLChild(const char *tag)
|
|
{
|
|
return HandleXMLChild(UTF8CTOWX(tag));
|
|
}
|