tools/source/inet/inetstrm.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include <cassert>
  23
  24 #include <sal/types.h>
  25 #include <tools/inetmsg.hxx>
  26 #include <tools/inetstrm.hxx>
  27
  28 int INetMIMEMessageStream::GetHeaderLine(char* pData, sal_uInt32 nSize)
  29 {
  30     char* pWBuf = pData;
  31
  32     sal_uInt32 i, n;
  33
  34     if (maMsgBuffer.Tell() == 0)
  35     {
  36         // Insert formatted header into buffer.
  37         n = pSourceMsg->GetHeaderCount();
  38         for (i = 0; i < n; i++)
  39         {
  40             INetMessageHeader aHeader (pSourceMsg->GetHeaderField(i));
  41             if (aHeader.GetValue().getLength())
  42             {
  43                 // NYI: Folding long lines.
  44                 maMsgBuffer.WriteOString( aHeader.GetName() );
  45                 maMsgBuffer.WriteOString( ": " );
  46                 maMsgBuffer.WriteOString( aHeader.GetValue() );
  47                 maMsgBuffer.WriteOString( "\r\n" );
  48             }
  49         }
  50
  51         pMsgWrite = const_cast<char *>(static_cast<char const *>(maMsgBuffer.GetData()));
  52         pMsgRead  = pMsgWrite + maMsgBuffer.Tell();
  53     }
  54
  55     n = pMsgRead - pMsgWrite;
  56     if (n > 0)
  57     {
  58         // Move to caller.
  59         if (nSize < n) n = nSize;
  60         for (i = 0; i < n; i++) *pWBuf++ = *pMsgWrite++;
  61     }
  62     else
  63     {
  64         // Reset buffer.
  65         maMsgBuffer.Seek(STREAM_SEEK_TO_BEGIN);
  66     }
  67
  68     return (pWBuf - pData);
  69 }
  70
  71 int INetMIMEMessageStream::GetBodyLine(char* pData, sal_uInt32 nSize)
  72 {
  73     char* pWBuf = pData;
  74     char* pWEnd = pData + nSize;
  75
  76     if (pSourceMsg->GetDocumentLB())
  77     {
  78         sal_uInt32 nRead = pSourceMsg->GetDocumentLB()->ReadBytes(pWBuf, (pWEnd - pWBuf));
  79         pWBuf += nRead;
  80     }
  81
  82     return (pWBuf - pData);
  83 }
  84
  85 int INetMIMEMessageStream::GetMsgLine(char* pData, sal_uInt32 nSize)
  86 {
  87     // Check for header or body.
  88     if (!bHeaderGenerated)
  89     {
  90         if (!done)
  91         {
  92             // Prepare special header fields.
  93             if (pSourceMsg->GetParent())
  94             {
  95                 OUString aPCT(pSourceMsg->GetParent()->GetContentType());
  96                 if (aPCT.startsWithIgnoreAsciiCase("message/rfc822"))
  97                     pSourceMsg->SetMIMEVersion(u"1.0"_ustr);
  98                 else
  99                     pSourceMsg->SetMIMEVersion(OUString());
 100             }
 101             else
 102             {
 103                 pSourceMsg->SetMIMEVersion(u"1.0"_ustr);
 104             }
 105
 106             // Check ContentType.
 107             OUString aContentType(pSourceMsg->GetContentType());
 108             if (!aContentType.isEmpty())
 109             {
 110                 // Determine default Content-Type.
 111                 OUString aDefaultType = pSourceMsg->GetDefaultContentType();
 112
 113                 if (aDefaultType.equalsIgnoreAsciiCase(aContentType))
 114                 {
 115                     // No need to specify default.
 116                     pSourceMsg->SetContentType(OUString());
 117                 }
 118             }
 119
 120             // No need to specify default.
 121             pSourceMsg->SetContentTransferEncoding(OUString());
 122
 123             // Mark we're done.
 124             done = true;
 125         }
 126
 127         // Generate the message header.
 128         int nRead = GetHeaderLine(pData, nSize);
 129         if (nRead <= 0)
 130         {
 131             // Reset state.
 132             done = false;
 133         }
 134         return nRead;
 135     }
 136     else
 137     {
 138         // Generate the message body.
 139         if (pSourceMsg->IsContainer())
 140         {
 141             // Encapsulated message body.
 142             while (!done)
 143             {
 144                 if (pChildStrm == nullptr)
 145                 {
 146                     INetMIMEMessage *pChild = pSourceMsg->GetChild(nChildIndex);
 147                     if (pChild)
 148                     {
 149                         // Increment child index.
 150                         nChildIndex++;
 151
 152                         // Create child stream.
 153                         pChildStrm.reset(new INetMIMEMessageStream(pChild, false));
 154
 155                         if (pSourceMsg->IsMultipart())
 156                         {
 157                             // Insert multipart delimiter.
 158                             OString aDelim = "--" +
 159                                 pSourceMsg->GetMultipartBoundary() +
 160                                 "\r\n";
 161
 162                             memcpy(pData, aDelim.getStr(),
 163                                 aDelim.getLength());
 164                             return aDelim.getLength();
 165                         }
 166                     }
 167                     else
 168                     {
 169                         // No more parts. Mark we're done.
 170                         done = true;
 171                         nChildIndex = 0;
 172
 173                         if (pSourceMsg->IsMultipart())
 174                         {
 175                             // Insert close delimiter.
 176                             OString aDelim = "--" +
 177                                 pSourceMsg->GetMultipartBoundary() +
 178                                 "--\r\n";
 179
 180                             memcpy(pData, aDelim.getStr(),
 181                                 aDelim.getLength());
 182                             return aDelim.getLength();
 183                         }
 184                     }
 185                 }
 186                 else
 187                 {
 188                     // Read current child stream.
 189                     int nRead = pChildStrm->Read(pData, nSize);
 190                     if (nRead > 0)
 191                     {
 192                         return nRead;
 193                     }
 194                     else
 195                     {
 196                         // Cleanup exhausted child stream.
 197                         pChildStrm.reset();
 198                     }
 199                 }
 200             }
 201             return 0;
 202         }
 203         else
 204         {
 205             // Single part message body.
 206             if (pSourceMsg->GetDocumentLB() == nullptr)
 207             {
 208                 // Empty message body.
 209                 return 0;
 210             }
 211
 212             // No Encoding.
 213             return GetBodyLine(pData, nSize);
 214         }
 215     }
 216 }
 217
 218 namespace
 219 {
 220
 221 const int BUFFER_SIZE = 2048;
 222
 223 }
 224
 225 INetMIMEMessageStream::INetMIMEMessageStream(
 226     INetMIMEMessage *pMsg, bool headerGenerated):
 227     pSourceMsg(pMsg),
 228     bHeaderGenerated(headerGenerated),
 229     mvBuffer(BUFFER_SIZE),
 230     pMsgRead(nullptr),
 231     pMsgWrite(nullptr),
 232     done(false),
 233     nChildIndex(0)
 234 {
 235     assert(pMsg != nullptr);
 236     maMsgBuffer.SetStreamCharSet(RTL_TEXTENCODING_ASCII_US);
 237     pRead = pWrite = mvBuffer.data();
 238 }
 239
 240 INetMIMEMessageStream::~INetMIMEMessageStream()
 241 {
 242     pChildStrm.reset();
 243 }
 244
 245 int INetMIMEMessageStream::Read(char* pData, sal_uInt32 nSize)
 246 {
 247     char* pWBuf = pData;
 248     char* pWEnd = pData + nSize;
 249
 250     while (pWBuf < pWEnd)
 251     {
 252         // Caller's buffer not yet filled.
 253         sal_uInt32 n = pRead - pWrite;
 254         if (n > 0)
 255         {
 256             // Bytes still in buffer.
 257             sal_uInt32 m = pWEnd - pWBuf;
 258             if (m < n) n = m;
 259             for (sal_uInt32 i = 0; i < n; i++) *pWBuf++ = *pWrite++;
 260         }
 261         else
 262         {
 263             // Buffer empty. Reset to <Begin-of-Buffer>.
 264             pRead = pWrite = mvBuffer.data();
 265
 266             // Read next message line.
 267             int nRead = GetMsgLine(mvBuffer.data(), mvBuffer.size());
 268             if (nRead > 0)
 269             {
 270                 // Set read pointer.
 271                 pRead = mvBuffer.data() + nRead;
 272             }
 273             else
 274             {
 275                 if (!bHeaderGenerated)
 276                 {
 277                     // Header generated. Insert empty line.
 278                     bHeaderGenerated = true;
 279                     *pRead++ = '\r';
 280                     *pRead++ = '\n';
 281                 }
 282                 else
 283                 {
 284                     // Body generated.
 285                     return (pWBuf - pData);
 286                 }
 287             }
 288         }
 289     }
 290     return (pWBuf - pData);
 291 }
 292
 293 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */