/usr/include/Poco/Net/MultipartReader.h is in libpoco-dev 1.8.0.1-1ubuntu4.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 | //
// MultipartReader.h
//
// Library: Net
// Package: Messages
// Module: MultipartReader
//
// Definition of the MultipartReader class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_MultipartReader_INCLUDED
#define Net_MultipartReader_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/BufferedStreamBuf.h"
#include <istream>
namespace Poco {
namespace Net {
class MessageHeader;
class Net_API MultipartStreamBuf: public Poco::BufferedStreamBuf
/// This is the streambuf class used for reading from a multipart message stream.
{
public:
MultipartStreamBuf(std::istream& istr, const std::string& boundary);
~MultipartStreamBuf();
bool lastPart() const;
protected:
int readFromDevice(char* buffer, std::streamsize length);
private:
enum
{
STREAM_BUFFER_SIZE = 1024
};
std::istream& _istr;
std::string _boundary;
bool _lastPart;
};
class Net_API MultipartIOS: public virtual std::ios
/// The base class for MultipartInputStream.
{
public:
MultipartIOS(std::istream& istr, const std::string& boundary);
~MultipartIOS();
MultipartStreamBuf* rdbuf();
bool lastPart() const;
protected:
MultipartStreamBuf _buf;
};
class Net_API MultipartInputStream: public MultipartIOS, public std::istream
/// This class is for internal use by MultipartReader only.
{
public:
MultipartInputStream(std::istream& istr, const std::string& boundary);
~MultipartInputStream();
};
class Net_API MultipartReader
/// This class is used to split a MIME multipart
/// message into its single parts.
///
/// The format of multipart messages is described
/// in section 5.1 of RFC 2046.
///
/// To split a multipart message into its parts,
/// do the following:
/// - Create a MultipartReader object, passing it
/// an input stream and optionally a boundary string.
/// - while hasNextPart() returns true, call nextPart()
/// and read the part from stream().
///
/// Always ensure that you read all data from the part
/// stream, otherwise the MultipartReader will fail to
/// find the next part.
{
public:
explicit MultipartReader(std::istream& istr);
/// Creates the MultipartReader and attaches it to the
/// given input stream.
///
/// The boundary string is determined from the input
/// stream. The message must not contain a preamble
/// preceding the first encapsulation boundary.
MultipartReader(std::istream& istr, const std::string& boundary);
/// Creates the MultipartReader and attaches it to the
/// given input stream. The given boundary string is
/// used to find message boundaries.
~MultipartReader();
/// Destroys the MultipartReader.
void nextPart(MessageHeader& messageHeader);
/// Moves to the next part in the message and stores the
/// part's header fields in messageHeader.
///
/// Throws an MultipartException if there are no more parts
/// available, or if no boundary line can be found in
/// the input stream.
bool hasNextPart();
/// Returns true iff more parts are available.
///
/// Before the first call to nextPart(), returns
/// always true.
std::istream& stream() const;
/// Returns a reference to the reader's stream that
/// can be used to read the current part.
///
/// The returned reference will be valid until
/// nextPart() is called or the MultipartReader
/// object is destroyed.
const std::string& boundary() const;
/// Returns the multipart boundary used by this reader.
protected:
void findFirstBoundary();
void guessBoundary();
void parseHeader(MessageHeader& messageHeader);
bool readLine(std::string& line, std::string::size_type n);
private:
MultipartReader();
MultipartReader(const MultipartReader&);
MultipartReader& operator = (const MultipartReader&);
std::istream& _istr;
std::string _boundary;
MultipartInputStream* _pMPI;
};
} } // namespace Poco::Net
#endif // Net_MultipartReader_INCLUDED
|