/* * we may need to check for version mismatch */ int build_st(struct iptables_target *target, struct ipt_entry_target *t) { unsigned int nfcache = 0; if (target) { size_t size; size = IPT_ALIGN(sizeof (struct ipt_entry_target)) + target->size; if (NULL == t) { target->t = fw_calloc(1, size); target->t->u.target_size = size; if (target->init != NULL) target->init(target->t, &nfcache); set_revision(target->t->u.user.name, target->revision); } else { target->t = t; } strcpy(target->t->u.user.name, target->name); return 0; } return -1; }
/* * we may need to check for version mismatch */ int build_st(struct xtables_target *target, struct xt_entry_target *t) { size_t size = XT_ALIGN(sizeof(struct xt_entry_target)) + target->size; if (t == NULL) { target->t = fw_calloc(1, size); target->t->u.target_size = size; strcpy(target->t->u.user.name, target->name); set_revision(target->t->u.user.name, target->revision); if (target->init != NULL) target->init(target->t); } else { target->t = t; } return 0; }
static EContact * do_create (EBookBackendVCF *bvcf, const gchar *vcard_req, gboolean dirty_the_file) { gchar *id; EContact *contact; gchar *vcard; const gchar *rev; /* at the very least we need the unique_id generation to be protected by the lock, even if the actual vcard parsing isn't. */ g_mutex_lock (bvcf->priv->mutex); id = e_book_backend_vcf_create_unique_id (); contact = e_contact_new_from_vcard (vcard_req); e_contact_set (contact, E_CONTACT_UID, id); g_free (id); rev = e_contact_get_const (contact, E_CONTACT_REV); if (!(rev && *rev)) set_revision (contact); vcard = e_vcard_to_string (E_VCARD (contact), EVC_FORMAT_VCARD_30); insert_contact (bvcf, vcard); if (dirty_the_file) { bvcf->priv->dirty = TRUE; if (!bvcf->priv->flush_timeout_tag) bvcf->priv->flush_timeout_tag = g_timeout_add (FILE_FLUSH_TIMEOUT, vcf_flush_file, bvcf); } g_mutex_unlock (bvcf->priv->mutex); return contact; }
bool Blockchain::AssignAddress( const Identifier& nymID, const Identifier& accountID, const std::uint32_t index, const Identifier& contactID, const BIP44Chain chain) const { LOCK_ACCOUNT() const std::string sNymID = nymID.str(); const std::string sAccountID = accountID.str(); const std::string sContactID = contactID.str(); auto account = load_account(accountLock, sNymID, sAccountID); if (false == bool(account)) { otErr << OT_METHOD << __FUNCTION__ << ": Account does not exist." << std::endl; return false; } const auto& type = account->type(); const auto allocatedIndex = chain ? account->internalindex() : account->externalindex(); if (index > allocatedIndex) { otErr << OT_METHOD << __FUNCTION__ << ": Address has not been allocated." << std::endl; return false; } auto& address = find_address(index, chain, *account); const auto& existing = address.contact(); if (false == existing.empty()) { move_transactions(nymID, address, existing, sContactID); } address.set_contact(sContactID); account->set_revision(account->revision() + 1); // check: does the activity thread exist between nym and contact? bool threadExists = false; const auto threadList = api_.Storage().ThreadList(sNymID, false); for (const auto it : threadList) { const auto& id = it.first; if (id == sContactID) { threadExists = true; } } if (threadExists) { // check: does every incoming transaction exist as an activity std::shared_ptr<proto::StorageThread> thread = activity_.Thread(nymID, contactID); OT_ASSERT(thread); for (const std::string& txID : address.incoming()) { bool exists = false; for (const auto activity : thread->item()) if (txID.compare(activity.id()) == 0) exists = true; // add: transaction to the thread if (!exists) { activity_.AddBlockchainTransaction( nymID, contactID, StorageBox::INCOMINGBLOCKCHAIN, *Transaction(txID)); } } } else { // create the thread and add the transactions for (const auto txID : address.incoming()) { activity_.AddBlockchainTransaction( nymID, contactID, StorageBox::INCOMINGBLOCKCHAIN, *Transaction(txID)); } } return api_.Storage().Store(sNymID, type, *account); }