public static async Task RunList(MemoryStream stream, int from, int to)
{
using (var cn = new SqlConnection(Database.ConnectionString))
using (var cmd = cn.CreateCommand())
{
cmd.CommandText = "SELECT [Id], [Value] FROM [Values] WHERE [Id] BETWEEN @from AND @to";
cmd.Parameters.Add("@from", SqlDbType.Int).Value = from;
cmd.Parameters.Add("@to", SqlDbType.Int).Value = to;
await cn.OpenAsync();
using (var reader = await cmd.ExecuteReaderAsync())
{
if (_writer == null)
{
_writer = CreateWriter(reader);
}
await _writer.Write(reader, stream);
}
}
}
// Parse the delivery status byte array to downgrade
// the Original-Recipient and Final-Recipient header fields
internal static byte[] DowngradeDeliveryStatus(byte[] bytes) {
var sb = new StringBuilder();
var index = 0;
int endIndex = bytes.Length;
var lastIndex = -1;
ArrayWriter writer = null;
while (index < endIndex) {
sb.Remove(0, sb.Length);
var first = true;
int headerNameStart = index;
int headerNameEnd = index;
// lineCount = 0;
var endOfHeaders = false;
while (true) {
if (index >= endIndex) {
// All headers read
endOfHeaders = true;
break;
}
int c = (index < endIndex) ? (((int)bytes[index]) & 0xff) : -1;
// ++lineCount;
++index;
if (c == '\r') {
c = (index < endIndex) ? (((int)bytes[index]) & 0xff) : -1;
++index;
if (c == '\n') {
// lineCount = 0;
headerNameStart = index;
} else {
--index;
headerNameEnd = index;
}
continue;
}
if ((c >= 0x21 && c <= 57) || (c >= 59 && c <= 0x7e)) {
first = false;
if (c >= 'A' && c <= 'Z') {
c += 0x20;
}
sb.Append((char)c);
} else if (!first && c == ':') {
break;
} else {
first &= c != 0x20 && c != 0x09;
}
if (c != 0x20 && c != 0x09) {
headerNameEnd = index;
}
}
if (endOfHeaders) {
break;
}
int headerValueStart = index;
int headerValueEnd = index;
string origFieldName =
DataUtilities.GetUtf8String(
bytes,
headerNameStart,
headerValueStart - headerNameStart,
true);
string fieldName = DataUtilities.ToLowerCaseAscii(
DataUtilities.GetUtf8String(
bytes,
headerNameStart,
headerNameEnd - headerNameStart,
true));
bool origRecipient = fieldName.Equals("original-recipient");
bool finalRecipient = fieldName.Equals("final-recipient");
// Read the header field value using UTF-8 characters
// rather than bytes
while (true) {
if (index >= endIndex) {
// All headers read
headerValueEnd = index;
break;
}
int c = (index < endIndex) ? (((int)bytes[index]) & 0xff) : -1;
++index;
if (c == '\r') {
c = (index < endIndex) ? (((int)bytes[index]) & 0xff) : -1;
++index;
if (c == '\n') {
// lineCount = 0;
// Parse obsolete folding whitespace (obs-fws) under RFC5322
// (parsed according to errata), same as LWSP in RFC5234
var fwsFirst = true;
var haveFWS = false;
var lineStart = true;
while (true) {
// Skip the CRLF pair, if any (except if iterating for
// the first time, since CRLF was already parsed)
if (!fwsFirst) {
c = (index < endIndex) ? (((int)bytes[index]) & 0xff) : -1;
++index;
if (c == '\r') {
c = (index < endIndex) ? (((int)bytes[index]) & 0xff) : -1;
++index;
if (c == '\n') {
// CRLF was read
lineStart = true;
} else {
// It's the first part of the line, where the header name
// should be, so the CR here is illegal
throw new MessageDataException("CR not followed by LF");
}
} else {
// anything else, unget
--index;
}
}
fwsFirst = false;
// Use ReadByte here since we're just looking for the single
// byte characters space and tab
int c2 = (index < endIndex) ? (((int)bytes[index]) & 0xff) : -1;
++index;
if (c2 == 0x20 || c2 == 0x09) {
lineStart = false;
haveFWS = true;
} else {
--index;
// this isn't space or tab; if this is the start
// of the line, this is no longer FWS
if (lineStart) {
haveFWS = false;
}
break;
}
}
if (haveFWS) {
// We have folding whitespace, line
// count found as above
continue;
}
// This ends the header field
// (the last two characters will be CRLF)
headerValueEnd = index - 2;
break;
}
--index;
// ++lineCount;
}
// ++lineCount;
}
if (origRecipient || finalRecipient) {
string headerValue = DataUtilities.GetUtf8String(
bytes,
headerValueStart,
headerValueEnd - headerValueStart,
true);
var status = new int[1];
headerValue = DowngradeRecipientHeaderValue(headerValue, status);
if (status[0] == 2 || status[0] == 1) {
// Downgraded or encapsulated
if (writer == null) {
writer = new ArrayWriter();
writer.Write(bytes, 0, headerNameStart);
} else {
writer.Write(bytes, lastIndex, headerNameStart - lastIndex);
}
var encoder = new WordWrapEncoder(true);
string field = (origRecipient ?
"Downgraded-Original-Recipient" : "Downgraded-Final-Recipient") +
": ";
if (status[0] != 2) {
field = origFieldName + " ";
}
encoder.AddString(field + headerValue);
byte[] newBytes = DataUtilities.GetUtf8Bytes(
encoder.ToString(),
true);
writer.Write(newBytes, 0, newBytes.Length);
lastIndex = headerValueEnd;
}
}
}
if (writer != null) {
writer.Write(bytes, lastIndex, bytes.Length - lastIndex);
bytes = writer.ToArray();
}
return bytes;
}
/// <include file='../../docs.xml'
/// path='docs/doc[@name="M:PeterO.Mail.Message.Generate"]/*'/>
public string Generate() {
var aw = new ArrayWriter();
this.Generate(aw, 0);
return DataUtilities.GetUtf8String(aw.ToArray(), false);
}
private void ReadSimpleBody(IByteReader stream) {
IByteReader transform = MakeTransferEncoding(
stream,
this.transferEncoding,
this.ContentType.TypeAndSubType.Equals("text/plain"));
var buffer = new byte[8192];
var bufferCount = 0;
int bufferLength = buffer.Length;
var aw = new ArrayWriter();
{
while (true) {
var ch = 0;
try {
ch = transform.ReadByte();
} catch (MessageDataException ex) {
string valueExMessage = ex.Message;
#if DEBUG
aw.Write(buffer, 0, bufferCount);
buffer = aw.ToArray();
string ss = DataUtilities.GetUtf8String(
buffer,
Math.Max(buffer.Length - 35, 0),
Math.Min(buffer.Length, 35),
true);
ss = String.Empty;
string transferEnc = this.GetHeader("content-transfer-encoding");
valueExMessage += " [" + ss + "] [type=" + (this.ContentType ??
MediaType.TextPlainAscii) + "] [encoding=" + transferEnc +
"]";
valueExMessage = valueExMessage.Replace('\r', ' ')
.Replace('\n', ' ').Replace('\0', ' ');
#endif
throw new MessageDataException(valueExMessage, ex);
}
if (ch < 0) {
break;
}
buffer[bufferCount++] = (byte)ch;
if (bufferCount >= bufferLength) {
aw.Write(buffer, 0, bufferCount);
bufferCount = 0;
}
}
if (bufferCount > 0) {
aw.Write(buffer, 0, bufferCount);
}
this.body = aw.ToArray();
}
}
private void ReadMultipartBody(IByteReader stream) {
int baseTransferEncoding = this.transferEncoding;
var boundaryChecker = new BoundaryCheckerTransform(stream);
// Be liberal on the preamble and epilogue of multipart
// messages, as they will be ignored.
IByteReader currentTransform = MakeTransferEncoding(
boundaryChecker,
baseTransferEncoding,
true);
IList<MessageStackEntry> multipartStack = new List<MessageStackEntry>();
var entry = new MessageStackEntry(this);
multipartStack.Add(entry);
boundaryChecker.PushBoundary(entry.Boundary);
Message leaf = null;
var buffer = new byte[8192];
var bufferCount = 0;
int bufferLength = buffer.Length;
this.body = new byte[0];
var aw = new ArrayWriter();
{
while (true) {
var ch = 0;
try {
ch = currentTransform.ReadByte();
} catch (MessageDataException ex) {
string valueExMessage = ex.Message;
#if DEBUG
aw.Write(buffer, 0, bufferCount);
buffer = aw.ToArray();
string ss = DataUtilities.GetUtf8String(
buffer,
Math.Max(buffer.Length - 35, 0),
Math.Min(buffer.Length, 35),
true);
ss = String.Empty;
string transferEnc = (leaf ?? this)
.GetHeader("content-transfer-encoding");
valueExMessage += " [" + ss + "] [type=" + ((leaf ??
this).ContentType ?? MediaType.TextPlainAscii) +
"] [encoding=" + transferEnc + "]";
valueExMessage = valueExMessage.Replace('\r', ' ')
.Replace('\n', ' ').Replace('\0', ' ');
#endif
throw new MessageDataException(valueExMessage);
}
if (ch < 0) {
if (boundaryChecker.HasNewBodyPart) {
var msg = new Message();
int stackCount = boundaryChecker.BoundaryCount();
// Pop entries if needed to match the stack
#if DEBUG
if (multipartStack.Count < stackCount) {
throw new ArgumentException("multipartStack.Count (" +
multipartStack.Count + ") is less than " + stackCount);
}
#endif
if (leaf != null) {
if (bufferCount > 0) {
aw.Write(buffer, 0, bufferCount);
}
leaf.body = aw.ToArray();
// Clear for the next body
aw.Clear();
bufferCount = 0;
} else {
// Clear for the next body
bufferCount = 0;
aw.Clear();
}
while (multipartStack.Count > stackCount) {
multipartStack.RemoveAt(stackCount);
}
Message parentMessage = multipartStack[multipartStack.Count -
1].Message;
boundaryChecker.StartBodyPartHeaders();
MediaType ctype = parentMessage.ContentType;
bool parentIsDigest = ctype.SubType.Equals("digest") &&
ctype.IsMultipart;
ReadHeaders(stream, msg.headers, false);
msg.ProcessHeaders(true, parentIsDigest);
entry = new MessageStackEntry(msg);
// Add the body part to the multipart
// message's list of parts
parentMessage.Parts.Add(msg);
multipartStack.Add(entry);
aw.Clear();
ctype = msg.ContentType;
leaf = ctype.IsMultipart ? null : msg;
boundaryChecker.PushBoundary(entry.Boundary);
boundaryChecker.EndBodyPartHeaders();
currentTransform = MakeTransferEncoding(
boundaryChecker,
msg.transferEncoding,
ctype.TypeAndSubType.Equals("text/plain"));
} else {
// All body parts were read
if (leaf != null) {
if (bufferCount > 0) {
aw.Write(buffer, 0, bufferCount);
bufferCount = 0;
}
leaf.body = aw.ToArray();
}
return;
}
} else {
buffer[bufferCount++] = (byte)ch;
if (bufferCount >= bufferLength) {
aw.Write(buffer, 0, bufferCount);
bufferCount = 0;
}
}
}
}
}
protected override void WriteInlineType(ref ArrayWriter writer, Instruction instr)
{
writer.WriteUInt32(metadata.GetToken(instr.Operand).Raw);
}
public void Write()
{
uint codeSize = InitializeInstructionOffsets();
jitBody.MaxStack = keepMaxStack ? body.MaxStack : GetMaxStack();
jitBody.Options = 0;
if (body.InitLocals)
{
jitBody.Options |= 0x10;
}
if (body.Variables.Count > 0)
{
var local = new LocalSig(body.Variables.Select(var => var.Type).ToList());
jitBody.LocalVars = SignatureWriter.Write(metadata, local);
}
else
{
jitBody.LocalVars = new byte[0];
}
{
var newCode = new byte[codeSize];
var writer = new ArrayWriter(newCode);
uint _codeSize = WriteInstructions(ref writer);
Debug.Assert(codeSize == _codeSize);
jitBody.ILCode = newCode;
}
jitBody.EHs = new JITEHClause[exceptionHandlers.Count];
if (exceptionHandlers.Count > 0)
{
jitBody.Options |= 8;
for (int i = 0; i < exceptionHandlers.Count; i++)
{
ExceptionHandler eh = exceptionHandlers[i];
jitBody.EHs[i].Flags = (uint)eh.HandlerType;
uint tryStart = GetOffset(eh.TryStart);
uint tryEnd = GetOffset(eh.TryEnd);
jitBody.EHs[i].TryOffset = tryStart;
jitBody.EHs[i].TryLength = tryEnd - tryStart;
uint handlerStart = GetOffset(eh.HandlerStart);
uint handlerEnd = GetOffset(eh.HandlerEnd);
jitBody.EHs[i].HandlerOffset = handlerStart;
jitBody.EHs[i].HandlerLength = handlerEnd - handlerStart;
if (eh.HandlerType == ExceptionHandlerType.Catch)
{
uint token = metadata.GetToken(eh.CatchType).Raw;
if ((token & 0xff000000) == 0x1b000000)
{
jitBody.Options |= 0x80;
}
jitBody.EHs[i].ClassTokenOrFilterOffset = token;
}
else if (eh.HandlerType == ExceptionHandlerType.Filter)
{
jitBody.EHs[i].ClassTokenOrFilterOffset = GetOffset(eh.FilterStart);
}
}
}
}