private ODataBatchOperationHeaders ValidatePartHeaders(ODataBatchOperationHeaders headers, out bool isChangeSetPart)
{
string str;
if (!headers.TryGetValue("Content-Type", out str))
{
throw new ODataException(Strings.ODataBatchReaderStream_MissingContentTypeHeader);
}
if (MediaTypeUtils.MediaTypeAndSubtypeAreEqual(str, "application/http"))
{
string str2;
isChangeSetPart = false;
if (!headers.TryGetValue("Content-Transfer-Encoding", out str2) || (string.Compare(str2, "binary", StringComparison.OrdinalIgnoreCase) != 0))
{
throw new ODataException(Strings.ODataBatchReaderStream_MissingOrInvalidContentEncodingHeader("Content-Transfer-Encoding", "binary"));
}
return(headers);
}
if (!MediaTypeUtils.MediaTypeStartsWithTypeAndSubtype(str, "multipart/mixed"))
{
throw new ODataException(Strings.ODataBatchReaderStream_InvalidContentTypeSpecified("Content-Type", str, "multipart/mixed", "application/http"));
}
isChangeSetPart = true;
if (this.changesetBoundary != null)
{
throw new ODataException(Strings.ODataBatchReaderStream_NestedChangesetsAreNotSupported);
}
return(headers);
}
/// <summary>
/// Reads the headers of a part.
/// </summary>
/// <returns>true if the start of a changeset part was detected; otherwise false.</returns>
internal bool ProcessPartHeader()
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(this.batchEncoding != null, "Batch encoding should have been established on first call to SkipToBoundary.");
bool isChangeSetPart;
ODataBatchOperationHeaders headers = this.ReadPartHeaders(out isChangeSetPart);
if (isChangeSetPart)
{
// determine the changeset boundary and the changeset encoding from the content type header
this.DetermineChangesetBoundaryAndEncoding(headers[ODataConstants.ContentTypeHeader]);
if (this.changesetEncoding == null)
{
// NOTE: No changeset encoding was specified in the changeset's content type header.
// Determine the changeset encoding from the first bytes in the changeset.
// NOTE: We do not have to skip over the potential preamble of the encoding
// because the batch reader will skip over everything (incl. the preamble)
// until it finds the first changeset (or batch) boundary
this.changesetEncoding = this.DetectEncoding();
}
// Verify that we only allow single byte encodings and UTF-8 for now.
ReaderValidationUtils.ValidateEncodingSupportedInBatch(this.changesetEncoding);
}
return(isChangeSetPart);
}
/// <summary>
/// Returns the cached <see cref="ODataBatchOperationRequestMessage"/> for reading the content of an operation
/// in a batch request.
/// </summary>
/// <returns>The message that can be used to read the content of the batch request operation from.</returns>
private ODataBatchOperationResponseMessage CreateOperationResponseMessageImplementation()
{
this.operationState = OperationState.MessageCreated;
string responseLine = this.batchStream.ReadFirstNonEmptyLine();
int statusCode = this.ParseResponseLine(responseLine);
// Read all headers and create the response message
ODataBatchOperationHeaders headers = this.batchStream.ReadHeaders();
// In responses we don't need to use our batch URL resolver, since there are no cross referencing URLs
// so use the URL resolver from the batch message instead.
ODataBatchOperationResponseMessage responseMessage = ODataBatchOperationResponseMessage.CreateReadMessage(
this.batchStream,
statusCode,
headers,
/*operationListener*/ this,
this.urlResolver.BatchMessageUrlResolver);
//// NOTE: Content-IDs for cross referencing are only supported in request messages; in responses
//// we allow a Content-ID header but don't process it (i.e., don't add the content ID to the URL resolver).
return(responseMessage);
}
private ODataBatchOperationRequestMessage CreateOperationRequestMessageImplementation()
{
string str2;
Uri uri;
string str3;
this.operationState = OperationState.MessageCreated;
string requestLine = this.batchStream.ReadLine();
while (requestLine.Length == 0)
{
requestLine = this.batchStream.ReadLine();
}
this.ParseRequestLine(requestLine, out str2, out uri);
ODataBatchOperationHeaders headers = this.batchStream.ReadHeaders();
ODataBatchOperationRequestMessage message = ODataBatchOperationRequestMessage.CreateReadMessage(this.batchStream, str2, uri, headers, this, this.urlResolver);
if (headers.TryGetValue("Content-ID", out str3))
{
if ((str3 != null) && this.urlResolver.ContainsContentId(str3))
{
throw new ODataException(Strings.ODataBatchReader_DuplicateContentIDsNotAllowed(str3));
}
this.contentIdToAddOnNextRead = str3;
}
return(message);
}
/// <summary>
/// Creates a batch operation stream from the specified batch stream.
/// </summary>
/// <param name="batchReaderStream">The batch stream to create the operation read stream for.</param>
/// <param name="headers">The headers of the current part; based on the header we create different, optimized stream implementations.</param>
/// <param name="operationListener">The operation listener to be passed to the newly created read stream.</param>
/// <returns>A new <see cref="ODataBatchOperationReadStream"/> instance.</returns>
internal static ODataBatchOperationReadStream CreateBatchOperationReadStream(
ODataBatchReaderStream batchReaderStream,
ODataBatchOperationHeaders headers,
IODataBatchOperationListener operationListener)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(batchReaderStream != null, "batchReaderStream != null");
Debug.Assert(operationListener != null, "operationListener != null");
// See whether we have a Content-Length header
string contentLengthValue;
if (headers.TryGetValue(ODataConstants.ContentLengthHeader, out contentLengthValue))
{
int length = Int32.Parse(contentLengthValue, CultureInfo.InvariantCulture);
if (length < 0)
{
throw new ODataException(Strings.ODataBatchReaderStream_InvalidContentLengthSpecified(contentLengthValue));
}
return(ODataBatchOperationReadStream.Create(batchReaderStream, operationListener, length));
}
return(ODataBatchOperationReadStream.Create(batchReaderStream, operationListener));
}
internal ODataBatchOperationMessage(Func <Stream> contentStreamCreatorFunc, ODataBatchOperationHeaders headers, IODataBatchOperationListener operationListener, IODataUrlResolver urlResolver, bool writing) : base(writing, false, -1L)
{
this.contentStreamCreatorFunc = contentStreamCreatorFunc;
this.operationListener = operationListener;
this.headers = headers;
this.urlResolver = urlResolver;
}
/// <summary>
/// Reads the headers of a batch part or an operation.
/// </summary>
/// <returns>A dictionary of header names to header values; never null.</returns>
internal ODataBatchOperationHeaders ReadHeaders()
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(this.batchEncoding != null, "Batch encoding should have been established on first call to SkipToBoundary.");
ODataBatchOperationHeaders headers = new ODataBatchOperationHeaders();
// Read all the headers
string headerLine = this.ReadLine();
while (headerLine != null && headerLine.Length > 0)
{
string headerName, headerValue;
ValidateHeaderLine(headerLine, out headerName, out headerValue);
if (headers.ContainsKeyOrdinal(headerName))
{
throw new ODataException(Strings.ODataBatchReaderStream_DuplicateHeaderFound(headerName));
}
headers.Add(headerName, headerValue);
headerLine = this.ReadLine();
}
return(headers);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="contentStreamCreatorFunc">A function to retrieve the content stream for this batch operation message.</param>
/// <param name="headers">The headers of the batch operation message.</param>
/// <param name="operationListener">Listener interface to be notified of part changes.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs written to the payload.</param>
/// <param name="writing">true if the request message is being written; false when it is read.</param>
private ODataBatchOperationResponseMessage(
Func <Stream> contentStreamCreatorFunc,
ODataBatchOperationHeaders headers,
IODataBatchOperationListener operationListener,
IODataUrlResolver urlResolver,
bool writing)
{
Debug.Assert(contentStreamCreatorFunc != null, "contentStreamCreatorFunc != null");
Debug.Assert(operationListener != null, "operationListener != null");
this.message = new ODataBatchOperationMessage(contentStreamCreatorFunc, headers, operationListener, urlResolver, writing);
}
private ODataBatchOperationResponseMessage CreateOperationResponseMessageImplementation()
{
this.operationState = OperationState.MessageCreated;
string responseLine = this.batchStream.ReadLine();
while (responseLine.Length == 0)
{
responseLine = this.batchStream.ReadLine();
}
int statusCode = this.ParseResponseLine(responseLine);
ODataBatchOperationHeaders headers = this.batchStream.ReadHeaders();
return(ODataBatchOperationResponseMessage.CreateReadMessage(this.batchStream, statusCode, headers, this, this.urlResolver.BatchMessageUrlResolver));
}
/// <summary>
/// Creates an operation request message that can be used to read the operation content from.
/// </summary>
/// <param name="batchReaderStream">The batch stream underyling the operation response message.</param>
/// <param name="method">The HTTP method to use for the message to create.</param>
/// <param name="requestUrl">The request URL for the message to create.</param>
/// <param name="headers">The headers to use for the operation request message.</param>
/// <param name="operationListener">The operation listener.</param>
/// <param name="urlResolver">The (optional) URL resolver for the message to create.</param>
/// <returns>An <see cref="ODataBatchOperationRequestMessage"/> to read the request content from.</returns>
internal static ODataBatchOperationRequestMessage CreateReadMessage(
ODataBatchReaderStream batchReaderStream,
string method,
Uri requestUrl,
ODataBatchOperationHeaders headers,
IODataBatchOperationListener operationListener,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(batchReaderStream != null, "batchReaderStream != null");
Debug.Assert(operationListener != null, "operationListener != null");
Func <Stream> streamCreatorFunc = () => ODataBatchUtils.CreateBatchOperationReadStream(batchReaderStream, headers, operationListener);
return(new ODataBatchOperationRequestMessage(streamCreatorFunc, method, requestUrl, headers, operationListener, urlResolver, /*writing*/ false));
}
internal bool ProcessPartHeader()
{
bool flag;
ODataBatchOperationHeaders headers = this.ReadPartHeaders(out flag);
if (flag)
{
this.DetermineChangesetBoundaryAndEncoding(headers["Content-Type"]);
if (this.changesetEncoding == null)
{
this.changesetEncoding = this.DetectEncoding();
}
ReaderValidationUtils.ValidateEncodingSupportedInBatch(this.changesetEncoding);
}
return(flag);
}
internal ODataBatchOperationHeaders ReadHeaders()
{
ODataBatchOperationHeaders headers = new ODataBatchOperationHeaders();
for (string str = this.ReadLine(); (str != null) && (str.Length > 0); str = this.ReadLine())
{
string str2;
string str3;
ValidateHeaderLine(str, out str2, out str3);
if (headers.ContainsKeyOrdinal(str2))
{
throw new ODataException(Strings.ODataBatchReaderStream_DuplicateHeaderFound(str2));
}
headers.Add(str2, str3);
}
return(headers);
}
/// <summary>
/// Constructor. Base class constructor to create a message for an operation of a batch request/response.
/// </summary>
/// <param name="contentStreamCreatorFunc">A function to retrieve the content stream for this batch operation message.</param>
/// <param name="headers">The headers of the batch operation message.</param>
/// <param name="operationListener">Listener interface to be notified of part changes.</param>
/// <param name="urlResolver">The URL resolver to perform custom URL resolution for URLs read or written from/to the payload.</param>
/// <param name="writing">true if the request message is being written; false when it is read.</param>
internal ODataBatchOperationMessage(
Func <Stream> contentStreamCreatorFunc,
ODataBatchOperationHeaders headers,
IODataBatchOperationListener operationListener,
IODataUrlResolver urlResolver,
bool writing)
: base(writing, /*disableMessageStreamDisposal*/ false, /*maxMessageSize*/ -1)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(contentStreamCreatorFunc != null, "contentStreamCreatorFunc != null");
Debug.Assert(operationListener != null, "operationListener != null");
this.contentStreamCreatorFunc = contentStreamCreatorFunc;
this.operationListener = operationListener;
this.headers = headers;
this.urlResolver = urlResolver;
}
/// <summary>
/// Validates the headers that have been read for a part.
/// </summary>
/// <param name="headers">The set of headers to validate.</param>
/// <param name="isChangeSetPart">true if the headers indicate a changset part; otherwise false.</param>
/// <returns>The set of validated headers.</returns>
/// <remarks>
/// An operation part is required to have content type 'application/http' and content transfer
/// encoding 'binary'. A changeset is required to have content type 'multipart/mixed'.
/// Note that we allow additional headers for batch parts; clients of the library can choose
/// to be more strict.
/// </remarks>
private ODataBatchOperationHeaders ValidatePartHeaders(ODataBatchOperationHeaders headers, out bool isChangeSetPart)
{
string contentType;
if (!headers.TryGetValue(ODataConstants.ContentTypeHeader, out contentType))
{
throw new ODataException(Strings.ODataBatchReaderStream_MissingContentTypeHeader);
}
if (MediaTypeUtils.MediaTypeAndSubtypeAreEqual(contentType, MimeConstants.MimeApplicationHttp))
{
isChangeSetPart = false;
// An operation part is required to have application/http content type and
// binary content transfer encoding.
string transferEncoding;
if (!headers.TryGetValue(ODataConstants.ContentTransferEncoding, out transferEncoding) ||
string.Compare(transferEncoding, ODataConstants.BatchContentTransferEncoding, StringComparison.OrdinalIgnoreCase) != 0)
{
throw new ODataException(Strings.ODataBatchReaderStream_MissingOrInvalidContentEncodingHeader(
ODataConstants.ContentTransferEncoding,
ODataConstants.BatchContentTransferEncoding));
}
}
else if (MediaTypeUtils.MediaTypeStartsWithTypeAndSubtype(contentType, MimeConstants.MimeMultipartMixed))
{
isChangeSetPart = true;
if (this.changesetBoundary != null)
{
// Nested changesets are not supported
throw new ODataException(Strings.ODataBatchReaderStream_NestedChangesetsAreNotSupported);
}
}
else
{
throw new ODataException(Strings.ODataBatchReaderStream_InvalidContentTypeSpecified(
ODataConstants.ContentTypeHeader,
contentType,
MimeConstants.MimeMultipartMixed,
MimeConstants.MimeApplicationHttp));
}
return(headers);
}
/// <summary>
/// Returns the cached <see cref="ODataBatchOperationRequestMessage"/> for reading the content of an operation
/// in a batch request.
/// </summary>
/// <returns>The message that can be used to read the content of the batch request operation from.</returns>
private ODataBatchOperationRequestMessage CreateOperationRequestMessageImplementation()
{
this.operationState = OperationState.MessageCreated;
// Read and parse the request line (skip all empty lines)
string requestLine = this.batchStream.ReadLine();
while (requestLine.Length == 0)
{
requestLine = this.batchStream.ReadLine();
}
string httpMethod;
Uri requestUri;
this.ParseRequestLine(requestLine, out httpMethod, out requestUri);
// Read all headers and create the request message
ODataBatchOperationHeaders headers = this.batchStream.ReadHeaders();
ODataBatchOperationRequestMessage requestMessage = ODataBatchOperationRequestMessage.CreateReadMessage(
this.batchStream,
httpMethod,
requestUri,
headers,
/*operationListener*/ this,
this.urlResolver);
// Add a potential Content-ID header to the URL resolver so that it will be available
// to subsequent operations.
string contentId;
if (headers.TryGetValue(ODataConstants.ContentIdHeader, out contentId))
{
Debug.Assert(this.contentIdToAddOnNextRead == null, "Must not have a content ID to be added to a part.");
if (contentId != null && this.urlResolver.ContainsContentId(contentId))
{
throw new ODataException(Strings.ODataBatchReader_DuplicateContentIDsNotAllowed(contentId));
}
this.contentIdToAddOnNextRead = contentId;
}
return(requestMessage);
}
/// <summary>
/// Creates an operation response message that can be used to read the operation content from.
/// </summary>
/// <param name="batchReaderStream">The batch stream underyling the operation response message.</param>
/// <param name="statusCode">The status code to use for the operation response message.</param>
/// <param name="headers">The headers to use for the operation response message.</param>
/// <param name="operationListener">The operation listener.</param>
/// <param name="urlResolver">The (optional) URL resolver for the message to create.</param>
/// <returns>An <see cref="ODataBatchOperationResponseMessage"/> that can be used to read the operation content.</returns>
internal static ODataBatchOperationResponseMessage CreateReadMessage(
ODataBatchReaderStream batchReaderStream,
int statusCode,
ODataBatchOperationHeaders headers,
IODataBatchOperationListener operationListener,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(batchReaderStream != null, "batchReaderStream != null");
Debug.Assert(operationListener != null, "operationListener != null");
Func <Stream> streamCreatorFunc = () => ODataBatchUtils.CreateBatchOperationReadStream(batchReaderStream, headers, operationListener);
ODataBatchOperationResponseMessage responseMessage =
new ODataBatchOperationResponseMessage(streamCreatorFunc, headers, operationListener, urlResolver, /*writing*/ false);
responseMessage.statusCode = statusCode;
return(responseMessage);
}
/// <summary>
/// Constructor. Creates a request message for an operation of a batch request.
/// </summary>
/// <param name="contentStreamCreatorFunc">A function to create the content stream.</param>
/// <param name="method">The HTTP method used for this request message.</param>
/// <param name="requestUrl">The request Url for this request message.</param>
/// <param name="headers">The headers for the this request message.</param>
/// <param name="operationListener">Listener interface to be notified of operation changes.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs written to the payload.</param>
/// <param name="writing">true if the request message is being written; false when it is read.</param>
private ODataBatchOperationRequestMessage(
Func <Stream> contentStreamCreatorFunc,
string method,
Uri requestUrl,
ODataBatchOperationHeaders headers,
IODataBatchOperationListener operationListener,
IODataUrlResolver urlResolver,
bool writing)
{
Debug.Assert(contentStreamCreatorFunc != null, "contentStreamCreatorFunc != null");
Debug.Assert(operationListener != null, "operationListener != null");
Debug.Assert(urlResolver != null, "urlResolver != null");
this.Method = method;
this.Url = requestUrl;
this.message = new ODataBatchOperationMessage(contentStreamCreatorFunc, headers, operationListener, urlResolver, writing);
}
public override void SetHeader(string headerName, string headerValue)
{
this.VerifyNotCompleted();
base.VerifyCanSetHeader();
if (headerValue == null)
{
if (this.headers != null)
{
this.headers.Remove(headerName);
}
}
else
{
if (this.headers == null)
{
this.headers = new ODataBatchOperationHeaders();
}
this.headers[headerName] = headerValue;
}
}
internal static ODataBatchOperationRequestMessage CreateReadMessage(ODataBatchReaderStream batchReaderStream, string method, Uri requestUrl, ODataBatchOperationHeaders headers, IODataBatchOperationListener operationListener, IODataUrlResolver urlResolver)
{
return(new ODataBatchOperationRequestMessage(() => ODataBatchUtils.CreateBatchOperationReadStream(batchReaderStream, headers, operationListener), method, requestUrl, headers, operationListener, urlResolver, false));
}
internal static ODataBatchOperationReadStream CreateBatchOperationReadStream(ODataBatchReaderStream batchReaderStream, ODataBatchOperationHeaders headers, IODataBatchOperationListener operationListener)
{
string str;
if (!headers.TryGetValue("Content-Length", out str))
{
return(ODataBatchOperationReadStream.Create(batchReaderStream, operationListener));
}
int length = int.Parse(str, CultureInfo.InvariantCulture);
if (length < 0)
{
throw new ODataException(Strings.ODataBatchReaderStream_InvalidContentLengthSpecified(str));
}
return(ODataBatchOperationReadStream.Create(batchReaderStream, operationListener, length));
}
internal static ODataBatchOperationResponseMessage CreateReadMessage(ODataBatchReaderStream batchReaderStream, int statusCode, ODataBatchOperationHeaders headers, IODataBatchOperationListener operationListener, IODataUrlResolver urlResolver)
{
return(new ODataBatchOperationResponseMessage(() => ODataBatchUtils.CreateBatchOperationReadStream(batchReaderStream, headers, operationListener), headers, operationListener, urlResolver, false)
{
statusCode = statusCode
});
}
private ODataBatchOperationResponseMessage(Func <Stream> contentStreamCreatorFunc, ODataBatchOperationHeaders headers, IODataBatchOperationListener operationListener, IODataUrlResolver urlResolver, bool writing)
{
this.message = new ODataBatchOperationMessage(contentStreamCreatorFunc, headers, operationListener, urlResolver, writing);
}
private ODataBatchOperationHeaders ReadPartHeaders(out bool isChangeSetPart)
{
ODataBatchOperationHeaders headers = this.ReadHeaders();
return(this.ValidatePartHeaders(headers, out isChangeSetPart));
}
