public int FormatBinaryLine(byte[] buffer, int offset, IHeaderField field)
{
//Only one special case
if (field.Type == HFType.Undefined)
{
return(FormatUndefined(field, buffer, offset));
}
int index = (int)field.Type;
var func = FormatFuncs[index];
if (func == null)
{
throw new NotSupportedException("HfBinaryFormatter do not support " + field.Type.ToString());
}
//1. copy header name bytes
int bhNameLen = BinaryHeaderName[index].Length;
for (int i = 0; i < bhNameLen; i++)
{
buffer[offset + i] = BinaryHeaderName[index][i];
}
//2. write value
int valueLen = func(buffer, offset + bhNameLen, field);
int crlfIndex = offset + valueLen + bhNameLen;
//3. write crlf
buffer[crlfIndex + 0] = (byte)'\r';
buffer[crlfIndex + 1] = (byte)'\n';
// ('2' == crlf length)
return(2 + bhNameLen + valueLen);
}
private static int FormatWWWAuthenticate(byte[] buffer, int offset, IHeaderField field)
{
WWWAuthenticateHf authHf = (WWWAuthenticateHf)field;
string result = string.Format("Basic realm=\"{0}\", charset=\"{1}\"", authHf.Realm, authHf.Charset);
return(Encoding.ASCII.GetBytes(result, 0, result.Length, buffer, offset));
}
private static int FormattedWWWAuthenticateLength(IHeaderField field)
{
WWWAuthenticateHf authHf = (WWWAuthenticateHf)field;
int len = authHf.Realm.Length + authHf.Charset.Length + 26;
return(len);
}
//
// Content-Encoding
//
private static int FormattedContentEncodingLength(IHeaderField field)
{
ContentEncodingHf ce = (ContentEncodingHf)field;
ThrowIfInvaludEncodingType(ce.EncodingType);
return(Enum.GetName(typeof(EncodingType), ce.EncodingType).Length);
}
//
// Date
//
private static int FormattedDateLength(IHeaderField field)
{
var curDate = ((DateHf)field).Date.ToUniversalTime();
string dateString = curDate.ToString("ddd, d MMM yyyy HH:mm:ss", CultureInfo.InvariantCulture);
string fullDateString = string.Format("{0} {1}", dateString, "GMT");
return(fullDateString.Length);
}
private static int FormatContentType(byte[] buffer, int offset, IHeaderField headerField)
{
ContentTypeHf contentType = (ContentTypeHf)headerField;
for (int i = 0; i < contentType.ContentType.Length; i++)
{
buffer[i + offset] = (byte)contentType.ContentType[i];
}
return(contentType.ContentType.Length);
}
//
// Server
//
private static int FormatServer(byte[] buffer, int offset, IHeaderField headerField)
{
string name = ((ServerHf)headerField).Name;
for (int i = 0; i < name.Length; i++)
{
buffer[i + offset] = (byte)name[i];
}
return(name.Length);
}
//
// value formatter definitions
//
//
// Content-Length
//
private static int FormatContentLength(byte[] buffer, int offset, IHeaderField hf)
{
ContentLengthHf cl = (ContentLengthHf)hf;
int len = cl.ContentLength > 0 ? (int)Math.Log10(cl.ContentLength) : 0;
long curV = cl.ContentLength;
for (int i = offset + len; i >= offset; i--)
{
buffer[i] = (byte)((curV % 10) + (byte)'0');
curV /= 10;
}
return(len + 1);
}
internal bool TryGetFirst(HFType type, out IHeaderField field)
{
foreach (var hf in headerFieldsList)
{
if (hf.Type == type)
{
field = hf;
return(true);
}
}
field = null;
return(false);
}
private static int FormattedContentLengthLength(IHeaderField field)
{
long length = ((ContentLengthHf)field).ContentLength;
if (length > 0)
{
int valueLen = (int)Math.Log(length) + 1;
return(valueLen);
}
else
{
return(1);
}
}
private static int FormatDate(byte[] buffer, int offset, IHeaderField headerField)
{
DateHf date = (DateHf)headerField;
DateTime curDate = date.Date.ToUniversalTime();
string dateString = curDate.ToString("ddd, d MMM yyyy HH:mm:ss", CultureInfo.InvariantCulture);
string fullDateString = string.Format("{0} {1}", dateString, "GMT");
for (int i = 0; i < fullDateString.Length; i++)
{
buffer[i + offset] = (byte)fullDateString[i];
}
return(fullDateString.Length);
}
//
// Special undefined header
//
private int FormatUndefined(IHeaderField field, byte[] buffer, int offset)
{
string nameStr = ((UndefinedHf)(field)).Name;
string valueStr = ((UndefinedHf)(field)).Value;
Encoding.ASCII.GetBytes(nameStr, 0, nameStr.Length, buffer, offset);
buffer[offset + nameStr.Length] = (byte)':';
Encoding.ASCII.GetBytes(valueStr, 0, valueStr.Length, buffer, offset + nameStr.Length + 1);
int endIndex = offset + 1 + nameStr.Length + valueStr.Length;
buffer[endIndex + 0] = (byte)'\r';
buffer[endIndex + 1] = (byte)'\n';
return(valueStr.Length + nameStr.Length + 1 + 2);
}
private IHeaderField[] ParseHeaderFields(byte[] array, int headerStartOffset, int length)
{
int fieldStartOffset = headerStartOffset;
int fieldLength = IndexOfCrlf(array, headerStartOffset, length) - fieldStartOffset;
List <IHeaderField> headerFields = new List <IHeaderField>();
while (fieldLength > 0)
{
//string fullHeader = Encoding.ASCII.GetString(array, startOffset, endOffset - startOffset);
IHeaderField field = HeaderFieldParser.Parse(array, fieldStartOffset, fieldLength);
headerFields.Add(field);
fieldStartOffset += fieldLength + 2;
fieldLength = IndexOfCrlf(array, fieldStartOffset, length) - fieldStartOffset;
}
return(headerFields.ToArray());
}
private static int FormatContentEncoding(byte[] buffer, int offset, IHeaderField headerField)
{
ContentEncodingHf ce = (ContentEncodingHf)headerField;
// this should not to be here
ThrowIfInvaludEncodingType(ce.EncodingType);
//get string from enum
string encodingStringValue = " " + Enum.GetName(typeof(EncodingType), ce.EncodingType).ToLower();
//inset bytes
for (int i = 0; i < encodingStringValue.Length; i++)
{
buffer[i + offset] = (byte)encodingStringValue[i];
}
//return writted bytes
return(encodingStringValue.Length);
}
public int GetFormattedLength(IHeaderField field)
{
int nLen = -1;
//Only one special case
if (field.Type == HFType.Undefined)
{
nLen = ((UndefinedHf)field).Name.Length; //name
nLen += ((UndefinedHf)field).Value.Length; // value
nLen += 1; // ':'
}
else
{
int index = (int)field.Type;
var func = LenFuncs[index];
nLen = BinaryHeaderName[index].Length;
nLen += func(field);
}
return(nLen + 2);
}
private static int FormattedServerValueLength(IHeaderField field)
{
return(((ServerHf)field).Name.Length);
}
public void Add(IHeaderField headerField)
{
headerFieldsList.Add(headerField);
}
//
// Content-Type
//
private static int FormattedContentTypeLength(IHeaderField field)
{
ContentTypeHf contentType = (ContentTypeHf)field;
return(contentType.ContentType.Length);
}
private void AddOnlySingleHeaderField(IHeaderField hf)
{
//error is unexpected and message format is invalid
onlySingleHeaderFields.Add(hf.Type, hf);
}
private static int FormatLocation(byte[] buffer, int offset, IHeaderField headerField)
{
LocationHf location = (LocationHf)headerField;
return(Encoding.ASCII.GetBytes(location.Location, 0, location.Location.Length, buffer, offset));
}
private void SpecialAddToCookie(IHeaderField hf)
{
cookieHfList.Add(hf);
}
private static int FormattedLocationLength(IHeaderField field)
{
LocationHf location = (LocationHf)field;
return(location.Location.Length);
}
