//---------------------------------------------------------------------------
int QueueElement::attachment_cb(struct MediaInfo_Event_Global_AttachedFile_0 *Event)
{
std::string attachment((const char*)Event->Content, Event->Content_Size);
std::string realname = "Unknown";
if (Event->Name && Event->Name[0])
realname = std::string(Event->Name);
std::string path;
if (Core::create_local_unique_data_filename("MediaconchTemp", "attachment", "", path) < 0)
return 0;
std::ofstream ofs(path.c_str(), std::ofstream::out);
ofs.write(attachment.c_str(), attachment.size());
ofs.close();
Attachment *attach = new Attachment;
attach->filename = path;
attach->realname = realname;
attachments.push_back(attach);
return 0;
}
void DeriveKey::activate()
{
if (!mActive)
{
check(CSSM_CSP_CreateDeriveKeyContext(attachment()->handle(), mAlgorithm,
mTargetType, mKeySize, mCred, mKey, mIterationCount, mSalt, mSeed, &mHandle));
mActive = true;
}
}
Key
WrapKey::operator () (Key &keyToBeWrapped, const CssmData *descriptiveData)
{
Key wrappedKey;
check(CSSM_WrapKey(handle(), neededCred(), keyToBeWrapped, descriptiveData,
wrappedKey.makeNewKey(attachment())));
wrappedKey->activate();
return wrappedKey;
}
Key
DeriveKey::operator () (CssmData *param, const KeySpec &spec)
{
Key derivedKey;
check(CSSM_DeriveKey(handle(), param, spec.usage, spec.attributes,
spec.label, &compositeRcc(),
derivedKey.makeNewKey(attachment())));
derivedKey->activate();
return derivedKey;
}
FramebufferConfiguration FramebufferConfiguration::DefaultFramebuffer(int w, int h)
{
FramebufferConfiguration config(w,h);
RenderbufferAttachment attachment(GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL_ATTACHMENT);
config.addRenderbuffer(attachment);
TextureConfig tCfg("color", GL_RGB, GL_RGB, GL_UNSIGNED_BYTE);
tCfg.setWrapMode(GL_CLAMP_TO_BORDER);
TextureAttachment tbuffer(tCfg,GL_COLOR_ATTACHMENT0);
config.addTexturebuffer(tbuffer);
return config;
}
CameraAttachmentPtr CameraAttachment::New( EventThreadServices& eventThreadServices, const SceneGraph::Node& parentNode )
{
CameraAttachmentPtr attachment( new CameraAttachment( eventThreadServices ) );
// Transfer object ownership of scene-object to message
SceneGraph::CameraAttachment* sceneObject = CreateSceneObject();
AttachToNodeMessage( eventThreadServices.GetUpdateManager(), parentNode, sceneObject );
// Keep raw pointer for message passing
attachment->mSceneObject = sceneObject;
return attachment;
}
Key
UnwrapKey::operator () (const CssmKey &keyToBeUnwrapped, const KeySpec &spec)
{
CssmData data(reinterpret_cast<uint8 *>(1), 0);
Key unwrappedKey;
check(CSSM_UnwrapKey(handle(), NULL,
&keyToBeUnwrapped, spec.usage, spec.attributes,
spec.label, &compositeRcc(),
unwrappedKey.makeNewKey(attachment()), &data));
unwrappedKey->activate();
return unwrappedKey;
}
Key
UnwrapKey::operator () (const CssmKey &keyToBeUnwrapped, const KeySpec &spec,
CssmData *descriptiveData)
{
Key unwrappedKey;
check(CSSM_UnwrapKey(handle(), NULL, &keyToBeUnwrapped, spec.usage,
spec.attributes, spec.label, &compositeRcc(),
unwrappedKey.makeNewKey(attachment()),
descriptiveData));
unwrappedKey->activate();
return unwrappedKey;
}
void Pop3::Message::OnAttachment (GenericInput<'\0'> & input, std::string const & filename)
{
Base64::Decoder decoder;
std::auto_ptr<Attachment> attachment (new Pop3::Attachment (filename));
Pop3::Attachment::Storage::Output output (attachment->GetStorage ());
try
{
decoder.Decode (input, output);
}
catch (Base64::Exception e)
{
throw Pop3::MsgCorruptException (e.GetMessage ());
}
_attachments.push_back (attachment);
}
LightAttachmentPtr LightAttachment::New( const SceneGraph::Node& parentNode )
{
StagePtr stage = Stage::GetCurrent();
LightAttachmentPtr attachment( new LightAttachment( *stage ) );
// Transfer object ownership of scene-object to message
SceneGraph::LightAttachment* sceneObject = SceneGraph::LightAttachment::New();
sceneObject->SetLight( attachment->mCachedLight );
AttachToNodeMessage( stage->GetUpdateManager(), parentNode, sceneObject );
// Keep raw pointer for message passing
attachment->mSceneObject = sceneObject;
return attachment;
}
void FillLayer::computeCachedPropertiesIfNeeded() const
{
if (m_cachedPropertiesComputed)
return;
m_thisOrNextLayersClipMax = clip();
m_thisOrNextLayersUseContentBox = clip() == ContentFillBox || origin() == ContentFillBox;
m_thisOrNextLayersHaveLocalAttachment = attachment() == LocalBackgroundAttachment;
m_cachedPropertiesComputed = true;
if (m_next) {
m_next->computeCachedPropertiesIfNeeded();
m_thisOrNextLayersClipMax = clipMax(thisOrNextLayersClipMax(), m_next->thisOrNextLayersClipMax());
m_thisOrNextLayersUseContentBox |= m_next->m_thisOrNextLayersUseContentBox;
m_thisOrNextLayersHaveLocalAttachment |= m_next->m_thisOrNextLayersHaveLocalAttachment;
}
}
QString Chord::toString(MinorPolicy mpolicy, EnharmonicPolicy epolicy) const
{
QString text = baseString(epolicy);
if (isMinor())
{
switch (mpolicy)
{
case LowerCase:
text = text.toLower();
break;
case FollowingM:
text += "m";
break;
}
}
return m_before + text + attachment() + m_after;
}
HDRScene::HDRScene(Context * ctx):
camera(ctx->getWindowWidth(),ctx->getWindowHeight()),
woodTex(TextureConfig("assets/textures/wood.png",GL_SRGB,GL_RGB,GL_UNSIGNED_BYTE), 64.0f,
TextureConfig("assets/textures/solid_black.png"))
{
tunnel.transform.setScale(glm::vec3(5.0f, 5.0f, 55.0f));
tunnel.transform.translate(glm::vec3(0.0,0.0,25.0));
hdrExposureProg = createProgram("Phong lighting program");
hdrPostProcessProg = createProgram("HDR Postprocessing program");
FramebufferConfiguration config(ctx->getWindowWidth(),ctx->getWindowHeight());
TextureAttachment attachment(TextureConfig("color",GL_RGB16F,GL_RGB,GL_FLOAT),GL_COLOR_ATTACHMENT0);
config.addTexturebuffer(attachment);
config.addRenderbuffer(RenderbufferAttachment(GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL_ATTACHMENT));
framebuffer.init(config);
}
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"));
}
TextAttachmentPtr TextAttachment::New( const SceneGraph::Node& parentNode, const TextArray& text, FontPointer font, bool isLeftToRight )
{
StagePtr stage = Stage::GetCurrent();
TextAttachmentPtr attachment( new TextAttachment( *stage ) );
// Second-phase construction
attachment->mFont = font;
attachment->mText = text;
attachment->mIsLeftToRight = isLeftToRight;
// Transfer object ownership of scene-object to message
SceneGraph::TextAttachment* sceneObject = SceneGraph::TextAttachment::New();
AttachToNodeMessage( stage->GetUpdateManager(), parentNode, sceneObject );
// Keep raw pointer for message passing
attachment->mSceneObject = sceneObject;
attachment->SetSmoothEdge(attachment->mSmoothing); // adjust smoothedge for font weight
return attachment;
}
void Post::Serialize(Json::Value& root) {
// General Post
if(!id_.empty())
root["id"] = id_;
if(!entity_.empty())
root["entity"] = entity_;
/*
if(!published_at_.empty())
root["published_at"] = published_at_;
*/
if(licenses_.size() > 0) {
Json::Value licenses;
jsn::SerializeVector(licenses_, licenses);
root["licenses"] = licenses;
}
if(!type_.empty())
root["type"] = type_;
if(content_.size() > 0) {
Json::Value content(Json::objectValue);
jsn::SerializeMapIntoObject(content, content_);
root["content"] = content;
}
if(attachments_.size() > 0) {
Json::Value attachment_arr(Json::arrayValue);
AttachmentMap::iterator itr = attachments_.begin();
for(;itr!= attachments_.end(); itr++) {
Json::Value attachment(Json::objectValue);
itr->second.Serialize(attachment);
attachment_arr.append(attachment);
}
root["attachments"] = attachment_arr;
}
if(mentions_.size() > 0) {
Json::Value mentions_array(Json::arrayValue);
MentionsList::iterator itr = mentions_.begin();
for(;itr!= mentions_.end(); itr++) {
Json::Value mention(Json::objectValue);
jsn::SerializeObject(&(*itr), mention);
mentions_array.append(mention);
}
root["mentions"] = mentions_array;
}
Json::Value app(Json::nullValue);
tent_app_.Serialize(app);
if(!app.isNull())
root["app"] = app;
if(views_.size() > 0) {
Json::Value views(Json::objectValue);
jsn::SerializeMapIntoObject(views, views_);
root["views"] = views;
}
Json::Value permissions(Json::objectValue);
jsn::SerializeObject(&permissions_, permissions);
root["permissions"] = permissions;
Json::Value version(Json::objectValue);
jsn::SerializeObject(&version_, version);
root["version"] = version;
}
{
check(CSSM_QuerySize(handle(), encrypt, count, &sizes));
}
//
// The override() method of Context is an expert feature. It replaces the entire
// context with a context object provided. It is up to the caller to keep this context
// consistent with the purpose of the Context subclass he is (mis)using.
// This feature is currently used by the SecurityServer.
//
void Context::override(const Security::Context &ctx)
{
if (!isActive()) {
// make a valid context object (it doesn't matter what kind - keep it cheap)
check(CSSM_CSP_CreateDigestContext(attachment()->handle(), CSSM_ALGID_NONE, &mHandle));
}
// now replace everything with the context data provided
check(CSSM_SetContext(mHandle, &ctx));
mActive = true; // now active
}
//
// RccContexts
//
const ResourceControlContext &RccBearer::compositeRcc() const
{
// explicitly specified RCC wins
if (mRcc)
return *mRcc;
