Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2024-10-01 02:35:48 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

renamed old flags into indices in rsgenexchange.cc. Fixed up duplicate constants between GxsGroupDialog and rsgxsflags.h

Browse Source
This commit is contained in:
csoler 2015-10-23 22:53:00 -04:00
parent 738dadadc9
commit a6851b63dc
7 changed files with 129 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
libretroshare/src/gxs/rsgenexchange.cc
View File

@ -49,9 +49,15 @@
#define PRIV_GRP_OFFSET 16 #define PRIV_GRP_OFFSET 16
#define GRP_OPTIONS_OFFSET 24 #define GRP_OPTIONS_OFFSET 24
/** authentication key indices. Used to store them in a map **/
static const uint32_t INDEX_AUTHEN_IDENTITY = 0x00000010; // identity
static const uint32_t INDEX_AUTHEN_PUBLISH = 0x00000020; // publish key
static const uint32_t INDEX_AUTHEN_ADMIN = 0x00000040; // admin key
#define GXS_MASK "GXS_MASK_HACK" #define GXS_MASK "GXS_MASK_HACK"
//#define GEN_EXCH_DEBUG 1 #define GEN_EXCH_DEBUG 1
#define MSG_CLEANUP_PERIOD 60*5 // 5 minutes #define MSG_CLEANUP_PERIOD 60*5 // 5 minutes
#define INTEGRITY_CHECK_PERIOD 60*30 // 30 minutes #define INTEGRITY_CHECK_PERIOD 60*30 // 30 minutes
@ -416,7 +422,7 @@ uint8_t RsGenExchange::createGroup(RsNxsGrp *grp, RsTlvSecurityKeySet& privateKe
bool ok = GxsSecurity::getSignature(allGrpData, allGrpDataLen, privAdminKey, adminSign); bool ok = GxsSecurity::getSignature(allGrpData, allGrpDataLen, privAdminKey, adminSign);
// add admin sign to grpMeta // add admin sign to grpMeta
meta->signSet.keySignSet[GXS_SERV::FLAG_AUTHEN_ADMIN] = adminSign; meta->signSet.keySignSet[INDEX_AUTHEN_ADMIN] = adminSign;
RsTlvBinaryData grpData(mServType); RsTlvBinaryData grpData(mServType);
grpData.setBinData(allGrpData, allGrpDataLen); grpData.setBinData(allGrpData, allGrpDataLen);
@ -494,7 +500,7 @@ int RsGenExchange::createGroupSignatures(RsTlvKeySignatureSet& signSet, RsTlvBin
id_ret = SIGN_FAIL; id_ret = SIGN_FAIL;
} }
signSet.keySignSet[GXS_SERV::FLAG_AUTHEN_IDENTITY] = sign; signSet.keySignSet[INDEX_AUTHEN_IDENTITY] = sign;
} }
else else
{ {
@ -609,12 +615,12 @@ int RsGenExchange::createMsgSignatures(RsTlvKeySignatureSet& signSet, RsTlvBinar
// private publish key // private publish key
publishKey = &(mit->second); publishKey = &(mit->second);
RsTlvKeySignature publishSign = signSet.keySignSet[GXS_SERV::FLAG_AUTHEN_PUBLISH]; RsTlvKeySignature publishSign = signSet.keySignSet[INDEX_AUTHEN_PUBLISH];
publishSignSuccess = GxsSecurity::getSignature((char*)msgData.bin_data, msgData.bin_len, *publishKey, publishSign); publishSignSuccess = GxsSecurity::getSignature((char*)msgData.bin_data, msgData.bin_len, *publishKey, publishSign);
//place signature in msg meta //place signature in msg meta
signSet.keySignSet[GXS_SERV::FLAG_AUTHEN_PUBLISH] = publishSign; signSet.keySignSet[INDEX_AUTHEN_PUBLISH] = publishSign;
}else }else
{ {
std::cerr << "RsGenExchange::createMsgSignatures()"; std::cerr << "RsGenExchange::createMsgSignatures()";
@ -653,7 +659,7 @@ int RsGenExchange::createMsgSignatures(RsTlvKeySignatureSet& signSet, RsTlvBinar
id_ret = SIGN_FAIL; id_ret = SIGN_FAIL;
} }
signSet.keySignSet[GXS_SERV::FLAG_AUTHEN_IDENTITY] = sign; signSet.keySignSet[INDEX_AUTHEN_IDENTITY] = sign;
} }
else else
{ {
@ -763,7 +769,7 @@ int RsGenExchange::createMessage(RsNxsMsg* msg)
} }
} }
int RsGenExchange::validateMsg(RsNxsMsg *msg, const uint32_t& grpFlag, RsTlvSecurityKeySet& grpKeySet) int RsGenExchange::validateMsg(RsNxsMsg *msg, const uint32_t& grpFlag, const uint32_t& signFlag, RsTlvSecurityKeySet& grpKeySet)
{ {
bool needIdentitySign = false; bool needIdentitySign = false;
bool needPublishSign = false; bool needPublishSign = false;
@ -796,12 +802,16 @@ int RsGenExchange::validateMsg(RsNxsMsg *msg, const uint32_t& grpFlag, RsTlvSecu
if ((checkAuthenFlag(pos, author_flag)) || (!msg->metaData->mAuthorId.isNull())) if ((checkAuthenFlag(pos, author_flag)) || (!msg->metaData->mAuthorId.isNull()))
needIdentitySign = true; needIdentitySign = true;
#ifdef GEN_EXCH_DEBUG
std::cerr << "Validate message: msgId=" << msg->msgId << ", grpId=" << msg->grpId << " grpFlags=" << std::hex << grpFlag << std::dec
<< ". Need publish=" << needPublishSign << ", needIdentitySign=" << needIdentitySign ;
#endif
RsGxsMsgMetaData& metaData = *(msg->metaData); RsGxsMsgMetaData& metaData = *(msg->metaData);
if(needPublishSign) if(needPublishSign)
{ {
RsTlvKeySignature sign = metaData.signSet.keySignSet[GXS_SERV::FLAG_AUTHEN_PUBLISH]; RsTlvKeySignature sign = metaData.signSet.keySignSet[INDEX_AUTHEN_PUBLISH];
std::map<RsGxsId, RsTlvSecurityKey>& keys = grpKeySet.keys; std::map<RsGxsId, RsTlvSecurityKey>& keys = grpKeySet.keys;
std::map<RsGxsId, RsTlvSecurityKey>::iterator mit = keys.begin(); std::map<RsGxsId, RsTlvSecurityKey>::iterator mit = keys.begin();
@ -856,8 +866,7 @@ int RsGenExchange::validateMsg(RsNxsMsg *msg, const uint32_t& grpFlag, RsTlvSecu
if (auth_key_fetched) if (auth_key_fetched)
{ {
RsTlvKeySignature sign = metaData.signSet.keySignSet[INDEX_AUTHEN_IDENTITY];
RsTlvKeySignature sign = metaData.signSet.keySignSet[GXS_SERV::FLAG_AUTHEN_IDENTITY];
idValidate &= GxsSecurity::validateNxsMsg(*msg, sign, authorKey); idValidate &= GxsSecurity::validateNxsMsg(*msg, sign, authorKey);
mGixs->timeStampKey(metaData.mAuthorId) ; mGixs->timeStampKey(metaData.mAuthorId) ;
} }
@ -869,11 +878,17 @@ int RsGenExchange::validateMsg(RsNxsMsg *msg, const uint32_t& grpFlag, RsTlvSecu
idValidate = false; idValidate = false;
} }
}else // if(signFlag & GXS_SERV::
}
else
{ {
std::list<RsPeerId> peers; std::list<RsPeerId> peers;
peers.push_back(msg->PeerId()); peers.push_back(msg->PeerId());
mGixs->requestKey(metaData.mAuthorId, peers); mGixs->requestKey(metaData.mAuthorId, peers);
#ifdef GEN_EXCH_DEBUG
std::cerr << ", Key missing. Retry later." << std::endl;
#endif
return VALIDATE_FAIL_TRY_LATER; return VALIDATE_FAIL_TRY_LATER;
} }
} }
@ -890,6 +905,10 @@ int RsGenExchange::validateMsg(RsNxsMsg *msg, const uint32_t& grpFlag, RsTlvSecu
idValidate = true; idValidate = true;
} }
#ifdef GEN_EXCH_DEBUG
std::cerr << ", publish val=" << publishValidate << ", idValidate=" << idValidate << ". Result=" << (publishValidate && idValidate) << std::endl;
#endif
if(publishValidate && idValidate) if(publishValidate && idValidate)
return VALIDATE_SUCCESS; return VALIDATE_SUCCESS;
else else
@ -930,7 +949,7 @@ int RsGenExchange::validateGrp(RsNxsGrp* grp)
if (auth_key_fetched) if (auth_key_fetched)
{ {
RsTlvKeySignature sign = metaData.signSet.keySignSet[GXS_SERV::FLAG_AUTHEN_IDENTITY]; RsTlvKeySignature sign = metaData.signSet.keySignSet[INDEX_AUTHEN_IDENTITY];
idValidate = GxsSecurity::validateNxsGrp(*grp, sign, authorKey); idValidate = GxsSecurity::validateNxsGrp(*grp, sign, authorKey);
mGixs->timeStampKey(metaData.mAuthorId) ; mGixs->timeStampKey(metaData.mAuthorId) ;
@ -2530,9 +2549,12 @@ void RsGenExchange::processRecvdMessages()
if(mit != grpMetas.end()) if(mit != grpMetas.end())
{ {
RsGxsGrpMetaData* grpMeta = mit->second; RsGxsGrpMetaData* grpMeta = mit->second;
validateReturn = validateMsg(msg, grpMeta->mGroupFlags, grpMeta->keys); validateReturn = validateMsg(msg, grpMeta->mGroupFlags, grpMeta->mSignFlags, grpMeta->keys);
#ifdef GEN_EXCH_DEBUG #ifdef GEN_EXCH_DEBUG
std::cerr << " message validation result: " << validateReturn << std::endl; std::cerr << " grpMeta.mSignFlags: " << std::hex << grpMeta->mSignFlags << std::dec << std::endl;
std::cerr << " grpMeta.mAuthFlags: " << std::hex << grpMeta->mAuthenFlags << std::dec << std::endl;
std::cerr << " message validation result: " << (int)validateReturn << std::endl;
#endif #endif
} }
@ -2821,7 +2843,7 @@ void RsGenExchange::performUpdateValidation()
bool RsGenExchange::updateValid(RsGxsGrpMetaData& oldGrpMeta, RsNxsGrp& newGrp) const bool RsGenExchange::updateValid(RsGxsGrpMetaData& oldGrpMeta, RsNxsGrp& newGrp) const
{ {
std::map<SignType, RsTlvKeySignature>& signSet = newGrp.metaData->signSet.keySignSet; std::map<SignType, RsTlvKeySignature>& signSet = newGrp.metaData->signSet.keySignSet;
std::map<SignType, RsTlvKeySignature>::iterator mit = signSet.find(GXS_SERV::FLAG_AUTHEN_ADMIN); std::map<SignType, RsTlvKeySignature>::iterator mit = signSet.find(INDEX_AUTHEN_ADMIN);
if(mit == signSet.end()) if(mit == signSet.end())
{ {

5
libretroshare/src/gxs/rsgenexchange.h
View File

@ -739,12 +739,13 @@ private:
/*! /*!
* Attempts to validate msg signatures * Attempts to validate msg signatures
* @param msg message to be validated * @param msg message to be validated
* @param grpFlag the flag for the group the message belongs to * @param grpFlag the distribution flag for the group the message belongs to
* @param grpFlag the signature flag for the group the message belongs to
* @param grpKeySet the key set user has for the message's group * @param grpKeySet the key set user has for the message's group
* @return VALIDATE_SUCCESS for success, VALIDATE_FAIL for fail, * @return VALIDATE_SUCCESS for success, VALIDATE_FAIL for fail,
* VALIDATE_ID_SIGN_NOT_AVAIL for Id sign key not avail (but requested) * VALIDATE_ID_SIGN_NOT_AVAIL for Id sign key not avail (but requested)
*/ */
int validateMsg(RsNxsMsg* msg, const uint32_t& grpFlag, RsTlvSecurityKeySet& grpKeySet); int validateMsg(RsNxsMsg* msg, const uint32_t& grpFlag, const uint32_t &signFlag, RsTlvSecurityKeySet& grpKeySet);
/*! /*!
* Attempts to validate group signatures * Attempts to validate group signatures

2
libretroshare/src/gxs/rsgxsdata.h
View File

@ -52,7 +52,7 @@ public:
RsGxsGroupId mGroupId; RsGxsGroupId mGroupId;
RsGxsGroupId mOrigGrpId; RsGxsGroupId mOrigGrpId;
std::string mGroupName; std::string mGroupName;
uint32_t mGroupFlags; uint32_t mGroupFlags; // GXS_SERV::FLAG_PRIVACY_RESTRICTED | GXS_SERV::FLAG_PRIVACY_PRIVATE | GXS_SERV::FLAG_PRIVACY_PUBLIC
uint32_t mPublishTs; uint32_t mPublishTs;
uint32_t mSignFlags; uint32_t mSignFlags;
RsGxsId mAuthorId; RsGxsId mAuthorId;

55
libretroshare/src/retroshare/rsgxsflags.h
View File

@ -19,46 +19,33 @@ namespace GXS_SERV {
/** START privacy **/ /** START privacy **/
static const uint32_t FLAG_PRIVACY_MASK = 0x0000000f; static const uint32_t FLAG_PRIVACY_MASK = 0x0000000f;
static const uint32_t FLAG_PRIVACY_PRIVATE = 0x00000001; // pub key encrypted
// pub key encrypted static const uint32_t FLAG_PRIVACY_RESTRICTED = 0x00000002; // publish private key needed to publish
static const uint32_t FLAG_PRIVACY_PRIVATE = 0x00000001; static const uint32_t FLAG_PRIVACY_PUBLIC = 0x00000004; // anyone can publish, publish key pair not needed
// publish private key needed to publish
static const uint32_t FLAG_PRIVACY_RESTRICTED = 0x00000002;
// anyone can publish, publish key pair not needed
static const uint32_t FLAG_PRIVACY_PUBLIC = 0x00000004;
/** END privacy **/ /** END privacy **/
/** START authentication **/
static const uint32_t FLAG_AUTHEN_MASK = 0x000000f0;
// identity
static const uint32_t FLAG_AUTHEN_IDENTITY = 0x000000010;
// publish key
static const uint32_t FLAG_AUTHEN_PUBLISH = 0x000000020;
// admin key
static const uint32_t FLAG_AUTHEN_ADMIN = 0x00000040;
// pgp sign identity
static const uint32_t FLAG_AUTHEN_PGP_IDENTITY = 0x00000080;
/** END authentication **/ /** END authentication **/
/** START author authentication flags **/
static const uint32_t FLAG_AUTHOR_AUTHENTICATION_MASK = 0x0000ff00;
static const uint32_t FLAG_AUTHOR_AUTHENTICATION_NONE = 0x00000000;
static const uint32_t FLAG_AUTHOR_AUTHENTICATION_GPG = 0x00000100;
static const uint32_t FLAG_AUTHOR_AUTHENTICATION_REQUIRED = 0x00000200;
static const uint32_t FLAG_AUTHOR_AUTHENTICATION_IFNOPUBSIGN = 0x00000400;
static const uint32_t FLAG_GROUP_SIGN_PUBLISH_MASK = 0x000000ff;
static const uint32_t FLAG_GROUP_SIGN_PUBLISH_ENCRYPTED = 0x00000001;
static const uint32_t FLAG_GROUP_SIGN_PUBLISH_ALLSIGNED = 0x00000002;
static const uint32_t FLAG_GROUP_SIGN_PUBLISH_THREADHEAD = 0x00000004;
static const uint32_t FLAG_GROUP_SIGN_PUBLISH_NONEREQ = 0x00000008;
/** START msg authentication flags **/ /** START msg authentication flags **/
static const uint8_t MSG_AUTHEN_MASK = 0x0f; static const uint8_t MSG_AUTHEN_MASK = 0x0f;
static const uint8_t MSG_AUTHEN_ROOT_PUBLISH_SIGN = 0x01; static const uint8_t MSG_AUTHEN_ROOT_PUBLISH_SIGN = 0x01;
static const uint8_t MSG_AUTHEN_CHILD_PUBLISH_SIGN = 0x02; static const uint8_t MSG_AUTHEN_CHILD_PUBLISH_SIGN = 0x02;
static const uint8_t MSG_AUTHEN_ROOT_AUTHOR_SIGN = 0x04; static const uint8_t MSG_AUTHEN_ROOT_AUTHOR_SIGN = 0x04;
static const uint8_t MSG_AUTHEN_CHILD_AUTHOR_SIGN = 0x08; static const uint8_t MSG_AUTHEN_CHILD_AUTHOR_SIGN = 0x08;
/** END msg authentication flags **/ /** END msg authentication flags **/
@ -72,11 +59,8 @@ namespace GXS_SERV {
/** START Subscription Flags. (LOCAL) **/ /** START Subscription Flags. (LOCAL) **/
static const uint32_t GROUP_SUBSCRIBE_ADMIN = 0x01; static const uint32_t GROUP_SUBSCRIBE_ADMIN = 0x01;
static const uint32_t GROUP_SUBSCRIBE_PUBLISH = 0x02; static const uint32_t GROUP_SUBSCRIBE_PUBLISH = 0x02;
static const uint32_t GROUP_SUBSCRIBE_SUBSCRIBED = 0x04; static const uint32_t GROUP_SUBSCRIBE_SUBSCRIBED = 0x04;
static const uint32_t GROUP_SUBSCRIBE_NOT_SUBSCRIBED = 0x08; static const uint32_t GROUP_SUBSCRIBE_NOT_SUBSCRIBED = 0x08;
/*! /*!
@ -96,16 +80,11 @@ namespace GXS_SERV {
* NOTE: RsGxsCommentService uses 0x000f0000. * NOTE: RsGxsCommentService uses 0x000f0000.
*/ */
static const uint32_t GXS_MSG_STATUS_GEN_MASK = 0x0000ffff; static const uint32_t GXS_MSG_STATUS_GEN_MASK = 0x0000ffff;
static const uint32_t GXS_MSG_STATUS_UNPROCESSED = 0x00000001; static const uint32_t GXS_MSG_STATUS_UNPROCESSED = 0x00000001;
static const uint32_t GXS_MSG_STATUS_GUI_UNREAD = 0x00000002; static const uint32_t GXS_MSG_STATUS_GUI_UNREAD = 0x00000002;
static const uint32_t GXS_MSG_STATUS_GUI_NEW = 0x00000004; static const uint32_t GXS_MSG_STATUS_GUI_NEW = 0x00000004;
static const uint32_t GXS_MSG_STATUS_KEEP = 0x00000008; static const uint32_t GXS_MSG_STATUS_KEEP = 0x00000008;
static const uint32_t GXS_MSG_STATUS_DELETE = 0x00000020;
static const uint32_t GXS_MSG_STATUS_DELETE = 0x000000020;
/** END GXS Msg status flags **/ /** END GXS Msg status flags **/

64
retroshare-gui/src/gui/gxs/GxsGroupDialog.cpp
View File

@ -37,18 +37,24 @@
#include <iostream> #include <iostream>
// Control of Publish Signatures. // Control of Publish Signatures.
#define RSGXS_GROUP_SIGN_PUBLISH_MASK 0x000000ff //
#define RSGXS_GROUP_SIGN_PUBLISH_ENCRYPTED 0x00000001 // These are now defined in rsgxsflags.h
#define RSGXS_GROUP_SIGN_PUBLISH_ALLSIGNED 0x00000002 //
#define RSGXS_GROUP_SIGN_PUBLISH_THREADHEAD 0x00000004 // #define FLAG_GROUP_SIGN_PUBLISH_MASK 0x000000ff
#define RSGXS_GROUP_SIGN_PUBLISH_NONEREQ 0x00000008 // #define FLAG_GROUP_SIGN_PUBLISH_ENCRYPTED 0x00000001
// #define FLAG_GROUP_SIGN_PUBLISH_ALLSIGNED 0x00000002
// #define FLAG_GROUP_SIGN_PUBLISH_THREADHEAD 0x00000004
// #define FLAG_GROUP_SIGN_PUBLISH_NONEREQ 0x00000008
// Author Signature. // // Author Signature.
#define RSGXS_GROUP_SIGN_AUTHOR_MASK 0x0000ff00 //
#define RSGXS_GROUP_SIGN_AUTHOR_GPG 0x00000100 // These are now defined in rsgxsflags.h
#define RSGXS_GROUP_SIGN_AUTHOR_REQUIRED 0x00000200 //
#define RSGXS_GROUP_SIGN_AUTHOR_IFNOPUBSIGN 0x00000400 // #define FLAG_AUTHOR_AUTHENTICATION_MASK 0x0000ff00
#define RSGXS_GROUP_SIGN_AUTHOR_NONE 0x00000800 // #define FLAG_AUTHOR_AUTHENTICATION_NONE 0x00000000
// #define FLAG_AUTHOR_AUTHENTICATION_GPG 0x00000100
// #define FLAG_AUTHOR_AUTHENTICATION_REQUIRED 0x00000200
// #define FLAG_AUTHOR_AUTHENTICATION_IFNOPUBSIGN 0x00000400
#define GXSGROUP_NEWGROUPID 1 #define GXSGROUP_NEWGROUPID 1
#define GXSGROUP_LOADGROUP 2 #define GXSGROUP_LOADGROUP 2
@ -576,54 +582,54 @@ uint32_t GxsGroupDialog::getGroupSignFlags()
/* grab from the ui options -> */ /* grab from the ui options -> */
uint32_t signFlags = 0; uint32_t signFlags = 0;
if (ui.publish_encrypt->isChecked()) { if (ui.publish_encrypt->isChecked()) {
signFlags |= RSGXS_GROUP_SIGN_PUBLISH_ENCRYPTED; signFlags |= GXS_SERV::FLAG_GROUP_SIGN_PUBLISH_ENCRYPTED;
} else if (ui.publish_required->isChecked()) { } else if (ui.publish_required->isChecked()) {
signFlags |= RSGXS_GROUP_SIGN_PUBLISH_ALLSIGNED; signFlags |= GXS_SERV::FLAG_GROUP_SIGN_PUBLISH_ALLSIGNED;
} else if (ui.publish_threads->isChecked()) { } else if (ui.publish_threads->isChecked()) {
signFlags |= RSGXS_GROUP_SIGN_PUBLISH_THREADHEAD; signFlags |= GXS_SERV::FLAG_GROUP_SIGN_PUBLISH_THREADHEAD;
} else { // publish_open (default). } else { // publish_open (default).
signFlags |= RSGXS_GROUP_SIGN_PUBLISH_NONEREQ; signFlags |= GXS_SERV::FLAG_GROUP_SIGN_PUBLISH_NONEREQ;
} }
// Author Signature. // Author Signature.
if (ui.personal_pgp->isChecked()) { if (ui.personal_pgp->isChecked()) {
signFlags |= RSGXS_GROUP_SIGN_AUTHOR_GPG; signFlags |= GXS_SERV::FLAG_AUTHOR_AUTHENTICATION_GPG;
} else if (ui.personal_required->isChecked()) { } else if (ui.personal_required->isChecked()) {
signFlags |= RSGXS_GROUP_SIGN_AUTHOR_REQUIRED; signFlags |= GXS_SERV::FLAG_AUTHOR_AUTHENTICATION_REQUIRED;
} else if (ui.personal_ifnopub->isChecked()) { } else if (ui.personal_ifnopub->isChecked()) {
signFlags |= RSGXS_GROUP_SIGN_AUTHOR_IFNOPUBSIGN; signFlags |= GXS_SERV::FLAG_AUTHOR_AUTHENTICATION_IFNOPUBSIGN;
} else { // shouldn't allow this one. } else { // shouldn't allow this one.
signFlags |= RSGXS_GROUP_SIGN_AUTHOR_NONE; signFlags |= GXS_SERV::FLAG_AUTHOR_AUTHENTICATION_NONE;
} }
return signFlags; return signFlags;
} }
void GxsGroupDialog::setGroupSignFlags(uint32_t signFlags) void GxsGroupDialog::setGroupSignFlags(uint32_t signFlags)
{ {
if (signFlags & RSGXS_GROUP_SIGN_PUBLISH_ENCRYPTED) { if (signFlags & GXS_SERV::FLAG_GROUP_SIGN_PUBLISH_ENCRYPTED) {
ui.publish_encrypt->setChecked(true); ui.publish_encrypt->setChecked(true);
} else if (signFlags & RSGXS_GROUP_SIGN_PUBLISH_ALLSIGNED) { } else if (signFlags & GXS_SERV::FLAG_GROUP_SIGN_PUBLISH_ALLSIGNED) {
ui.publish_required->setChecked(true); ui.publish_required->setChecked(true);
} else if (signFlags & RSGXS_GROUP_SIGN_PUBLISH_THREADHEAD) { } else if (signFlags & GXS_SERV::FLAG_GROUP_SIGN_PUBLISH_THREADHEAD) {
ui.publish_threads->setChecked(true); ui.publish_threads->setChecked(true);
} else if (signFlags & RSGXS_GROUP_SIGN_PUBLISH_NONEREQ) { } else if (signFlags & GXS_SERV::FLAG_GROUP_SIGN_PUBLISH_NONEREQ) {
ui.publish_open->setChecked(true); ui.publish_open->setChecked(true);
} }
if (signFlags & RSGXS_GROUP_SIGN_AUTHOR_GPG) { if (signFlags & GXS_SERV::FLAG_AUTHOR_AUTHENTICATION_GPG) {
ui.personal_pgp->setChecked(true); ui.personal_pgp->setChecked(true);
} else if (signFlags & RSGXS_GROUP_SIGN_AUTHOR_REQUIRED) { } else if (signFlags & GXS_SERV::FLAG_AUTHOR_AUTHENTICATION_REQUIRED) {
ui.personal_required->setChecked(true); ui.personal_required->setChecked(true);
} else if (signFlags & RSGXS_GROUP_SIGN_AUTHOR_IFNOPUBSIGN) { } else if (signFlags & GXS_SERV::FLAG_AUTHOR_AUTHENTICATION_IFNOPUBSIGN) {
ui.personal_ifnopub->setChecked(true); ui.personal_ifnopub->setChecked(true);
} else if (signFlags & RSGXS_GROUP_SIGN_AUTHOR_NONE) { } else if (signFlags & GXS_SERV::FLAG_AUTHOR_AUTHENTICATION_NONE) {
// Its the same... but not quite. // Its the same... but not quite.
//ui.personal_noifpub->setChecked(); //ui.personal_noifpub->setChecked();
} }
/* guess at comments */ /* guess at comments */
if ((signFlags & RSGXS_GROUP_SIGN_PUBLISH_THREADHEAD) && if ((signFlags & GXS_SERV::FLAG_GROUP_SIGN_PUBLISH_THREADHEAD) &&
(signFlags & RSGXS_GROUP_SIGN_AUTHOR_IFNOPUBSIGN)) (signFlags & GXS_SERV::FLAG_AUTHOR_AUTHENTICATION_IFNOPUBSIGN))
{ {
ui.comments_allowed->setChecked(true); ui.comments_allowed->setChecked(true);
ui.comments_allowed_3->setChecked(true); ui.comments_allowed_3->setChecked(true);

4
retroshare-gui/src/gui/gxsforums/GxsForumGroupDialog.cpp
View File

@ -33,7 +33,7 @@ const uint32_t ForumCreateEnabledFlags = (
GXS_GROUP_FLAGS_DISTRIBUTION | GXS_GROUP_FLAGS_DISTRIBUTION |
// GXS_GROUP_FLAGS_PUBLISHSIGN | // GXS_GROUP_FLAGS_PUBLISHSIGN |
GXS_GROUP_FLAGS_SHAREKEYS | GXS_GROUP_FLAGS_SHAREKEYS |
// GXS_GROUP_FLAGS_PERSONALSIGN | GXS_GROUP_FLAGS_PERSONALSIGN |
// GXS_GROUP_FLAGS_COMMENTS | // GXS_GROUP_FLAGS_COMMENTS |
0); 0);
@ -46,7 +46,7 @@ const uint32_t ForumCreateDefaultsFlags = ( GXS_GROUP_DEFAULTS_DISTRIB_PUBLIC
//GXS_GROUP_DEFAULTS_PUBLISH_REQUIRED | //GXS_GROUP_DEFAULTS_PUBLISH_REQUIRED |
//GXS_GROUP_DEFAULTS_PUBLISH_ENCRYPTED | //GXS_GROUP_DEFAULTS_PUBLISH_ENCRYPTED |
//GXS_GROUP_DEFAULTS_PERSONAL_GPG | //GXS_GROUP_DEFAULTS_PERSONAL_PGP |
GXS_GROUP_DEFAULTS_PERSONAL_REQUIRED | GXS_GROUP_DEFAULTS_PERSONAL_REQUIRED |
//GXS_GROUP_DEFAULTS_PERSONAL_IFNOPUB | //GXS_GROUP_DEFAULTS_PERSONAL_IFNOPUB |