void VHTTPServerLog::_WriteUsername (const XBOX::VString& inUserName, XBOX::VString& ioStream)
{
if (!inUserName.IsEmpty())
{
bool wasCtrl = false;
XBOX::VString userName;
for (XBOX::VIndex pos = 0; pos < inUserName.GetLength(); ++pos)
{
// When user name contains CHAR_SPACE, replace it by CHAR_LOW_LINE '_'
if ((inUserName[pos] <= CHAR_SPACE) && (inUserName[pos] > 0))
{
if (!wasCtrl)
userName.AppendUniChar (CHAR_LOW_LINE);
wasCtrl = (inUserName[pos] != CHAR_SPACE);
}
else
{
userName.AppendUniChar (inUserName[pos]);
wasCtrl = false;
}
}
ioStream.AppendString (userName);
}
else
{
ioStream.AppendUniChar (CHAR_HYPHEN_MINUS);
}
}
static
void BuildFolderPath (const XBOX::VFilePath& inBaseFolder, const XBOX::VString& inPath, XBOX::VFilePath& outPath)
{
if (inPath.IsEmpty())
{
outPath.FromFilePath (inBaseFolder);
}
else
{
XBOX::VString pathString (inPath);
if ((pathString[0] == CHAR_SOLIDUS) // POSIX Path ?
#if VERSIONWIN
|| ((pathString.GetLength() > 2) && (pathString[1] == CHAR_COLON) && (pathString[2] == CHAR_SOLIDUS)) // POSIX path like c:/blahblah/
#endif
)
{
if (!pathString.IsEmpty() && (pathString[pathString.GetLength()-1] != CHAR_SOLIDUS))
pathString.AppendUniChar (CHAR_SOLIDUS);
outPath.FromFullPath (pathString, XBOX::FPS_POSIX);
}
else if ((pathString[0] != CHAR_FULL_STOP) && (pathString.FindUniChar (XBOX::FOLDER_SEPARATOR) > 0))
{
if (!pathString.IsEmpty() && (pathString[pathString.GetLength()-1] != XBOX::FOLDER_SEPARATOR))
pathString.AppendUniChar (XBOX::FOLDER_SEPARATOR);
outPath.FromFullPath (pathString, XBOX::FPS_SYSTEM);
}
else
{
XBOX::VFilePath baseFolder (inBaseFolder);
if ((pathString[0] == CHAR_FULL_STOP) && (pathString[1] == CHAR_SOLIDUS))
pathString.Remove (1, 2);
while ((pathString[0] == CHAR_FULL_STOP) && (pathString[1] == CHAR_FULL_STOP) && (pathString[2] == CHAR_SOLIDUS))
{
pathString.Remove (1, 3);
baseFolder = baseFolder.ToParent();
}
pathString.ExchangeAll (CHAR_SOLIDUS, XBOX::FOLDER_SEPARATOR);
if (!pathString.IsEmpty() && (pathString[pathString.GetLength()-1] != XBOX::FOLDER_SEPARATOR))
pathString.AppendUniChar (XBOX::FOLDER_SEPARATOR);
outPath.FromRelativePath (baseFolder, pathString);
}
}
}
XBOX::VError VHTTPServerLog::_WriteFileHeader (XBOX::VString& ioBuffer)
{
/*
see: http://www.w3.org/TR/WD-logfile.html
*/
XBOX::VString serverName;
XBOX::VString dateString;
XBOX::VString formatName;
XBOX::VString tokenNames;
fNeedHeader = false;
/*
#Version: 1.0
#Date: 12-Jan-1996 00:00:00
*/
HTTPProtocol::MakeServerString (serverName);
_GetCurrentFormatedDate (dateString);
HTTPServerTools::GetLogFormatName (fSettings.GetLogFormat(), formatName);
HTTPServerTools::GetLogTokenNamesList (fSettings.GetLogTokens(), tokenNames);
ioBuffer.AppendCString ("#Version: 1.0\n#Software: ");
ioBuffer.AppendString (serverName);
ioBuffer.AppendCString ("\n#Date: ");
ioBuffer.AppendString (dateString);
ioBuffer.AppendCString ("\n#Remark: format ");
ioBuffer.AppendString (formatName);
ioBuffer.AppendCString ("\n#Fields: ");
ioBuffer.AppendString (tokenNames);
ioBuffer.AppendUniChar (HTTP_LF);
return XBOX::VE_OK;
}
bool VHTTPResponse::IsCookieSet (const VHTTPCookie& inCookie) const
{
XBOX::VectorOfVString cookieValues;
if (GetHeaders().GetHeaderValues (HEADER_SET_COOKIE, cookieValues))
{
XBOX::VString cookieName (inCookie.GetName());
cookieName.AppendUniChar (CHAR_EQUALS_SIGN);
for (XBOX::VectorOfVString::const_iterator it = cookieValues.begin(); it != cookieValues.end(); ++it)
{
XBOX::VectorOfVString multipleCookieValues;
(*it).GetSubStrings (CHAR_SEMICOLON, multipleCookieValues, false, true);
XBOX::VectorOfVString::const_iterator found = std::find_if (multipleCookieValues.begin(), multipleCookieValues.end(), FindVStringFunctor (cookieName));
if (found != multipleCookieValues.end())
{
VHTTPCookie cookie (*found);
if (cookie == inCookie)
return true;
}
}
}
return false;
}
void VMIMEMessage::_ReadUrl (const XBOX::VString& inString)
{
if (!inString.IsEmpty())
{
const UniChar *stringPtr = inString.GetCPointer();
UniChar ch = *stringPtr;
while (ch != '\0')
{
XBOX::VString name;
XBOX::VString value;
while (ch != '\0' && ch != CHAR_EQUALS_SIGN && ch != CHAR_AMPERSAND)
{
if (ch == CHAR_PLUS_SIGN) ch = CHAR_SPACE;
name.AppendUniChar (ch);
ch = *(++stringPtr);
}
if (ch == CHAR_EQUALS_SIGN)
{
ch = *(++stringPtr);
while (ch != '\0' && ch != CHAR_AMPERSAND)
{
if (ch == CHAR_PLUS_SIGN) ch = CHAR_SPACE;
value.AppendUniChar (ch);
ch = *(++stringPtr);
}
}
XBOX::VString decodedName (name);
XBOX::VString decodedValue (value);
XBOX::VURL::Decode (decodedName);
XBOX::VURL::Decode (decodedValue);
XBOX::StStringConverter<char> buffer (decodedValue, XBOX::VTC_UTF_8);
_AddValuePair (decodedName, CONST_TEXT_PLAIN_UTF_8, (void *)buffer.GetCPointer(), buffer.GetLength());
if (ch == CHAR_AMPERSAND) ch = *(++stringPtr);
}
}
}
void MakeHostString (const XBOX::VString& inHost, PortNumber inPort, XBOX::VString& outHostString)
{
outHostString.Clear();
if (!inHost.IsEmpty())
outHostString.AppendString (inHost);
if (inPort != DEFAULT_LISTENING_PORT)
{
outHostString.AppendUniChar (CHAR_COLON);
outHostString.AppendLong (inPort);
}
}
void GetLogTokenNamesList (const VectorOfLogToken& inLogTokens, XBOX::VString& outTokenNames, const UniChar inSeparator)
{
XBOX::VString string;
VectorOfLogToken::const_iterator nextToken = inLogTokens.begin();
outTokenNames.Clear();
for (VectorOfLogToken::const_iterator it = inLogTokens.begin(); it != inLogTokens.end(); ++it)
{
GetLogTokenName (*it, string);
outTokenNames.AppendString (string);
nextToken = it;
if (++nextToken != inLogTokens.end())
outTokenNames.AppendUniChar (CHAR_SPACE);
}
}
bool VHTTPResponse::IsCookieSet (const XBOX::VString& inName) const
{
XBOX::VectorOfVString cookieValues;
if (GetHeaders().GetHeaderValues (HEADER_SET_COOKIE, cookieValues))
{
XBOX::VString cookieName (inName);
cookieName.AppendUniChar (CHAR_EQUALS_SIGN);
for (XBOX::VectorOfVString::const_iterator it = cookieValues.begin(); it != cookieValues.end(); ++it)
{
if (HTTPServerTools::FindASCIIVString ((*it), cookieName) > 0)
return true;
}
}
return false;
}
XBOX::VError VHTTPServerLog::_RotateFile()
{
XBOX::VError error = XBOX::VE_OK;
XBOX::VFilePath logFilePath;
XBOX::VTime curTime;
curTime.FromSystemTime();
_GetLogFilePath (logFilePath);
if (fLogFileAccessLock.Lock())
{
if (NULL == fLogFile)
fLogFile = new XBOX::VFile (logFilePath);
if (fLogFile->Exists())
{
// the backup fileName will look like "HTTPServer_DAAAAMMJJT00000000.waLog" => "HTTPServer_D20100122T113307.waLog"
// I used this format to have the files sorted by time thanks to their name
XBOX::VString newFileName;
XBOX::VString dateTimeString;
GetFormatedDateTimeString (curTime, dateTimeString);
fLogFile->GetNameWithoutExtension (newFileName);
newFileName.AppendUniChar (CHAR_LOW_LINE);
newFileName.AppendString (dateTimeString);
newFileName.AppendUniChar (CHAR_FULL_STOP);
newFileName.AppendString (fSettings.GetLogFileNameExtension());
if (fSettings.GetArchivesFolderName().IsEmpty())
{
error = fLogFile->Rename (newFileName);
}
else
{
XBOX::VFilePath destinationFilePath;
fLogFile->GetPath (destinationFilePath);
destinationFilePath.ToParent().ToSubFolder (fSettings.GetArchivesFolderName());
if (destinationFilePath.IsFolder())
{
XBOX::VFolder * destinationFolder = new XBOX::VFolder (destinationFilePath);
if (NULL != destinationFolder)
{
if (!destinationFolder->Exists())
error = destinationFolder->CreateRecursive();
XBOX::ReleaseRefCountable (&destinationFolder);
if (XBOX::VE_OK == error)
{
destinationFilePath.SetFileName (newFileName);
error = fLogFile->Move (destinationFilePath, NULL, XBOX::FCP_Overwrite);
}
}
else
{
error = XBOX::VE_MEMORY_FULL;
}
}
}
XBOX::ReleaseRefCountable (&fLogFile);
}
//Creating the log file
if ((XBOX::VE_OK == error) && (NULL == fLogFile))
{
fLogFile = new XBOX::VFile (logFilePath);
if (NULL != fLogFile)
{
error = fLogFile->Create();
// Set correct dates & times (used later to determine the next backup time)
if (XBOX::VE_OK == error)
error = fLogFile->SetTimeAttributes (&curTime, &curTime, &curTime);
fLogFileSize = 0;
fLastFileRotationTime.FromTime (curTime);
_CalculateNextFileRotationTime();
}
else
{
error = VE_CANNOT_CREATE_LOG_FILE;
}
}
else
{
error = VE_CANNOT_OPEN_LOG_FILE;
}
fNeedSplit = false;
fLogFileAccessLock.Unlock();
}
return error;
}
void VHTTPServerProject::SaveToBag (XBOX::VValueBag& outBag)
{
outBag.SetLong (NSHTTPServerProject::refCount, GetRefCount());
outBag.SetLong (NSHTTPServerProject::taskID, fServerTaskID);
outBag.SetTime (NSHTTPServerProject::startingTime, fStartingTime);
outBag.SetBool (NSHTTPServerProject::acceptRequests, fAcceptIncommingRequests);
outBag.SetLong (NSHTTPServerProject::hitCount, GetHitsCount());
outBag.SetLong (NSHTTPServerProject::runningRequests, GetRunningRequestsCount());
outBag.SetBool (NSHTTPServerProject::securityComponentAvailable, (NULL != fSecurityManager));
outBag.SetBool (NSHTTPServerProject::authenticationManagerAvailable, (NULL != fAuthenticationManager));
XBOX::VBagArray *bagArray = new XBOX::VBagArray();
if (NULL != bagArray)
{
XBOX::VTaskLock lock (&fRequestHandlersLock);
for (VectorOfRequestHandler::const_iterator it = fRequestHandlers.begin(); it != fRequestHandlers.end(); ++it)
{
XBOX::VString string;
XBOX::VectorOfVString patterns;
(*it)->GetPatterns (&patterns);
for (XBOX::VectorOfVString::const_iterator itString = patterns.begin(); itString != patterns.end(); ++itString)
{
string.AppendString (*itString);
string.AppendUniChar (CHAR_SEMICOLON);
}
XBOX::VValueBag *handlerBag = new XBOX::VValueBag();
if (NULL != handlerBag)
{
handlerBag->SetLong (NSHTTPServerProject::requestHandlers::refCount, (*it)->GetRefCount());
handlerBag->SetString (NSHTTPServerProject::requestHandlers::patterns, string);
handlerBag->SetBool (NSHTTPServerProject::requestHandlers::enabled, (*it)->GetEnable());
bagArray->AddTail (handlerBag);
XBOX::QuickReleaseRefCountable (handlerBag);
}
}
outBag.SetElements (L"requestHandlers", bagArray);
XBOX::QuickReleaseRefCountable (bagArray);
}
XBOX::VValueBag *settingsBag = new XBOX::VValueBag();
if (NULL != settingsBag)
{
fSettings->SaveToBag (settingsBag);
outBag.AddElement (L"settings", settingsBag);
XBOX::QuickReleaseRefCountable (settingsBag);
}
XBOX::VValueBag *serverBag = new XBOX::VValueBag();
if (NULL != serverBag)
{
serverBag->SetLong (NSHTTPServerProject::serverInfos::refCount, fHTTPServer->GetRefCount());
serverBag->SetBool (NSHTTPServerProject::serverInfos::zipComponentAvailable, fHTTPServer->GetZipComponentAvailable());
outBag.AddElement (L"server", serverBag);
XBOX::QuickReleaseRefCountable (serverBag);
}
bagArray = new XBOX::VBagArray();
if (NULL != bagArray)
{
XBOX::VTaskLock lock (&fVirtualHostsLock);
for (std::vector<VVirtualHost *>::const_iterator it = fVirtualHosts.begin(); it != fVirtualHosts.end(); ++it)
{
XBOX::VValueBag *virtualHostBag = new XBOX::VValueBag();
if (NULL != virtualHostBag)
{
(*it)->SaveToBag (*virtualHostBag);
bagArray->AddTail (virtualHostBag);
XBOX::QuickReleaseRefCountable (virtualHostBag);
}
}
outBag.SetElements (L"virtualHosts", bagArray);
XBOX::QuickReleaseRefCountable (bagArray);
}
bagArray = new XBOX::VBagArray();
if (NULL != bagArray)
{
if ((NULL != fAuthenticationManager) && (NULL != fAuthenticationManager->GetAuthenticationReferee()))
{
XBOX::VValueBag *authResourcesBag = new XBOX::VValueBag();
if (NULL != authResourcesBag)
{
fAuthenticationManager->GetAuthenticationReferee()->SaveToBag (authResourcesBag);
bagArray->AddTail (authResourcesBag);
XBOX::QuickReleaseRefCountable (authResourcesBag);
}
}
if (bagArray->GetCount() > 0)
outBag.SetElements (L"authResources", bagArray);
XBOX::QuickReleaseRefCountable (bagArray);
}
}
XBOX::VString VHTTPCookie::ToString (bool inAlwaysExpires) const
{
XBOX::VString result;
if (!IsValid())
return result;
result.AppendString (fName);
result.AppendUniChar (CHAR_EQUALS_SIGN);
if (0 == fVersion)
{
// Netscape cookie
result.AppendString (fValue);
if (!fDomain.IsEmpty())
{
result.AppendCString ("; Domain=");
result.AppendString (fDomain);
}
if (!fPath.IsEmpty())
{
result.AppendCString ("; Path=");
result.AppendString (fPath);
}
if (fMaxAge >= 0)
{
XBOX::VTime curTime;
XBOX::VString timeString;
XBOX::VTime::Now (curTime);
curTime.AddSeconds (fMaxAge);
_GetRFC1123DateString (curTime, timeString);
result.AppendCString ("; Expires=");
result.AppendString (timeString);
}
if (fSecure)
{
result.AppendCString ("; Secure");
}
if (fHTTPOnly)
{
result.AppendCString ("; HttpOnly");
}
}
else
{
// RFC 2109 cookie
result.AppendString (fValue);
if (!fComment.IsEmpty())
{
result.AppendCString ("; Comment=\"");
result.AppendString (fComment);
result.AppendUniChar (CHAR_QUOTATION_MARK);
}
if (!fDomain.IsEmpty())
{
result.AppendCString ("; Domain=");
result.AppendString (fDomain);
}
if (!fPath.IsEmpty())
{
result.AppendCString ("; Path=");
result.AppendString (fPath);
}
else
{
result.AppendCString ("; Path=/");
}
if (fMaxAge >= 0)
{
result.AppendCString ("; Max-Age=");
result.AppendLong (fMaxAge);
/* For Internet Explorer 6, 7 & 8 which does not support 'max-age' */
if (inAlwaysExpires)
{
XBOX::VTime curTime;
XBOX::VString timeString;
XBOX::VTime::Now (curTime);
curTime.AddSeconds (fMaxAge);
_GetRFC1123DateString (curTime, timeString);
result.AppendCString ("; Expires=");
result.AppendString (timeString);
}
}
if (fSecure)
{
result.AppendCString ("; Secure");
}
if (fHTTPOnly)
{
result.AppendCString ("; HttpOnly");
}
result.AppendCString ("; Version=1");
}
return result;
}