Ejemplo n.º 1
0
        private ImapWebResponse GetListLsubResponse(bool sendList)
        {
            ImapMailbox[] mailboxes;

              var response = new ImapWebResponse(sendList ? Session.List(out mailboxes) : Session.Lsub(out mailboxes));

              if (response.Result.Succeeded)
            response.Mailboxes = mailboxes;

              return response;
        }
        protected ImapWebResponse GetCopyResponse(ImapSequenceSet requestUidSet)
        {
            ImapCopiedUidSet copiedUids;
              ImapMailbox createdMailbox = null;

              var mailbox = GetDestinationMailbox();
              var response = new ImapWebResponse(AllowCreateMailbox
                                         ? Session.Copy(requestUidSet, mailbox, out copiedUids, out createdMailbox)
                                         : Session.Copy(requestUidSet, mailbox, out copiedUids));

              if (response.Result.Succeeded) {
            if (createdMailbox != null) {
              if (Subscription) {
            Session.Subscribe(createdMailbox);
            Session.Lsub(createdMailbox);
              }
              else {
            Session.List(createdMailbox);
              }

              response.Mailboxes = new[] {createdMailbox};
            }

            if (copiedUids != null) {
              var builder = new ImapUriBuilder(DestinationUri);

              builder.UidValidity = copiedUids.UidValidity;

              if (copiedUids.AssignedUidSet.IsSingle)
            builder.Uid = copiedUids.AssignedUidSet.ToNumber();
              else
            builder.SearchCriteria = ImapSearchCriteria.Uid(copiedUids.AssignedUidSet);

              response.SetResponseUri(builder.Uri);
            }
              }

              return response;
        }
        private ImapWebResponse GetSearchResponse(ImapMatchedSequenceSet matched)
        {
            ImapMessageAttribute[] messageAttributes;

              var response = new ImapWebResponse(Session.Fetch(matched,
                                                       GetFetchDataItem(),
                                                       out messageAttributes));

              if (response.Result.Succeeded)
            response.MessageAttributes = messageAttributes;

              return response;
        }
        private static ImapWebResponse CreateSearchErrorResponse(ImapCommandResult result)
        {
            var response = new ImapWebResponse(result);

              if (result.TaggedStatusResponse.ResponseText.Code == ImapResponseCode.BadCharset) {
            var supportedCharsets = new List<Encoding>();

            foreach (var charset in ImapResponseTextConverter.FromBadCharset(result.TaggedStatusResponse.ResponseText)) {
              try {
            supportedCharsets.Add(Encoding.GetEncoding(charset));
              }
              catch (ArgumentException) {
            // not supported by framework
              }
            }

            response.SupportedCharsets = supportedCharsets.ToArray();
              }

              return response;
        }
        private static ImapWebResponse CreateNotMatchedResponse(ImapCommandResult result)
        {
            var response = new ImapWebResponse(result);

              response.MessageAttributes = new IImapMessageAttribute[] {};

              return response;
        }
        private ImapWebResponse GetFullFetchResponse(ImapSequenceSet requestedUidSet)
        {
            var responseStream = new ImapWebClientFetchMessageBodyStream(Session,
                                                                   KeepAlive,
                                                                   FetchPeek,
                                                                   requestedUidSet,
                                                                   FetchBlockSize,
                                                                   ReadWriteTimeout);

              IImapMessageAttribute messageAttr;
              var response = new ImapWebResponse(responseStream.Prepare(GetFetchDataItem(), out messageAttr));

              if (response.Result.Failed)
            return response;

              response.MessageAttributes = new[] {messageAttr};
              response.SetResponseStream(responseStream,
                                 responseStream.Length,
                                 true);

              if (messageAttr.BodyStructure != null)
            response.SetContentType((string)messageAttr.BodyStructure.MediaType);

              return response;
        }
        private ImapWebResponse GetPartialFetchResponse(ImapSequenceSet requestedUidSet, string section, ImapPartialRange? partial)
        {
            var responseStream = new ImapWebClientFetchMessageBodyStream(Session,
                                                                   KeepAlive,
                                                                   FetchPeek,
                                                                   requestedUidSet,
                                                                   section,
                                                                   partial,
                                                                   FetchBlockSize,
                                                                   ReadWriteTimeout);

              IImapMessageAttribute discard;
              var response = new ImapWebResponse(responseStream.Prepare(GetFetchDataItem(), out discard));

              if (response.Result.Failed)
            return response;

              response.SetResponseStream(responseStream,
                                 responseStream.Length,
                                 true);

              return response;
        }
Ejemplo n.º 8
0
        private ImapWebResponse GetResponseProc()
        {
            try {
            ImapCommandResult noopResult = null;

            if (beginAppendAsyncResult == null)
              GetSession(out noopResult);

            ImapWebResponse response = null;

            try {
              try {
            if (string.Equals(Method, ImapWebRequestMethods.NoOp, StringComparison.OrdinalIgnoreCase)) {
              if (noopResult == null)
                response = GetNoOpResponse();
              else
                response = new ImapWebResponse(noopResult);
            }
            else {
              response = InternalGetResponse();
            }
              }
              catch (TimeoutException ex) {
            throw new WebException("timed out", ex, WebExceptionStatus.Timeout, null);
              }
              catch (ImapException ex) {
            if (ex is ImapProtocolViolationException)
              throw new ProtocolViolationException(ex.Message);
            else if (ex is ImapIncapableException)
              throw new ProtocolViolationException(ex.Message);
            else
              throw new WebException("unexpected error", ex, WebExceptionStatus.UnknownError, null);
              }

              if (response != null)
            response.SetSessionInfo(session);
            }
            finally {
              if (!keepAlive && (response == null || !response.IsSessionClosedByResponseStream))
            CloseSession();
            }

            if (response == null)
              // success
              throw new WebException("No error was encountered.", WebExceptionStatus.Success);

            if (response.ResponseUri == null)
              response.SetResponseUri(requestUri);

            if (response.Result.Succeeded)
              // succeeded
              return response;

            if (expectedErrorResponseCodes != null && response.ResponseCode != null) {
              foreach (var code in expectedErrorResponseCodes) {
            if (response.ResponseCode == code)
              // expected error
              return response;
              }
            }

            // unexpected error
            throw new WebException(response.ResponseDescription, null, WebExceptionStatus.ProtocolError, response);
              }
              finally {
            session = null;
              }
        }
Ejemplo n.º 9
0
        private ImapWebResponse GetStatusResponse()
        {
            if (StatusDataItem == null)
            throw new InvalidOperationException("StatusDataItem must be set");

              ImapMailbox statusMailbox;

              var response = new ImapWebResponse(Session.Status(RequestMailbox, StatusDataItem, out statusMailbox));

              if (response.Result.Succeeded)
            response.Mailboxes = new ImapMailbox[] {statusMailbox};

              return response;
        }
Ejemplo n.º 10
0
        private ImapWebResponse GetFetchResponse()
        {
            var response = SelectRequestMailbox();

              if (response != null && response.Result.Failed)
            return response;

              ImapMessageAttribute[] messageAttributes;

              response = new ImapWebResponse(Session.Fetch(ImapSequenceSet.CreateUidFromSet(1),
                                                   GetFetchDataItem(),
                                                   out messageAttributes));

              if (response.Result.Succeeded)
            response.MessageAttributes = messageAttributes;

              return response;
        }
Ejemplo n.º 11
0
        private ImapWebResponse GetRenameResponse()
        {
            CloseMailbox(); // ignore error

              ImapMailbox renamedMailbox;

              var mailbox = RequestMailbox;
              var response = new ImapWebResponse(Session.Rename(mailbox, GetDestinationMailbox(), out renamedMailbox));

              if (response.Result.Failed)
            return response;

              if (Subscription) {
            Session.Unsubscribe(mailbox);
            Session.Subscribe(renamedMailbox);
            Session.Lsub(renamedMailbox);
              }
              else {
            Session.List(renamedMailbox);
              }

              // unsubscribe/subscribe children
              if (Subscription && !string.IsNullOrEmpty(renamedMailbox.HierarchyDelimiter)) {
            var wildcard = renamedMailbox.HierarchyDelimiter + "*";
            ImapMailbox[] children;

            if (Session.Lsub(mailbox + wildcard, out children).Succeeded) {
              foreach (var child in children) {
            Session.Unsubscribe(child);
              }
            }

            if (Session.List(renamedMailbox.Name + wildcard, out children).Succeeded) {
              foreach (var child in children) {
            Session.Subscribe(child);
              }
            }
              }

              response.Mailboxes = new[] {renamedMailbox};
              response.SetResponseUri(renamedMailbox.Url);

              return response;
        }
Ejemplo n.º 12
0
        private ImapWebResponse GetDeleteResponse()
        {
            CloseMailbox(); // ignore error

              var mailbox = RequestMailbox;
              var response = new ImapWebResponse(Session.Delete(mailbox));

              if (response.Result.Failed)
            return response;

              if (Subscription)
            Session.Unsubscribe(mailbox);

              return response;
        }
Ejemplo n.º 13
0
        private ImapWebResponse GetCreateResponse()
        {
            CloseMailbox(); // ignore error

              ImapMailbox createdMailbox;

              var response = new ImapWebResponse(Session.Create(RequestMailbox, out createdMailbox));

              if (response.Result.Failed)
            return response;

              if (Subscription) {
            Session.Subscribe(createdMailbox);
            Session.Lsub(createdMailbox);
              }
              else {
            Session.List(createdMailbox);
              }

              response.Mailboxes = new[] {createdMailbox};
              response.SetResponseUri(createdMailbox.Url);

              return response;
        }
Ejemplo n.º 14
0
        private ImapWebResponse GetAppendResponse()
        {
            if (beginAppendAsyncResult == null)
            throw new InvalidOperationException("GetRequestStream not called");

              try {
            appendMessageBodyStream.UpdateLength();

            ImapAppendedUidSet appendedUid;

            var response = new ImapWebResponse(Session.EndAppend(beginAppendAsyncResult, out appendedUid));

            if (response.Result.Succeeded) {
              // set empty stream; WebClient.Upload*() methods call WebResponse.GetResponseStream
              response.SetResponseStream(Stream.Null, 0L, false);

              if (appendedUid != null) {
            var builder = new ImapUriBuilder(RequestUri);

            builder.UidValidity = appendedUid.UidValidity;
            builder.Uid = appendedUid.ToNumber(); // if appendedUid.IsSingle

            response.SetResponseUri(builder.Uri);
              }
            }

            return response;
              }
              finally {
            appendMessageBodyStream.InternalDispose();
            appendMessageBodyStream = null;

            beginAppendAsyncResult = null;
              }
        }
        private ImapWebResponse GetSortResponse()
        {
            if (SortCriteria == null)
            throw new InvalidOperationException("SortCriteria must be set");

              string charset;
              ImapMatchedSequenceSet matched;

              var result = Session.UidSortPreformatted(SortCriteria,
                                               GetSearchCriteria(Session.ServerCapabilities, out charset),
                                               charset,
                                               out matched);

              if (result.Failed)
            return CreateSearchErrorResponse(result);
              else if (matched.IsEmpty)
            return CreateNotMatchedResponse(result);

              ImapMessageAttribute[] messageAttributes;

              var response = new ImapWebResponse(Session.Fetch(matched,
                                                       GetFetchDataItem(),
                                                       out messageAttributes));

              if (response.Result.Failed)
            return response;

              var sortedUids = matched.ToArray();
              var sortedMessageAttributes = new IImapMessageAttribute[sortedUids.Length];

              for (var i = 0; i < sortedUids.Length; i++) {
            sortedMessageAttributes[i] = null;

            for (var j = 0; j < messageAttributes.Length; j++) {
              if (sortedUids[i] == messageAttributes[j].Uid) {
            sortedMessageAttributes[i] = messageAttributes[j];
            break;
              }
            }
              }

              response.MessageAttributes = sortedMessageAttributes;

              return response;
        }
Ejemplo n.º 16
0
        private ImapWebResponse GetXListResponse()
        {
            ImapMailbox[] mailboxes;

              var response = new ImapWebResponse(Session.XList(out mailboxes));

              if (response.Result.Succeeded)
            response.Mailboxes = mailboxes;

              return response;
        }
        private ImapWebResponse GetThreadResponse()
        {
            if (ThreadingAlgorithm == null)
            throw new InvalidOperationException("ThreadingAlgorithm must be set");

              string charset;
              ImapThreadList threadList;

              var result = Session.UidThreadPreformatted(ThreadingAlgorithm,
                                                 GetSearchCriteria(Session.ServerCapabilities, out charset),
                                                 charset,
                                                 out threadList);

              if (result.Failed)
            return CreateSearchErrorResponse(result);
              else if (threadList.Children.Length == 0)
            return CreateNotMatchedResponse(result);

              ImapMessageAttribute[] messageAttributes;

              var response = new ImapWebResponse(Session.Fetch(threadList.ToSequenceSet(),
                                                       GetFetchDataItem(),
                                                       out messageAttributes));

              if (response.Result.Failed)
            return response;

              response.MessageAttributes = messageAttributes;

              var messageDictionary = new Dictionary<long, IImapMessageAttribute>();

              foreach (var messageAttr in messageAttributes) {
            messageDictionary.Add(messageAttr.Uid, messageAttr);
              }

              response.ThreadTree = new ImapThreadTree(true, null, CreateMessageTree(threadList.Children, messageDictionary));

              return response;
        }
Ejemplo n.º 18
0
        protected ImapWebResponse SelectRequestMailbox(bool selectAsReadOnly)
        {
            var mailbox = RequestMailbox;

              ImapWebResponse response = null;

              if (Session.State == ImapSessionState.Selected &&
              (!string.Equals(Session.SelectedMailbox.Name, mailbox) || selectAsReadOnly != session.SelectedMailbox.ReadOnly)) {
            response = CloseMailbox();

            if (response != null && response.Result.Failed)
              return response;
              }

              if (Session.State != ImapSessionState.Selected)
            response = new ImapWebResponse(selectAsReadOnly ? Session.Examine(mailbox) : Session.Select(mailbox));

              return response;
        }