/// <summary>
/// Tries to parse a chunk size line for the message
/// </summary>
/// <returns></returns>
private bool TryAndParseChunkSizeLine(ref HttpMessage message, HttpMessageProgressEventHandler onProgress, object stateObject)
{
// try and parse a token from the data
HttpByteParserToken token = _parser.GetNextToken();
if (token == null)
{
return(false);
}
// the first line of any message is never empty
if (token.IsEmpty)
{
return(false);
}
// success! this line is a header
string line = token.ToString(HttpUtils.Encoding);
// parse the size line
HttpChunkSizeLine chunkSizeLine = HttpChunkSizeLine.Parse(line);
// create a new chunk
_chunk = new HttpChunk(chunkSizeLine, null);
// change state to processing chunk data
_state = Processing.ChunkData;
return(true);
}
/// <summary>
/// Tries to parse a trailer header for the message
/// </summary>
/// <returns></returns>
private bool TryAndParseTrailerHeaderLine(ref HttpMessage message, HttpMessageProgressEventHandler onProgress, object stateObject)
{
// try and parse a token from the data
HttpByteParserToken token = _parser.GetNextToken();
if (token == null)
{
// change state to processing the body
_state = Processing.Finished;
// we're done with the headers
return(true);
}
// the first line of any message is never empty
if (token.IsEmpty)
{
// change state to processing the body
_state = Processing.Finished;
// we're done with the headers
return(true);
}
// success! this line is a header
string line = token.ToString(HttpUtils.Encoding);
// parse the line into a new header
HttpHeader header = HttpHeader.Parse(line);
// save the header in the chunked body trailers
_chunkedBody.TrailerHeaders.Add(header);
return(true);
}
/// <summary>
/// Tries to parse the first line for the message
/// </summary>
/// <returns></returns>
private bool TryAndParseFirstLine(ref HttpMessage message, HttpMessageProgressEventHandler onProgress, object stateObject)
{
// try and parse a token from the data
HttpByteParserToken token = _parser.GetNextToken();
if (token == null)
{
return(false);
}
// the first line of any message is never empty
if (token.IsEmpty)
{
return(false);
}
// success! store the first line of the message
message._firstLine = token.ToString(HttpUtils.Encoding);
// save the offset into the data where the headers start
_headerOffsetStart = _parser.Index;
// change state to processing headers!
_state = Processing.HeaderLine;
return(true);
}
/// <summary>
/// Tries to parse out a line of text from the underlying byte array by searching for '\r\n' combinations.
/// </summary>
/// <returns></returns>
public HttpByteParserToken GetNextToken()
{
HttpByteParserToken line = null;
// Start searching at our last index, and work our way towards the end of our bytes (|| until we strike a valid CRLF combination)
for (int i = _index; i < _bytes.Length; i++)
{
// if the current byte is the LF char
if (_bytes[i] == (byte)'\n')
{
// try backing up and seeing if the one before was a CR char (the length of it will be our current position - where we started
int length = i - _index;
// if there is a non-zero length, and the char matches (back the length up one more so that we do not include the CR char
if (length > 0 && _bytes[i - 1] == (byte)'\r')
{
length--;
}
// now that we have a line (and we have possibly excluded the '\r' from the line using the code above :P let's construct a new line around these bytes
line = new HttpByteParserToken(_bytes, _index, length);
// now push the index ahead so that we're sitting ahead of the '\n' that we stopped on
_index = i + 1;
// return the object
return(line);
}
}
return(null);
}
/// <summary>
/// Tries to parse a header line for the message
/// </summary>
/// <returns></returns>
private bool TryAndParseHeaderLine(ref HttpMessage message, HttpMessageProgressEventHandler onProgress, object stateObject)
{
// try and parse a token from the data
HttpByteParserToken token = _parser.GetNextToken();
if (token == null)
{
return(false);
}
// the first line of any message is never empty
if (token.IsEmpty)
{
// save the offset into the data where the headers end
_headerOffsetEnd = _parser.Index;
// determine if the body is chunked, as we have all the headers now we can determine how the message is going to come in
if (message.IsChunked)
{
// change state to processing a chunk size line
_state = Processing.ChunkSizeLine;
}
else
{
// change state to processing the body
_state = Processing.Body;
}
// notify the callback that we have received the headers
this.OnProgress(onProgress, this, new HttpMessageProgressEventArgs(message, true, new byte[] {}, _receivedBytes.Length, stateObject));
// we're done with the headers
return(true);
}
// success! this line is a header
string line = token.ToString(HttpUtils.Encoding);
// parse the line into a new header
HttpHeader header = HttpHeader.Parse(line);
// save the header
message.Headers.Add(header);
return(true);
}
/// <summary>
/// Splits the byte array into an array of chunks using the specified character separator
/// </summary>
/// <param name="separator"></param>
/// <returns></returns>
public HttpByteParserToken[] Split(char separator)
{
ArrayList list = new ArrayList();
int pos = 0;
while (pos < _bytes.Length)
{
int i = IndexOf(separator, pos);
if (i < 0)
{
break;
}
list.Add(Substring(pos, i - pos));
pos = i + 1;
while (this[pos] == (byte)separator && pos < _bytes.Length)
{
pos++;
}
}
if (pos < _bytes.Length)
{
list.Add(Substring(pos));
}
int n = list.Count;
HttpByteParserToken[] result = new HttpByteParserToken[n];
for (int i = 0; i < n; i++)
{
result[i] = (HttpByteParserToken)list[i];
}
return(result);
}
/// <summary>
/// Splits the byte array into an array of chunks using the specified character separator
/// </summary>
/// <param name="separator"></param>
/// <returns></returns>
public HttpByteParserToken[] Split(char separator)
{
ArrayList list = new ArrayList();
int pos = 0;
while (pos < _bytes.Length)
{
int i = IndexOf(separator, pos);
if (i < 0)
break;
list.Add(Substring(pos, i-pos));
pos = i+1;
while (this[pos] == (byte)separator && pos < _bytes.Length)
pos++;
}
if (pos < _bytes.Length)
list.Add(Substring(pos));
int n = list.Count;
HttpByteParserToken[] result = new HttpByteParserToken[n];
for (int i = 0; i < n; i++)
result[i] = (HttpByteParserToken)list[i];
return result;
}
/// <summary>
/// Tries to parse out a line of text from the underlying byte array by searching for '\r\n' combinations.
/// </summary>
/// <returns></returns>
public HttpByteParserToken GetNextToken()
{
HttpByteParserToken line = null;
// Start searching at our last index, and work our way towards the end of our bytes (|| until we strike a valid CRLF combination)
for (int i = _index; i < _bytes.Length; i++)
{
// if the current byte is the LF char
if (_bytes[i] == (byte)'\n')
{
// try backing up and seeing if the one before was a CR char (the length of it will be our current position - where we started
int length = i - _index;
// if there is a non-zero length, and the char matches (back the length up one more so that we do not include the CR char
if (length > 0 && _bytes[i-1] == (byte)'\r')
length--;
// now that we have a line (and we have possibly excluded the '\r' from the line using the code above :P let's construct a new line around these bytes
line = new HttpByteParserToken(_bytes, _index, length);
// now push the index ahead so that we're sitting ahead of the '\n' that we stopped on
_index = i+1;
// return the object
return line;
}
}
return null;
}