void TestKeePass2Format::initTestCase() { QVERIFY(Crypto::init()); // read raw XML database bool hasError; QString errorString; m_xmlDb = readXml(QString(KEEPASSX_TEST_DATA_DIR).append("/NewDatabase.xml"), true, hasError, errorString); if (hasError) { QFAIL(qPrintable(QString("Error while reading XML: ").append(errorString))); } QVERIFY(m_xmlDb.data()); // construct and write KDBX to buffer auto key = QSharedPointer<CompositeKey>::create(); key->addKey(QSharedPointer<PasswordKey>::create("test")); m_kdbxSourceDb = QSharedPointer<Database>::create(); m_kdbxSourceDb->setKey(key); m_kdbxSourceDb->metadata()->setName("TESTDB"); Group* group = m_kdbxSourceDb->rootGroup(); group->setUuid(QUuid::createUuid()); group->setNotes("I'm a note!"); auto entry = new Entry(); entry->setPassword(QString::fromUtf8("\xc3\xa4\xa3\xb6\xc3\xbc\xe9\x9b\xbb\xe7\xb4\x85")); entry->setUuid(QUuid::createUuid()); entry->attributes()->set("test", "protectedTest", true); QVERIFY(entry->attributes()->isProtected("test")); entry->attachments()->set("myattach.txt", QByteArray("this is an attachment")); entry->attachments()->set("aaa.txt", QByteArray("also an attachment")); entry->setGroup(group); auto groupNew = new Group(); groupNew->setUuid(QUuid::createUuid()); groupNew->setName("TESTGROUP"); groupNew->setNotes("I'm a sub group note!"); groupNew->setParent(group); m_kdbxTargetBuffer.open(QBuffer::ReadWrite); writeKdbx(&m_kdbxTargetBuffer, m_kdbxSourceDb.data(), hasError, errorString); if (hasError) { QFAIL(qPrintable(QString("Error while writing database: ").append(errorString))); } // call sub class init method initTestCaseImpl(); }
void Attachments::remove() { QListWidgetItem *listItem = attList->currentItem(); if( !listItem || !item ) return; delete listItem; item->setAttachments( attachments() ); }
QVariant NewsFeedModel::data(const QModelIndex &index, int role) const { int row = index.row(); auto news = m_newsList.at(row); switch (role) { case TypeRole: return news.type(); case PostIdRole: return news.postId(); break; case SourceRole: { int source = news.sourceId(); return qVariantFromValue(findContact(source)); } case DateRole: return news.date(); case BodyRole: return news.body(); case AttachmentsRole: return vk::Attachment::toVariantMap(news.attachments()); case LikesRole: return news.likes(); case RepostsRole: return news.reposts(); case CommentsRole: return news.property("comments"); case OwnerNameRole: { int ownerId = news.property("copy_owner_id").toInt(); if (ownerId) { auto contact = findContact(ownerId); return contact->name(); } return QVariant(); } case SourcePhotoRole: { if (auto contact = findContact(news.sourceId())) return contact->photoSource(); break; } case SourceNameRole: { if (auto contact = findContact(news.sourceId())) return contact->name(); break; } case LikesCount: { return news.likes().value("count").toInt(); } case CommentsCount: return news.property("comments").toMap().value("count").toInt(); default: break; } return QVariant::Invalid; }
nsresult nsEudoraCompose::GetLocalAttachments(nsIArray **aArray) { /* nsIURI *url = nullptr; */ nsresult rv; nsCOMPtr<nsIMutableArray> attachments (do_CreateInstance(NS_ARRAY_CONTRACTID, &rv)); NS_ENSURE_SUCCESS(rv, rv); NS_IF_ADDREF(*aArray = attachments); int32_t count = 0; if (m_pAttachments) count = m_pAttachments->Length(); if (!count) return NS_OK; nsCString urlStr; ImportAttachment * pAttach; for (int32_t i = 0; i < count; i++) { nsCOMPtr<nsIMsgAttachedFile> a(do_CreateInstance(NS_MSGATTACHEDFILE_CONTRACTID, &rv)); NS_ENSURE_SUCCESS(rv, rv); // nsMsgNewURL(&url, "file://C:/boxster.jpg"); // a[i].orig_url = url; pAttach = m_pAttachments->ElementAt(i); nsCOMPtr<nsIFile> tmpFile = do_QueryInterface(pAttach->pAttachment); a->SetTmpFile(tmpFile); urlStr.Adopt(0); nsCOMPtr <nsIURI> uri; nsresult rv = NS_NewFileURI(getter_AddRefs(uri), pAttach->pAttachment); NS_ENSURE_SUCCESS(rv, rv); uri->GetSpec(urlStr); if (urlStr.IsEmpty()) return NS_ERROR_FAILURE; nsCOMPtr<nsIURI> origUrl; rv = m_pIOService->NewURI(urlStr, nullptr, nullptr, getter_AddRefs(origUrl)); NS_ENSURE_SUCCESS(rv, rv); a->SetOrigUrl(origUrl); a->SetType(nsDependentCString(pAttach->mimeType)); a->SetRealName(nsDependentCString(pAttach->description)); a->SetEncoding(NS_LITERAL_CSTRING(ENCODING_BINARY)); attachments->AppendElement(a, false); } return NS_OK; }
void Attachments::add() { if( !item ) return; AttDialog dialog; int result = dialog.exec(); if( result == QDialog::Rejected //|| dialog.name().isEmpty() || dialog.uri().isEmpty() ) return; QListWidgetItem *item = new QListWidgetItem( attList ); item->setText( !dialog.name().isEmpty() ? dialog.name() : dialog.uri() ); item->setToolTip( dialog.uri() ); item->setData( URI_ROLE, dialog.uri() ); this->item->setAttachments( attachments() ); }
nsresult CMapiMessage::GetAttachments(nsIArray **aArray) { nsresult rv; nsCOMPtr<nsIMutableArray> attachments (do_CreateInstance(NS_ARRAY_CONTRACTID, &rv)); NS_ENSURE_SUCCESS(rv, rv); NS_IF_ADDREF(*aArray = attachments); for (std::vector<attach_data*>::const_iterator it = m_stdattachments.begin(); it != m_stdattachments.end(); it++) { nsCOMPtr<nsIMsgAttachedFile> a(do_CreateInstance(NS_MSGATTACHEDFILE_CONTRACTID, &rv)); NS_ENSURE_SUCCESS(rv, rv); a->SetOrigUrl((*it)->orig_url); a->SetTmpFile((*it)->tmp_file); a->SetEncoding(nsDependentCString((*it)->encoding)); a->SetRealName(nsDependentCString((*it)->real_name)); a->SetType(nsDependentCString((*it)->type)); attachments->AppendElement(a, false); } return rv; }
VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) { VkRenderPassCreateInfo intercepted = *pCreateInfo; std::vector<VkAttachmentDescription> attachments( pCreateInfo->attachmentCount); for (size_t i = 0; i < pCreateInfo->attachmentCount; ++i) { attachments[i] = pCreateInfo->pAttachments[i]; if (attachments[i].initialLayout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR) { attachments[i].initialLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; } if (attachments[i].finalLayout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR) { attachments[i].finalLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; } } PFN_vkCreateRenderPass func = GetGlobalContext().GetDeviceData(device)->vkCreateRenderPass; return func(device, &intercepted, pAllocator, pRenderPass); }
void TestKeePass2Format::testKdbxDeviceFailure() { auto key = QSharedPointer<CompositeKey>::create(); key->addKey(QSharedPointer<PasswordKey>::create("test")); QScopedPointer<Database> db(new Database()); db->setKey(key); // Disable compression so we write a predictable number of bytes. db->setCompressionAlgorithm(Database::CompressionNone); auto entry = new Entry(); entry->setParent(db->rootGroup()); QByteArray attachment(4096, 'Z'); entry->attachments()->set("test", attachment); FailDevice failDevice(512); QVERIFY(failDevice.open(QIODevice::WriteOnly)); bool hasError; QString errorString; writeKdbx(&failDevice, db.data(), hasError, errorString); QVERIFY(hasError); QCOMPARE(errorString, QString("FAILDEVICE")); }
QMessageId addMessage(const Parameters ¶ms) { QString parentAccountName(params["parentAccountName"]); QString parentFolderPath(params["parentFolderPath"]); QString to(params["to"]); QString from(params["from"]); QString cc(params["cc"]); QString bcc(params["bcc"]); QString date(params["date"]); QString receivedDate(params["receivedDate"]); QString subject(params["subject"]); QString text(params["text"]); QString mimeType(params["mimeType"]); QString attachments(params["attachments"]); QString priority(params["priority"]); QString size(params["size"]); QString type(params["type"]); QString read(params["status-read"]); QString hasAttachments(params["status-hasAttachments"]); QMessageManager mgr; if (!to.isEmpty() && !from.isEmpty() && !date.isEmpty() && !subject.isEmpty() && !parentAccountName.isEmpty() && !parentFolderPath.isEmpty()) { // Find the named account QMessageAccountIdList accountIds(mgr.queryAccounts(QMessageAccountFilter::byName(parentAccountName))); if (accountIds.count() == 1) { // Find the specified folder QMessageFolderFilter filter(QMessageFolderFilter::byPath(parentFolderPath, QMessageDataComparator::Equal) & QMessageFolderFilter::byParentAccountId(accountIds.first())); QMessageFolderIdList folderIds(mgr.queryFolders(filter)); if (folderIds.count() == 1) { QMessage message; QMessagePrivate *p = MapiSession::privateMessage(message); message.setParentAccountId(accountIds.first()); p->_parentFolderId = folderIds.first(); QMessage::StatusFlags flags(0); if (read.toLower() == "true") { flags |= QMessage::Read; } if (hasAttachments.toLower() == "true") { flags |= QMessage::HasAttachments; } message.setStatus(flags); QList<QMessageAddress> toList; foreach (const QString &addr, to.split(",", QString::SkipEmptyParts)) { toList.append(QMessageAddress(QMessageAddress::Email, addr.trimmed())); } message.setTo(toList); QList<QMessageAddress> ccList; foreach (const QString &addr, cc.split(",", QString::SkipEmptyParts)) { ccList.append(QMessageAddress(QMessageAddress::Email, addr.trimmed())); } if (!ccList.isEmpty()) { message.setCc(ccList); } QList<QMessageAddress> bccList; foreach (const QString &addr, bcc.split(",")) { if (!addr.isEmpty()) { bccList.append(QMessageAddress(QMessageAddress::Email, addr.trimmed())); } } message.setBcc(bccList); message.setFrom(QMessageAddress(QMessageAddress::Email, from)); message.setSubject(subject); QDateTime dt(QDateTime::fromString(date, Qt::ISODate)); dt.setTimeSpec(Qt::UTC); message.setDate(dt); if (type.isEmpty()) { message.setType(QMessage::Email); } else { if (type.toLower() == "mms") { message.setType(QMessage::Mms); } else if (type.toLower() == "sms") { message.setType(QMessage::Sms); } else if (type.toLower() == "instantmessage") { message.setType(QMessage::InstantMessage); } else { message.setType(QMessage::Email); } } if (!receivedDate.isEmpty()) { QDateTime dt(QDateTime::fromString(receivedDate, Qt::ISODate)); dt.setTimeSpec(Qt::UTC); message.setReceivedDate(dt); } if (!priority.isEmpty()) { if (priority.toLower() == "high") { message.setPriority(QMessage::HighPriority); } else if (priority.toLower() == "low") { message.setPriority(QMessage::LowPriority); } } if (!text.isEmpty()) { message.setBody(text, mimeType.toAscii()); } if (!attachments.isEmpty()) { qDebug() << attachments; message.appendAttachments(attachments.split("\n")); } else { qDebug() << "Support: No attchments"; } if (!size.isEmpty()) { p->_size = size.toUInt(); } if (!mgr.addMessage(&message)) { qWarning() << "Unable to addMessage:" << to << from << date << subject; } else { return message.id(); } } else {
bool Connection::processMessage() { if (m_readBufferSize < sizeof(MessageInfo)) return false; uint8_t* messageData = m_readBuffer.data(); MessageInfo messageInfo; memcpy(&messageInfo, messageData, sizeof(messageInfo)); messageData += sizeof(messageInfo); size_t messageLength = sizeof(MessageInfo) + messageInfo.attachmentCount() * sizeof(AttachmentInfo) + (messageInfo.isMessageBodyIsOutOfLine() ? 0 : messageInfo.bodySize()); if (m_readBufferSize < messageLength) return false; size_t attachmentFileDescriptorCount = 0; size_t attachmentCount = messageInfo.attachmentCount(); std::unique_ptr<AttachmentInfo[]> attachmentInfo; if (attachmentCount) { attachmentInfo = std::make_unique<AttachmentInfo[]>(attachmentCount); memcpy(attachmentInfo.get(), messageData, sizeof(AttachmentInfo) * attachmentCount); messageData += sizeof(AttachmentInfo) * attachmentCount; for (size_t i = 0; i < attachmentCount; ++i) { switch (attachmentInfo[i].getType()) { case Attachment::MappedMemoryType: case Attachment::SocketType: if (!attachmentInfo[i].isNull()) attachmentFileDescriptorCount++; break; case Attachment::Uninitialized: default: ASSERT_NOT_REACHED(); break; } } if (messageInfo.isMessageBodyIsOutOfLine()) attachmentCount--; } Vector<Attachment> attachments(attachmentCount); AttachmentResourceGuard<Vector<Attachment>, Vector<Attachment>::iterator> attachementDisposer(attachments); RefPtr<WebKit::SharedMemory> oolMessageBody; size_t fdIndex = 0; for (size_t i = 0; i < attachmentCount; ++i) { int fd = -1; switch (attachmentInfo[i].getType()) { case Attachment::MappedMemoryType: if (!attachmentInfo[i].isNull()) fd = m_fileDescriptors[fdIndex++]; attachments[attachmentCount - i - 1] = Attachment(fd, attachmentInfo[i].getSize()); break; case Attachment::SocketType: if (!attachmentInfo[i].isNull()) fd = m_fileDescriptors[fdIndex++]; attachments[attachmentCount - i - 1] = Attachment(fd); break; case Attachment::Uninitialized: attachments[attachmentCount - i - 1] = Attachment(); default: break; } } if (messageInfo.isMessageBodyIsOutOfLine()) { ASSERT(messageInfo.bodySize()); if (attachmentInfo[attachmentCount].isNull()) { ASSERT_NOT_REACHED(); return false; } WebKit::SharedMemory::Handle handle; handle.adoptFromAttachment(m_fileDescriptors[attachmentFileDescriptorCount - 1], attachmentInfo[attachmentCount].getSize()); oolMessageBody = WebKit::SharedMemory::create(handle, WebKit::SharedMemory::ReadOnly); if (!oolMessageBody) { ASSERT_NOT_REACHED(); return false; } } ASSERT(attachments.size() == (messageInfo.isMessageBodyIsOutOfLine() ? messageInfo.attachmentCount() - 1 : messageInfo.attachmentCount())); uint8_t* messageBody = messageData; if (messageInfo.isMessageBodyIsOutOfLine()) messageBody = reinterpret_cast<uint8_t*>(oolMessageBody->data()); auto decoder = std::make_unique<MessageDecoder>(DataReference(messageBody, messageInfo.bodySize()), std::move(attachments)); processIncomingMessage(std::move(decoder)); if (m_readBufferSize > messageLength) { memmove(m_readBuffer.data(), m_readBuffer.data() + messageLength, m_readBufferSize - messageLength); m_readBufferSize -= messageLength; } else m_readBufferSize = 0; if (attachmentFileDescriptorCount) { if (m_fileDescriptorsSize > attachmentFileDescriptorCount) { size_t fileDescriptorsLength = attachmentFileDescriptorCount * sizeof(int); memmove(m_fileDescriptors.data(), m_fileDescriptors.data() + fileDescriptorsLength, m_fileDescriptorsSize - fileDescriptorsLength); m_fileDescriptorsSize -= fileDescriptorsLength; } else m_fileDescriptorsSize = 0; } return true; }
agpu_framebuffer *_agpu_framebuffer::create(agpu_device *device, agpu_uint width, agpu_uint height, agpu_uint colorCount, agpu_texture_view_description* colorViews, agpu_texture_view_description* depthStencilView) { agpu_framebuffer *result = nullptr; // Attachments std::vector<VkAttachmentDescription> attachments(colorCount + (depthStencilView != nullptr ? 1 : 0)); for (agpu_uint i = 0; i < colorCount; ++i) { auto view = &colorViews[i]; auto &attachment = attachments[i]; if (!view || !view->texture) return nullptr; attachment.format = mapTextureFormat(view->format); attachment.samples = VK_SAMPLE_COUNT_1_BIT; attachment.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD; attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE; attachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; attachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; attachment.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; attachment.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; } if (depthStencilView != nullptr) { if (!depthStencilView->texture) return nullptr; auto &attachment = attachments.back(); attachment.format = mapTextureFormat(depthStencilView->format); attachment.samples = VK_SAMPLE_COUNT_1_BIT; attachment.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD; attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE; attachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD; attachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE; attachment.initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; attachment.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; } // Color reference std::vector<VkAttachmentReference> colorReference(colorCount); for (agpu_uint i = 0; i < colorCount; ++i) { colorReference[i].attachment = i; colorReference[i].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; } // Depth reference VkAttachmentReference depthReference; memset(&depthReference, 0, sizeof(depthReference)); depthReference.attachment = colorCount; depthReference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; // Sub pass VkSubpassDescription subpass; memset(&subpass, 0, sizeof(subpass)); subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; subpass.colorAttachmentCount = colorCount; subpass.pColorAttachments = &colorReference[0]; subpass.pDepthStencilAttachment = &depthReference; if (!depthStencilView) subpass.pDepthStencilAttachment = nullptr; // Render pass VkRenderPassCreateInfo renderPassCreateInfo; memset(&renderPassCreateInfo, 0, sizeof(renderPassCreateInfo)); renderPassCreateInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; renderPassCreateInfo.attachmentCount = attachments.size(); renderPassCreateInfo.pAttachments = &attachments[0]; renderPassCreateInfo.subpassCount = 1; renderPassCreateInfo.pSubpasses = &subpass; VkRenderPass renderPass; auto error = vkCreateRenderPass(device->device, &renderPassCreateInfo, nullptr, &renderPass); if (error) return nullptr; // Create the framebuffer std::vector<VkImageView> attachmentViews(attachments.size()); for (agpu_uint i = 0; i < colorCount; ++i) { auto view = agpu_texture::createImageView(device, &colorViews[i]); if (!view) goto failure; attachmentViews[i] = view; } if (depthStencilView) { auto view = agpu_texture::createImageView(device, depthStencilView); if (!view) goto failure; attachmentViews.back() = view; } VkFramebufferCreateInfo createInfo; memset(&createInfo, 0, sizeof(createInfo)); createInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; createInfo.attachmentCount = attachmentViews.size(); createInfo.pAttachments = &attachmentViews[0]; createInfo.renderPass = renderPass; createInfo.width = width; createInfo.height = height; createInfo.layers = 1; VkFramebuffer framebuffer; error = vkCreateFramebuffer(device->device, &createInfo, nullptr, &framebuffer); if (error) goto failure; result = new agpu_framebuffer(device); result->colorCount = colorCount; result->hasDepthStencil = depthStencilView != nullptr; result->width = width; result->height = height; result->renderPass = renderPass; result->framebuffer = framebuffer; result->attachmentViews = attachmentViews; result->attachmentTextures.resize(attachmentViews.size()); for (agpu_uint i = 0; i < colorCount; ++i) { auto texture = colorViews[i].texture; texture->retain(); result->attachmentTextures[i] = texture; } if (depthStencilView) { auto texture = depthStencilView->texture; texture->retain(); result->attachmentTextures.back() = texture; } return result; failure: vkDestroyRenderPass(device->device, renderPass, nullptr); for (auto view : attachmentViews) { if (view) vkDestroyImageView(device->device, view, nullptr); } return nullptr; }
QByteArray QxtMailMessage::rfc2822() const { // Use quoted-printable if requested bool useQuotedPrintable = (extraHeader(QStringLiteral("Content-Transfer-Encoding")).toLower() == QLatin1String("quoted-printable")); // Use base64 if requested bool useBase64 = (extraHeader(QStringLiteral("Content-Transfer-Encoding")).toLower() == QLatin1String("base64")); // Check to see if plain text is ASCII-clean; assume it isn't if QP or base64 was requested QTextCodec* latin1 = QTextCodec::codecForName("latin1"); bool bodyIsAscii = latin1->canEncode(body()) && !useQuotedPrintable && !useBase64; QHash<QString, QxtMailAttachment> attach = attachments(); QByteArray rv; if (!sender().isEmpty() && !hasExtraHeader(QStringLiteral("From"))) { rv += qxt_fold_mime_header(QStringLiteral("From"), sender(), latin1); } if (!qxt_d->rcptTo.isEmpty()) { rv += qxt_fold_mime_header(QStringLiteral("To"), qxt_d->rcptTo.join(QStringLiteral(", ")), latin1); } if (!qxt_d->rcptCc.isEmpty()) { rv += qxt_fold_mime_header(QStringLiteral("Cc"), qxt_d->rcptCc.join(QStringLiteral(", ")), latin1); } if (!subject().isEmpty()) { rv += qxt_fold_mime_header(QStringLiteral("Subject"), subject(), latin1); } if (!bodyIsAscii) { if (!hasExtraHeader(QStringLiteral("MIME-Version")) && !attach.count()) rv += "MIME-Version: 1.0\r\n"; // If no transfer encoding has been requested, guess. // Heuristic: If >20% of the first 100 characters aren't // 7-bit clean, use base64, otherwise use Q-P. if(!bodyIsAscii && !useQuotedPrintable && !useBase64) { QString b = body(); int nonAscii = 0; int ct = b.length(); for (int i = 0; i < ct && i < 100; i++) { if (QXT_MUST_QP(b[i])) nonAscii++; } useQuotedPrintable = !(nonAscii > 20); useBase64 = !useQuotedPrintable; } } if (attach.count()) { if (qxt_d->boundary.isEmpty()) qxt_d->boundary = QUuid::createUuid().toString().toLatin1().replace("{", "").replace("}", ""); if (!hasExtraHeader(QStringLiteral("MIME-Version"))) rv += "MIME-Version: 1.0\r\n"; if (!hasExtraHeader(QStringLiteral("Content-Type"))) rv += "Content-Type: multipart/mixed; boundary=" + qxt_d->boundary + "\r\n"; } else if (!bodyIsAscii && !hasExtraHeader(QStringLiteral("Content-Transfer-Encoding"))) { if (!useQuotedPrintable) { // base64 rv += "Content-Transfer-Encoding: base64\r\n"; } else { // quoted-printable rv += "Content-Transfer-Encoding: quoted-printable\r\n"; } } for(const QString& r: qxt_d->extraHeaders.keys()) { if ((r.toLower() == QLatin1String("content-type") || r.toLower() == QLatin1String("content-transfer-encoding")) && attach.count()) { // Since we're in multipart mode, we'll be outputting this later continue; } rv += qxt_fold_mime_header(r, extraHeader(r), latin1); } rv += "\r\n"; if (attach.count()) { // we're going to have attachments, so output the lead-in for the message body rv += "This is a message with multiple parts in MIME format.\r\n"; rv += "--" + qxt_d->boundary + "\r\nContent-Type: "; if (hasExtraHeader(QStringLiteral("Content-Type"))) rv += extraHeader(QStringLiteral("Content-Type")).toLatin1() + "\r\n"; else rv += "text/plain; charset=UTF-8\r\n"; if (hasExtraHeader(QStringLiteral("Content-Transfer-Encoding"))) { rv += "Content-Transfer-Encoding: " + extraHeader(QStringLiteral("Content-Transfer-Encoding")).toLatin1() + "\r\n"; } else if (!bodyIsAscii) { if (!useQuotedPrintable) { // base64 rv += "Content-Transfer-Encoding: base64\r\n"; } else { // quoted-printable rv += "Content-Transfer-Encoding: quoted-printable\r\n"; } } rv += "\r\n"; } if (bodyIsAscii) { QByteArray b = latin1->fromUnicode(body()); int len = b.length(); QByteArray line = ""; QByteArray word = ""; for (int i = 0; i < len; i++) { if (b[i] == '\n' || b[i] == '\r') { if (line.isEmpty()) { line = word; word = ""; } else if (line.length() + word.length() + 1 <= 78) { line = line + ' ' + word; word = ""; } if(line[0] == '.') rv += "."; rv += line + "\r\n"; if ((b[i+1] == '\n' || b[i+1] == '\r') && b[i] != b[i+1]) { // If we're looking at a CRLF pair, skip the second half i++; } line = word; } else if (b[i] == ' ') { if (line.length() + word.length() + 1 > 78) { if(line[0] == '.') rv += "."; rv += line + "\r\n"; line = word; } else if (line.isEmpty()) { line = word; } else { line = line + ' ' + word; } word = ""; } else { word += b[i]; } } if (line.length() + word.length() + 1 > 78) { if(line[0] == '.') rv += "."; rv += line + "\r\n"; line = word; } else if (!word.isEmpty()) { line += ' ' + word; } if(!line.isEmpty()) { if(line[0] == '.') rv += "."; rv += line + "\r\n"; } } else if (useQuotedPrintable) { QByteArray b = body().toUtf8(); int ct = b.length(); QByteArray line; for (int i = 0; i < ct; i++) { if(b[i] == '\n' || b[i] == '\r') { if(line[0] == '.') rv += "."; rv += line + "\r\n"; line = ""; if ((b[i+1] == '\n' || b[i+1] == '\r') && b[i] != b[i+1]) { // If we're looking at a CRLF pair, skip the second half i++; } } else if (line.length() > 74) { rv += line + "=\r\n"; line = ""; } if (QXT_MUST_QP(b[i])) { line += "=" + b.mid(i, 1).toHex().toUpper(); } else { line += b[i]; } } if(!line.isEmpty()) { if(line[0] == '.') rv += "."; rv += line + "\r\n"; } } else /* base64 */ { QByteArray b = body().toUtf8().toBase64(); int ct = b.length(); for (int i = 0; i < ct; i += 78) { rv += b.mid(i, 78) + "\r\n"; } } if (attach.count()) { for(const QString& filename: attach.keys()) { rv += "--" + qxt_d->boundary + "\r\n"; rv += qxt_fold_mime_header(QStringLiteral("Content-Disposition"), QDir(filename).dirName(), latin1, "attachment; filename="); rv += attach[filename].mimeData(); } rv += "--" + qxt_d->boundary + "--\r\n"; } return rv; }
/** * Test for catching mapping errors with duplicate attachments. */ void TestKeePass2Format::testDuplicateAttachments() { auto db = QSharedPointer<Database>::create(); db->setKey(QSharedPointer<CompositeKey>::create()); const QByteArray attachment1("abc"); const QByteArray attachment2("def"); const QByteArray attachment3("ghi"); auto entry1 = new Entry(); entry1->setGroup(db->rootGroup()); entry1->setUuid(QUuid::fromRfc4122("aaaaaaaaaaaaaaaa")); entry1->attachments()->set("a", attachment1); auto entry2 = new Entry(); entry2->setGroup(db->rootGroup()); entry2->setUuid(QUuid::fromRfc4122("bbbbbbbbbbbbbbbb")); entry2->attachments()->set("b1", attachment1); entry2->beginUpdate(); entry2->attachments()->set("b2", attachment1); entry2->endUpdate(); entry2->beginUpdate(); entry2->attachments()->set("b3", attachment2); entry2->endUpdate(); entry2->beginUpdate(); entry2->attachments()->set("b4", attachment2); entry2->endUpdate(); auto entry3 = new Entry(); entry3->setGroup(db->rootGroup()); entry3->setUuid(QUuid::fromRfc4122("cccccccccccccccc")); entry3->attachments()->set("c1", attachment2); entry3->attachments()->set("c2", attachment2); entry3->attachments()->set("c3", attachment3); QBuffer buffer; buffer.open(QBuffer::ReadWrite); bool hasError = false; QString errorString; writeKdbx(&buffer, db.data(), hasError, errorString); if (hasError) { QFAIL(qPrintable(QString("Error while writing database: %1").arg(errorString))); } buffer.seek(0); readKdbx(&buffer, QSharedPointer<CompositeKey>::create(), db, hasError, errorString); if (hasError) { QFAIL(qPrintable(QString("Error while reading database: %1").arg(errorString))); } QCOMPARE(db->rootGroup()->entries()[0]->attachments()->value("a"), attachment1); QCOMPARE(db->rootGroup()->entries()[1]->attachments()->value("b1"), attachment1); QCOMPARE(db->rootGroup()->entries()[1]->attachments()->value("b2"), attachment1); QCOMPARE(db->rootGroup()->entries()[1]->attachments()->value("b3"), attachment2); QCOMPARE(db->rootGroup()->entries()[1]->attachments()->value("b4"), attachment2); QCOMPARE(db->rootGroup()->entries()[1]->historyItems()[0]->attachments()->value("b1"), attachment1); QCOMPARE(db->rootGroup()->entries()[1]->historyItems()[1]->attachments()->value("b1"), attachment1); QCOMPARE(db->rootGroup()->entries()[1]->historyItems()[1]->attachments()->value("b2"), attachment1); QCOMPARE(db->rootGroup()->entries()[1]->historyItems()[2]->attachments()->value("b1"), attachment1); QCOMPARE(db->rootGroup()->entries()[1]->historyItems()[2]->attachments()->value("b2"), attachment1); QCOMPARE(db->rootGroup()->entries()[1]->historyItems()[2]->attachments()->value("b3"), attachment2); QCOMPARE(db->rootGroup()->entries()[2]->attachments()->value("c1"), attachment2); QCOMPARE(db->rootGroup()->entries()[2]->attachments()->value("c2"), attachment2); QCOMPARE(db->rootGroup()->entries()[2]->attachments()->value("c3"), attachment3); }
void GrVkRenderPass::init(const GrVkGpu* gpu, const LoadStoreOps& colorOp, const LoadStoreOps& resolveOp, const LoadStoreOps& stencilOp) { uint32_t numAttachments = fAttachmentsDescriptor.fAttachmentCount; // Attachment descriptions to be set on the render pass SkTArray<VkAttachmentDescription> attachments(numAttachments); attachments.reset(numAttachments); memset(attachments.begin(), 0, numAttachments * sizeof(VkAttachmentDescription)); // Refs to attachments on the render pass (as described by teh VkAttachmentDescription above), // that are used by the subpass. VkAttachmentReference colorRef; VkAttachmentReference resolveRef; VkAttachmentReference stencilRef; uint32_t currentAttachment = 0; // Go through each of the attachment types (color, resolve, stencil) and set the necessary // on the various Vk structs. VkSubpassDescription subpassDesc; memset(&subpassDesc, 0, sizeof(VkSubpassDescription)); subpassDesc.flags = 0; subpassDesc.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; subpassDesc.inputAttachmentCount = 0; subpassDesc.pInputAttachments = nullptr; if (fAttachmentFlags & kColor_AttachmentFlag) { // set up color attachment fAttachmentsDescriptor.fColor.fLoadStoreOps = colorOp; setup_vk_attachment_description(&attachments[currentAttachment], fAttachmentsDescriptor.fColor, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); // setup subpass use of attachment colorRef.attachment = currentAttachment++; colorRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; subpassDesc.colorAttachmentCount = 1; } else { // I don't think there should ever be a time where we don't have a color attachment SkASSERT(false); colorRef.attachment = VK_ATTACHMENT_UNUSED; colorRef.layout = VK_IMAGE_LAYOUT_UNDEFINED; subpassDesc.colorAttachmentCount = 0; } subpassDesc.pColorAttachments = &colorRef; if (fAttachmentFlags & kResolve_AttachmentFlag) { // set up resolve attachment fAttachmentsDescriptor.fResolve.fLoadStoreOps = resolveOp; setup_vk_attachment_description(&attachments[currentAttachment], fAttachmentsDescriptor.fResolve, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); // setup subpass use of attachment resolveRef.attachment = currentAttachment++; // I'm really not sure what the layout should be for the resolve textures. resolveRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; subpassDesc.pResolveAttachments = &resolveRef; } else { subpassDesc.pResolveAttachments = nullptr; } if (fAttachmentFlags & kStencil_AttachmentFlag) { // set up stencil attachment fAttachmentsDescriptor.fStencil.fLoadStoreOps = stencilOp; setup_vk_attachment_description(&attachments[currentAttachment], fAttachmentsDescriptor.fStencil, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); // setup subpass use of attachment stencilRef.attachment = currentAttachment++; stencilRef.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; } else { stencilRef.attachment = VK_ATTACHMENT_UNUSED; stencilRef.layout = VK_IMAGE_LAYOUT_UNDEFINED; } subpassDesc.pDepthStencilAttachment = &stencilRef; subpassDesc.preserveAttachmentCount = 0; subpassDesc.pPreserveAttachments = nullptr; SkASSERT(numAttachments == currentAttachment); // Create the VkRenderPass compatible with the attachment descriptions above VkRenderPassCreateInfo createInfo; memset(&createInfo, 0, sizeof(VkRenderPassCreateInfo)); createInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; createInfo.pNext = nullptr; createInfo.flags = 0; createInfo.attachmentCount = numAttachments; createInfo.pAttachments = attachments.begin(); createInfo.subpassCount = 1; createInfo.pSubpasses = &subpassDesc; createInfo.dependencyCount = 0; createInfo.pDependencies = nullptr; GR_VK_CALL_ERRCHECK(gpu->vkInterface(), CreateRenderPass(gpu->device(), &createInfo, nullptr, &fRenderPass)); }