Move Photoshopb class to internal namespace
Luis Díaz Más
3 years ago
parent
047f6b733e
commit
f942ba89bd
@ -0,0 +1,70 @@
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#ifndef PHOTOSHOP_INT_HPP
|
||||
#define PHOTOSHOP_INT_HPP
|
||||
|
||||
#include "exiv2lib_export.h"
|
||||
|
||||
#include "types.hpp"
|
||||
|
||||
#include <array>
|
||||
|
||||
namespace Exiv2 {
|
||||
// Forward declarations
|
||||
class IptcData;
|
||||
|
||||
/// @brief Helper class, has methods to deal with %Photoshop "Information Resource Blocks" (IRBs).
|
||||
struct EXIV2API Photoshop {
|
||||
// Todo: Public for now
|
||||
static constexpr std::array irbId_{"8BIM", "AgHg", "DCSR", "PHUT"}; //!< %Photoshop IRB markers
|
||||
static constexpr auto ps3Id_ = "Photoshop 3.0\0"; //!< %Photoshop marker
|
||||
static constexpr uint16_t iptc_ = 0x0404; //!< %Photoshop IPTC marker
|
||||
static constexpr uint16_t preview_ = 0x040c; //!< %Photoshop preview marker
|
||||
|
||||
/// @brief Checks an IRB
|
||||
/// @param pPsData Existing IRB buffer. It is expected to be of size 4.
|
||||
/// @return true if the IRB marker is known
|
||||
/// @todo This should be an implementation detail and not exposed in the API. An attacker could try to pass
|
||||
/// a smaller buffer or null pointer.
|
||||
static bool isIrb(const byte* pPsData);
|
||||
|
||||
/// @brief Validates all IRBs
|
||||
/// @param pPsData Existing IRB buffer
|
||||
/// @param sizePsData Size of the IRB buffer, may be 0
|
||||
/// @return true if all IRBs are valid;<BR> false otherwise
|
||||
static bool valid(const byte* pPsData, size_t sizePsData);
|
||||
|
||||
/// @brief Locates the data for a %Photoshop tag in a %Photoshop formated memory buffer.
|
||||
/// Operates on raw data to simplify reuse.
|
||||
/// @param pPsData Pointer to buffer containing entire payload of %Photoshop formated data (from APP13 Jpeg segment)
|
||||
/// @param sizePsData Size in bytes of pPsData.
|
||||
/// @param psTag %Tag number of the block to look for.
|
||||
/// @param record Output value that is set to the start of the data block within pPsData (may not be null).
|
||||
/// @param sizeHdr Output value that is set to the size of the header within the data block pointed to by record
|
||||
/// (may not be null).
|
||||
/// @param sizeData Output value that is set to the size of the actual data within the data block pointed to by record
|
||||
/// (may not be null).
|
||||
/// @return 0 if successful;<BR>
|
||||
/// 3 if no data for psTag was found in pPsData;<BR>
|
||||
/// -2 if the pPsData buffer does not contain valid data.
|
||||
static int locateIrb(const byte* pPsData, size_t sizePsData, uint16_t psTag, const byte** record,
|
||||
uint32_t* const sizeHdr, uint32_t* const sizeData);
|
||||
|
||||
/// @brief Forwards to locateIrb() with \em psTag = \em iptc_
|
||||
static int locateIptcIrb(const byte* pPsData, size_t sizePsData, const byte** record, uint32_t* const sizeHdr,
|
||||
uint32_t* const sizeData);
|
||||
|
||||
/// @brief Forwards to locatePreviewIrb() with \em psTag = \em preview_
|
||||
static int locatePreviewIrb(const byte* pPsData, size_t sizePsData, const byte** record, uint32_t* const sizeHdr,
|
||||
uint32_t* const sizeData);
|
||||
|
||||
/// @brief Set the new IPTC IRB, keeps existing IRBs but removes the IPTC block if there is no new IPTC data to write.
|
||||
/// @param pPsData Existing IRB buffer
|
||||
/// @param sizePsData Size of the IRB buffer, may be 0
|
||||
/// @param iptcData Iptc data to embed, may be empty
|
||||
/// @return A data buffer containing the new IRB buffer, may have 0 size
|
||||
static DataBuf setIptcIrb(const byte* pPsData, size_t sizePsData, const IptcData& iptcData);
|
||||
};
|
||||
} // namespace Exiv2
|
||||
|
||||
#endif // PHOTOSHOP_INT_HPP
|
||||
@ -0,0 +1,182 @@
|
||||
#include "photoshop.hpp"
|
||||
|
||||
#include "enforce.hpp"
|
||||
#include "image.hpp"
|
||||
#include "safe_op.hpp"
|
||||
|
||||
namespace Exiv2 {
|
||||
|
||||
bool Photoshop::isIrb(const byte* data) {
|
||||
if (data == nullptr) {
|
||||
return false;
|
||||
}
|
||||
return std::any_of(irbId_.begin(), irbId_.end(), [data](auto id) { return memcmp(data, id, 4) == 0; });
|
||||
}
|
||||
|
||||
bool Photoshop::valid(const byte* pPsData, size_t sizePsData) {
|
||||
const byte* record = nullptr;
|
||||
uint32_t sizeIptc = 0;
|
||||
uint32_t sizeHdr = 0;
|
||||
const byte* pCur = pPsData;
|
||||
const byte* pEnd = pPsData + sizePsData;
|
||||
int ret = 0;
|
||||
while (pCur < pEnd && 0 == (ret = Photoshop::locateIptcIrb(pCur, (pEnd - pCur), &record, &sizeHdr, &sizeIptc))) {
|
||||
pCur = record + sizeHdr + sizeIptc + (sizeIptc & 1);
|
||||
}
|
||||
return ret >= 0;
|
||||
}
|
||||
|
||||
// Todo: Generalised from JpegBase::locateIptcData without really understanding
|
||||
// the format (in particular the header). So it remains to be confirmed
|
||||
// if this also makes sense for psTag != Photoshop::iptc
|
||||
int Photoshop::locateIrb(const byte* pPsData, size_t sizePsData, uint16_t psTag, const byte** record,
|
||||
uint32_t* const sizeHdr, uint32_t* const sizeData) {
|
||||
if (sizePsData < 12) {
|
||||
return 3;
|
||||
}
|
||||
|
||||
// Used for error checking
|
||||
size_t position = 0;
|
||||
#ifdef EXIV2_DEBUG_MESSAGES
|
||||
std::cerr << "Photoshop::locateIrb: ";
|
||||
#endif
|
||||
// Data should follow Photoshop format, if not exit
|
||||
while (position <= (sizePsData - 12) && isIrb(pPsData + position)) {
|
||||
const byte* hrd = pPsData + position;
|
||||
position += 4;
|
||||
uint16_t type = getUShort(pPsData + position, bigEndian);
|
||||
position += 2;
|
||||
#ifdef EXIV2_DEBUG_MESSAGES
|
||||
std::cerr << "0x" << std::hex << type << std::dec << " ";
|
||||
#endif
|
||||
// Pascal string is padded to have an even size (including size byte)
|
||||
byte psSize = pPsData[position] + 1;
|
||||
psSize += (psSize & 1);
|
||||
position += psSize;
|
||||
if (position + 4 > sizePsData) {
|
||||
#ifdef EXIV2_DEBUG_MESSAGES
|
||||
std::cerr << "Warning: "
|
||||
<< "Invalid or extended Photoshop IRB\n";
|
||||
#endif
|
||||
return -2;
|
||||
}
|
||||
uint32_t dataSize = getULong(pPsData + position, bigEndian);
|
||||
position += 4;
|
||||
if (dataSize > (sizePsData - position)) {
|
||||
#ifdef EXIV2_DEBUG_MESSAGES
|
||||
std::cerr << "Warning: "
|
||||
<< "Invalid Photoshop IRB data size " << dataSize << " or extended Photoshop IRB\n";
|
||||
#endif
|
||||
return -2;
|
||||
}
|
||||
#ifdef EXIV2_DEBUG_MESSAGES
|
||||
if ((dataSize & 1) && position + dataSize == sizePsData) {
|
||||
std::cerr << "Warning: "
|
||||
<< "Photoshop IRB data is not padded to even size\n";
|
||||
}
|
||||
#endif
|
||||
if (type == psTag) {
|
||||
#ifdef EXIV2_DEBUG_MESSAGES
|
||||
std::cerr << "ok\n";
|
||||
#endif
|
||||
*sizeData = dataSize;
|
||||
*sizeHdr = psSize + 10;
|
||||
*record = hrd;
|
||||
return 0;
|
||||
}
|
||||
// Data size is also padded to be even
|
||||
position += dataSize + (dataSize & 1);
|
||||
}
|
||||
#ifdef EXIV2_DEBUG_MESSAGES
|
||||
std::cerr << "pPsData doesn't start with '8BIM'\n";
|
||||
#endif
|
||||
if (position < sizePsData) {
|
||||
#ifdef EXIV2_DEBUG_MESSAGES
|
||||
std::cerr << "Warning: "
|
||||
<< "Invalid or extended Photoshop IRB\n";
|
||||
#endif
|
||||
return -2;
|
||||
}
|
||||
return 3;
|
||||
}
|
||||
|
||||
int Photoshop::locateIptcIrb(const byte* pPsData, size_t sizePsData, const byte** record, uint32_t* const sizeHdr,
|
||||
uint32_t* const sizeData) {
|
||||
return locateIrb(pPsData, sizePsData, iptc_, record, sizeHdr, sizeData);
|
||||
}
|
||||
|
||||
int Photoshop::locatePreviewIrb(const byte* pPsData, size_t sizePsData, const byte** record, uint32_t* const sizeHdr,
|
||||
uint32_t* const sizeData) {
|
||||
return locateIrb(pPsData, sizePsData, preview_, record, sizeHdr, sizeData);
|
||||
}
|
||||
|
||||
DataBuf Photoshop::setIptcIrb(const byte* pPsData, size_t sizePsData, const IptcData& iptcData) {
|
||||
#ifdef EXIV2_DEBUG_MESSAGES
|
||||
std::cerr << "IRB block at the beginning of Photoshop::setIptcIrb\n";
|
||||
if (sizePsData == 0)
|
||||
std::cerr << " None.\n";
|
||||
else
|
||||
hexdump(std::cerr, pPsData, sizePsData);
|
||||
#endif
|
||||
const byte* record = pPsData;
|
||||
uint32_t sizeIptc = 0;
|
||||
uint32_t sizeHdr = 0;
|
||||
DataBuf rc;
|
||||
if (0 > Photoshop::locateIptcIrb(pPsData, sizePsData, &record, &sizeHdr, &sizeIptc)) {
|
||||
return rc;
|
||||
}
|
||||
|
||||
Blob psBlob;
|
||||
const auto sizeFront = static_cast<size_t>(record - pPsData);
|
||||
// Write data before old record.
|
||||
if (sizePsData > 0 && sizeFront > 0) {
|
||||
append(psBlob, pPsData, sizeFront);
|
||||
}
|
||||
|
||||
// Write new iptc record if we have it
|
||||
DataBuf rawIptc = IptcParser::encode(iptcData);
|
||||
if (!rawIptc.empty()) {
|
||||
std::array<byte, 12> tmpBuf;
|
||||
std::copy_n(Photoshop::irbId_[0], 4, tmpBuf.data());
|
||||
us2Data(tmpBuf.data() + 4, iptc_, bigEndian);
|
||||
tmpBuf[6] = 0;
|
||||
tmpBuf[7] = 0;
|
||||
ul2Data(tmpBuf.data() + 8, static_cast<uint32_t>(rawIptc.size()), bigEndian);
|
||||
append(psBlob, tmpBuf.data(), 12);
|
||||
append(psBlob, rawIptc.c_data(), rawIptc.size());
|
||||
// Data is padded to be even (but not included in size)
|
||||
if (rawIptc.size() & 1)
|
||||
psBlob.push_back(0x00);
|
||||
}
|
||||
|
||||
// Write existing stuff after record, skip the current and all remaining IPTC blocks
|
||||
size_t pos = sizeFront;
|
||||
long nextSizeData = Safe::add<long>(static_cast<long>(sizePsData), -static_cast<long>(pos));
|
||||
enforce(nextSizeData >= 0, ErrorCode::kerCorruptedMetadata);
|
||||
while (0 == Photoshop::locateIptcIrb(pPsData + pos, nextSizeData, &record, &sizeHdr, &sizeIptc)) {
|
||||
const auto newPos = static_cast<size_t>(record - pPsData);
|
||||
if (newPos > pos) { // Copy data up to the IPTC IRB
|
||||
append(psBlob, pPsData + pos, newPos - pos);
|
||||
}
|
||||
pos = newPos + sizeHdr + sizeIptc + (sizeIptc & 1); // Skip the IPTC IRB
|
||||
nextSizeData = Safe::add<long>(static_cast<long>(sizePsData), -static_cast<long>(pos));
|
||||
enforce(nextSizeData >= 0, ErrorCode::kerCorruptedMetadata);
|
||||
}
|
||||
if (pos < sizePsData) {
|
||||
append(psBlob, pPsData + pos, sizePsData - pos);
|
||||
}
|
||||
|
||||
// Data is rounded to be even
|
||||
if (!psBlob.empty())
|
||||
rc = DataBuf(&psBlob[0], psBlob.size());
|
||||
#ifdef EXIV2_DEBUG_MESSAGES
|
||||
std::cerr << "IRB block at the end of Photoshop::setIptcIrb\n";
|
||||
if (rc.empty())
|
||||
std::cerr << " None.\n";
|
||||
else
|
||||
hexdump(std::cerr, rc.c_data(), rc.size());
|
||||
#endif
|
||||
return rc;
|
||||
}
|
||||
|
||||
} // namespace Exiv2
|
||||
Loading…
Reference in New Issue