public override void Close()
			{
				int num = 3;
				for (int i = 0; i < num; i++)
				{
					bool flag = i == num - 1;
					try
					{
						HeaderList headerList = new HeaderList();
						headerList.Add("content-type", this.contentType);
						headerList.Add("x-amz-acl", "public-read");
						this.s3OutputMethod.s3adaptor.put(this.s3OutputMethod.bucketName, this.s3key, new S3Content(this.ToArray()), headerList);
						break;
					}
					catch (WebException)
					{
						if (flag)
						{
							throw;
						}
					}
					catch (SoapException)
					{
						if (flag)
						{
							throw;
						}
					}
				}
				base.Close();
			}
		internal MimeMessage (ParserOptions options, IEnumerable<Header> headers)
		{
			addresses = new Dictionary<string, InternetAddressList> (icase);
			Headers = new HeaderList (options);

			// initialize our address lists
			foreach (var name in StandardAddressHeaders) {
				var list = new InternetAddressList ();
				list.Changed += InternetAddressListChanged;
				addresses.Add (name, list);
			}

			references = new MessageIdList ();
			references.Changed += ReferencesChanged;
			inreplyto = null;

			Headers.Changed += HeadersChanged;

			// add all of our message headers...
			foreach (var header in headers) {
				if (header.Field.StartsWith ("Content-", StringComparison.OrdinalIgnoreCase))
					continue;

				Headers.Add (header);
			}
		}
Exemple #3
0
        public void TestReplacingHeaders()
        {
            const string ReplacedContentType = "text/plain; charset=iso-8859-1; name=body.txt";
            const string ReplacedContentDisposition = "inline; filename=body.txt";
            const string ReplacedContentId = "<content.id.2@localhost>";
            var headers = new HeaderList ();

            headers.Add ("Content-Type", "text/plain");
            headers.Add ("Content-Disposition", "attachment");
            headers.Add ("Content-Id", "<content-id.1@localhost>");

            headers.Replace ("Content-Disposition", ReplacedContentDisposition);
            Assert.AreEqual (3, headers.Count, "Unexpected number of headers after replacing Content-Disposition.");
            Assert.AreEqual (ReplacedContentDisposition, headers["Content-Disposition"], "Content-Disposition has unexpected value after replacing it.");
            Assert.AreEqual (1, headers.IndexOf ("Content-Disposition"), "Replaced Content-Disposition not in the expected position.");

            headers.Replace ("Content-Type", ReplacedContentType);
            Assert.AreEqual (3, headers.Count, "Unexpected number of headers after replacing Content-Type.");
            Assert.AreEqual (ReplacedContentType, headers["Content-Type"], "Content-Type has unexpected value after replacing it.");
            Assert.AreEqual (0, headers.IndexOf ("Content-Type"), "Replaced Content-Type not in the expected position.");

            headers.Replace ("Content-Id", ReplacedContentId);
            Assert.AreEqual (3, headers.Count, "Unexpected number of headers after replacing Content-Id.");
            Assert.AreEqual (ReplacedContentId, headers["Content-Id"], "Content-Id has unexpected value after replacing it.");
            Assert.AreEqual (2, headers.IndexOf ("Content-Id"), "Replaced Content-Id not in the expected position.");
        }
	  protected AuthenticationBase()
	  {
	    _Params = new HeaderList();
	    _AuthParams = new HeaderList();
	    _CurrentStep = 0;
	    Reset();
	  }
Exemple #5
0
        /// <summary>
        /// Get the list of emails for a search
        /// </summary>
        /// <param name="args">The search condition followed by the header only and set as seen booleans</param>
        /// <returns>The list of mail message that match the search</returns>
        private List <MimeMessage> GetSearchResults(params object[] args)
        {
            List <MimeMessage> messageList = new List <MimeMessage>();
            IMailFolder        folder      = this.GetCurrentFolder();

            foreach (UniqueId uid in folder.Search((SearchQuery)args[0], default(CancellationToken)))
            {
                if ((bool)args[2])
                {
                    folder.AddFlags(uid, MessageFlags.Seen, true);
                }

                MimeMessage message = null;

                if ((bool)args[1])
                {
                    HeaderList headers = folder.GetHeaders(uid);
                    message = new MimeMessage(headers);
                }
                else
                {
                    message = folder.GetMessage(uid);
                }

                messageList.Add(message);
            }

            return(messageList);
        }
Exemple #6
0
        internal static bool ResubmitApprovedMessage(MessageItem messageItem, TransportMailItem transportMailItem, string approverAddress)
        {
            DateTime   utcNow     = DateTime.UtcNow;
            HeaderList headerList = (transportMailItem.RootPart != null) ? transportMailItem.RootPart.Headers : null;

            if (!ModerationHelper.RestoreOriginalMessage(messageItem, transportMailItem, TraceHelper.ModeratedTransportTracer, TraceHelper.MessageProbeActivityId))
            {
                return(false);
            }
            transportMailItem.RootPart.Headers.RemoveAll("X-MS-Exchange-Organization-Approval-Approved");
            TextHeader textHeader = (TextHeader)Header.Create("X-MS-Exchange-Organization-Approval-Approved");

            textHeader.Value = (string)transportMailItem.Recipients[0].Email;
            foreach (MailRecipient mailRecipient in transportMailItem.Recipients)
            {
                if (mailRecipient.Status == Status.Ready)
                {
                    textHeader.Value = (string)mailRecipient.Email;
                    break;
                }
            }
            transportMailItem.RootPart.Headers.AppendChild(textHeader);
            if (transportMailItem.RootPart.Headers.FindFirst("X-MS-Exchange-Organization-Moderation-SavedArrivalTime") == null)
            {
                Header header = transportMailItem.RootPart.Headers.FindFirst("X-MS-Exchange-Organization-OriginalArrivalTime");
                string value  = null;
                if (header != null)
                {
                    value = header.Value;
                }
                if (!string.IsNullOrEmpty(value))
                {
                    transportMailItem.RootPart.Headers.AppendChild(new AsciiTextHeader("X-MS-Exchange-Organization-Moderation-SavedArrivalTime", value));
                }
            }
            TextHeader textHeader2     = (TextHeader)Header.Create("X-Moderation-Data");
            ExDateTime?valueAsNullable = messageItem.GetValueAsNullable <ExDateTime>(MessageItemSchema.ApprovalDecisionTime);

            if (valueAsNullable != null)
            {
                textHeader2.Value = valueAsNullable.ToString();
                transportMailItem.RootPart.Headers.AppendChild(textHeader2);
            }
            if (headerList != null)
            {
                Header[] array = headerList.FindAll(HeaderId.Received);
                foreach (Header header2 in array)
                {
                    Header header3 = Header.Create(HeaderId.Received);
                    header2.CopyTo(header3);
                    transportMailItem.RootPart.Headers.PrependChild(header3);
                }
            }
            transportMailItem.RootPart.Headers.RemoveAll("X-MS-Exchange-Organization-OriginalArrivalTime");
            transportMailItem.RootPart.Headers.AppendChild(new AsciiTextHeader("X-MS-Exchange-Organization-OriginalArrivalTime", Util.FormatOrganizationalMessageArrivalTime(utcNow)));
            transportMailItem.UpdateDirectionalityAndScopeHeaders();
            transportMailItem.UpdateCachedHeaders();
            MessageTrackingLog.TrackReceiveForApprovalRelease(transportMailItem, approverAddress, messageItem.InternetMessageId);
            return(true);
        }
        public void TestHeaderParser()
        {
            var bytes = Encoding.ASCII.GetBytes("Header-1: value 1\r\nHeader-2: value 2\r\nHeader-3: value 3\r\n\r\n");

            using (var memory = new MemoryStream(bytes, false)) {
                try {
                    var    headers = HeaderList.Load(memory);
                    string value;

                    Assert.AreEqual(3, headers.Count, "Unexpected header count.");

                    value = headers["Header-1"];

                    Assert.AreEqual("value 1", value, "Unexpected header value.");

                    value = headers["Header-2"];

                    Assert.AreEqual("value 2", value, "Unexpected header value.");

                    value = headers["Header-3"];

                    Assert.AreEqual("value 3", value, "Unexpected header value.");
                } catch (Exception ex) {
                    Assert.Fail("Failed to parse headers: {0}", ex);
                }
            }
        }
Exemple #8
0
        public void TestRemovingHeaders()
        {
            var headers = new HeaderList();

            headers.Add("From", "sender@localhost");
            headers.Add("To", "first@localhost");
            headers.Add("To", "second@localhost");
            headers.Add("To", "third@localhost");
            headers.Add("To", "fourth@localhost");
            headers.Add("Cc", "carbon.copy@localhost");

            Assert.IsFalse(headers.IsReadOnly);
            Assert.IsFalse(headers.Contains(new Header(HeaderId.Received, "value")));
            Assert.AreEqual(-1, headers.IndexOf(new Header(HeaderId.Received, "value")));
            Assert.AreEqual(-1, headers.IndexOf("Received"));
            Assert.AreEqual(-1, headers.LastIndexOf(HeaderId.Received));
            Assert.AreEqual(null, headers[HeaderId.Received]);

            Assert.IsTrue(headers.Remove("Cc"));

            // try removing a header that no longer exists
            Assert.IsFalse(headers.Remove(new Header(HeaderId.Cc, "value")));
            Assert.IsFalse(headers.Remove(HeaderId.Cc));
            Assert.IsFalse(headers.Remove("Cc"));

            // removing this will change the result of headers[HeaderId.To]
            Assert.AreEqual("first@localhost", headers[HeaderId.To]);
            Assert.IsTrue(headers.Remove(HeaderId.To));
            Assert.AreEqual("second@localhost", headers[HeaderId.To]);
            Assert.IsTrue(headers.Remove("To"));
            Assert.AreEqual("third@localhost", headers[HeaderId.To]);
            headers.RemoveAt(headers.IndexOf("To"));
            Assert.AreEqual("fourth@localhost", headers[HeaderId.To]);
        }
Exemple #9
0
        /// <summary>
        /// Evaluates the node, using the variables provided in the <paramref name="Variables"/> collection.
        /// </summary>
        /// <param name="Arguments">Function arguments.</param>
        /// <param name="Variables">Variables collection.</param>
        /// <returns>Result.</returns>
        public override IElement Evaluate(IElement[] Arguments, Variables Variables)
        {
            Uri Url = new Uri(Arguments[0].AssociatedObjectValue?.ToString());
            List <KeyValuePair <string, string> > HeaderList = null;

            if (Arguments.Length > 1)
            {
                object Arg1 = Arguments[1].AssociatedObjectValue;

                if (Arg1 is IDictionary <string, IElement> Headers)
                {
                    HeaderList = new List <KeyValuePair <string, string> >();

                    foreach (KeyValuePair <string, IElement> P in Headers)
                    {
                        HeaderList.Add(new KeyValuePair <string, string>(P.Key, P.Value.AssociatedObjectValue?.ToString()));
                    }
                }
                else if (Arg1 is string Accept)
                {
                    HeaderList = new List <KeyValuePair <string, string> >()
                    {
                        new KeyValuePair <string, string>("Accept", Accept)
                    };
                }
                else
                {
                    throw new ScriptRuntimeException("Invalid second parameter to Get. Should be either an accept string, or an object with protocol-specific headers or options.", this);
                }
            }

            object Result = InternetContent.GetAsync(Url, HeaderList?.ToArray() ?? new KeyValuePair <string, string> [0]).Result;

            return(new ObjectValue(Result));
        }
Exemple #10
0
 internal static void SetProperty(HeaderList mimeHeaders, string name, string value)
 {
     mimeHeaders.RemoveAll(name);
     if (!string.IsNullOrEmpty(value))
     {
         mimeHeaders.AppendChild(new TextHeader(name, value));
     }
 }
Exemple #11
0
 private void Initialize(HttpMethod method)
 {
     Method = method;
     StatusLine.Clear();
     HeaderList.Clear();
     MessageBody = null;
     c           = TextStore.ReadChar();
 }
        public static bool IsInitiationMessage(EmailMessage message)
        {
            HeaderList headers = message.MimeDocument.RootPart.Headers;
            Header     header  = headers.FindFirst("X-MS-Exchange-Organization-Approval-Initiator");
            Header     header2 = headers.FindFirst("X-MS-Exchange-Organization-Approval-Allowed-Decision-Makers");

            return(header != null && header2 != null);
        }
Exemple #13
0
 public override byte[] GetHeader(params HttpHeader[] rewrites)
 {
     sb.Clear();
     sb.Append(StatusLine.ToString());
     HeaderList.Format(sb, rewrites);
     sb.Append("\r\n");
     return(Encoding.GetBytes(sb.ToString()));
 }
Exemple #14
0
		public HeaderEnumerator (HeaderList headers)
		{
			if (headers == null)
				throw new ArgumentNullException ("headers");
			
			iter = headers.GetIter ();
			this.headers = headers;
		}
Exemple #15
0
        private void AddUnparkedHeader(HeaderList headers, Guid messageId)
        {
            headers.RemoveAll("X-MS-Exchange-Calendar-Series-Instance-Unparked");
            Header header = Header.Create("X-MS-Exchange-Calendar-Series-Instance-Unparked");

            header.Value = messageId.ToString();
            headers.AppendChild(header);
        }
Exemple #16
0
		public S3Response put(string bucket, string key, S3Content content, HeaderList headers)
		{
			WebRequest webRequest = this.BuildWebRequest("PUT", bucket + "/" + this.EncodeKeyForSignature(key), headers);
			webRequest.ContentLength = (long)content.Bytes.Length;
			Stream requestStream = webRequest.GetRequestStream();
			requestStream.Write(content.Bytes, 0, content.Bytes.Length);
			requestStream.Close();
			return S3Response.Execute(webRequest);
		}
        private void SendApprovalRequest(ApprovalRequestWriter writer, ICollection <RoutingAddress> p1DecisionMakers, CultureInfo cultureInfo, string messageId, byte[] corelationBlob)
        {
            IList <RoutingAddress> decisionMakers = this.initiationMessage.DecisionMakers;

            byte[] conversationIndex = this.initiationMessageItem.ConversationIndex;
            (string)this.initiationMessage.Requestor;
            using (MessageItemApprovalRequest messageItemApprovalRequest = this.requestCreate(this.mbxTransportMailItem))
            {
                messageItemApprovalRequest.SetSender(this.approvalRequestSender);
                foreach (RoutingAddress routingAddress in decisionMakers)
                {
                    bool flag = p1DecisionMakers == null || p1DecisionMakers.Contains(routingAddress);
                    messageItemApprovalRequest.AddRecipient(routingAddress, flag);
                    InitiationProcessor.diag.TraceDebug <RoutingAddress, bool>(0L, "Added recipient '{0}' with promote to P1={1}.", routingAddress, flag);
                }
                CultureInfo cultureInfo2;
                if (!writer.WriteSubjectAndBody(messageItemApprovalRequest, cultureInfo, out cultureInfo2))
                {
                    InitiationProcessor.diag.TraceError <ApprovalRequestWriter>(0L, "Approval request body cannot be written with writer {0}", writer);
                }
                messageItemApprovalRequest.ApprovalRequestor = this.initiationMessage.Requestor;
                messageItemApprovalRequest.MessageItem[ItemSchema.NormalizedSubject] = this.initiationMessageItem.ConversationTopic;
                messageItemApprovalRequest.MessageItem.Importance = this.initiationMessageItem.Importance;
                messageItemApprovalRequest.MessageItem.References = InitiationProcessor.ConstructApprovalRequestReferences(this.initiationMessageItem);
                ConversationIndex o = ConversationIndex.CreateFromParent(conversationIndex);
                if (!ConversationIndex.Empty.Equals(o))
                {
                    messageItemApprovalRequest.MessageItem.ConversationIndex = o.ToByteArray();
                }
                if (cultureInfo2 != null)
                {
                    InitiationProcessor.diag.TraceDebug <CultureInfo>(0L, "Approval request written in {0}", cultureInfo2);
                    messageItemApprovalRequest.MessageItem[MessageItemSchema.MessageLocaleId] = cultureInfo2.LCID;
                }
                foreach (Attachment attachment in this.initiationMessage.EmailMessage.Attachments)
                {
                    messageItemApprovalRequest.AddAttachment(attachment, this.mbxTransportMailItem.ADRecipientCache.ADSession);
                }
                if (this.initiationMessage.EmailMessage.RootPart != null && this.initiationMessage.EmailMessage.RootPart.Headers != null)
                {
                    HeaderList headers = this.initiationMessage.EmailMessage.RootPart.Headers;
                    Header[]   array   = headers.FindAll("X-MS-Exchange-Inbox-Rules-Loop");
                    if (array != null && array.Length > 0)
                    {
                        string[] array2 = new string[array.Length];
                        for (int i = 0; i < array.Length; i++)
                        {
                            array2[i] = array[i].Value;
                        }
                        messageItemApprovalRequest.MessageItem.SafeSetProperty(MessageItemSchema.XLoop, array2);
                    }
                }
                InitiationProcessor.AddVotingToApprovalRequest(messageItemApprovalRequest, this.initiationMessage.VotingActions, cultureInfo2);
                messageItemApprovalRequest.Send(messageId, corelationBlob, this.mbxTransportMailItem);
            }
        }
        public bool IsHeaderExist(string Name, bool throwException = true)
        {
            bool exist = HeaderList.Any(x => x.Name == Name);

            if (exist && throwException)
            {
                throw new HttpHandlerExceptiosn($"Global Param: {Name} is already declared", "Encabezados", ExceptionError.Internal_InconsistencyData);
            }
            return(exist);
        }
        public void RemoveParameter(string ParameterName)
        {
            if (!IsHeaderExist(ParameterName, false))
            {
                throw new HttpHandlerExceptiosn($"Parameter : {ParameterName} not found", "Encabezados", ExceptionError.Internal_InconsistencyData);
            }
            var removeItem = HeaderList.First(x => x.Name == ParameterName);

            HeaderList.Remove(removeItem);
        }
Exemple #20
0
        internal static string GetProperty(HeaderList mimeHeaders, string name)
        {
            Header header = mimeHeaders.FindFirst(name);

            if (header == null || header.Value == null)
            {
                return(null);
            }
            return(header.Value);
        }
        public HeaderEnumerator(HeaderList headers)
        {
            if (headers == null)
            {
                throw new ArgumentNullException("headers");
            }

            iter         = headers.GetIter();
            this.headers = headers;
        }
Exemple #22
0
        protected override void Execute(CodeActivityContext context)
        {
            var                     csvPath    = CSVPath.Get(context);
            var                     isHeader   = IsHeader.Get(context);
            char                    delimeter  = Delimeter.Get(context);
            List <string>           headerList = HeaderList.Get(context);
            CSVToDataTableConverter converter  = new CSVToDataTableConverter(csvPath, isHeader, headerList, delimeter);

            ResultListItems.Set(context, converter.getDataTableCSVFile());
        }
Exemple #23
0
        private void decompress_Mode(byte[] buffer, byte mode, ushort windowSize)
        {
            CircularBuffer circularBuffer = new CircularBuffer(windowSize);
            string         outputPath     = FilePath + ".OUT";

            using (BinaryWriter writer = new BinaryWriter(new FileStream(outputPath, FileMode.Create)))
            {
                writer.Write(buffer, 0, 1);
                circularBuffer.AddData(new byte[] { buffer[0] });

                for (int i = 1; i < buffer.Length; i++)
                {
                    bool[] flags = GetFlags(buffer[i]);

                    for (int j = 7; j >= 0; j--)
                    {
                        if (flags[j])
                        {
                            byte[] wordBytes = new byte[2];
                            Array.Copy(buffer, ++i, wordBytes, 0, 2);
                            CompressedWord word   = new CompressedWord(wordBytes, mode);
                            byte[]         result = circularBuffer.GetData(word.Offset, word.Length);
                            i++;

                            writer.Write(result, 0, result.Length);
                        }
                        else
                        {
                            if (i < buffer.Length - 1)
                            {
                                writer.Write(buffer, ++i, 1);
                                circularBuffer.AddData(new byte[] { buffer[i] });
                            }
                        }
                        if (writer.BaseStream.Length >= LZSSHeader.UncompressedSize)
                        {
                            break;
                        }
                    }
                    if (writer.BaseStream.Length >= LZSSHeader.UncompressedSize)
                    {
                        break;
                    }
                }
            }
            DecompressedFile = HeaderList.GetTypeFromFile(outputPath);

            string headerPath = Path.Combine(Path.GetDirectoryName(FilePath), Path.GetFileName(FilePath) + ".HEADER");

            using (BinaryWriter writer = new BinaryWriter(new FileStream(headerPath, FileMode.Create)))
            {
                writer.Write(LZSSHeader.GetBytes());
            }
            HeaderFile = new BaseFile(headerPath);
        }
Exemple #24
0
        public void CanAddCustomerHeader()
        {
            // Arrange
            Request request = Session.Request(HeaderListUrl);

            // Act
            HeaderList headers = request.Header("X-Ramone", "123").Get <HeaderList>().Body;

            // Assert
            Assert.IsTrue(headers.Any(h => h == "X-Ramone: 123"), "Must contain customer header");
        }
        private static Guid GetAddressBookPolicy(HeaderList headers)
        {
            ArgumentValidator.ThrowIfNull("headers", headers);
            Header header = headers.FindFirst("X-MS-Exchange-ABP-GUID");

            if (header != null)
            {
                return(StoreDriverDelivery.GetHeaderValueAsGuid(header));
            }
            return(Guid.Empty);
        }
        private static Guid GetGal(HeaderList headers)
        {
            ArgumentValidator.ThrowIfNull("headers", headers);
            Header header = headers.FindFirst("X-MS-Exchange-Forest-GAL-Scope");

            if (header != null)
            {
                return(StoreDriverDelivery.GetHeaderValueAsGuid(header));
            }
            return(Guid.Empty);
        }
Exemple #27
0
        private void CacheInstanceId(HeaderList headers, StoreId instanceCalendarItemId)
        {
            Header header = headers.FindFirst("X-MS-Exchange-Calendar-Series-Instance-Calendar-Item-Id");

            if (header == null)
            {
                header = Header.Create("X-MS-Exchange-Calendar-Series-Instance-Calendar-Item-Id");
                headers.AppendChild(header);
            }
            header.Value = StoreId.GetStoreObjectId(instanceCalendarItemId).ToBase64String();
        }
        /// <summary>
        /// Creates an empty mail merge message.
        /// </summary>
        public MailMergeMessage()
        {
            Config.IgnoreIllegalRecipientAddresses = true;
            Config.Priority = MessagePriority.Normal;
            Headers         = new HeaderList();
            Subject         = string.Empty;

            SmartFormatter = new MailSmartFormatter(this);
            // Smart.Format("{Name:choose(null|):N/A|empty|{Name}}", variable), where abc.Name NULL, string.Emtpy or a string

            MailMergeAddresses = new MailMergeAddressCollection(this);
        }
        public object Get()
        {
            HeaderList list = new HeaderList();
              NameValueCollection headers = HttpContext.Current.Request.Headers;

              foreach (string header in headers.AllKeys)
              {
            list.Add(string.Format("{0}: {1}", header, headers[header]));
              }

              return list;
        }
Exemple #30
0
        public object Get()
        {
            HeaderList          list    = new HeaderList();
            NameValueCollection headers = HttpContext.Current.Request.Headers;

            foreach (string header in headers.AllKeys)
            {
                list.Add(string.Format("{0}: {1}", header, headers[header]));
            }

            return(list);
        }
        internal static bool TryGetFromHeader(HeaderList mimeHeader, out EmailMessageHash result)
        {
            result = null;
            string property = XHeaderUtils.GetProperty(mimeHeader, "X-MS-Exchange-Forest-EmailMessageHash");

            if (string.IsNullOrEmpty(property))
            {
                return(false);
            }
            result = new EmailMessageHash(property);
            return(true);
        }
Exemple #32
0
        internal static string GetMessageId(this HeaderList headerCollection)
        {
            var messageIdHeaderEntry = headerCollection["Message-ID"];

            if (string.IsNullOrEmpty(messageIdHeaderEntry))
            {
                messageIdHeaderEntry = headerCollection.ToHMSGID();
                return(messageIdHeaderEntry);
            }

            return(messageIdHeaderEntry);
        }
Exemple #33
0
        private static void AddExchangeOrganizationBccHeader(List <MimeRecipient> bccRecipientList, TransportMailItem mailItem)
        {
            AddressHeader addressHeader = new AddressHeader("X-MS-Exchange-Organization-BCC");

            foreach (MimeRecipient newChild in bccRecipientList)
            {
                addressHeader.AppendChild(newChild);
            }
            HeaderList headers = mailItem.Message.MimeDocument.RootPart.Headers;

            headers.AppendChild(addressHeader);
        }
        public void TestSerializedContent()
        {
            const string expected  = "Reporting-MTA: dns; mm1\nArrival-Date: Mon, 29 Jul 1996 02:12:50 -0700\n\nFinal-Recipient: RFC822; [email protected]\nAction: failed\nDiagnostic-Code: X-LOCAL; 500 (err.nosuchuser)\n\n";
            var          mds       = new MessageDeliveryStatus();
            var          recipient = new HeaderList();
            var          status    = new HeaderList();

            status.Add("Reporting-MTA", "dns; mm1");
            status.Add("Arrival-Date", DateUtils.FormatDate(new DateTimeOffset(1996, 7, 29, 2, 12, 50, new TimeSpan(-7, 0, 0))));

            recipient.Add("Final-Recipient", "RFC822; [email protected]");
            recipient.Add("Action", "failed");
            recipient.Add("Diagnostic-Code", "X-LOCAL; 500 (err.nosuchuser)");

            mds.StatusGroups.Add(status);
            mds.StatusGroups.Add(recipient);

            Assert.IsTrue(mds.StatusGroups.Contains(status), "Expected the groups to contain the per-message status group.");
            Assert.IsTrue(mds.StatusGroups.Contains(recipient), "Expected the groups to contain the recipient status group.");
            Assert.IsFalse(mds.StatusGroups.IsReadOnly, "The status groups should not be read-only.");

            using (var memory = new MemoryStream()) {
                mds.ContentObject.DecodeTo(memory);

                var text = Encoding.ASCII.GetString(memory.GetBuffer(), 0, (int)memory.Length).Replace("\r\n", "\n");
                Assert.AreEqual(expected, text);
            }

            var dummy = new HeaderList();

            dummy.Add("Dummy-Header", "dummy value");

            mds.StatusGroups.Add(dummy);

            Assert.IsTrue(mds.StatusGroups.Contains(dummy), "Expected the groups to contain the dummy group.");
            Assert.IsTrue(mds.StatusGroups.Remove(dummy), "Expected removal of the dummy group to be successful.");

            var expectedContent = mds.ContentObject;

            dummy.Add("Bogus-Header", "bogus value");

            Assert.AreEqual(expectedContent, mds.ContentObject, "The content should not have changed since the dummy group has been removed.");

            mds.StatusGroups.Clear();

            using (var memory = new MemoryStream()) {
                mds.ContentObject.DecodeTo(memory);

                var text = Encoding.ASCII.GetString(memory.GetBuffer(), 0, (int)memory.Length).Replace("\r\n", "\n");

                Assert.AreEqual(string.Empty, text);
            }
        }
		public void TestSerializedContent ()
		{
			const string expected = "Reporting-MTA: dns; mm1\nArrival-Date: Mon, 29 Jul 1996 02:12:50 -0700\n\nFinal-Recipient: RFC822; [email protected]\nAction: failed\nDiagnostic-Code: X-LOCAL; 500 (err.nosuchuser)\n\n";
			var mds = new MessageDeliveryStatus ();
			var recipient = new HeaderList ();
			var status = new HeaderList ();

			status.Add ("Reporting-MTA", "dns; mm1");
			status.Add ("Arrival-Date", DateUtils.FormatDate (new DateTimeOffset (1996, 7, 29, 2, 12, 50, new TimeSpan (-7, 0, 0))));

			recipient.Add ("Final-Recipient", "RFC822; [email protected]");
			recipient.Add ("Action", "failed");
			recipient.Add ("Diagnostic-Code", "X-LOCAL; 500 (err.nosuchuser)");

			mds.StatusGroups.Add (status);
			mds.StatusGroups.Add (recipient);

			Assert.IsTrue (mds.StatusGroups.Contains (status), "Expected the groups to contain the per-message status group.");
			Assert.IsTrue (mds.StatusGroups.Contains (recipient), "Expected the groups to contain the recipient status group.");
			Assert.IsFalse (mds.StatusGroups.IsReadOnly, "The status groups should not be read-only.");

			using (var memory = new MemoryStream ()) {
				mds.ContentObject.DecodeTo (memory);

				var text = Encoding.ASCII.GetString (memory.GetBuffer (), 0, (int) memory.Length).Replace ("\r\n", "\n");
				Assert.AreEqual (expected, text);
			}

			var dummy = new HeaderList ();
			dummy.Add ("Dummy-Header", "dummy value");

			mds.StatusGroups.Add (dummy);

			Assert.IsTrue (mds.StatusGroups.Contains (dummy), "Expected the groups to contain the dummy group.");
			Assert.IsTrue (mds.StatusGroups.Remove (dummy), "Expected removal of the dummy group to be successful.");

			var expectedContent = mds.ContentObject;

			dummy.Add ("Bogus-Header", "bogus value");

			Assert.AreEqual (expectedContent, mds.ContentObject, "The content should not have changed since the dummy group has been removed.");

			mds.StatusGroups.Clear ();

			using (var memory = new MemoryStream ()) {
				mds.ContentObject.DecodeTo (memory);

				var text = Encoding.ASCII.GetString (memory.GetBuffer (), 0, (int) memory.Length).Replace ("\r\n", "\n");

				Assert.AreEqual (string.Empty, text);
			}
		}
Exemple #36
0
        public void TestReplacingHeaders()
        {
            const string ReplacedContentType        = "text/plain; charset=iso-8859-1; name=body.txt";
            const string ReplacedContentDisposition = "inline; filename=body.txt";
            const string ReplacedContentLocation    = "http://www.example.com/location";
            const string ReplacedContentId          = "<content.id.2@localhost>";
            var          headers = new HeaderList();

            headers.Add(HeaderId.ContentId, "<content-id.1@localhost>");
            headers.Add("Content-Location", "http://www.location.com");
            headers.Insert(0, HeaderId.ContentDisposition, "attachment");
            headers.Insert(0, "Content-Type", "text/plain");

            Assert.IsTrue(headers.Contains(HeaderId.ContentType), "Expected the list of headers to contain HeaderId.ContentType.");
            Assert.IsTrue(headers.Contains("Content-Type"), "Expected the list of headers to contain a Content-Type header.");
            Assert.AreEqual(0, headers.LastIndexOf(HeaderId.ContentType), "Expected the Content-Type header to be the first header.");

            headers.Replace("Content-Disposition", ReplacedContentDisposition);
            Assert.AreEqual(4, headers.Count, "Unexpected number of headers after replacing Content-Disposition.");
            Assert.AreEqual(ReplacedContentDisposition, headers["Content-Disposition"], "Content-Disposition has unexpected value after replacing it.");
            Assert.AreEqual(1, headers.IndexOf("Content-Disposition"), "Replaced Content-Disposition not in the expected position.");

            headers.Replace(HeaderId.ContentType, ReplacedContentType);
            Assert.AreEqual(4, headers.Count, "Unexpected number of headers after replacing Content-Type.");
            Assert.AreEqual(ReplacedContentType, headers["Content-Type"], "Content-Type has unexpected value after replacing it.");
            Assert.AreEqual(0, headers.IndexOf("Content-Type"), "Replaced Content-Type not in the expected position.");

            headers.Replace(HeaderId.ContentId, Encoding.UTF8, ReplacedContentId);
            Assert.AreEqual(4, headers.Count, "Unexpected number of headers after replacing Content-Id.");
            Assert.AreEqual(ReplacedContentId, headers["Content-Id"], "Content-Id has unexpected value after replacing it.");
            Assert.AreEqual(2, headers.IndexOf("Content-Id"), "Replaced Content-Id not in the expected position.");

            headers.Replace("Content-Location", Encoding.UTF8, ReplacedContentLocation);
            Assert.AreEqual(4, headers.Count, "Unexpected number of headers after replacing Content-Location.");
            Assert.AreEqual(ReplacedContentLocation, headers["Content-Location"], "Content-Location has unexpected value after replacing it.");
            Assert.AreEqual(3, headers.IndexOf("Content-Location"), "Replaced Content-Location not in the expected position.");

            headers.RemoveAll("Content-Location");
            Assert.AreEqual(3, headers.Count, "Unexpected number of headers after removing Content-Location.");

            headers.Clear();

            headers.Add(HeaderId.Received, "received 1");
            headers.Add(HeaderId.Received, "received 2");
            headers.Add(HeaderId.Received, "received 3");
            headers.Add(HeaderId.ReturnPath, "return-path");

            headers[0] = new Header(HeaderId.ReturnPath, "new return-path");
            Assert.AreEqual("new return-path", headers[HeaderId.ReturnPath]);
            headers[0] = new Header(HeaderId.Received, "new received");
            Assert.AreEqual("new received", headers[HeaderId.Received]);
        }
        public void WhenSendingRequestItPassesUserAgent()
        {
            // Arrange
            Session.UserAgent = "AgentTest/007";
            Request req = Session.Request(HeaderListUrl);

            // Act
            HeaderList headers = req.Get <HeaderList>().Body;

            // Assert
            Assert.IsNotNull(headers);
            Assert.IsTrue(headers.Exists(h => h == "User-Agent: AgentTest/007"));
        }
Exemple #38
0
        public void CanSetTypedAcceptHeaderWithQValueFromString()
        {
            // Act
            var request = AcceptSession.Bind(HeaderListUrl).Accept <HeaderList>("application/xml", 0.34);

            using (var r = request.Get())
            {
                HeaderList headers = r.Body;

                // Assert
                Assert.IsTrue(headers.Any(h => h == "Accept: application/xml; q=0.34"), "Must contain Accept header with q-value");
            }
        }
Exemple #39
0
		/// <summary>
		/// Initializes a new instance of the <see cref="MimeKit.MimeEntity"/> class
		/// based on the <see cref="MimeEntityConstructorInfo"/>.
		/// </summary>
		/// <remarks>
		/// Custom <see cref="MimeEntity"/> subclasses MUST implement this constructor
		/// in order to register it using <see cref="ParserOptions.RegisterMimeType"/>.
		/// </remarks>
		/// <param name="entity">Information used by the constructor.</param>
		protected MimeEntity (MimeEntityConstructorInfo entity)
		{
			if (entity == null)
				throw new ArgumentNullException ("entity");

			Headers = new HeaderList (entity.ParserOptions);
			ContentType = entity.ContentType;

			ContentType.Changed += ContentTypeChanged;
			Headers.Changed += HeadersChanged;

			foreach (var header in entity.Headers) {
				if (entity.IsTopLevel && !header.Field.StartsWith ("Content-", StringComparison.OrdinalIgnoreCase))
					continue;

				Headers.Add (header);
			}
		}
Exemple #40
0
		public void TestReplacingMultipleHeaders ()
		{
			const string CombinedRecpients = "first@localhost, second@localhost, third@localhost";
			var headers = new HeaderList ();

			headers.Add ("From", "sender@localhost");
			headers.Add ("To", "first@localhost");
			headers.Add ("To", "second@localhost");
			headers.Add ("To", "third@localhost");
			headers.Add ("Cc", "carbon.copy@localhost");

			headers.Replace ("To", CombinedRecpients);
			Assert.AreEqual (3, headers.Count, "Unexpected number of headers after replacing To header.");
			Assert.AreEqual (CombinedRecpients, headers["To"], "To header has unexpected value after being replaced.");
			Assert.AreEqual (1, headers.IndexOf ("To"), "Replaced To header not in the expected position.");
			Assert.AreEqual (0, headers.IndexOf ("From"), "From header not in the expected position.");
			Assert.AreEqual (2, headers.IndexOf ("Cc"), "Cc header not in the expected position.");
		}
		public void SetHeaders(HeaderList AHeaders) {
			string S = "";
			if (_Authentication != null) {
				S = _Authentication.Authentication();
				if (S.Length > 0) {
					AHeaders.Values("Proxy-Authentication", S);
				}
			} else {
				if (_BasicByDefault) {
					_Authentication = new BasicAuthentication();
					_Authentication.UserName = _UserName;
					_Authentication.Password = _Password;
					S = _Authentication.Authentication();
					if (S.Length > 0) {
						AHeaders.Values("Proxy-Authentication", S);
					}
				}
			}
		}
Exemple #42
0
		public void TestReplacingHeaders ()
		{
			const string ReplacedContentType = "text/plain; charset=iso-8859-1; name=body.txt";
			const string ReplacedContentDisposition = "inline; filename=body.txt";
			const string ReplacedContentLocation = "http://www.example.com/location";
			const string ReplacedContentId = "<content.id.2@localhost>";
			var headers = new HeaderList ();

			headers.Add (HeaderId.ContentId, "<content-id.1@localhost>");
			headers.Add ("Content-Location", "http://www.location.com");
			headers.Insert (0, HeaderId.ContentDisposition, "attachment");
			headers.Insert (0, "Content-Type", "text/plain");

			Assert.IsTrue (headers.Contains (HeaderId.ContentType), "Expected the list of headers to contain HeaderId.ContentType.");
			Assert.IsTrue (headers.Contains ("Content-Type"), "Expected the list of headers to contain a Content-Type header.");
			Assert.AreEqual (0, headers.LastIndexOf (HeaderId.ContentType), "Expected the Content-Type header to be the first header.");

			headers.Replace ("Content-Disposition", ReplacedContentDisposition);
			Assert.AreEqual (4, headers.Count, "Unexpected number of headers after replacing Content-Disposition.");
			Assert.AreEqual (ReplacedContentDisposition, headers["Content-Disposition"], "Content-Disposition has unexpected value after replacing it.");
			Assert.AreEqual (1, headers.IndexOf ("Content-Disposition"), "Replaced Content-Disposition not in the expected position.");

			headers.Replace (HeaderId.ContentType, ReplacedContentType);
			Assert.AreEqual (4, headers.Count, "Unexpected number of headers after replacing Content-Type.");
			Assert.AreEqual (ReplacedContentType, headers["Content-Type"], "Content-Type has unexpected value after replacing it.");
			Assert.AreEqual (0, headers.IndexOf ("Content-Type"), "Replaced Content-Type not in the expected position.");

			headers.Replace (HeaderId.ContentId, Encoding.UTF8, ReplacedContentId);
			Assert.AreEqual (4, headers.Count, "Unexpected number of headers after replacing Content-Id.");
			Assert.AreEqual (ReplacedContentId, headers["Content-Id"], "Content-Id has unexpected value after replacing it.");
			Assert.AreEqual (2, headers.IndexOf ("Content-Id"), "Replaced Content-Id not in the expected position.");

			headers.Replace ("Content-Location", Encoding.UTF8, ReplacedContentLocation);
			Assert.AreEqual (4, headers.Count, "Unexpected number of headers after replacing Content-Location.");
			Assert.AreEqual (ReplacedContentLocation, headers["Content-Location"], "Content-Location has unexpected value after replacing it.");
			Assert.AreEqual (3, headers.IndexOf ("Content-Location"), "Replaced Content-Location not in the expected position.");

			headers.RemoveAll ("Content-Location");
			Assert.AreEqual (3, headers.Count, "Unexpected number of headers after removing Content-Location.");
		}
        /// <summary>
        /// Init components.
        /// </summary>
        private void _initializeComponents()
        {
            VBox MainContent = new VBox()
            {
                Margin = 0
            };

            // Info window
            InfoBox MainInfoBox = new InfoBox(Director.Properties.Resources.DefaultServerHeaders, DirectorImages.SETTINGS_IMAGE);
            MainContent.PackStart(MainInfoBox);

            // Add header list
            HeaderControl = new HeaderList(ActiveServer.DefaultHeaders)
            {
                BackgroundColor = Colors.White
            };
            MainContent.PackStart(HeaderControl, expand: true, fill: true);

            // Close button
            Buttons.Add(new DialogButton(Director.Properties.Resources.Confirm, Command.Ok));

            // Set content
            Content = MainContent;
        }
		public Stream ReadFile(string relativePath)
		{
			string path = this.GetPath(relativePath);
			HeaderList headers = new HeaderList();
			return this.s3adaptor.getStream(this.bucketName, path, headers);
		}
		public EntityHeaderInfo() {
			_CustomHeaders = new HeaderList();
			_RawHeaders = new HeaderList();
			_RawHeaders.FoldLength = 1024;
			Clear();
		}
Exemple #46
0
        /// <summary>
        /// Get the headers of the messages within the specified range.
        /// </summary>
        /// <remarks>
        /// Gets the headers of the messages within the specified range.
        /// </remarks>
        /// <returns>The headers of the messages within the specified range.</returns>
        /// <param name="startIndex">The index of the first message to get.</param>
        /// <param name="count">The number of messages to get.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <exception cref="System.ArgumentOutOfRangeException">
        /// <paramref name="startIndex"/> and <paramref name="count"/> do not specify
        /// a valid range of messages.
        /// </exception>
        /// <exception cref="System.ObjectDisposedException">
        /// The <see cref="Pop3Client"/> has been disposed.
        /// </exception>
        /// <exception cref="InvalidOperationException">
        /// The <see cref="Pop3Client"/> is not connected.
        /// </exception>
        /// <exception cref="System.UnauthorizedAccessException">
        /// The <see cref="Pop3Client"/> is not authenticated.
        /// </exception>
        /// <exception cref="System.NotSupportedException">
        /// The POP3 server does not support the UIDL extension.
        /// </exception>
        /// <exception cref="System.OperationCanceledException">
        /// The operation was canceled via the cancellation token.
        /// </exception>
        /// <exception cref="System.IO.IOException">
        /// An I/O error occurred.
        /// </exception>
        /// <exception cref="Pop3CommandException">
        /// The POP3 command failed.
        /// </exception>
        /// <exception cref="Pop3ProtocolException">
        /// A POP3 protocol error occurred.
        /// </exception>
        public override IList<HeaderList> GetMessageHeaders(int startIndex, int count, CancellationToken cancellationToken = default (CancellationToken))
        {
            if (startIndex < 0 || startIndex >= total)
                throw new ArgumentOutOfRangeException ("startIndex");

            if (count < 0 || count > (total - startIndex))
                throw new ArgumentOutOfRangeException ("count");

            CheckDisposed ();
            CheckConnected ();

            if (engine.State != Pop3EngineState.Transaction)
                throw new UnauthorizedAccessException ();

            if (count == 0)
                return new HeaderList[0];

            var seqids = new int[count];

            for (int i = 0; i < count; i++)
                seqids[i] = startIndex + i + 1;

            var messages = GetMessagesForSequenceIds (seqids, true, cancellationToken);
            var headers = new HeaderList[messages.Count];

            for (int i = 0; i < headers.Length; i++)
                headers[i] = messages[i].Headers;

            return headers;
        }
Exemple #47
0
        /// <summary>
        /// Get the headers for the specified messages.
        /// </summary>
        /// <remarks>
        /// Gets the headers for the specified messages.
        /// </remarks>
        /// <returns>The headers for the specified messages.</returns>
        /// <param name="uids">The UIDs of the messages.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <exception cref="System.ArgumentNullException">
        /// <paramref name="uids"/> is <c>null</c>.
        /// </exception>
        /// <exception cref="System.ArgumentException">
        /// <para>One or more of the <paramref name="uids"/> are invalid.</para>
        /// <para>-or-</para>
        /// <para>No uids were specified.</para>
        /// </exception>
        /// <exception cref="System.ObjectDisposedException">
        /// The <see cref="Pop3Client"/> has been disposed.
        /// </exception>
        /// <exception cref="InvalidOperationException">
        /// The <see cref="Pop3Client"/> is not connected.
        /// </exception>
        /// <exception cref="System.UnauthorizedAccessException">
        /// The <see cref="Pop3Client"/> is not authenticated.
        /// </exception>
        /// <exception cref="System.NotSupportedException">
        /// The POP3 server does not support the UIDL extension.
        /// </exception>
        /// <exception cref="System.OperationCanceledException">
        /// The operation was canceled via the cancellation token.
        /// </exception>
        /// <exception cref="System.IO.IOException">
        /// An I/O error occurred.
        /// </exception>
        /// <exception cref="Pop3CommandException">
        /// The POP3 command failed.
        /// </exception>
        /// <exception cref="Pop3ProtocolException">
        /// A POP3 protocol error occurred.
        /// </exception>
        public override IList<HeaderList> GetMessageHeaders(IList<string> uids, CancellationToken cancellationToken = default (CancellationToken))
        {
            if (uids == null)
                throw new ArgumentNullException ("uids");

            if (uids.Count == 0)
                throw new ArgumentException ("No uids specified.", "uids");

            CheckDisposed ();
            CheckConnected ();

            if (engine.State != Pop3EngineState.Transaction)
                throw new UnauthorizedAccessException ();

            var seqids = new int[uids.Count];

            for (int i = 0; i < uids.Count; i++) {
                int seqid;

                if (!dict.TryGetValue (uids[i], out seqid))
                    throw new ArgumentException ("One or more of the uids is invalid.", "uids");

                seqids[i] = seqid;
            }

            var messages = GetMessagesForSequenceIds (seqids, true, cancellationToken);
            var headers = new HeaderList[messages.Count];

            for (int i = 0; i < headers.Length; i++)
                headers[i] = messages[i].Headers;

            return headers;
        }
Exemple #48
0
		public void TestArgumentExceptions ()
		{
			var list = new HeaderList ();
			Header header;
			string value;

			// Add
			Assert.Throws<ArgumentNullException> (() => list.Add (null));
			Assert.Throws<ArgumentOutOfRangeException> (() => list.Add (HeaderId.Unknown, "value"));
			Assert.Throws<ArgumentNullException> (() => list.Add (HeaderId.AdHoc, null));
			Assert.Throws<ArgumentNullException> (() => list.Add (null, "value"));
			Assert.Throws<ArgumentNullException> (() => list.Add ("field", null));
			Assert.Throws<ArgumentOutOfRangeException> (() => list.Add (HeaderId.Unknown, Encoding.UTF8, "value"));
			Assert.Throws<ArgumentNullException> (() => list.Add (HeaderId.AdHoc, null, "value"));
			Assert.Throws<ArgumentNullException> (() => list.Add (HeaderId.AdHoc, Encoding.UTF8, null));
			Assert.Throws<ArgumentNullException> (() => list.Add (null, Encoding.UTF8, "value"));
			Assert.Throws<ArgumentNullException> (() => list.Add ("field", null, "value"));
			Assert.Throws<ArgumentNullException> (() => list.Add ("field", Encoding.UTF8, null));

			// Contains
			Assert.Throws<ArgumentOutOfRangeException> (() => list.Contains (HeaderId.Unknown));
			Assert.Throws<ArgumentNullException> (() => list.Contains ((Header) null));
			Assert.Throws<ArgumentNullException> (() => list.Contains ((string) null));

			// CopyTo
			Assert.Throws<ArgumentOutOfRangeException> (() => list.CopyTo (new Header[0], -1));
			Assert.Throws<ArgumentNullException> (() => list.CopyTo (null, 0));

			// IndexOf
			Assert.Throws<ArgumentOutOfRangeException> (() => list.IndexOf (HeaderId.Unknown));
			Assert.Throws<ArgumentNullException> (() => list.IndexOf ((Header) null));
			Assert.Throws<ArgumentNullException> (() => list.IndexOf ((string) null));

			// Insert
			list.Add ("field", "value");
			Assert.Throws<ArgumentOutOfRangeException> (() => list.Insert (-1, new Header (HeaderId.AdHoc, "value")));
			Assert.Throws<ArgumentOutOfRangeException> (() => list.Insert (-1, HeaderId.AdHoc, Encoding.UTF8, "value"));
			Assert.Throws<ArgumentOutOfRangeException> (() => list.Insert (-1, "field", Encoding.UTF8, "value"));
			Assert.Throws<ArgumentOutOfRangeException> (() => list.Insert (-1, HeaderId.AdHoc, "value"));
			Assert.Throws<ArgumentOutOfRangeException> (() => list.Insert (-1, "field", "value"));
			Assert.Throws<ArgumentOutOfRangeException> (() => list.Insert (0, HeaderId.Unknown, Encoding.UTF8, "value"));
			Assert.Throws<ArgumentOutOfRangeException> (() => list.Insert (0, HeaderId.Unknown, "value"));
			Assert.Throws<ArgumentNullException> (() => list.Insert (0, HeaderId.AdHoc, Encoding.UTF8, null));
			Assert.Throws<ArgumentNullException> (() => list.Insert (0, HeaderId.AdHoc, null, "value"));
			Assert.Throws<ArgumentNullException> (() => list.Insert (0, HeaderId.AdHoc, null));
			Assert.Throws<ArgumentNullException> (() => list.Insert (0, null, "value"));
			Assert.Throws<ArgumentNullException> (() => list.Insert (0, "field", null));
			Assert.Throws<ArgumentNullException> (() => list.Insert (0, null));

			// LastIndexOf
			Assert.Throws<ArgumentOutOfRangeException> (() => list.LastIndexOf (HeaderId.Unknown));
			Assert.Throws<ArgumentNullException> (() => list.LastIndexOf ((string) null));

			// Remove
			Assert.Throws<ArgumentOutOfRangeException> (() => list.Remove (HeaderId.Unknown));
			Assert.Throws<ArgumentNullException> (() => list.Remove ((Header) null));
			Assert.Throws<ArgumentNullException> (() => list.Remove ((string) null));

			// RemoveAll
			Assert.Throws<ArgumentOutOfRangeException> (() => list.RemoveAll (HeaderId.Unknown));
			Assert.Throws<ArgumentNullException> (() => list.RemoveAll ((string) null));

			// RemoveAt
			Assert.Throws<ArgumentOutOfRangeException> (() => list.RemoveAt (-1));

			// Replace
			Assert.Throws<ArgumentNullException> (() => list.Replace (null));
			Assert.Throws<ArgumentOutOfRangeException> (() => list.Replace (HeaderId.Unknown, "value"));
			Assert.Throws<ArgumentNullException> (() => list.Replace (HeaderId.AdHoc, null));
			Assert.Throws<ArgumentNullException> (() => list.Replace (null, "value"));
			Assert.Throws<ArgumentNullException> (() => list.Replace ("field", null));
			Assert.Throws<ArgumentOutOfRangeException> (() => list.Replace (HeaderId.Unknown, Encoding.UTF8, "value"));
			Assert.Throws<ArgumentNullException> (() => list.Replace (HeaderId.AdHoc, null, "value"));
			Assert.Throws<ArgumentNullException> (() => list.Replace (HeaderId.AdHoc, Encoding.UTF8, null));
			Assert.Throws<ArgumentNullException> (() => list.Replace (null, Encoding.UTF8, "value"));
			Assert.Throws<ArgumentNullException> (() => list.Replace ("field", null, "value"));
			Assert.Throws<ArgumentNullException> (() => list.Replace ("field", Encoding.UTF8, null));

			using (var stream = new MemoryStream ()) {
				// Load
				Assert.Throws<ArgumentNullException> (() => HeaderList.Load (ParserOptions.Default, (Stream) null));
				Assert.Throws<ArgumentNullException> (() => HeaderList.Load (ParserOptions.Default, (string) null));
				Assert.Throws<ArgumentNullException> (() => HeaderList.Load (null, stream));
				Assert.Throws<ArgumentNullException> (() => HeaderList.Load ((Stream) null));
				Assert.Throws<ArgumentNullException> (() => HeaderList.Load ((string) null));

				// WriteTo
				Assert.Throws<ArgumentNullException> (() => list.WriteTo (FormatOptions.Default, null));
				Assert.Throws<ArgumentNullException> (() => list.WriteTo (null, stream));
				Assert.Throws<ArgumentNullException> (() => list.WriteTo (null));
			}

			// Indexers
			Assert.Throws<ArgumentOutOfRangeException> (() => list[-1] = new Header (HeaderId.AdHoc, "value"));
			Assert.Throws<ArgumentOutOfRangeException> (() => list[HeaderId.Unknown] = "value");
			Assert.Throws<ArgumentOutOfRangeException> (() => value = list[HeaderId.Unknown]);
			Assert.Throws<ArgumentOutOfRangeException> (() => header = list[-1]);
			Assert.Throws<ArgumentNullException> (() => list[HeaderId.AdHoc] = null);
			Assert.Throws<ArgumentNullException> (() => value = list[null]);
			Assert.Throws<ArgumentNullException> (() => list[null] = "value");
			Assert.Throws<ArgumentNullException> (() => list["field"] = null);
			Assert.Throws<ArgumentNullException> (() => list[0] = null);
		}
Exemple #49
0
		/// <summary>
		/// Initializes a new instance of the <see cref="MimeKit.MimeEntity"/> class.
		/// </summary>
		/// <remarks>
		/// Initializes the <see cref="ContentType"/> to the one provided.
		/// </remarks>
		/// <param name="contentType">The content type.</param>
		/// <exception cref="System.ArgumentNullException">
		/// <paramref name="contentType"/> is <c>null</c>.
		/// </exception>
		protected MimeEntity (ContentType contentType)
		{
			if (contentType == null)
				throw new ArgumentNullException ("contentType");

			Headers = new HeaderList ();
			ContentType = contentType;

			ContentType.Changed += ContentTypeChanged;
			Headers.Changed += HeadersChanged;

			SerializeContentType ();
		}
Exemple #50
0
		public void TestRemovingHeaders ()
		{
			var headers = new HeaderList ();

			headers.Add ("From", "sender@localhost");
			headers.Add ("To", "first@localhost");
			headers.Add ("To", "second@localhost");
			headers.Add ("To", "third@localhost");
			headers.Add ("Cc", "carbon.copy@localhost");

			Assert.IsTrue (headers.Remove ("Cc"));

			// try removing a header that no longer exists
			Assert.IsFalse (headers.Remove (HeaderId.Cc));
			Assert.IsFalse (headers.Remove ("Cc"));

			// removing this will change the result of headers[HeaderId.To]
			Assert.AreEqual ("first@localhost", headers[HeaderId.To]);
			Assert.IsTrue (headers.Remove (HeaderId.To));
			Assert.AreEqual ("second@localhost", headers[HeaderId.To]);
			Assert.IsTrue (headers.Remove ("To"));
			Assert.AreEqual ("third@localhost", headers[HeaderId.To]);
		}
		public ResponseHeaderInfo() {
			_ProxyAuthenticate = new HeaderList();
			_WWWAuthenticate = new HeaderList();
		}
Exemple #52
0
		private WebRequest BuildWebRequest(string method, string objectPath, HeaderList protoHeaders)
		{
			UriBuilder uriBuilder = new UriBuilder("http", "s3.amazonaws.com", 80, objectPath);
			WebRequest webRequest = WebRequest.Create(uriBuilder.ToString());
			((HttpWebRequest)webRequest).AllowWriteStreamBuffering = false;
			webRequest.Method = method;
			HeaderList headerList = new HeaderList(protoHeaders);
			headerList.AddHeaderIfAbsent("x-amz-date", DateTime.UtcNow.ToString("ddd, dd MMM yyyy HH:mm:ss ", CultureInfo.InvariantCulture) + "GMT");
			for (int i = 0; i < headerList.Count; i++)
			{
				string a = headerList.Keys[i];
				string contentType = headerList.Values[i];
				if (a == "content-type")
				{
					webRequest.ContentType = contentType;
				}
				else
				{
					webRequest.Headers.Add(headerList.Keys[i], headerList.Values[i]);
				}
			}
			StringBuilder stringBuilder = new StringBuilder();
			HeaderList headerList2 = new HeaderList();
			foreach (string current in headerList.Keys)
			{
				string text = current.ToLower();
				if (text == "content-type" || text == "content-md5" || text == "date" || text.StartsWith("x-amz-"))
				{
					headerList2.Add(text, headerList[current]);
				}
			}
			if (headerList2.ContainsKey("x-amz-date"))
			{
				headerList2["date"] = "";
			}
			if (!headerList2.ContainsKey("content-type"))
			{
				headerList2["content-type"] = "";
			}
			if (!headerList2.ContainsKey("content-md5"))
			{
				headerList2["content-md5"] = "";
			}
			stringBuilder.Append(webRequest.Method);
			stringBuilder.Append("\n");
			for (int j = 0; j < headerList2.Count; j++)
			{
				if (headerList2.Keys[j].StartsWith("x-amz-"))
				{
					stringBuilder.Append(headerList2.Keys[j]);
					stringBuilder.Append(":");
					stringBuilder.Append(headerList2.Values[j].Trim());
				}
				else
				{
					stringBuilder.Append(headerList2.Values[j]);
				}
				stringBuilder.Append("\n");
			}
			stringBuilder.Append("/");
			stringBuilder.Append(objectPath);
			string text2 = stringBuilder.ToString();
			Encoding encoding = new UTF8Encoding();
			HMACSHA1 hMACSHA = new HMACSHA1(encoding.GetBytes(this.secretAccessKey));
			byte[] inArray = hMACSHA.ComputeHash(encoding.GetBytes(text2.ToCharArray()));
			string arg = Convert.ToBase64String(inArray);
			webRequest.Headers.Add("Authorization", string.Format("AWS {0}:{1}", this.accessKeyId, arg));
			return webRequest;
		}
Exemple #53
0
		public void Dispose ()
		{
			headers = null;
			iter = null;
		}
Exemple #54
0
        /// <summary>
        /// Initializes a new instance of the <see cref="MimeKit.MimeEntity"/> class.
        /// </summary>
        /// <param name="mediaType">The media type.</param>
        /// <param name="mediaSubtype">The media subtype.</param>
        /// <exception cref="System.ArgumentNullException">
        /// <para><paramref name="mediaType"/> is <c>null</c>.</para>
        /// <para>-or-</para>
        /// <para><paramref name="mediaSubtype"/> is <c>null</c>.</para>
        /// </exception>
        protected MimeEntity(string mediaType, string mediaSubtype)
        {
            ContentType = new ContentType (mediaType, mediaSubtype);
            Headers = new HeaderList ();

            ContentType.Changed += ContentTypeChanged;
            Headers.Changed += HeadersChanged;

            SerializeContentType ();
        }
Exemple #55
0
		internal MimeMessage (ParserOptions options)
		{
			addresses = new Dictionary<string, InternetAddressList> (StringComparer.OrdinalIgnoreCase);
			Headers = new HeaderList (options);

			// initialize our address lists
			foreach (var name in StandardAddressHeaders) {
				var list = new InternetAddressList ();
				list.Changed += InternetAddressListChanged;
				addresses.Add (name, list);
			}

			references = new MessageIdList ();
			references.Changed += ReferencesChanged;
			inreplyto = null;

			Headers.Changed += HeadersChanged;
		}
	  protected void SetAuthParams(HeaderList AValue)
	  {
      List<string> TempList = new List<string>();
      AValue.ConvertToStdValues(TempList);
      _AuthParams.AddStdValues(TempList);
	  }
Exemple #57
0
        /// <summary>
        /// Get the headers for the specified messages.
        /// </summary>
        /// <remarks>
        /// Gets the headers for the specified messages.
        /// </remarks>
        /// <returns>The headers for the specified messages.</returns>
        /// <param name="indexes">The indexes of the messages.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <exception cref="System.ArgumentNullException">
        /// <paramref name="indexes"/> is <c>null</c>.
        /// </exception>
        /// <exception cref="System.ArgumentException">
        /// <para>One or more of the <paramref name="indexes"/> are invalid.</para>
        /// <para>-or-</para>
        /// <para>No indexes were specified.</para>
        /// </exception>
        /// <exception cref="System.ObjectDisposedException">
        /// The <see cref="Pop3Client"/> has been disposed.
        /// </exception>
        /// <exception cref="InvalidOperationException">
        /// The <see cref="Pop3Client"/> is not connected.
        /// </exception>
        /// <exception cref="System.UnauthorizedAccessException">
        /// The <see cref="Pop3Client"/> is not authenticated.
        /// </exception>
        /// <exception cref="System.NotSupportedException">
        /// The POP3 server does not support the UIDL extension.
        /// </exception>
        /// <exception cref="System.OperationCanceledException">
        /// The operation was canceled via the cancellation token.
        /// </exception>
        /// <exception cref="System.IO.IOException">
        /// An I/O error occurred.
        /// </exception>
        /// <exception cref="Pop3CommandException">
        /// The POP3 command failed.
        /// </exception>
        /// <exception cref="Pop3ProtocolException">
        /// A POP3 protocol error occurred.
        /// </exception>
        public override IList<HeaderList> GetMessageHeaders(IList<int> indexes, CancellationToken cancellationToken = default (CancellationToken))
        {
            if (indexes == null)
                throw new ArgumentNullException ("indexes");

            if (indexes.Count == 0)
                throw new ArgumentException ("No indexes specified.", "indexes");

            CheckDisposed ();
            CheckConnected ();

            if (engine.State != Pop3EngineState.Transaction)
                throw new UnauthorizedAccessException ();

            var seqids = new int[indexes.Count];

            for (int i = 0; i < indexes.Count; i++) {
                if (indexes[i] < 0 || indexes[i] >= total)
                    throw new ArgumentException ("One or more of the indexes are invalid.", "indexes");

                seqids[i] = indexes[i] + 1;
            }

            var messages = GetMessagesForSequenceIds (seqids, true, cancellationToken);
            var headers = new HeaderList[messages.Count];

            for (int i = 0; i < headers.Length; i++)
                headers[i] = messages[i].Headers;

            return headers;
        }
Exemple #58
0
		public Stream getStream(string bucket, string key, HeaderList headers)
		{
			WebRequest webRequest = this.BuildWebRequest("GET", bucket + "/" + this.EncodeKeyForSignature(key), headers);
			WebResponse response = webRequest.GetResponse();
			return response.GetResponseStream();
		}