FCL/sf/mw/qtextensions: comparison qtmobility/plugins/contacts/symbiansim/src/cntsimstoreprivate.cpp

equal deleted inserted replaced

-:2b40d63a9c3d
+:90517678cc4f
 ****************************************************************************/
 #include "cntsimstoreprivate.h"
 #include "cntsymbiansimtransformerror.h"
 #include "cntsimstore.h"
+#include "cntsimstoreeventlistener.h"
 #include <mmtsy_names.h>
 #include <qtcontacts.h>
+#include <qcontactchangeset.h>
+#include <QDebug>
-const int KOneSimContactBufferSize = 512;
+const TInt KOneSimContactBufferSize = 512;
 const TInt KDataClientBuf  = 128;
 const TInt KEtsiTonPosition = 0x70;
 CntSimStorePrivate* CntSimStorePrivate::NewL(CntSymbianSimEngine &engine, CntSimStore &simStore, const QString &storeName)
 {
 :CActive(CActive::EPriorityStandard),
 m_state(InactiveState),
 m_engine(engine),
 m_simStore(simStore),
 m_storeName(storeName),
-m_storeInfoPckg(m_storeInfo)
+m_readOnlyAccess(false),
+m_storeInfoPckg(m_storeInfo),
+m_listener(0)
 {
 CActiveScheduler::Add(this);
 m_managerUri = engine.managerUri();
 }
 void CntSimStorePrivate::ConstructL()
 {
 TBuf<RMobilePhoneBookStore::KMaxPBIDSize> storeName;
 convertStoreNameL(storeName);
+// SDN store is always read only
+if (m_storeName == KParameterValueSimStoreNameSdn)
+m_readOnlyAccess = true;
 // Open etel server
 User::LeaveIfError(m_etelServer.Connect());
 User::LeaveIfError(m_etelServer.LoadPhoneModule(KMmTsyModuleName));
 // Open etel phone
 PbkPrintToLog(_L("CntSymbianSimEngine::getEtelStoreInfoL() - UsedEntries = %d"),
 m_storeInfo.iUsedEntries);
 PbkPrintToLog(_L("CntSymbianSimEngine::getEtelStoreInfoL() - MaxNumLength = %d"),
 m_storeInfo.iMaxNumLength);
 PbkPrintToLog(_L("CntSymbianSimEngine::getEtelStoreInfoL() - MaxTextLength = %d"),
 m_storeInfo.iMaxTextLength);
+m_listener = new (ELeave) CntSimStoreEventListener(m_engine, m_etelStore);
+m_listener->start();
 }
 CntSimStorePrivate::~CntSimStorePrivate()
 {
 Cancel();
-m_buffer.Close();
+delete m_listener;
 m_etelStore.Close();
 m_etelPhone.Close();
 m_etelServer.Close();
 }
 void CntSimStorePrivate::convertStoreNameL(TDes &storeName)
 {
 if(storeName.MaxLength() < RMobilePhoneBookStore::KMaxPBIDSize) {
 if(storeName.Length() == 0) {
 User::Leave(KErrArgument);
 }
 }
-QContactManager::Error CntSimStorePrivate::getInfo()
+bool CntSimStorePrivate::read(int index, int numSlots, QContactManager::Error *error)
 {
-if (IsActive())
+if (IsActive()) {
-return QContactManager::LockedError;
+*error = QContactManager::LockedError;
+return false;
-// start get info request
+}
-m_etelStore.GetInfo(iStatus, (TDes8&)m_storeInfoPckg);
-SetActive();
-m_state = GetInfoState;
-return QContactManager::NoError;
-}
-QContactManager::Error CntSimStorePrivate::read(int index, int numSlots)
-{
-if (IsActive())
-return QContactManager::LockedError;
 // start reading
 m_buffer.Zero();
 m_buffer.ReAlloc(KOneSimContactBufferSize*numSlots);
 m_etelStore.Read(iStatus, index, numSlots, m_buffer);
 SetActive();
 m_state = ReadState;
-return QContactManager::NoError;
+*error = QContactManager::NoError;
-}
+return true;
+}
-QContactManager::Error CntSimStorePrivate::write(const QContact &contact)
-{
+bool CntSimStorePrivate::write(const QContact &contact, QContactManager::Error *error)
-if (IsActive())
+{
-return QContactManager::LockedError;
+if (IsActive()) {
+*error = QContactManager::LockedError;
+return false;
+}
 // get index
 m_writeIndex = KErrNotFound;
 if (contact.id().managerUri() == m_managerUri &&
 contact.localId() > 0) {
 m_writeIndex = contact.localId();
+// TODO: check that the contact exist in the sim
 }
 // encode
 m_buffer.Zero();
 m_buffer.ReAlloc(KOneSimContactBufferSize);
-TRAPD(err, m_convertedContact = encodeSimContactL(&contact, m_buffer));
+m_convertedContact = QContact(contact);
+TRAPD(err, encodeSimContactL(&m_convertedContact, m_buffer));
 if (err != KErrNone) {
-QContactManager::Error qtError;
+CntSymbianSimTransformError::transformError(err, error);
-CntSymbianSimTransformError::transformError(err, qtError);
+return false;
-return qtError;
 }
 // start writing
 m_etelStore.Write(iStatus, m_buffer, m_writeIndex);
 SetActive();
 m_state = WriteState;
-return QContactManager::NoError;
+*error = QContactManager::NoError;
-}
+return true;
+}
-QContactManager::Error CntSimStorePrivate::remove(int index)
-{
+bool CntSimStorePrivate::remove(int index, QContactManager::Error *error)
-if (IsActive())
+{
-return QContactManager::LockedError;
+if (IsActive()) {
+*error = QContactManager::LockedError;
+return false;
+}
 // NOTE:
 // If index points to an empty slot and running in hardware the
 // delete operation will not return any error.
 m_etelStore.Delete(iStatus, index);
 SetActive();
 m_state = DeleteState;
-return QContactManager::NoError;
+*error = QContactManager::NoError;
+return true;
+}
+bool CntSimStorePrivate::getReservedSlots(QContactManager::Error *error)
+{
+if (IsActive()) {
+*error = QContactManager::LockedError;
+return false;
+}
+// start reading
+m_buffer.Zero();
+m_buffer.ReAlloc(KOneSimContactBufferSize*m_storeInfo.iTotalEntries);
+m_etelStore.Read(iStatus, 1, m_storeInfo.iTotalEntries, m_buffer);
+SetActive();
+m_state = ReadReservedSlotsState;
+*error = QContactManager::NoError;
+return true;
 }
 void CntSimStorePrivate::DoCancel()
 {
-if (m_state == GetInfoState)
-m_etelStore.CancelAsyncRequest(EMobilePhoneStoreGetInfo);
 if (m_state == ReadState)
 m_etelStore.CancelAsyncRequest(EMobilePhoneStoreRead);
 if (m_state == WriteState)
 m_etelStore.CancelAsyncRequest(EMobilePhoneStoreWrite);
 if (m_state == DeleteState)
 m_etelStore.CancelAsyncRequest(EMobilePhoneStoreDelete);
+if (m_state == ReadReservedSlotsState)
+m_etelStore.CancelAsyncRequest(EMobilePhoneStoreRead);
 m_state = InactiveState;
 }
 void CntSimStorePrivate::RunL()
 {
+//qDebug() << "CntSimStorePrivate::RunL()" << m_state << iStatus.Int();
+m_asyncError = iStatus.Int();
 User::LeaveIfError(iStatus.Int());
 // NOTE: It is assumed that emitting signals is queued
 switch (m_state)
 {
-case GetInfoState:
-{
-emit m_simStore.getInfoComplete(m_storeInfo, QContactManager::NoError);
-}
-break;
 case ReadState:
 {
 QList<QContact> contacts = decodeSimContactsL(m_buffer);
-m_buffer.Zero();
+// set sync target
+QList<QContact>::iterator i;
+for (i = contacts.begin(); i != contacts.end(); ++i) {
+QContactSyncTarget syncTarget;
+syncTarget.setSyncTarget(KSimSyncTarget);
+i->saveDetail(&syncTarget);
+}
 emit m_simStore.readComplete(contacts, QContactManager::NoError);
 }
 break;
 case WriteState:
 contactId.setLocalId(m_writeIndex);
 contactId.setManagerUri(m_managerUri);
 m_convertedContact.setId(contactId);
 // set sync target
-QContactSyncTarget syncTarget;
+if(m_convertedContact.detail(QContactSyncTarget::DefinitionName).isEmpty()) {
-syncTarget.setSyncTarget(KSimSyncTarget);
+QContactSyncTarget syncTarget = m_convertedContact.detail(QContactSyncTarget::DefinitionName);
-m_convertedContact.saveDetail(&syncTarget);
+syncTarget.setSyncTarget(KSimSyncTarget);
+m_convertedContact.saveDetail(&syncTarget);
+}
 emit m_simStore.writeComplete(m_convertedContact, QContactManager::NoError);
 }
 break;
 case DeleteState:
 {
 emit m_simStore.removeComplete(QContactManager::NoError);
 }
 break;
+case ReadReservedSlotsState:
+{
+QList<int> reservedSlots = decodeReservedSlotsL(m_buffer);
+emit m_simStore.getReservedSlotsComplete(reservedSlots, QContactManager::NoError);
+}
+break;
 default:
 {
 User::Leave(KErrUnknown);
 }
 break;
 }
 TInt CntSimStorePrivate::RunError(TInt aError)
 {
 QContactManager::Error qtError = QContactManager::NoError;
-CntSymbianSimTransformError::transformError(aError, qtError);
+CntSymbianSimTransformError::transformError(aError, &qtError);
 // NOTE: It is assumed that emitting signals is queued
-if (m_state == GetInfoState) {
+if (m_state == ReadState)
-RMobilePhoneBookStore::TMobilePhoneBookInfoV5 emptyInfo;
+emit m_simStore.readComplete(QList<QContact>(), qtError);
-emit m_simStore.getInfoComplete(emptyInfo, qtError);
+else if (m_state == WriteState)
-} else if (m_state == ReadState) {
-QList<QContact> emptyList;
-emit m_simStore.readComplete(emptyList, qtError);
-} else if (m_state == WriteState) {
 emit m_simStore.writeComplete(m_convertedContact, qtError);
-} else if (m_state == DeleteState) {
+else if (m_state == DeleteState)
 emit m_simStore.removeComplete(qtError);
-}
+else if (m_state == ReadReservedSlotsState)
+emit m_simStore.getReservedSlotsComplete(QList<int>(), qtError);
 m_state = InactiveState;
 return KErrNone;
 }
 QContactPhoneNumber lastNumber = static_cast<QContactPhoneNumber>(
 phoneNumbers.at(phoneNumbers.count() - 1));
 QString number = lastNumber.number();
 number.insert(0, "+");
 lastNumber.setNumber(number);
+if (m_readOnlyAccess)
+m_engine.setReadOnlyAccessConstraint(&lastNumber);
 currentContact.saveDetail(&lastNumber);
 }
 }
 }
 else {
 // Contact name otherwise
 QContactName name;
 QString nameString = QString::fromUtf16(bufPtr.Ptr(), bufPtr.Length());
 name.setCustomLabel(nameString);
+if (m_readOnlyAccess)
+m_engine.setReadOnlyAccessConstraint(&name);
 currentContact.saveDetail(&name);
 QContactManager::Error error(QContactManager::NoError);
-currentContact = m_engine.setContactDisplayLabel(m_engine.synthesizedDisplayLabel(currentContact, error), currentContact);
+m_engine.setContactDisplayLabel(&currentContact, m_engine.synthesizedDisplayLabel(currentContact, &error));
 }
 }
 break;
 }
 case RMobilePhoneBookStore::ETagPBSecondName:
 {
 if (pbBuffer->GetValue(bufPtr) == KErrNone) {
 QContactNickname nickName;
 QString name = QString::fromUtf16(bufPtr.Ptr(), bufPtr.Length());
 nickName.setNickname(name);
+if (m_readOnlyAccess)
+m_engine.setReadOnlyAccessConstraint(&nickName);
 currentContact.saveDetail(&nickName);
 }
 break;
 }
 case RMobilePhoneBookStore::ETagPBNumber:
 {
 if (pbBuffer->GetValue(bufPtr) == KErrNone) {
 QContactPhoneNumber phoneNumber;
-phoneNumber.setSubTypes( QContactPhoneNumber::SubTypeMobile );
 QString number = QString::fromUtf16(bufPtr.Ptr(), bufPtr.Length());
 phoneNumber.setNumber(number);
+if (m_readOnlyAccess)
+m_engine.setReadOnlyAccessConstraint(&phoneNumber);
 currentContact.saveDetail(&phoneNumber);
 }
 break;
 }
 case RMobilePhoneBookStore::ETagPBAnrStart:
 {
 if (pbBuffer->GetValue(bufPtr) == KErrNone) {
 QContactEmailAddress email;
 QString emailAddress = QString::fromUtf16(bufPtr.Ptr(), bufPtr.Length());
 email.setEmailAddress(emailAddress);
+if (m_readOnlyAccess)
+m_engine.setReadOnlyAccessConstraint(&email);
 currentContact.saveDetail(&email);
 }
 break;
 }
 case RMobilePhoneBookStore::ETagPBNewEntry:
 /*! Converts QContact to the TLV format which is used to save it to the Etel store.
 *
 * \param contact QContact to be converted
 * \param rawData Contact in TLV format on return.
-* \return QContact containing actually saved information.
 */
-QContact CntSimStorePrivate::encodeSimContactL(const QContact* contact, TDes8& rawData) const
+void CntSimStorePrivate::encodeSimContactL(QContact* contact, TDes8& rawData) const
 {
-PbkPrintToLog(_L("CntSymbianSimEngine::encodeSimContactL() - IN"));
+// TODO: get detail definition schema and verify (unique)
-QContact convertedContact;
+// Keep track of the count of phone numbers added
+int phoneNumberCount(0);
+int emailCount(0);
 CPhoneBookBuffer* pbBuffer = new(ELeave) CPhoneBookBuffer();
 CleanupStack::PushL(pbBuffer);
 pbBuffer->Set(&rawData);
-//add new enty tag
 User::LeaveIfError(pbBuffer->AddNewEntryTag());
-//add name
+foreach(QContactDetail detail, contact->details()) {
-QString name;
+QString definitionName = detail.definitionName();
-QList<QContactDetail> nameDetails = contact->details(QContactName::DefinitionName);
-if (nameDetails.count() == 0) {
+if (definitionName == QContactName::DefinitionName) {
-// TODO: should we leave name empty?
+// Name
-name.append("Unnamed");
+QContactName nameDetail = static_cast<QContactName>(detail);
-}
+// Trim to the max possible length
-else {
+QString name = nameDetail.customLabel().left(m_storeInfo.iMaxTextLength);
-QContactName nameDetail = static_cast<QContactName>(nameDetails.at(0));
+if (name.isEmpty()) {
-name.append(nameDetail.customLabel());
+name = "Unnamed";
-if (name.isNull()) {
+}
-// TODO: should we leave name empty?
+putTagAndValueL(
-name.append("Unnamed)");
+pbBuffer,
+RMobilePhoneBookStore::ETagPBText,
+name);
+// Replace detail value with the trimmed one
+nameDetail.setCustomLabel(name);
+contact->saveDetail(&nameDetail);
+} else if (definitionName == QContactPhoneNumber::DefinitionName
+#ifndef SYMBIANSIM_BACKEND_PHONEBOOKINFOV1
+&& (phoneNumberCount == 0
+|| phoneNumberCount <= m_storeInfo.iMaxAdditionalNumbers)) {
+#else
+&& phoneNumberCount == 0) {
+#endif
+// Phone number
+phoneNumberCount++;
+QContactPhoneNumber numberDetail = static_cast<QContactPhoneNumber>(detail);
+QString number = numberDetail.number();
+// Verify the number only contains legal digits
+foreach (const QChar character, number) {
+if(!character.isDigit()) {
+if(character != QChar('+')
+&& character != QChar('*')
+&& character != QChar('#')
+&& character != QChar('p')
+&& character != QChar('w')) {
+User::Leave(KErrArgument);
+}
+}
+}
+// TODO: check if the number is empty (do we have a test case for that?)
+// Verify the number length
+PbkPrintToLog(_L("CntSymbianSimEngine::encodeSimContactL() - phone number length = %d"),
+numberDetail.number().length());
+if (numberDetail.number().length() > m_storeInfo.iMaxNumLength) {
+User::Leave(KErrTooBig);
+}
+if (phoneNumberCount > 1) {
+// Mark the beginning of an additional number
+User::LeaveIfError(pbBuffer->AddNewNumberTag());
+}
+// The number itself
+putTagAndValueL(
+pbBuffer,
+RMobilePhoneBookStore::ETagPBNumber,
+number);
+#ifndef SYMBIANSIM_BACKEND_PHONEBOOKINFOV1
+// Phonebook info version 1 does not support nick name or e-mail
+} else if (definitionName == QContactNickname::DefinitionName
+&& m_storeInfo.iMaxSecondNames > 0) {
+// nickname
+QContactNickname nicknameDetail = static_cast<QContactNickname>(detail);
+// Trim to the max possible length;
+QString nickname = nicknameDetail.nickname().left(m_storeInfo.iMaxTextLengthSecondName);
+putTagAndValueL(
+pbBuffer,
+RMobilePhoneBookStore::ETagPBSecondName,
+nickname);
+// Replace detail value with the trimmed one
+nicknameDetail.setNickname(nickname);
+contact->saveDetail(&nicknameDetail);
+} else if (definitionName == QContactEmailAddress::DefinitionName
+&& emailCount < m_storeInfo.iMaxEmailAddr) {
+emailCount++;
+QContactEmailAddress emailDetail = static_cast<QContactEmailAddress>(detail);
+if (emailDetail.emailAddress().length() > m_storeInfo.iMaxTextLengthEmailAddr) {
+User::Leave(KErrTooBig);
+}
+putTagAndValueL(
+pbBuffer,
+RMobilePhoneBookStore::ETagPBEmailAddress,
+emailDetail.emailAddress());
+#endif
+// These are ignored in the conversion
+} else if (definitionName == QContactSyncTarget::DefinitionName
+|| definitionName == QContactDisplayLabel::DefinitionName
+|| definitionName == QContactType::DefinitionName) {
+// Do nothing
+} else {
+User::Leave(KErrArgument);
 }
 }
-name = name.left(m_storeInfo.iMaxTextLength); //trim to the max possible length
-TPtrC nameValue(reinterpret_cast<const TUint16*>(name.utf16()));
-User::LeaveIfError(pbBuffer->PutTagAndValue(RMobilePhoneBookStore::ETagPBText, nameValue));
-QContactName convertedNameDetail;
-convertedNameDetail.setCustomLabel(name);
-convertedContact.saveDetail(&convertedNameDetail);
-//add nickname
-if (m_storeInfo.iMaxSecondNames > 0) {
-QString nickname;
-QList<QContactDetail> nicknameDetails = contact->details(QContactNickname::DefinitionName);
-if (nicknameDetails.count() > 0) {
-QContactNickname nicknameDetail = static_cast<QContactNickname>(nicknameDetails.at(0));
-nickname = nicknameDetail.nickname();
-nickname = nickname.left(m_storeInfo.iMaxTextLengthSecondName); //trim to the max possible length
-TPtrC nicknameValue(reinterpret_cast<const TUint16*>(nickname.utf16()));
-User::LeaveIfError(pbBuffer->PutTagAndValue(RMobilePhoneBookStore::ETagPBSecondName, nicknameValue));
-QContactNickname convertedNicknameDetail;
-convertedNicknameDetail.setNickname(nickname);
-convertedContact.saveDetail(&convertedNicknameDetail);
-}
-}
-//add phone number
-QList<QContactDetail> phoneNumberDetails = contact->details(QContactPhoneNumber::DefinitionName);
-if (phoneNumberDetails.count() > 0) {
-PbkPrintToLog(_L("CntSymbianSimEngine::encodeSimContactL() - add phone number"));
-QContactPhoneNumber phoneNumberDetail = static_cast<QContactPhoneNumber>(phoneNumberDetails.at(0));
-QString number = phoneNumberDetail.number();
-foreach (const QChar character, number) {
-if(!character.isDigit()) {
-if(character != QChar('+')
-&& character != QChar('*')
-&& character != QChar('#')
-&& character != QChar('p')
-&& character != QChar('w')) {
-User::Leave(KErrArgument);
-}
-}
-}
-PbkPrintToLog(_L("CntSymbianSimEngine::encodeSimContactL() - phone number length = %d"),
-phoneNumberDetail.number().length());
-if (phoneNumberDetail.number().length() > m_storeInfo.iMaxNumLength) {
-User::Leave(KErrTooBig);
-}
-TPtrC phoneNumberValue(reinterpret_cast<const TUint16*>(phoneNumberDetail.number().utf16()));
-PbkPrintToLog(_L("CntSymbianSimEngine::encodeSimContactL() - number = %S"), &phoneNumberValue);
-User::LeaveIfError(pbBuffer->PutTagAndValue(RMobilePhoneBookStore::ETagPBNumber, phoneNumberValue));
-QContactPhoneNumber convertedPhoneNumberDetail;
-convertedPhoneNumberDetail.setNumber(phoneNumberDetail.number());
-convertedContact.saveDetail(&convertedPhoneNumberDetail);
-}
-//add additional numbers
-if (m_storeInfo.iMaxAdditionalNumbers > 0) {
-//one number is saved already
-for (int i = 1; i < phoneNumberDetails.count() && i-1 < m_storeInfo.iMaxAdditionalNumbers; ++i) {
-QContactPhoneNumber phoneNumberDetail = static_cast<QContactPhoneNumber>(phoneNumberDetails.at(i));
-if (phoneNumberDetail.number().length() > m_storeInfo.iMaxNumLengthAdditionalNumber) {
-User::Leave(KErrTooBig);
-}
-//mark the beginning of an additional number
-User::LeaveIfError(pbBuffer->AddNewNumberTag());
-//add number itself
-TPtrC phoneNumberValue(reinterpret_cast<const TUint16*>(phoneNumberDetail.number().utf16()));
-User::LeaveIfError(pbBuffer->PutTagAndValue(RMobilePhoneBookStore::ETagPBNumber, phoneNumberValue));
-QContactPhoneNumber convertedPhoneNumberDetail;
-convertedPhoneNumberDetail.setNumber(phoneNumberDetail.number());
-convertedContact.saveDetail(&convertedPhoneNumberDetail);
-}
-}
-//add e-mails
-if (m_storeInfo.iMaxEmailAddr > 0) {
-QList<QContactDetail> emailDetails = contact->details(QContactEmailAddress::DefinitionName);
-for (int i = 0; i < emailDetails.count() && i < m_storeInfo.iMaxEmailAddr; ++i) {
-QContactEmailAddress emailDetail = static_cast<QContactEmailAddress>(emailDetails.at(i));
-TPtrC emailValue(reinterpret_cast<const TUint16*>(emailDetail.emailAddress().utf16()));
-if (emailValue.Length() > m_storeInfo.iMaxTextLengthEmailAddr) {
-User::Leave(KErrTooBig);
-}
-User::LeaveIfError(pbBuffer->PutTagAndValue(RMobilePhoneBookStore::ETagPBEmailAddress, emailValue));
-QContactEmailAddress convertedEmailDetail;
-convertedEmailDetail.setEmailAddress(emailDetail.emailAddress());
-convertedContact.saveDetail(&convertedEmailDetail);
-}
-}
 CleanupStack::PopAndDestroy(pbBuffer);
-PbkPrintToLog(_L("CntSymbianSimEngine::encodeSimContactL() - OUT"));
+}
-return convertedContact;
-}
+void CntSimStorePrivate::putTagAndValueL(CPhoneBookBuffer* pbBuffer, TUint8 tag, QString data) const
+{
+TPtrC value(reinterpret_cast<const TUint16*>(data.utf16()));
+User::LeaveIfError(pbBuffer->PutTagAndValue(tag, value));
+}
+QList<int> CntSimStorePrivate::decodeReservedSlotsL(TDes8& rawData) const
+{
+QList<int> reservedSlots;
+TUint8 tagValue(0);
+CPhoneBookBuffer::TPhBkTagType dataType;
+CPhoneBookBuffer* pbBuffer = new (ELeave) CPhoneBookBuffer();
+CleanupStack::PushL(pbBuffer);
+pbBuffer->Set(&rawData);
+pbBuffer->StartRead();
+while (pbBuffer->GetTagAndType(tagValue, dataType) == KErrNone)
+{
+if (tagValue == RMobilePhoneBookStore::ETagPBAdnIndex)
+{
+TUint16 index;
+if (pbBuffer->GetValue(index) == KErrNone)
+reservedSlots.append(index);
+} else
+pbBuffer->SkipValue(dataType);
+} //while
+CleanupStack::PopAndDestroy(pbBuffer);
+return reservedSlots;
+}

changeset 4	90517678cc4f
parent 1	2b40d63a9c3d
child 5	453da2cfceef