void GetAuthenticationMethodName (const HTTPAuthenticationMethod inAuthenticationMethod, XBOX::VString& outAuthenticationMethodName)
{
switch (inAuthenticationMethod)
{
case AUTH_BASIC: outAuthenticationMethodName.FromCString ("Basic"); break;
case AUTH_DIGEST: outAuthenticationMethodName.FromCString ("Digest"); break;
case AUTH_KERBEROS: outAuthenticationMethodName.FromCString ("Kerberos"); break;
case AUTH_NTLM: outAuthenticationMethodName.FromCString ("NTLM"); break;
default: outAuthenticationMethodName.FromCString ("None"); break;
}
}
void GetLogFormatName (const EHTTPServerLogFormat inLogFormat, XBOX::VString& outLogFormatName)
{
switch (inLogFormat)
{
case LOG_FORMAT_WLF: outLogFormatName.FromCString ("WLF"); break;
case LOG_FORMAT_CLF: outLogFormatName.FromCString ("CLF"); break;
case LOG_FORMAT_ELF: outLogFormatName.FromCString ("ELF"); break;
case LOG_FORMAT_DLF: outLogFormatName.FromCString ("DLF"); break;
default: outLogFormatName.FromCString ("Unknown"); break;
}
}
BOOL CALLBACK XWinFontMgr::EnumFamScreenCallBackEx(ENUMLOGFONTEX* pelf, NEWTEXTMETRICEX* /*lpntm*/, int FontType,LPVOID pThis)
{
XBOX::VString fontName;
fontName.FromCString((const char*)(pelf->elfFullName));
((XWinFontMgr *)pThis)->AddFont(fontName);
return 1;
}
XBOX::VError VHTTPServerProject::_BuildRegexMatcher (const XBOX::VString& inPatternString, XBOX::VRegexMatcher **outMatcher)
{
if (NULL == outMatcher)
return XBOX::VE_INVALID_PARAMETER;
XBOX::VString patternString (inPatternString);
XBOX::VError error = XBOX::VE_OK;
sLONG pos = 0;
if (!HTTPServerTools::BeginsWithASCIICString (patternString.GetCPointer(), "(?i)"))
patternString.Insert (CVSTR ("(?i)"), 1);
if (HTTPServerTools::EndsWithASCIICString (patternString, "/") &&
!HTTPServerTools::EndsWithASCIICString (patternString, "$"))
patternString.AppendString (CVSTR (".*"));
XBOX::VString string;
if ((pos = patternString.FindUniChar (CHAR_CIRCUMFLEX_ACCENT)) == 0)
{
string.FromCString ("^");
pos = HTTPServerTools::FindASCIICString (patternString, "(?i)") + 4;
}
else
{
++pos;
}
#if HTTP_SERVER_USE_PROJECT_PATTERNS
if (!fSettings->GetProjectPattern().IsEmpty())
{
string.AppendCString ("(/");
string.AppendString (fSettings->GetProjectPattern());
string.AppendCString ("|)");
}
#endif
patternString.Insert (string, pos);
if (!patternString.IsEmpty())
*outMatcher = XBOX::VRegexMatcher::Create (patternString, &error);
return error;
}
void VProjectItemDataClassAttribute::GetDescription( XBOX::VString& outDescription) const
{
outDescription.FromCString( "Data Class Attribute");
}
void GetLogTokenName (const EHTTPServerLogToken inToken, XBOX::VString& outTokenName)
{
switch (inToken)
{
case LOG_TOKEN_DATE: outTokenName.FromCString ("DATE"); break;
case LOG_TOKEN_TIME: outTokenName.FromCString ("TIME"); break;
case LOG_TOKEN_HOST_NAME: outTokenName.FromCString ("HOST-NAME"); break;
case LOG_TOKEN_URL: outTokenName.FromCString ("URL"); break;
case LOG_TOKEN_PATH_ARGS: outTokenName.FromCString ("PATH_ARGS"); break;
case LOG_TOKEN_SEARCH_ARGS: outTokenName.FromCString ("SEARCH_ARGS"); break;
case LOG_TOKEN_METHOD: outTokenName.FromCString ("METHOD"); break;
case LOG_TOKEN_ELF_URI: outTokenName.FromCString ("CS-URI"); break;
case LOG_TOKEN_BYTES_SENT: outTokenName.FromCString ("BYTES_SENT"); break;
case LOG_TOKEN_TRANSFER_TIME: outTokenName.FromCString ("TIME-TAKEN"); break;
case LOG_TOKEN_AGENT: outTokenName.FromCString ("AGENT"); break;
case LOG_TOKEN_USER: outTokenName.FromCString ("USER"); break;
case LOG_TOKEN_REFERER: outTokenName.FromCString ("REFERER"); break;
case LOG_TOKEN_CONNECTION_ID: outTokenName.FromCString ("CONNECTION_ID"); break;
case LOG_TOKEN_STATUS: outTokenName.FromCString ("SC-STATUS"); break;
case LOG_TOKEN_ELF_C_IP: outTokenName.FromCString ("C-IP"); break;
case LOG_TOKEN_ELF_C_DNS: outTokenName.FromCString ("CS-CDNS"); break;
case LOG_TOKEN_ELF_CS_URI_STEM: outTokenName.FromCString ("CS-URI-STEM"); break;
case LOG_TOKEN_ELF_CS_URI_QUERY: outTokenName.FromCString ("CS-URI-QUERY"); break;
case LOG_TOKEN_ELF_CS_HOST: outTokenName.FromCString ("CS(HOST)"); break;
case LOG_TOKEN_CS_REFERER: outTokenName.FromCString ("CS(REFERER)"); break;
case LOG_TOKEN_CS_USER_AGENT: outTokenName.FromCString ("CS(USER-AGENT)"); break;
case LOG_TOKEN_ELF_CS_COOKIE: outTokenName.FromCString ("CS(COOKIE)"); break;
case LOG_TOKEN_ELF_S_IP: outTokenName.FromCString ("CS-SIP"); break;
case LOG_TOKEN_WLF_BYTES_RECEIVED: outTokenName.FromCString ("BYTES_RECEIVED"); break;
case LOG_TOKEN_RFC_931: outTokenName.FromCString ("RFC-931"); break;
case LOG_TOKEN_HTTP_REQUEST: outTokenName.FromCString ("HTTP-REQUEST"); break;
default: assert(false);
outTokenName.FromCString ("UNKNOWN"); break;
}
}
XBOX::VError SendValueBagResponse (IHTTPResponse& ioResponse, const XBOX::VValueBag& inBag, const XBOX::VString& inBagName)
{
XBOX::VError error = XBOX::VE_OK;
const XBOX::VString stringURL = ioResponse.GetRequest().GetURLQuery();
HTTPRequestMethod method = ioResponse.GetRequest().GetRequestMethod();
XBOX::VString resultString;
bool isJSON = true;
bool prettyFormatting = false;
bool isValidRequest = ((method == HTTP_GET) || (method == HTTP_HEAD));
if (isValidRequest)
{
sLONG posFormat = 0, posPretty = 0;
const UniChar * stringPtr = stringURL.GetCPointer();
const sLONG stringLen = stringURL.GetLength();
if ((posFormat = HTTPServerTools::FindASCIICString (stringPtr, "format=")) > 0)
{
posFormat += 6;
sLONG startPos = 0;
sLONG endPos = HTTPServerTools::FindASCIICString (stringPtr + posFormat, "&");
if (endPos <= 0)
endPos = stringLen;
else
endPos += (posFormat - 1);
if (((startPos = HTTPServerTools::FindASCIICString (stringPtr + posFormat, "xml")) > 0) && (startPos < endPos))
isJSON = false;
else if(((startPos = HTTPServerTools::FindASCIICString (stringPtr + posFormat, "json")) > 0) && (startPos < endPos))
isJSON = true;
else
isValidRequest = false;
}
if ((posPretty = HTTPServerTools::FindASCIICString (stringPtr, "pretty=")) > 0)
{
XBOX::VString prettyString;
posPretty += 6;
sLONG endPos = HTTPServerTools::FindASCIICString (stringPtr + posPretty, "&");
if (endPos <= 0)
endPos = stringLen;
else
endPos += (posPretty - 1);
if (endPos > posPretty)
{
GetSubString (stringURL, posPretty, endPos - 1, prettyString);
prettyFormatting = (HTTPServerTools::EqualASCIICString (prettyString, "yes"));
}
else
isValidRequest = false;
}
}
if (isValidRequest)
{
if (isJSON)
{
inBag.GetJSONString (resultString, prettyFormatting ? JSON_PrettyFormatting : JSON_Default);
}
else
{
resultString.FromCString ("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
inBag.DumpXML (resultString, inBagName, prettyFormatting);
}
XBOX::StStringConverter<char> buffer (resultString, XBOX::VTC_UTF_8);
error = ioResponse.SetResponseBody (buffer.GetCPointer(), buffer.GetLength());
ioResponse.SetExpiresHeader (GMT_NOW);
ioResponse.AddResponseHeader (STRING_HEADER_PRAGMA, STRING_HEADER_VALUE_NO_CACHE);
ioResponse.AddResponseHeader (STRING_HEADER_CONTENT_TYPE, (isJSON) ? STRING_CONTENT_TYPE_JSON : STRING_CONTENT_TYPE_XML);
ioResponse.SetContentLengthHeader (buffer.GetLength());
ioResponse.AllowCompression (true);
}
else
{
error = ioResponse.ReplyWithStatusCode (HTTP_BAD_REQUEST);
}
return error;
}
XBOX::VError VHTTPResponse::SendResponse()
{
XBOX::VError error = XBOX::VE_OK;
if (fIsChunked)
{
// First send buffered data that was not already sent...
if (XBOX::VE_OK == (error = _SendResponseBody()))
{
// Then send special ending line for chunked encoding
error = _WriteChunkSize (0);
}
}
else
{
XBOX::VString contentType;
XBOX::VString contentEncoding;
GetHeaders().GetContentType (contentType);
if (GetHeaders().GetHeaderValue (HEADER_CONTENT_ENCODING, contentEncoding) && !contentEncoding.IsEmpty())
{
if (HTTPProtocol::NegotiateEncodingMethod (contentEncoding) != COMPRESSION_UNKNOWN)
fCanCompressBody = false;
}
if (HTTP_UNDEFINED == fResponseStatusCode)
fResponseStatusCode = HTTP_OK;
VVirtualHost *virtualHost = dynamic_cast<VVirtualHost *>(GetVirtualHost());
if (NULL != virtualHost)
{
// Compress HTTP Message body when applicable
#if HTTP_SERVER_GLOBAL_SETTINGS
bool compressionEnabled = fHTTPServer->GetSettings()->GetEnableCompression();
#else
bool compressionEnabled = virtualHost->GetSettings()->GetEnableCompression();
#endif
if (fCanCompressBody && compressionEnabled)
{
sLONG size = (sLONG)GetBody().GetSize();
#if HTTP_SERVER_GLOBAL_SETTINGS
sLONG minThreshold = (fMinCompressionThreshold == -1) ? fHTTPServer->GetSettings()->GetCompressionMinThreshold() : fMinCompressionThreshold;
sLONG maxThreshold = (fMaxCompressionThreshold == -1) ? fHTTPServer->GetSettings()->GetCompressionMaxThreshold() : fMaxCompressionThreshold;
#else
sLONG minThreshold = (fMinCompressionThreshold == -1) ? virtualHost->GetSettings()->GetCompressionMinThreshold() : fMinCompressionThreshold;
sLONG maxThreshold = (fMaxCompressionThreshold == -1) ? virtualHost->GetSettings()->GetCompressionMaxThreshold() : fMaxCompressionThreshold;
#endif
if ((size > minThreshold) && (size <= maxThreshold))
{
if (!contentType.IsEmpty() && (VMimeTypeManager::IsMimeTypeCompressible (contentType)))
{
error = _CompressData();
}
}
}
}
// Put HTTP Message body in cache when applicable
if ((NULL != virtualHost) && fCanCacheBody && (fResponseStatusCode == HTTP_OK))
{
#if HTTP_SERVER_GLOBAL_CACHE
VCacheManager * cacheManager = virtualHost->GetProject()->GetHTTPServer()->GetCacheManager();
#else
VCacheManager * cacheManager = virtualHost->GetCacheManager();
#endif
XBOX::VFilePath filePath;
XBOX::VString locationPath;
XBOX::VTime lastModified;
XBOX::VString lastModifiedString;
XBOX::VError fileError = XBOX::VE_OK;
bool staticFile = false;
if (XBOX::VE_OK == (fileError = virtualHost->GetFilePathFromURL (fRequest->GetURL(), locationPath)))
{
filePath.FromFullPath (locationPath);
if (filePath.IsFile() && (XBOX::VE_OK == HTTPServerTools::GetFileInfos (filePath, &lastModified)))
{
staticFile = true;
HTTPProtocol::MakeRFC822GMTDateString (lastModified, lastModifiedString);
}
}
if ((XBOX::VE_OK == fileError) && (NULL != cacheManager) && cacheManager->GetEnableDataCache())
{
uLONG bufferSize = (uLONG)GetBody().GetSize();
if (bufferSize <= cacheManager->GetCachedObjectMaxSize())
{
void * buffer = GetBody().GetDataPtr();
XBOX::VTime lastChecked;
VCachedObject * cachedObject = NULL;
XBOX::VTime::Now (lastChecked);
bool ok = cacheManager->AddPageToCache (fRequest->GetURL(),
virtualHost->GetUUIDString(),
contentType,
buffer,
bufferSize,
filePath,
lastChecked,
lastModified,
staticFile,
fCompressionMode,
&cachedObject);
if (ok)
{
if (NULL != cachedObject)
{
XBOX::VTime expirationDate;
sLONG maxAge = cachedObject->GetMaxAge();
if (maxAge > 0)
{
XBOX::VString string;
string.FromCString ("max-age=");
string.AppendLong (maxAge);
AddResponseHeader (STRING_HEADER_CACHE_CONTROL, string);
AddResponseHeader (STRING_HEADER_AGE, cachedObject->GetAge());
if (cachedObject->GetExpirationDate (expirationDate))
AddResponseHeader (STRING_HEADER_EXPIRES, expirationDate);
}
else if (cachedObject->GetExpirationDate (expirationDate) && IsVTimeValid (expirationDate))
{
AddResponseHeader (STRING_HEADER_EXPIRES, expirationDate);
}
XBOX::QuickReleaseRefCountable (cachedObject);
}
}
}
}
if (!lastModifiedString.IsEmpty())
AddResponseHeader (STRING_HEADER_LAST_MODIFIED, lastModifiedString);
}
if (HTTP_OK == fResponseStatusCode)
{
if (NULL != fFileToSend)
{
if (fFileToSend->Exists())
{
sLONG8 fileSize = 0;
fFileToSend->GetSize (&fileSize);
this->SetContentLengthHeader (fileSize); // YT 18-Jul-2011 - ACI0072287
if (XBOX::VE_OK == (error = _SendResponseHeader()))
{
const sLONG CHUNK_BUFFER_SIZE = 0xFFFF;
char * chunkBuffer = (char *)XBOX::vMalloc (CHUNK_BUFFER_SIZE, 0);
if (testAssert (NULL != chunkBuffer))
{
XBOX::VFileDesc *fileDesc = NULL;
if ((XBOX::VE_OK == fFileToSend->Open (XBOX::FA_READ, &fileDesc, XBOX::FO_SequentialScan)) && (NULL != fileDesc))
{
uLONG chunkSize = 0;
XBOX::VSize readBytes = 0;
XBOX::VError fileError = XBOX::VE_OK;
sLONG8 unreadSize = 0;
unreadSize = fileSize;
fileDesc->SetPos (0, true);
while ((XBOX::VE_OK == fileError) && (unreadSize > 0))
{
chunkSize = (unreadSize > CHUNK_BUFFER_SIZE) ? CHUNK_BUFFER_SIZE : unreadSize;
fileError = fileDesc->GetDataAtPos (chunkBuffer, chunkSize, 0, &readBytes);
unreadSize -= (sLONG8)readBytes;
if ((XBOX::VE_OK == fileError) || (XBOX::VE_STREAM_EOF == fileError))
{
error = _WriteToSocket (chunkBuffer, &chunkSize);
if (XBOX::VE_OK != error)
break;
}
}
delete fileDesc;
fileDesc = NULL;
}
else
{
error = _SendResponseWithStatusCode (HTTP_INTERNAL_SERVER_ERROR);
}
XBOX::vFree (chunkBuffer);
chunkBuffer = NULL;
}
else
{
error = _SendResponseWithStatusCode (HTTP_INTERNAL_SERVER_ERROR);
}
}
}
else
{
error = _SendResponseWithStatusCode (HTTP_NOT_FOUND);
}
XBOX::ReleaseRefCountable (&fFileToSend);
}
else if (GetBody().GetDataSize() >= 0)
{
if (XBOX::VE_OK == (error = _SendResponseHeader()))
{
if (NULL != GetBody().GetDataPtr())
error = _SendResponseBody();
}
}
else
{
error = _SendResponseWithStatusCode (HTTP_INTERNAL_SERVER_ERROR);
}
}
else
{
error = _SendResponseWithStatusCode (fResponseStatusCode);
}
}
return error;
}
int main (int inArgc, char * const inArgv[])
{
// set pattern matching wild char asap
VCollator::SetDefaultWildChar( '*');
// First, create the application. So, everything is initialized and ready to use
VRIAServerApplication application;
VProcess::InitOptions initOptions = VProcess::Init_Default & ~VProcess::Init_WithQuickTime;
#if VERSION_LINUX
XBOX::VString versionString;
versionString.FromCString (STRPRODUCTVER); // YT 18-May-2012 - WAK0076647
VRIAServerApplication::Get()->SetProductVersion (versionString);
#endif
//jmo - We may want to quit after parsing the command line
bool shouldQuit=false;
if (application.Init( initOptions))
{
// Parse the command line argument
VError err = VE_OK;
// remote admin: feature development in progress
//VRIAServerSupervisor* srvSup = VRIAServerSupervisor::Get();
VRIAServerStartupParameters *startupParameters = new VRIAServerStartupParameters();
if (startupParameters != NULL)
{
// skip first argument (executable path)
if (inArgc > 1)
{
int curArg = 1;
while (curArg < inArgc && err == VE_OK)
{
VString argument( inArgv[curArg]);
if (argument.BeginsWith( kARG_ADMINISTRATOR_PORT))
{
++curArg;
argument.Remove( 1, kARG_ADMINISTRATOR_PORT.GetLength());
if (!argument.IsEmpty() && argument.GetUniChar(1) == '=')
{
argument.Remove( 1, 1);
if (!argument.IsEmpty())
{
sLONG port = argument.GetLong();
if (port > 0)
startupParameters->SetAdministratorHttpPort( port);
else
err = VE_RIA_INVALID_COMMAND_LINE_ARGUMENTS;
}
else
{
err = VE_RIA_INVALID_COMMAND_LINE_ARGUMENTS;
}
}
else
{
err = VE_RIA_INVALID_COMMAND_LINE_ARGUMENTS;
}
}
else if (argument.BeginsWith( kARG_ADMINISTRATOR_SSL_PORT))
{
++curArg;
argument.Remove( 1, kARG_ADMINISTRATOR_SSL_PORT.GetLength());
if (!argument.IsEmpty() && argument.GetUniChar(1) == '=')
{
argument.Remove( 1, 1);
if (!argument.IsEmpty())
{
sLONG port = argument.GetLong();
if (port > 0)
startupParameters->SetAdministratorSSLPort( port);
else
err = VE_RIA_INVALID_COMMAND_LINE_ARGUMENTS;
}
else
{
err = VE_RIA_INVALID_COMMAND_LINE_ARGUMENTS;
}
}
else
{
err = VE_RIA_INVALID_COMMAND_LINE_ARGUMENTS;
}
}
else if (argument.BeginsWith( kVERSION_NUMBER))
{
++curArg;
argument.Remove(1, kVERSION_NUMBER.GetLength());
VString version;
VRIAServerApplication::Get()->GetProductVersion(version);
char buf[100];
version.ToCString(buf, sizeof(buf));
printf("Wakanda Server %s\n", buf);
shouldQuit=true;
}
else if (argument.BeginsWith( kLOG_DUMP))
{
++curArg;
argument.Remove(1, kLOG_DUMP.GetLength());
startupParameters->SetNetDump(true);
}
else if (argument.EqualToString( kARG_DEBUG_OFF))
{
++curArg;
startupParameters->SetDebuggingAuthorized( false);
}
else if (argument.EqualToString( kARG_SYSLOG))
{
++curArg;
#if VERSIONMAC || VERSION_LINUX
VSysLogOutput *syslogOutput = new VSysLogOutput( L"Wakanda Server");
application.GetLogger()->AddLogListener( syslogOutput);
syslogOutput->Release();
#endif
}
else
{
++curArg;
// check whether it's a solution file path
VFilePath fullPath;
#if VERSIONWIN
fullPath.FromFullPath( argument, FPS_SYSTEM);
#else // VERSIONMAC
VURL::Decode( argument);
fullPath.FromFullPath( argument, FPS_POSIX);
#endif
if (fullPath.IsValid())
{
VFile *file = new VFile( fullPath);
if (file != NULL)
{
if (file->Exists())
{
if (file->ConformsTo( RIAFileKind::kSolutionFileKind) && (startupParameters->GetSolutionToLaunch() == NULL))
{
startupParameters->SetSolutionToLaunch( file);
}
else if (file->ConformsTo( L"com.netscape.javascript-source") && (startupParameters->GetJavaScriptFileToExecute() == NULL))
{
startupParameters->SetJavaScriptFileToExecute( file);
}
}
}
else
{
err = VE_MEMORY_FULL;
}
ReleaseRefCountable( &file);
}
// Skip unknown argument without generate an error
}
}
}
if (err == VE_OK && shouldQuit == false)
{
VRIAServerStartupMessage *msg = new VRIAServerStartupMessage( &application, startupParameters);
if (msg != NULL)
{
msg->PostTo( VTaskMgr::Get()->GetMainTask());
msg->Release();
}
ReleaseRefCountable( &startupParameters);
application.Run();
}
else
{
ReleaseRefCountable( &startupParameters);
}
}
}
return 0;
}
XBOX::VError VMIMEMessage::ToStream (XBOX::VStream& outStream, sLONG inEncoding)
{
XBOX::VError error = XBOX::VE_OK;
if (XBOX::VE_OK == outStream.OpenWriting())
{
outStream.SetCarriageReturnMode(eCRM_CRLF);
if (!fMIMEParts.empty())
{
XBOX::VString string;
XBOX::VString charsetName;
bool bEncodeBody; // Encode using base64.
for (XBOX::VectorOfMIMEPart::const_iterator it = fMIMEParts.begin(); it != fMIMEParts.end(); ++it)
{
outStream.PutPrintf ("\r\n--%S\r\n", &fBoundary);
string.FromCString ("Content-Type: ");
string.AppendString ((*it)->GetMediaType());
if (!(*it)->GetFileName().IsEmpty())
{
string.AppendCString ("; name=\"");
if (!(*it)->GetName().IsEmpty())
string.AppendString ((*it)->GetName());
else
string.AppendString ((*it)->GetFileName());
string.AppendCString("\"\r\nContent-Disposition: ");
string.AppendCString((*it)->IsInline() ? "inline; " : "attachment; ");
string.AppendCString("filename=\"");
string.AppendString ((*it)->GetFileName());
string.AppendCString ("\"\r\n");
if (inEncoding == ENCODING_BINARY) {
string.AppendCString ("Content-Transfer-Encoding: 8bit\r\n");
bEncodeBody = false;
} else {
if ((inEncoding == ENCODING_BINARY_ONLY) && ((*it)->GetMediaTypeKind() == MIMETYPE_TEXT))
{
bEncodeBody = false;
}
else
{
string.AppendCString ("Content-Transfer-Encoding: base64\r\n");
bEncodeBody = true;
}
}
}
else
{
if ((*it)->GetMediaTypeCharSet() != XBOX::VTC_UNKNOWN)
{
string.AppendCString ("; charset=\"");
XBOX::VTextConverters::Get()->GetNameFromCharSet ((*it)->GetMediaTypeCharSet(), charsetName);
string.AppendString (charsetName);
string.AppendCString ("\"");
}
if (!(*it)->GetName().IsEmpty()) {
string.AppendCString("; name=\"");
string.AppendString((*it)->GetName());
string.AppendCString("\"");
}
string.AppendCString ("\r\n");
if ((*it)->IsInline())
string.AppendCString("Content-Disposition: inline\r\n");
if (inEncoding == ENCODING_7BIT || ((inEncoding == ENCODING_BINARY_ONLY) && ((*it)->GetMediaTypeKind() != MIMETYPE_TEXT))) {
string.AppendCString ("Content-Transfer-Encoding: base64\r\n");
bEncodeBody = true;
} else {
string.AppendCString("Content-Transfer-Encoding: 8bit\r\n");
bEncodeBody = false;
}
}
if ((*it)->GetContentID().GetLength()) {
string.AppendCString("Content-ID: <");
string.AppendString((*it)->GetContentID());
string.AppendCString(">\r\n");
}
string.AppendCString ("\r\n");
outStream.PutText (string);
if (bEncodeBody)
{
XBOX::VMemoryBuffer<> buffer;
if (XBOX::Base64Coder::Encode ((*it)->GetData().GetDataPtr(), (*it)->GetData().GetDataSize(), buffer, kBASE64_QUADS_PER_LINE))
{
outStream.PutData (buffer.GetDataPtr(), buffer.GetDataSize());
}
}
else
{
outStream.PutData ((*it)->GetData().GetDataPtr(), (*it)->GetData().GetDataSize());
}
}
outStream.PutPrintf ("\r\n--%S--\r\n", &fBoundary);
}
outStream.CloseWriting();
}
return error;
}