srmpparse.cxx

Windows CE 6.0 Server 源码

inline BYTE GetBase64Value(WCHAR Base64CharW, BYTE *pByte) {
	if((Base64CharW >= 128) || (bAscii2Base64[Base64CharW] == 255))
		return FALSE;

	*pByte = bAscii2Base64[Base64CharW];
	return TRUE;
}

const int xFirst6bChar = 0x00fc0000;
const int xSecond6bChar = 0x0003f000;
const int xThird6bChar = 0x00000fc0;
const int xFourth6bChar = 0x0000003f;

const int xFirst6bShift = 18;
const int xSecond6bShift = 12;
const int xThird6bShift = 6;
const int xFourth6bShift = 0;

//
// Mask bits in 24 bit value for the three 8 bit units
// note the first char is the most significant byte !!
//
const int xFirst8bChar = 0x00ff0000;
const int xSecond8bChar = 0x0000ff00;
const int xThird8bChar = 0x000000ff;

const int xFirst8bShift = 16;
const int xSecond8bShift = 8;
const int xThird8bShift = 0;


// Transform wchar_t base64 string to Octet string
BYTE* Base642OctetW(LPCWSTR szBase64, DWORD cbBase64, DWORD *pdwOctLen) {
	DWORD Complete4Chars   = cbBase64 / 4;
	BYTE* OctetBuffer      = NULL;
	BOOL  fRet             = FALSE;
	BYTE* pOctetBuffer     = NULL;
	DWORD i;

	if((Complete4Chars * 4) != cbBase64)
		goto done;

	*pdwOctLen = Complete4Chars * 3;
	if (NULL == (OctetBuffer = (BYTE*)g_funcAlloc(*pdwOctLen,g_pvAllocData)))
		goto done;

	if(szBase64[cbBase64 - 2] == L'=') {
		// '==' padding --> only 1 of the last 3 in the char is used
		if (szBase64[cbBase64 - 1] != L'=')
			goto done;
		*pdwOctLen -= 2;
	}
	else if(szBase64[cbBase64 - 1] == L'=') {
		// '=' padding --> only 2 of the last 3 char are used
		*pdwOctLen -= 1;
	}
	pOctetBuffer = OctetBuffer;

	// Convert each 4 wchar_t of base64 (6 bits) to 3 Octet bytes of 8 bits
	// note '=' is mapped to 0 so no need to worry about last 4 base64 block
	// they might be extra Octet byte created in the last block
	// but we will ignore them because the correct value of pdwOctLen
	for(i=0; i< Complete4Chars; ++i, szBase64 += 4)  {
		// Calc 24 bits value - from 4 bytes of 6 bits
		BYTE b1;
		BYTE b2;
		BYTE b3;
		BYTE b4;
		if (!GetBase64Value(szBase64[0],&b1) || !GetBase64Value(szBase64[1],&b2) ||
		    !GetBase64Value(szBase64[2],&b3) || !GetBase64Value(szBase64[3],&b4))
			goto done;
		    
		DWORD Temp =   (b1 << xFirst6bShift) 
				     + (b2 << xSecond6bShift) 
				     + (b3 << xThird6bShift) 
				     + (b4 << xFourth6bShift);

		// Calc first 8 bits
		DWORD Res = ((Temp & xFirst8bChar) >> xFirst8bShift); 
		if (Res >= 256)
			goto done;
		*pOctetBuffer = static_cast<unsigned char>(Res);
		++pOctetBuffer;

		// Calc second 8 bits
		Res = ((Temp & xSecond8bChar) >> xSecond8bShift); 
		if (Res >= 256)
			goto done;
		*pOctetBuffer = static_cast<unsigned char>(Res);
		++pOctetBuffer;

		// Calc third 8 bits
		Res = ((Temp & xThird8bChar) >> xThird8bShift); 
		if (Res >= 256)
			goto done;
		*pOctetBuffer = static_cast<unsigned char>(Res); 
		++pOctetBuffer;
	}

	fRet = TRUE;
done:
	if (!fRet && OctetBuffer) {
		g_funcFree(OctetBuffer,g_pvFreeData);
		OctetBuffer = NULL;
	}

	return OctetBuffer;
}


const WCHAR xBase642AsciiW[] = {
	L'A', L'B', L'C', L'D', L'E', L'F', L'G', L'H', L'I', L'J',
	L'K', L'L', L'M', L'N', L'O', L'P', L'Q', L'R', L'S', L'T',
	L'U', L'V', L'W', L'X', L'Y', L'Z', L'a', L'b', L'c', L'd', 
	L'e', L'f', L'g', L'h', L'i', L'j', L'k', L'l', L'm', L'n', 
	L'o', L'p', L'q', L'r', L's', L't', L'u', L'v', L'w', L'x', 
	L'y', L'z', L'0', L'1', L'2', L'3', L'4', L'5', L'6', L'7', 
	L'8', L'9', L'+', L'/'
	};


LPWSTR Convert3OctetTo4Base64(DWORD ThreeOctet,	LPWSTR pBase64Buffer)
/*++
Arguments:
	ThreeOctet - input 3Octet value (24 bit) 
	pBase64Buffer - base64 buffer that will be filled with 4 base64 wchar_t

Returned Value:
	updated pointer of pBase64Buffer which points to the next location
--*/
{
	DWORD Res = ((ThreeOctet & xFirst6bChar) >> xFirst6bShift);
	SVSUTIL_ASSERT(Res < 64);
	*pBase64Buffer = xBase642AsciiW[Res];
	++pBase64Buffer;

	//
	// Calc second 6 bits
	//
	Res = ((ThreeOctet & xSecond6bChar) >> xSecond6bShift); 
	SVSUTIL_ASSERT(Res < 64);
	*pBase64Buffer = xBase642AsciiW[Res];
	++pBase64Buffer;

	//
	// Calc third 6 bits
	//
	Res = ((ThreeOctet & xThird6bChar) >> xThird6bShift);
	SVSUTIL_ASSERT(Res < 64);
	*pBase64Buffer = xBase642AsciiW[Res];
	++pBase64Buffer;

	//
	// Calc fourth 6 bits
	//
	Res = ((ThreeOctet & xFourth6bChar) >> xFourth6bShift); 
	SVSUTIL_ASSERT(Res < 64);
	*pBase64Buffer = xBase642AsciiW[Res];
	++pBase64Buffer;

	return(pBase64Buffer);
}


LPWSTR Octet2Base64W(const BYTE* OctetBuffer, DWORD OctetLen, DWORD *Base64Len)
/*++
Arguments:
	OctetBuffer - input Octet buffer 
	OctetLen - Length of the Octet buffer (number of byte elements in buffer)
	Base64Len - (out) base64 buffer len (number of WCHAR elements in buffer)

Returned Value:
    wchar_t Base64 buffer

--*/
{
	*Base64Len =  ((OctetLen + 2) / 3) * 4;

	LPWSTR Base64Buffer = (LPWSTR) (g_funcAlloc(sizeof(WCHAR)*(*Base64Len+1),g_pvAllocData));
	LPWSTR pBase64Buffer = Base64Buffer;

	if (!Base64Buffer)
		return NULL;

	int Complete3Chars = OctetLen / 3;

	for(int i=0; i< Complete3Chars; ++i, OctetBuffer += 3) {
		DWORD Temp = ((OctetBuffer[0]) << xFirst8bShift) 
					 + ((OctetBuffer[1]) << xSecond8bShift) 
					 + ((OctetBuffer[2]) << xThird8bShift);

		pBase64Buffer = Convert3OctetTo4Base64(Temp, pBase64Buffer); 
	}

	int Remainder = OctetLen - Complete3Chars * 3;

	switch(Remainder)
	{
		DWORD Temp;

		case 0:
			break;

		case 1:
			Temp = ((OctetBuffer[0]) << xFirst8bShift); 

			pBase64Buffer = Convert3OctetTo4Base64(Temp, pBase64Buffer); 
			pBase64Buffer -= 2;
			*pBase64Buffer = L'='; 
			++pBase64Buffer;
			*pBase64Buffer = L'='; 
			++pBase64Buffer;
			break;

		case 2:
			Temp = ((OctetBuffer[0]) << xFirst8bShift) 
				   + ((OctetBuffer[1]) << xSecond8bShift);

			pBase64Buffer = Convert3OctetTo4Base64(Temp, pBase64Buffer); 

			--pBase64Buffer;
			*pBase64Buffer = L'='; 
			++pBase64Buffer;
			break;

		default:
			SVSUTIL_ASSERT(0);
			break;
	}

	Base64Buffer[*Base64Len] = L'\0';
	return(Base64Buffer);
}



PSTR FindMimeBoundary(PSTR pszHttpHeaders, BOOL *pfBadRequest) {
	PSTR pszContentType;
	PSTR pszEnd;
	PSTR pszTrav;
	PSTR pszEndBoundary;
	PSTR pszBoundary;

	// find the boundary value.
	pszContentType = FindHeader(pszHttpHeaders,cszContentType);
	if (!pszContentType) {
		SVSUTIL_ASSERT(0); // should've been caught by ISAPI extension already.
		if (pfBadRequest)
			*pfBadRequest = TRUE;
		return NULL;
	}
	
	pszEnd = strstr(pszContentType,cszCRLF);
	pszTrav = MyStrStrI(pszContentType,cszBoundary);

	if (NULL == pszTrav || pszTrav > pszEnd) {
		if (pfBadRequest)
			*pfBadRequest = TRUE;
		return NULL;
	}

	pszTrav += ccBoundary;
	pszTrav = RemoveLeadingSpace(pszTrav,pszEnd);
	
	// mime attribute value can be enclosed by '"' or not
	if (*pszTrav =='"')
		pszTrav++;

	// end is either CRLF or ;
	pszEndBoundary = strchr(pszTrav,';');
    if ((pszEndBoundary != NULL) && (pszEnd > pszEndBoundary))  {
        pszEnd = --pszEndBoundary;
    }

	pszEnd = RemoveTralingSpace(pszTrav, pszEnd);

	// set the pszEnd to one char behind buffer to temporarily make it a string.
	// mime attribute value can be enclosed by '"'; if it's present \0 it, otherwise advance one.
    if (*pszEnd !='"')
        pszEnd++;

	CHAR cSave = *pszEnd;
	*pszEnd = 0;

	if (NULL == (pszBoundary = svsutil_strdup(pszTrav))) {
		scerror_DebugOutM(VERBOSE_MASK_SRMP,(L"Unable to allocate memory.  GLE=0x%08x\r\n",GetLastError()));
		return NULL;
	}
	*pszEnd = cSave;
	return pszBoundary;
}