Skip to content

Commit a5974d6

Browse files
dexX7dexX7
committed
Use new methods to parse packet per transaction type
1 parent e8b4505 commit a5974d6

File tree

1 file changed

+37
-130
lines changed

1 file changed

+37
-130
lines changed

‎src/omnicore/omnicore.cpp‎

Lines changed: 37 additions & 130 deletions
Original file line numberDiff line numberDiff line change
@@ -3627,7 +3627,7 @@ int CMPTransaction::interpretPacket(CMPOffer *obj_o, CMPMetaDEx *mdex_o)
36273627
{
36283628
int rc = PKT_ERROR;
36293629

3630-
if (0>step1()) return -98765;
3630+
if (!interpret_TransactionType()) return -98765;
36313631

36323632
if ((obj_o) && (MSC_TYPE_TRADE_OFFER != type)) return -777; // can't fill in the Offer object !
36333633
if ((mdex_o) && (MSC_TYPE_METADEX != type)) return -778; // can't fill in the MetaDEx object !
@@ -3638,23 +3638,19 @@ int rc = PKT_ERROR;
36383638
{
36393639
case MSC_TYPE_SIMPLE_SEND:
36403640
{
3641-
memcpy(&property, &pkt[4], 4);
3642-
swapByteOrder32(property);
3643-
memcpy(&nValue, &pkt[8], 8);
3644-
swapByteOrder64(nValue);
3645-
nNewValue = nValue;
3641+
if (!interpret_SimpleSend()) {
3642+
return PKT_ERROR;
3643+
}
36463644

36473645
rc = logicMath_SimpleSend();
36483646
break;
36493647
}
36503648

36513649
case MSC_TYPE_SEND_TO_OWNERS:
36523650
{
3653-
memcpy(&property, &pkt[4], 4);
3654-
swapByteOrder32(property);
3655-
memcpy(&nValue, &pkt[8], 8);
3656-
swapByteOrder64(nValue);
3657-
nNewValue = nValue;
3651+
if (!interpret_SendToOwners()) {
3652+
return PKT_ERROR;
3653+
}
36583654

36593655
boost::filesystem::path pathOwners = GetDataDir() / OWNERS_FILENAME;
36603656
FILE *fp = fopen(pathOwners.string().c_str(), "a");
@@ -3672,198 +3668,109 @@ int rc = PKT_ERROR;
36723668

36733669
case MSC_TYPE_TRADE_OFFER:
36743670
{
3675-
memcpy(&property, &pkt[4], 4);
3676-
swapByteOrder32(property);
3677-
memcpy(&nValue, &pkt[8], 8);
3678-
swapByteOrder64(nValue);
3679-
nNewValue = nValue;
3680-
3681-
memcpy(&amount_desired, &pkt[16], 8);
3682-
memcpy(&blocktimelimit, &pkt[24], 1);
3683-
memcpy(&min_fee, &pkt[25], 8);
3684-
memcpy(&subaction, &pkt[33], 1);
3685-
swapByteOrder64(amount_desired);
3686-
swapByteOrder64(min_fee);
3671+
if (!interpret_TradeOffer()) {
3672+
return PKT_ERROR;
3673+
}
36873674

36883675
rc = logicMath_TradeOffer(obj_o);
36893676
break;
36903677
}
36913678

36923679
case MSC_TYPE_METADEX:
36933680
{
3694-
memcpy(&property, &pkt[4], 4);
3695-
swapByteOrder32(property);
3696-
memcpy(&nValue, &pkt[8], 8);
3697-
swapByteOrder64(nValue);
3698-
nNewValue = nValue;
3699-
3700-
memcpy(&desired_property, &pkt[16], 4);
3701-
swapByteOrder32(desired_property);
3702-
memcpy(&desired_value, &pkt[20], 8);
3703-
swapByteOrder64(desired_value);
3704-
memcpy(&action, &pkt[28], 1);
3681+
if (!interpret_MetaDEx()) {
3682+
return PKT_ERROR;
3683+
}
37053684

37063685
rc = logicMath_MetaDEx(mdex_o);
37073686
break;
37083687
}
37093688

37103689
case MSC_TYPE_ACCEPT_OFFER_BTC:
37113690
{
3712-
memcpy(&property, &pkt[4], 4);
3713-
swapByteOrder32(property);
3714-
memcpy(&nValue, &pkt[8], 8);
3715-
swapByteOrder64(nValue);
3716-
nNewValue = nValue;
3691+
if (!interpret_AcceptOfferBTC()) {
3692+
return PKT_ERROR;
3693+
}
37173694

37183695
rc = logicMath_AcceptOffer_BTC();
37193696
break;
37203697
}
37213698

37223699
case MSC_TYPE_CREATE_PROPERTY_FIXED:
37233700
{
3724-
const char* p = 11 + (char*) &pkt;
3725-
std::vector<std::string> spstr;
3726-
memcpy(&ecosystem, &pkt[4], 1);
3727-
memcpy(&prop_type, &pkt[5], 2);
3728-
swapByteOrder16(prop_type);
3729-
memcpy(&prev_prop_id, &pkt[7], 4);
3730-
swapByteOrder32(prev_prop_id);
3731-
for (int i = 0; i < 5; i++) {
3732-
spstr.push_back(std::string(p));
3733-
p += spstr.back().size() + 1;
3701+
if (!interpret_CreatePropertyFixed()) {
3702+
return PKT_ERROR;
37343703
}
3735-
int i = 0;
3736-
memcpy(category, spstr[i].c_str(), std::min(spstr[i].length(), sizeof(category)-1)); i++;
3737-
memcpy(subcategory, spstr[i].c_str(), std::min(spstr[i].length(), sizeof(subcategory)-1)); i++;
3738-
memcpy(name, spstr[i].c_str(), std::min(spstr[i].length(), sizeof(name)-1)); i++;
3739-
memcpy(url, spstr[i].c_str(), std::min(spstr[i].length(), sizeof(url)-1)); i++;
3740-
memcpy(data, spstr[i].c_str(), std::min(spstr[i].length(), sizeof(data)-1)); i++;
3741-
if (isOverrun(p, __LINE__)) return (PKT_ERROR_SP - 800);
3742-
if (!p) return (PKT_ERROR_SP -11);
3743-
3744-
memcpy(&nValue, p, 8);
3745-
swapByteOrder64(nValue);
3746-
p += 8;
3747-
nNewValue = nValue;
3748-
if (isOverrun(p, __LINE__)) return (PKT_ERROR_SP -900);
37493704

37503705
rc = logicMath_CreatePropertyFixed();
37513706
break;
37523707
}
37533708

37543709
case MSC_TYPE_CREATE_PROPERTY_VARIABLE:
37553710
{
3756-
const char* p = 11 + (char*) &pkt;
3757-
std::vector<std::string> spstr;
3758-
memcpy(&ecosystem, &pkt[4], 1);
3759-
memcpy(&prop_type, &pkt[5], 2);
3760-
swapByteOrder16(prop_type);
3761-
memcpy(&prev_prop_id, &pkt[7], 4);
3762-
swapByteOrder32(prev_prop_id);
3763-
for (int i = 0; i < 5; i++) {
3764-
spstr.push_back(std::string(p));
3765-
p += spstr.back().size() + 1;
3711+
if (!interpret_CreatePropertyVariable()) {
3712+
return PKT_ERROR;
37663713
}
3767-
int i = 0;
3768-
memcpy(category, spstr[i].c_str(), std::min(spstr[i].length(), sizeof(category)-1)); i++;
3769-
memcpy(subcategory, spstr[i].c_str(), std::min(spstr[i].length(), sizeof(subcategory)-1)); i++;
3770-
memcpy(name, spstr[i].c_str(), std::min(spstr[i].length(), sizeof(name)-1)); i++;
3771-
memcpy(url, spstr[i].c_str(), std::min(spstr[i].length(), sizeof(url)-1)); i++;
3772-
memcpy(data, spstr[i].c_str(), std::min(spstr[i].length(), sizeof(data)-1)); i++;
3773-
if (isOverrun(p, __LINE__)) return (PKT_ERROR_SP - 800);
3774-
if (!p) return (PKT_ERROR_SP -12);
3775-
3776-
memcpy(&property, p, 4);
3777-
swapByteOrder32(property);
3778-
p += 4;
3779-
memcpy(&nValue, p, 8);
3780-
swapByteOrder64(nValue);
3781-
p += 8;
3782-
nNewValue = nValue;
3783-
memcpy(&deadline, p, 8);
3784-
swapByteOrder64(deadline);
3785-
p += 8;
3786-
memcpy(&early_bird, p++, 1);
3787-
memcpy(&percentage, p++, 1);
3788-
if (isOverrun(p, __LINE__)) return (PKT_ERROR_SP -765);
37893714

37903715
rc = logicMath_CreatePropertyVariable();
37913716
break;
37923717
}
37933718

37943719
case MSC_TYPE_CLOSE_CROWDSALE:
37953720
{
3796-
memcpy(&property, &pkt[4], 4);
3797-
swapByteOrder32(property);
3721+
if (!interpret_CloseCrowdsale()) {
3722+
return PKT_ERROR;
3723+
}
37983724

37993725
rc = logicMath_CloseCrowdsale();
38003726
break;
38013727
}
38023728

38033729
case MSC_TYPE_CREATE_PROPERTY_MANUAL:
38043730
{
3805-
const char* p = 11 + (char*) &pkt;
3806-
std::vector<std::string> spstr;
3807-
memcpy(&ecosystem, &pkt[4], 1);
3808-
memcpy(&prop_type, &pkt[5], 2);
3809-
swapByteOrder16(prop_type);
3810-
memcpy(&prev_prop_id, &pkt[7], 4);
3811-
swapByteOrder32(prev_prop_id);
3812-
for (int i = 0; i < 5; i++) {
3813-
spstr.push_back(std::string(p));
3814-
p += spstr.back().size() + 1;
3731+
if (!interpret_CreatePropertyMananged()) {
3732+
return PKT_ERROR;
38153733
}
3816-
int i = 0;
3817-
memcpy(category, spstr[i].c_str(), std::min(spstr[i].length(), sizeof(category)-1)); i++;
3818-
memcpy(subcategory, spstr[i].c_str(), std::min(spstr[i].length(), sizeof(subcategory)-1)); i++;
3819-
memcpy(name, spstr[i].c_str(), std::min(spstr[i].length(), sizeof(name)-1)); i++;
3820-
memcpy(url, spstr[i].c_str(), std::min(spstr[i].length(), sizeof(url)-1)); i++;
3821-
memcpy(data, spstr[i].c_str(), std::min(spstr[i].length(), sizeof(data)-1)); i++;
3822-
if (isOverrun(p, __LINE__)) return (PKT_ERROR_SP - 800);
3823-
if (!p) return (PKT_ERROR_SP -11);
38243734

38253735
rc = logicMath_CreatePropertyMananged();
38263736
break;
38273737
}
38283738

38293739
case MSC_TYPE_GRANT_PROPERTY_TOKENS:
38303740
{
3831-
memcpy(&property, &pkt[4], 4);
3832-
swapByteOrder32(property);
3833-
memcpy(&nValue, &pkt[8], 8);
3834-
swapByteOrder64(nValue);
3835-
nNewValue = nValue;
3741+
if (!interpret_GrantTokens()) {
3742+
return PKT_ERROR;
3743+
}
38363744

38373745
rc = logicMath_GrantTokens();
38383746
break;
38393747
}
38403748

38413749
case MSC_TYPE_REVOKE_PROPERTY_TOKENS:
38423750
{
3843-
memcpy(&property, &pkt[4], 4);
3844-
swapByteOrder32(property);
3845-
memcpy(&nValue, &pkt[8], 8);
3846-
swapByteOrder64(nValue);
3847-
nNewValue = nValue;
3751+
if (!interpret_RevokeTokens()) {
3752+
return PKT_ERROR;
3753+
}
38483754

38493755
rc = logicMath_RevokeTokens();
38503756
break;
38513757
}
38523758

38533759
case MSC_TYPE_CHANGE_ISSUER_ADDRESS:
38543760
{
3855-
memcpy(&property, &pkt[4], 4);
3856-
swapByteOrder32(property);
3761+
if (!interpret_ChangeIssuer()) {
3762+
return PKT_ERROR;
3763+
}
38573764

38583765
rc = logicMath_ChangeIssuer();
38593766
break;
38603767
}
38613768

38623769
case OMNICORE_MESSAGE_TYPE_ALERT:
38633770
{
3864-
const char* p = 4 + (char*) &pkt;
3865-
std::string spstr(p);
3866-
memcpy(alertString, spstr.c_str(), std::min(spstr.length(), sizeof(alertString)-1));
3771+
if (!interpret_Alert()) {
3772+
return PKT_ERROR;
3773+
}
38673774

38683775
rc = logicMath_Alert();
38693776
break;

0 commit comments

Comments
 (0)