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

Fixed up the retroshare message system.

Browse Source 
git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@331 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
drbob 2008-02-04 17:55:13 +00:00
parent 07a458367b
commit 8527a5e53f
17 changed files with 947 additions and 609 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
libretroshare/src/rsiface/rsiface.h
View File

@ -98,24 +98,20 @@ virtual void unlockData() = 0;
const PersonInfo *getPerson(std::string id); const PersonInfo *getPerson(std::string id);
const DirInfo *getDirectory(std::string id, std::string path); const DirInfo *getDirectory(std::string id, std::string path);
const std::list<MessageInfo> &getMessages()
{ return mMessageList; }
const std::map<RsChanId, ChannelInfo> &getChannels() const std::map<RsChanId, ChannelInfo> &getChannels()
{ return mChannelMap; } { return mChannelMap; }
const std::map<RsChanId, ChannelInfo> &getOurChannels() const std::map<RsChanId, ChannelInfo> &getOurChannels()
{ return mChannelOwnMap; } { return mChannelOwnMap; }
const MessageInfo *getMessage(std::string cId, std::string mId); //const MessageInfo *getChannelMsg(std::string chId, std::string mId);
const MessageInfo *getChannelMsg(std::string chId, std::string mId);
std::list<ChatInfo> getChatNew() //std::list<ChatInfo> getChatNew()
{ // {
std::list<ChatInfo> newList = mChatList; // std::list<ChatInfo> newList = mChatList;
mChatList.clear(); // mChatList.clear();
return newList; // return newList;
} // }
const std::list<FileInfo> &getRecommendList() const std::list<FileInfo> &getRecommendList()
{ return mRecommendList; } { return mRecommendList; }
@ -162,10 +158,10 @@ void fillLists(); /* create some dummy data to display */
std::list<PersonInfo> mRemoteDirList; std::list<PersonInfo> mRemoteDirList;
std::list<PersonInfo> mLocalDirList; std::list<PersonInfo> mLocalDirList;
std::list<FileTransferInfo> mTransferList; std::list<FileTransferInfo> mTransferList;
std::list<MessageInfo> mMessageList; //std::list<MessageInfo> mMessageList;
std::map<RsChanId, ChannelInfo> mChannelMap; std::map<RsChanId, ChannelInfo> mChannelMap;
std::map<RsChanId, ChannelInfo> mChannelOwnMap; std::map<RsChanId, ChannelInfo> mChannelOwnMap;
std::list<ChatInfo> mChatList; //std::list<ChatInfo> mChatList;
std::list<FileInfo> mRecommendList; std::list<FileInfo> mRecommendList;
bool mChanged[NumOfFlags]; bool mChanged[NumOfFlags];
@ -218,9 +214,9 @@ virtual int FileSetBandwidthTotals(float outkB, float inkB) = 0;
/****************************************/ /****************************************/
/* Message Items */ /* Message Items */
virtual int MessageSend(MessageInfo &info) = 0; //virtual int MessageSend(MessageInfo &info) = 0;
virtual int MessageDelete(std::string mid) = 0; //virtual int MessageDelete(std::string mid) = 0;
virtual int MessageRead(std::string mid) = 0; //virtual int MessageRead(std::string mid) = 0;
/* Channel Items */ /* Channel Items */
virtual int ChannelCreateNew(ChannelInfo &info) = 0; virtual int ChannelCreateNew(ChannelInfo &info) = 0;
@ -228,7 +224,7 @@ virtual int ChannelSendMsg(ChannelInfo &info) = 0;
/****************************************/ /****************************************/
/* Chat */ /* Chat */
virtual int ChatSend(ChatInfo &ci) = 0; //virtual int ChatSend(ChatInfo &ci) = 0;
/****************************************/ /****************************************/
@ -244,6 +240,9 @@ virtual int ClearInBroadcast() = 0;
virtual int ClearInSubscribe() = 0; virtual int ClearInSubscribe() = 0;
virtual int ClearInRecommend() = 0; virtual int ClearInRecommend() = 0;
virtual bool IsInChat(std::string id) = 0; /* friend : chat msgs */
virtual bool IsInMsg(std::string id) = 0; /* friend : msg recpts*/
/****************************************/ /****************************************/
/* RsIface Networking */ /* RsIface Networking */
//virtual int NetworkDHTActive(bool active) = 0; //virtual int NetworkDHTActive(bool active) = 0;

138
libretroshare/src/rsiface/rsmsgs.h Normal file
View File

@ -0,0 +1,138 @@
#ifndef RS_MSG_GUI_INTERFACE_H
#define RS_MSG_GUI_INTERFACE_H
/*
* libretroshare/src/rsiface: rsmsgs.h
*
* RetroShare C++ Interface.
*
* Copyright 2007-2008 by Robert Fernie.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License Version 2 as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
* USA.
*
* Please report all bugs and problems to "retroshare@lunamutt.com".
*
*/
#include <list>
#include <iostream>
#include <string>
#include "rsiface/rstypes.h"
/********************** For Messages and Channels *****************/
#define RS_MSG_BOXMASK 0x000f /* Mask for determining Box */
#define RS_MSG_OUTGOING 0x0001 /* !Inbox */
#define RS_MSG_PENDING 0x0002 /* OutBox */
#define RS_MSG_DRAFT 0x0004 /* Draft */
/* ORs of above */
#define RS_MSG_INBOX 0x00 /* Inbox */
#define RS_MSG_SENTBOX 0x01 /* Sentbox */
#define RS_MSG_OUTBOX 0x03 /* Outbox */
#define RS_MSG_DRAFTBOX 0x05 /* Draftbox */
#define RS_MSG_NEW 0x0010
class MessageInfo
{
public:
MessageInfo() {}
std::string msgId;
std::string srcId;
unsigned int msgflags;
std::list<std::string> msgto;
std::list<std::string> msgcc;
std::list<std::string> msgbcc;
std::wstring title;
std::wstring msg;
std::wstring attach_title;
std::wstring attach_comment;
std::list<FileInfo> files;
int size; /* total of files */
int count; /* file count */
int ts;
};
class MsgInfoSummary
{
public:
MsgInfoSummary() {}
std::string msgId;
std::string srcId;
uint32_t msgflags;
std::wstring title;
int count; /* file count */
time_t ts;
};
#define RS_CHAT_PUBLIC 0x0001
#define RS_CHAT_PRIVATE 0x0002
class ChatInfo
{
public:
std::string rsid;
unsigned int chatflags;
std::string name;
std::wstring msg;
};
std::ostream &operator<<(std::ostream &out, const MessageInfo &info);
std::ostream &operator<<(std::ostream &out, const ChatInfo &info);
class RsMsgs;
extern RsMsgs *rsMsgs;
class RsMsgs
{
public:
RsMsgs() { return; }
virtual ~RsMsgs() { return; }
/****************************************/
/* Message Items */
virtual bool getMessageSummaries(std::list<MsgInfoSummary> &msgList) = 0;
virtual bool getMessage(std::string mId, MessageInfo &msg) = 0;
virtual bool MessageSend(MessageInfo &info) = 0;
virtual bool MessageDelete(std::string mid) = 0;
virtual bool MessageRead(std::string mid) = 0;
/****************************************/
/* Chat */
virtual bool ChatSend(ChatInfo &ci) = 0;
virtual bool getNewChat(std::list<ChatInfo> &chats) = 0;
/****************************************/
};
#endif

77
libretroshare/src/rsiface/rstypes.h
View File

@ -32,25 +32,6 @@
#include <string> #include <string>
#if 0
#define RSCERTIDLEN 16
class RsCertId
{
public:
RsCertId();
RsCertId(std::string idstr);
bool operator<(const RsCertId &ref) const;
bool operator==(const RsCertId &ref) const;
bool operator!=(const RsCertId &ref) const;
char data[RSCERTIDLEN];
};
std::ostream &operator<<(std::ostream &out, const RsCertId &id);
#endif
typedef std::string RsCertId; typedef std::string RsCertId;
typedef std::string RsChanId; typedef std::string RsChanId;
typedef std::string RsMsgId; typedef std::string RsMsgId;
@ -157,48 +138,6 @@ class FileTransferInfo: public FileInfo
int downloadStatus; /* 0 = Err, 1 = Ok, 2 = Done */ int downloadStatus; /* 0 = Err, 1 = Ok, 2 = Done */
}; };
/********************** For Messages and Channels *****************/
#define RS_MSG_BOXMASK 0x000f /* Mask for determining Box */
#define RS_MSG_OUTGOING 0x0001 /* !Inbox */
#define RS_MSG_PENDING 0x0002 /* OutBox */
#define RS_MSG_DRAFT 0x0004 /* Draft */
/* ORs of above */
#define RS_MSG_INBOX 0x00 /* Inbox */
#define RS_MSG_SENTBOX 0x01 /* Sentbox */
#define RS_MSG_OUTBOX 0x03 /* Outbox */
#define RS_MSG_DRAFTBOX 0x05 /* Draftbox */
#define RS_MSG_NEW 0x0010
class MessageInfo: public BaseInfo
{
public:
MessageInfo() {}
RsMsgId msgId;
unsigned int msgflags;
std::string srcname;
std::list<PersonInfo> msgto;
std::list<PersonInfo> msgcc;
std::list<PersonInfo> msgbcc;
std::wstring title;
std::wstring msg;
std::wstring attach_title;
std::wstring attach_comment;
std::list<FileInfo> files;
int size; /* total of files */
int count; /* file count */
int ts;
};
class ChannelInfo: public BaseInfo class ChannelInfo: public BaseInfo
{ {
public: public:
@ -206,7 +145,7 @@ class ChannelInfo: public BaseInfo
RsChanId chanId; RsChanId chanId;
bool publisher; bool publisher;
std::string chanName; std::string chanName;
std::list<MessageInfo> msglist; //std::list<MessageInfo> msglist;
/* details */ /* details */
int mode; int mode;
@ -219,18 +158,6 @@ class ChannelInfo: public BaseInfo
int count; /* msg count */ int count; /* msg count */
}; };
#define RS_CHAT_PUBLIC 0x0001
#define RS_CHAT_PRIVATE 0x0002
class ChatInfo: public BaseInfo
{
public:
std::string rsid;
unsigned int chatflags;
std::string name;
std::wstring msg;
};
/* matched to the uPnP states */ /* matched to the uPnP states */
#define UPNP_STATE_UNINITIALISED 0 #define UPNP_STATE_UNINITIALISED 0
#define UPNP_STATE_UNAVAILABILE 1 #define UPNP_STATE_UNAVAILABILE 1
@ -303,9 +230,7 @@ class SearchRequest
}; };
std::ostream &operator<<(std::ostream &out, const MessageInfo &info);
std::ostream &operator<<(std::ostream &out, const ChannelInfo &info); std::ostream &operator<<(std::ostream &out, const ChannelInfo &info);
std::ostream &operator<<(std::ostream &out, const ChatInfo &info);
std::ostream &operator<<(std::ostream &out, const PersonInfo &info); std::ostream &operator<<(std::ostream &out, const PersonInfo &info);
std::ostream &print(std::ostream &out, const DirInfo &info, int indentLvl); std::ostream &print(std::ostream &out, const DirInfo &info, int indentLvl);

9
libretroshare/src/rsserver/Makefile
View File

@ -7,15 +7,16 @@ RS_TOP_DIR = ..
include $(RS_TOP_DIR)/scripts/config.mk include $(RS_TOP_DIR)/scripts/config.mk
############################################################### ###############################################################
RSOBJ = p3face-file.o \ RSOBJ = p3peers.o \
p3face-msgs.o \ p3rank.o \
p3msgs.o \
p3face-file.o \
p3face-server.o \ p3face-server.o \
p3face-config.o \ p3face-config.o \
p3face-startup.o \ p3face-startup.o \
rstypes.o \ rstypes.o \
rsiface.o \ rsiface.o \
p3peers.o \ p3face-msgs.o
p3rank.o
# pqistrings.o \ # pqistrings.o \
# p3face-people.o # p3face-people.o

421
libretroshare/src/rsserver/p3face-msgs.cc
View File

@ -37,130 +37,6 @@ const int p3facemsgzone = 11453;
#include <sys/time.h> #include <sys/time.h>
#include <time.h> #include <time.h>
#if 0
unsigned long getMsgId(RsMsgId &id)
{
unsigned long mid = 0;
mid = (id.data[0] << 24);
mid |= (id.data[1] << 16);
mid |= (id.data[2] << 8);
mid |= id.data[3];
return mid;
}
void setMsgId(RsMsgId &rsmid, unsigned int mid)
{
/* version that uses the uniqueMsgId stored in sid */
/* 16 Bytes XXX Must be equal! */
for(int i = 0; i < CHAN_SIGN_SIZE; i++)
rsmid.data[i] = 0;
rsmid.data[0] = (0xff & (mid >> 24));
rsmid.data[1] = (0xff & (mid >> 16));
rsmid.data[2] = (0xff & (mid >> 8));
rsmid.data[3] = (0xff & (mid >> 0));
return;
}
#endif
/****************************************/
/****************************************/
/* Message Items */
int RsServer::MessageSend(MessageInfo &info)
{
/* so we send this.... */
lockRsCore(); /* LOCK */
RsMsgItem *msg = new RsMsgItem();
/* id who it is to ???? handled lower */
msg -> PeerId("");
msg -> msgFlags = 0;
msg -> msgId = 0;
msg -> sendTime = time(NULL);
msg -> recvTime = 0;
msg -> subject = info.title;
msg -> message = info.msg;
std::list<PersonInfo>::iterator pit;
for(pit = info.msgto.begin(); pit != info.msgto.end(); pit++)
{
msg -> msgto.ids.push_back(pit->id);
}
for(pit = info.msgcc.begin(); pit != info.msgcc.end(); pit++)
{
msg -> msgcc.ids.push_back(pit->id);
}
for(pit = info.msgbcc.begin(); pit != info.msgbcc.end(); pit++)
{
msg -> msgbcc.ids.push_back(pit->id);
}
msg -> attachment.title = info.attach_title;
msg -> attachment.comment = info.attach_comment;
std::list<FileInfo>::iterator it;
for(it = info.files.begin(); it != info.files.end(); it++)
{
RsTlvFileItem mfi;
mfi.hash = it -> hash;
mfi.name = it -> fname;
mfi.filesize = it -> size;
msg -> attachment.items.push_back(mfi);
}
std::cerr << "RsServer::MessageSend()" << std::endl;
msg->print(std::cerr);
msgSrv -> sendMessage(msg);
unlockRsCore(); /* UNLOCK */
UpdateAllMsgs();
return 1;
}
/****************************************/
/****************************************/
int RsServer::MessageDelete(std::string mid)
{
lockRsCore(); /* LOCK */
std::cerr << "RsServer::MessageDelete() ";
std::cerr << "mid: " << mid << std::endl;
msgSrv -> removeMsgId(atoi(mid.c_str()));
unlockRsCore(); /* UNLOCK */
UpdateAllMsgs();
return 1;
}
int RsServer::MessageRead(std::string mid)
{
lockRsCore(); /* LOCK */
std::cerr << "RsServer::MessageRead() ";
std::cerr << "mid: " << mid << std::endl;
msgSrv -> markMsgIdRead(atoi(mid.c_str()));
unlockRsCore(); /* UNLOCK */
// (needed?) UpdateAllMsgs();
return 1;
}
/****************************************/ /****************************************/
/****************************************/ /****************************************/
int RsServer::ChannelCreateNew(ChannelInfo &info) int RsServer::ChannelCreateNew(ChannelInfo &info)
@ -177,105 +53,6 @@ int RsServer::ChannelSendMsg(ChannelInfo &info)
return 1; return 1;
} }
/****************************************/
/****************************************/
int RsServer::ChatSend(ChatInfo &ci)
{
lockRsCore(); /* LOCK */
/* send a message to all for now */
if (ci.chatflags & RS_CHAT_PRIVATE)
{
chatSrv -> sendPrivateChat(ci.msg, ci.rsid);
}
else
{
/* global */
chatSrv -> sendChat(ci.msg);
}
unlockRsCore(); /* UNLOCK */
UpdateAllChat();
return 1;
}
int RsServer::UpdateAllChat()
{
RsIface &iface = getIface();
/* lock Mutexes */
lockRsCore(); /* LOCK */
iface.lockData(); /* LOCK */
/* get any messages and push them to iface */
// get the items from the list.
std::list<RsChatItem *> clist = chatSrv -> getChatQueue();
std::list<RsChatItem *>::iterator it;
for(it = clist.begin(); it != clist.end(); it++)
{
ChatInfo ci;
initRsChatInfo((*it), ci);
iface.mChatList.push_back(ci);
delete (*it);
}
iface.setChanged(RsIface::Chat);
/* unlock Mutexes */
iface.unlockData(); /* UNLOCK */
unlockRsCore(); /* UNLOCK */
return 1;
}
/****************************************/
/****************************************/
int RsServer::UpdateAllMsgs()
{
NotifyBase &cb = getNotify();
cb.notifyListPreChange(NOTIFY_LIST_MESSAGELIST, NOTIFY_TYPE_MOD);
RsIface &iface = getIface();
/* lock Mutexes */
lockRsCore(); /* LOCK */
iface.lockData(); /* LOCK */
/* do stuff */
std::list<RsMsgItem *> &msglist = msgSrv -> getMsgList();
std::list<RsMsgItem *> &msgOutlist = msgSrv -> getMsgOutList();
std::list<RsMsgItem *>::iterator mit;
std::list<MessageInfo> &msgs = iface.mMessageList;
msgs.clear();
for(mit = msglist.begin(); mit != msglist.end(); mit++)
{
MessageInfo mi;
initRsMI(*mit, mi);
msgs.push_back(mi);
}
for(mit = msgOutlist.begin(); mit != msgOutlist.end(); mit++)
{
MessageInfo mi;
initRsMI(*mit, mi);
msgs.push_back(mi);
}
iface.setChanged(RsIface::Message);
/* unlock Mutexes */
iface.unlockData(); /* UNLOCK */
unlockRsCore(); /* UNLOCK */
cb.notifyListChange(NOTIFY_LIST_MESSAGELIST, NOTIFY_TYPE_MOD);
return 1;
}
/****************************************/ /****************************************/
/****************************************/ /****************************************/
int RsServer::UpdateAllChannels() int RsServer::UpdateAllChannels()
@ -374,25 +151,6 @@ int RsServer::UpdateAllChannels()
* for intAddChannel / intAddChannelMsg. * for intAddChannel / intAddChannelMsg.
*/ */
void RsServer::initRsChatInfo(RsChatItem *c, ChatInfo &i)
{
i.rsid = c -> PeerId();
i.name = mAuthMgr->getName(i.rsid);
i.msg = c -> message;
if (c -> chatFlags & RS_CHAT_FLAG_PRIVATE)
{
std::cerr << "RsServer::initRsChatInfo() Chat Private!!!";
i.chatflags = RS_CHAT_PRIVATE;
}
else
{
i.chatflags = RS_CHAT_PUBLIC;
std::cerr << "RsServer::initRsChatInfo() Chat Public!!!";
}
std::cerr << std::endl;
}
#ifdef PQI_USE_CHANNELS #ifdef PQI_USE_CHANNELS
int RsServer::intAddChannel(ChannelInfo &info) int RsServer::intAddChannel(ChannelInfo &info)
@ -503,101 +261,13 @@ void RsServer::intCheckFileStatus(FileInfo &file)
} }
void RsServer::initRsMI(RsMsgItem *msg, MessageInfo &mi)
{
mi.msgflags = 0;
/* translate flags, if we sent it... outgoing */
if ((msg->msgFlags & RS_MSG_FLAGS_OUTGOING)
|| (msg->PeerId() == mAuthMgr->OwnId()))
{
mi.msgflags |= RS_MSG_OUTGOING;
}
/* if it has a pending flag, then its in the outbox */
if (msg->msgFlags & RS_MSG_FLAGS_PENDING)
{
mi.msgflags |= RS_MSG_PENDING;
}
if (msg->msgFlags & RS_MSG_FLAGS_NEW)
{
mi.msgflags |= RS_MSG_NEW;
}
mi.id = msg->PeerId();
mi.srcname = mAuthMgr->getName(mi.id);
std::list<std::string>::iterator pit;
for(pit = msg->msgto.ids.begin();
pit != msg->msgto.ids.end(); pit++)
{
PersonInfo pi;
pi.id = (*pit);
pi.name = mAuthMgr->getName(pi.id);
mi.msgto.push_back(pi);
}
for(pit = msg->msgcc.ids.begin();
pit != msg->msgcc.ids.end(); pit++)
{
PersonInfo pi;
pi.id = (*pit);
pi.name = mAuthMgr->getName(pi.id);
mi.msgcc.push_back(pi);
}
for(pit = msg->msgbcc.ids.begin();
pit != msg->msgbcc.ids.end(); pit++)
{
PersonInfo pi;
pi.id = (*pit);
pi.name = mAuthMgr->getName(pi.id);
mi.msgbcc.push_back(pi);
}
mi.title = msg->subject;
mi.msg = msg->message;
mi.attach_title = msg->attachment.title;
mi.attach_comment = msg->attachment.comment;
mi.count = 0;
mi.size = 0;
std::list<RsTlvFileItem>::iterator it;
for(it = msg->attachment.items.begin();
it != msg->attachment.items.end(); it++)
{
FileInfo fi;
fi.fname = RsDirUtil::getTopDir(it->name);
fi.size = it->filesize;
fi.hash = it->hash;
fi.path = it->path;
mi.files.push_back(fi);
mi.count++;
mi.size += fi.size;
}
mi.ts = msg->sendTime;
mi.msgId = msg->msgId;
}
/* Flagging Persons / Channels / Files in or out of a set (CheckLists) */ /* Flagging Persons / Channels / Files in or out of a set (CheckLists) */
int RsServer::ClearInChat() int RsServer::ClearInChat()
{ {
lockRsCore(); /* LOCK */ lockRsCore(); /* LOCK */
#if 0
std::list<cert *>::iterator it;
std::list<cert *> &certs = sslr -> getCertList();
for(it = certs.begin(); it != certs.end(); it++) mInChatList.clear();
{
(*it)->InChat(false);
}
sslr->IndicateCertsChanged();
#endif
unlockRsCore(); /* UNLOCK */ unlockRsCore(); /* UNLOCK */
return 1; return 1;
@ -610,25 +280,26 @@ int RsServer::SetInChat(std::string id, bool in) /* friend : cha
/* so we send this.... */ /* so we send this.... */
lockRsCore(); /* LOCK */ lockRsCore(); /* LOCK */
#if 0
RsCertId rsid(id);
cert *c = intFindCert(rsid);
if (c)
{
c->InChat(in);
sslr->IndicateCertsChanged();
std::cerr << "Set InChat(" << id << ") to " << (in ? "True" : "False") << std::endl; std::cerr << "Set InChat(" << id << ") to " << (in ? "True" : "False") << std::endl;
std::list<std::string>::iterator it;
it = std::find(mInChatList.begin(), mInChatList.end(), id);
if (it == mInChatList.end())
{
if (in)
{
mInChatList.push_back(id);
}
} }
else else
{ {
std::cerr << "FAILED TO Set InChat(" << id << ") to " << (in ? "True" : "False") << std::endl; if (!in)
{
mInChatList.erase(it);
}
} }
#endif
unlockRsCore(); /* UNLOCK */ unlockRsCore(); /* UNLOCK */
//UpdateAllCerts();
return 1; return 1;
} }
@ -637,16 +308,7 @@ int RsServer::ClearInMsg()
{ {
lockRsCore(); /* LOCK */ lockRsCore(); /* LOCK */
#if 0 mInMsgList.clear();
std::list<cert *>::iterator it;
std::list<cert *> &certs = sslr -> getCertList();
for(it = certs.begin(); it != certs.end(); it++)
{
(*it)->InMessage(false);
}
sslr->IndicateCertsChanged();
#endif
unlockRsCore(); /* UNLOCK */ unlockRsCore(); /* UNLOCK */
@ -659,31 +321,60 @@ int RsServer::SetInMsg(std::string id, bool in) /* friend : msgs
/* so we send this.... */ /* so we send this.... */
lockRsCore(); /* LOCK */ lockRsCore(); /* LOCK */
#if 0
RsCertId rsid(id);
cert *c = intFindCert(rsid);
if (c)
{
c->InMessage(in);
sslr->IndicateCertsChanged();
std::cerr << "Set InMsg(" << id << ") to " << (in ? "True" : "False") << std::endl; std::cerr << "Set InMsg(" << id << ") to " << (in ? "True" : "False") << std::endl;
std::list<std::string>::iterator it;
it = std::find(mInMsgList.begin(), mInMsgList.end(), id);
if (it == mInMsgList.end())
{
if (in)
{
mInMsgList.push_back(id);
}
} }
else else
{ {
std::cerr << "FAILED to Set InMsg(" << id << ") to " << (in ? "True" : "False") << std::endl; if (!in)
{
mInMsgList.erase(it);
}
} }
#endif
unlockRsCore(); /* UNLOCK */
return 1;
}
bool RsServer::IsInChat(std::string id) /* friend : chat msgs */
{
/* so we send this.... */
lockRsCore(); /* LOCK */
std::list<std::string>::iterator it;
it = std::find(mInChatList.begin(), mInChatList.end(), id);
bool inChat = (it != mInChatList.end());
unlockRsCore(); /* UNLOCK */ unlockRsCore(); /* UNLOCK */
//UpdateAllCerts(); return inChat;
return 1;
} }
bool RsServer::IsInMsg(std::string id) /* friend : msg recpts*/
{
/* so we send this.... */
lockRsCore(); /* LOCK */
std::list<std::string>::iterator it;
it = std::find(mInMsgList.begin(), mInMsgList.end(), id);
bool inMsg = (it != mInMsgList.end());
unlockRsCore(); /* UNLOCK */
return inMsg;
}
int RsServer::ClearInBroadcast() int RsServer::ClearInBroadcast()
{ {
return 1; return 1;

7
libretroshare/src/rsserver/p3face-server.cc
View File

@ -175,11 +175,6 @@ void RsServer::run()
{ {
lastSec = (int) ts; lastSec = (int) ts;
/* Chat needs to be quick too! */
//std::cerr << "RsServer::run() UpdateAllChat()" << std::endl;
UpdateAllChat();
// every five loops (> 5 secs) // every five loops (> 5 secs)
if (loop % 5 == 0) if (loop % 5 == 0)
{ {
@ -199,8 +194,6 @@ void RsServer::run()
//std::cerr << "RsServer::run() UpdateAllTransfers()" << std::endl; //std::cerr << "RsServer::run() UpdateAllTransfers()" << std::endl;
UpdateAllTransfers(); UpdateAllTransfers();
//std::cerr << "RsServer::run() UpdateAllMsgs()" << std::endl;
UpdateAllMsgs();
//std::cerr << "RsServer::run() UpdateAllChannels()" << std::endl; //std::cerr << "RsServer::run() UpdateAllChannels()" << std::endl;
UpdateAllChannels(); UpdateAllChannels();

3
libretroshare/src/rsserver/p3face-startup.cc
View File

@ -38,7 +38,6 @@
#include "upnp/upnphandler.h" #include "upnp/upnphandler.h"
#include "dht/opendhtmgr.h" #include "dht/opendhtmgr.h"
// Removed temporarily...
#include "services/p3disc.h" #include "services/p3disc.h"
#include "services/p3msgservice.h" #include "services/p3msgservice.h"
#include "services/p3chatservice.h" #include "services/p3chatservice.h"
@ -56,6 +55,7 @@
#include "rsserver/p3face.h" #include "rsserver/p3face.h"
#include "rsserver/p3peers.h" #include "rsserver/p3peers.h"
#include "rsserver/p3rank.h" #include "rsserver/p3rank.h"
#include "rsserver/p3msgs.h"
#include "rsiface/rsgame.h" #include "rsiface/rsgame.h"
/**************** PQI_USE_XPGP ******************/ /**************** PQI_USE_XPGP ******************/
@ -621,6 +621,7 @@ int RsServer::StartupRetroShare(RsInit *config)
/* setup the gui */ /* setup the gui */
rsGameLauncher = gameLauncher; rsGameLauncher = gameLauncher;
rsRanks = new p3Rank(ranking); rsRanks = new p3Rank(ranking);
rsMsgs = new p3Msgs(mAuthMgr, msgSrv, chatSrv);
/* put a welcome message in! */ /* put a welcome message in! */
if (config->firsttime_run) if (config->firsttime_run)

26
libretroshare/src/rsserver/p3face.h
View File

@ -36,12 +36,9 @@
#include "rsiface/rstypes.h" #include "rsiface/rstypes.h"
#include "util/rsthreads.h" #include "util/rsthreads.h"
class p3disc; #include "services/p3disc.h"
class p3MsgService;
class p3ChatService;
#include "services/p3chatservice.h"
#include "services/p3msgservice.h" #include "services/p3msgservice.h"
#include "services/p3chatservice.h"
/* The Main Interface Class - for controlling the server */ /* The Main Interface Class - for controlling the server */
@ -159,18 +156,10 @@ int UpdateRemotePeople();
/* p3face-msg Operations */ /* p3face-msg Operations */
public: public:
/* Message Items */
virtual int MessageSend(MessageInfo &info);
virtual int MessageDelete(std::string mid);
virtual int MessageRead(std::string mid);
/* Channel Items */ /* Channel Items */
virtual int ChannelCreateNew(ChannelInfo &info); virtual int ChannelCreateNew(ChannelInfo &info);
virtual int ChannelSendMsg(ChannelInfo &info); virtual int ChannelSendMsg(ChannelInfo &info);
/* Chat */
virtual int ChatSend(ChatInfo &ci);
/* Flagging Persons / Channels / Files in or out of a set (CheckLists) */ /* Flagging Persons / Channels / Files in or out of a set (CheckLists) */
virtual int SetInChat(std::string id, bool in); /* friend : chat msgs */ virtual int SetInChat(std::string id, bool in); /* friend : chat msgs */
virtual int SetInMsg(std::string id, bool in); /* friend : msg receipients */ virtual int SetInMsg(std::string id, bool in); /* friend : msg receipients */
@ -183,15 +172,16 @@ virtual int ClearInBroadcast();
virtual int ClearInSubscribe(); virtual int ClearInSubscribe();
virtual int ClearInRecommend(); virtual int ClearInRecommend();
virtual bool IsInChat(std::string id); /* friend : chat msgs */
virtual bool IsInMsg(std::string id); /* friend : msg recpts*/
private: private:
/* Internal Update Iface Fns */ std::list<std::string> mInChatList, mInMsgList;
int UpdateAllChat();
int UpdateAllMsgs();
int UpdateAllChannels();
void initRsChatInfo(RsChatItem *c, ChatInfo &i); /* Internal Update Iface Fns */
int UpdateAllChannels();
#ifdef PQI_USE_CHANNELS #ifdef PQI_USE_CHANNELS

155
libretroshare/src/rsserver/p3msgs.cc Normal file
View File

@ -0,0 +1,155 @@
/*
* "$Id: p3face-msgs.cc,v 1.7 2007-05-05 16:10:06 rmf24 Exp $"
*
* RetroShare C++ Interface.
*
* Copyright 2004-2006 by Robert Fernie.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License Version 2 as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
* USA.
*
* Please report all bugs and problems to "retroshare@lunamutt.com".
*
*/
#include "rsserver/p3face.h"
#include "util/rsdir.h"
#include <iostream>
#include <sstream>
#include "pqi/pqidebug.h"
const int p3facemsgzone = 11453;
#include <sys/time.h>
#include <time.h>
#include "rsserver/p3msgs.h"
/* external reference point */
RsMsgs *rsMsgs = NULL;
/****************************************/
/****************************************/
bool p3Msgs::getMessageSummaries(std::list<MsgInfoSummary> &msgList)
{
return mMsgSrv->getMessageSummaries(msgList);
}
bool p3Msgs::getMessage(std::string mid, MessageInfo &msg)
{
return mMsgSrv->getMessage(mid, msg);
}
/****************************************/
/****************************************/
/* Message Items */
bool p3Msgs::MessageSend(MessageInfo &info)
{
return mMsgSrv->MessageSend(info);
}
/****************************************/
/****************************************/
bool p3Msgs::MessageDelete(std::string mid)
{
std::cerr << "p3Msgs::MessageDelete() ";
std::cerr << "mid: " << mid << std::endl;
mMsgSrv -> removeMsgId(mid);
return 1;
}
bool p3Msgs::MessageRead(std::string mid)
{
std::cerr << "p3Msgs::MessageRead() ";
std::cerr << "mid: " << mid << std::endl;
mMsgSrv -> markMsgIdRead(mid);
return 1;
}
/****************************************/
/****************************************/
bool p3Msgs::ChatSend(ChatInfo &ci)
{
/* send a message to all for now */
if (ci.chatflags & RS_CHAT_PRIVATE)
{
mChatSrv -> sendPrivateChat(ci.msg, ci.rsid);
}
else
{
/* global */
mChatSrv -> sendChat(ci.msg);
}
return true;
}
bool p3Msgs::getNewChat(std::list<ChatInfo> &chats)
{
/* get any messages and push them to iface */
// get the items from the list.
std::list<RsChatItem *> clist = mChatSrv -> getChatQueue();
if (clist.size() < 1)
{
return false;
}
std::list<RsChatItem *>::iterator it;
for(it = clist.begin(); it != clist.end(); it++)
{
ChatInfo ci;
initRsChatInfo((*it), ci);
chats.push_back(ci);
delete (*it);
}
return true;
}
/**** HELPER FNS For Chat/Msg/Channel Lists ************
*
* The iface->Mutex is required to be locked
* for intAddChannel / intAddChannelMsg.
*/
void p3Msgs::initRsChatInfo(RsChatItem *c, ChatInfo &i)
{
i.rsid = c -> PeerId();
i.name = mAuthMgr->getName(i.rsid);
i.msg = c -> message;
if (c -> chatFlags & RS_CHAT_FLAG_PRIVATE)
{
std::cerr << "RsServer::initRsChatInfo() Chat Private!!!";
i.chatflags = RS_CHAT_PRIVATE;
}
else
{
i.chatflags = RS_CHAT_PUBLIC;
std::cerr << "RsServer::initRsChatInfo() Chat Public!!!";
}
std::cerr << std::endl;
}

71
libretroshare/src/rsserver/p3msgs.h Normal file
View File

@ -0,0 +1,71 @@
#ifndef RS_P3MSG_INTERFACE_H
#define RS_P3MSG_INTERFACE_H
/*
* libretroshare/src/rsserver: p3msgs.h
*
* RetroShare C++ Interface.
*
* Copyright 2007-2008 by Robert Fernie.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License Version 2 as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
* USA.
*
* Please report all bugs and problems to "retroshare@lunamutt.com".
*
*/
#include "rsiface/rsmsgs.h"
class p3AuthMgr;
class p3MsgService;
class p3ChatService;
class p3Msgs: public RsMsgs
{
public:
p3Msgs(p3AuthMgr *p3a, p3MsgService *p3m, p3ChatService *p3c)
:mAuthMgr(p3a), mMsgSrv(p3m), mChatSrv(p3c) { return; }
virtual ~p3Msgs() { return; }
/****************************************/
/* Message Items */
virtual bool getMessageSummaries(std::list<MsgInfoSummary> &msgList);
virtual bool getMessage(std::string mId, MessageInfo &msg);
virtual bool MessageSend(MessageInfo &info);
virtual bool MessageDelete(std::string mid);
virtual bool MessageRead(std::string mid);
/****************************************/
/* Chat */
virtual bool ChatSend(ChatInfo &ci);
virtual bool getNewChat(std::list<ChatInfo> &chats);
/****************************************/
private:
void initRsChatInfo(RsChatItem *c, ChatInfo &i);
p3AuthMgr *mAuthMgr;
p3MsgService *mMsgSrv;
p3ChatService *mChatSrv;
};
#endif

3
libretroshare/src/rsserver/rsiface.cc
View File

@ -111,6 +111,7 @@ DirInfo *RsIface::getDirectoryMod(std::string uid, std::string path)
#if 0
const MessageInfo *RsIface::getMessage(std::string cid_in, std::string mid_in) const MessageInfo *RsIface::getMessage(std::string cid_in, std::string mid_in)
{ {
@ -172,6 +173,8 @@ const MessageInfo *RsIface::getChannelMsg(std::string chid_in, std::string mid_i
return NULL; return NULL;
} }
#endif
/* set to true */ /* set to true */
bool RsIface::setChanged(DataFlags set) bool RsIface::setChanged(DataFlags set)
{ {

12
libretroshare/src/rsserver/rstypes.cc
View File

@ -89,6 +89,8 @@ std::ostream &print(std::ostream &out, const DirInfo &info, int indentLvl)
} }
#if 0
std::ostream &operator<<(std::ostream &out, const MessageInfo &info) std::ostream &operator<<(std::ostream &out, const MessageInfo &info)
{ {
out << "MessageInfo(TODO)"; out << "MessageInfo(TODO)";
@ -96,16 +98,18 @@ std::ostream &operator<<(std::ostream &out, const MessageInfo &info)
return out; return out;
} }
std::ostream &operator<<(std::ostream &out, const ChannelInfo &info) std::ostream &operator<<(std::ostream &out, const ChatInfo &info)
{ {
out << "ChannelInfo(TODO)"; out << "ChatInfo(TODO)";
out << std::endl; out << std::endl;
return out; return out;
} }
std::ostream &operator<<(std::ostream &out, const ChatInfo &info) #endif
std::ostream &operator<<(std::ostream &out, const ChannelInfo &info)
{ {
out << "ChatInfo(TODO)"; out << "ChannelInfo(TODO)";
out << std::endl; out << std::endl;
return out; return out;
} }

16
libretroshare/src/serialiser/rsserial.cc
View File

@ -212,6 +212,12 @@ uint32_t RsSerialiser::size(RsItem *item)
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsSerialiser::size() serialiser missing!"; std::cerr << "RsSerialiser::size() serialiser missing!";
std::ostringstream out;
out << std::hex << item->PacketId();
std::cerr << "RsSerialiser::size() PacketId: ";
std::cerr << out.str();
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
return 0; return 0;
@ -248,6 +254,11 @@ bool RsSerialiser::serialise (RsItem *item, void *data, uint32_t *size)
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsSerialiser::serialise() serialiser missing!"; std::cerr << "RsSerialiser::serialise() serialiser missing!";
std::ostringstream out;
out << std::hex << item->PacketId();
std::cerr << "RsSerialiser::serialise() PacketId: ";
std::cerr << out.str();
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
return false; return false;
@ -308,6 +319,11 @@ RsItem * RsSerialiser::deserialise(void *data, uint32_t *size)
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsSerialiser::deserialise() deserialiser missing!"; std::cerr << "RsSerialiser::deserialise() deserialiser missing!";
std::ostringstream out;
out << std::hex << getRsItemId(data);
std::cerr << "RsSerialiser::deserialise() PacketId: ";
std::cerr << out.str();
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
return NULL; return NULL;

494
libretroshare/src/services/p3msgservice.cc
View File

@ -31,6 +31,8 @@
#include "services/p3msgservice.h" #include "services/p3msgservice.h"
#include "util/rsdir.h"
#include <sstream> #include <sstream>
#include <iomanip> #include <iomanip>
@ -57,8 +59,16 @@ p3MsgService::p3MsgService(p3ConnectMgr *cm)
:p3Service(RS_SERVICE_TYPE_MSG), mConnMgr(cm), :p3Service(RS_SERVICE_TYPE_MSG), mConnMgr(cm),
msgChanged(1), msgMajorChanged(1) msgChanged(1), msgMajorChanged(1)
{ {
addSerialType(new RsMsgSerialiser());
} }
bool p3MsgService::ModifiedMsgs()
{
bool m1 = msgChanged.Changed();
bool m2 = msgMajorChanged.Changed();
return (m1 || m2);
}
int p3MsgService::tick() int p3MsgService::tick()
{ {
@ -111,91 +121,12 @@ int p3MsgService::incomingMsgs()
/* STORE MsgID */ /* STORE MsgID */
mi -> msgId = getNewUniqueMsgId(); mi -> msgId = getNewUniqueMsgId();
imsg.push_back(mi); imsg[mi->msgId] = mi;
msgChanged.IndicateChanged(); msgChanged.IndicateChanged();
} }
return 1; return 1;
} }
std::list<RsMsgItem *> &p3MsgService::getMsgList()
{
return imsg;
}
std::list<RsMsgItem *> &p3MsgService::getMsgOutList()
{
return msgOutgoing;
}
/* remove based on the unique mid (stored in sid) */
int p3MsgService::removeMsgId(uint32_t mid)
{
std::list<RsMsgItem *>::iterator it;
for(it = imsg.begin(); it != imsg.end(); it++)
{
if ((*it)->msgId == mid)
{
RsMsgItem *mi = (*it);
imsg.erase(it);
delete mi;
msgChanged.IndicateChanged();
msgMajorChanged.IndicateChanged();
return 1;
}
}
/* try with outgoing messages otherwise */
for(it = msgOutgoing.begin(); it != msgOutgoing.end(); it++)
{
if ((*it)->msgId == mid)
{
RsMsgItem *mi = (*it);
msgOutgoing.erase(it);
delete mi;
msgChanged.IndicateChanged();
msgMajorChanged.IndicateChanged();
return 1;
}
}
return 0;
}
int p3MsgService::markMsgIdRead(uint32_t mid)
{
std::list<RsMsgItem *>::iterator it;
for(it = imsg.begin(); it != imsg.end(); it++)
{
if ((*it)->msgId == mid)
{
RsMsgItem *mi = (*it);
mi -> msgFlags &= ~(RS_MSG_FLAGS_NEW);
msgChanged.IndicateChanged();
return 1;
}
}
return 0;
}
int p3MsgService::sendMessage(RsMsgItem *item)
{
pqioutput(PQL_DEBUG_BASIC, msgservicezone,
"p3MsgService::sendMessage()");
/* add pending flag */
item->msgFlags |=
(RS_MSG_FLAGS_OUTGOING |
RS_MSG_FLAGS_PENDING);
/* STORE MsgID */
item -> msgId = getNewUniqueMsgId();
msgOutgoing.push_back(item);
return 1;
}
int p3MsgService::checkOutgoingMessages() int p3MsgService::checkOutgoingMessages()
{ {
/* iterate through the outgoing queue /* iterate through the outgoing queue
@ -205,38 +136,59 @@ int p3MsgService::checkOutgoingMessages()
const std::string ownId = mConnMgr->getOwnId(); const std::string ownId = mConnMgr->getOwnId();
std::list<RsMsgItem *>::iterator it; std::list<uint32_t>::iterator it;
for(it = msgOutgoing.begin(); it != msgOutgoing.end();) std::list<uint32_t> toErase;
std::map<uint32_t, RsMsgItem *>::iterator mit;
for(mit = msgOutgoing.begin(); mit != msgOutgoing.end(); mit++)
{ {
/* find the certificate */ /* find the certificate */
std::string pid = (*it)->PeerId(); std::string pid = mit->second->PeerId();
peerConnectState pstate; peerConnectState pstate;
if (!mConnMgr->getFriendNetStatus(pid, pstate)) bool toSend = false;
if (mConnMgr->getFriendNetStatus(pid, pstate))
{ {
delete(*it); if (pstate.state & RS_PEER_S_ONLINE)
it = msgOutgoing.erase(it); {
toSend = true;
} }
/* if online, send it */ }
else if ((pstate.state & RS_PEER_S_ONLINE) else if (pid == ownId) /* FEEDBACK Msg to Ourselves */
|| (pid == ownId)) {
toSend = true;
}
if (toSend)
{ {
/* send msg */ /* send msg */
pqioutput(PQL_ALERT, msgservicezone, pqioutput(PQL_ALERT, msgservicezone,
"p3MsgService::checkOutGoingMessages() Sending out message"); "p3MsgService::checkOutGoingMessages() Sending out message");
/* remove the pending flag */ /* remove the pending flag */
(*it)->msgFlags &= ~RS_MSG_FLAGS_PENDING; (mit->second)->msgFlags &= ~RS_MSG_FLAGS_PENDING;
sendItem(*it); sendItem(mit->second);
it = msgOutgoing.erase(it); toErase.push_back(mit->first);
} }
else else
{ {
pqioutput(PQL_ALERT, msgservicezone, pqioutput(PQL_ALERT, msgservicezone,
"p3MsgService::checkOutGoingMessages() Delaying until available..."); "p3MsgService::checkOutGoingMessages() Delaying until available...");
it++;
} }
} }
/* clean up */
for(it = toErase.begin(); it != toErase.end(); it++)
{
mit = msgOutgoing.find(*it);
if (mit != msgOutgoing.end())
{
msgOutgoing.erase(mit);
}
}
return 0; return 0;
} }
@ -260,11 +212,10 @@ int p3MsgService::save_config()
pqiarchive *pa_out = new pqiarchive(rss, out, BIN_FLAGS_WRITEABLE | BIN_FLAGS_NO_DELETE); pqiarchive *pa_out = new pqiarchive(rss, out, BIN_FLAGS_WRITEABLE | BIN_FLAGS_NO_DELETE);
bool written = false; bool written = false;
std::list<RsMsgItem *>::iterator mit; std::map<uint32_t, RsMsgItem *>::iterator mit;
for(mit = imsg.begin(); mit != imsg.end(); mit++) for(mit = imsg.begin(); mit != imsg.end(); mit++)
{ {
//RsMsgItem *mi = (*mit)->clone(); if (pa_out -> SendItem(mit->second))
if (pa_out -> SendItem(*mit))
{ {
written = true; written = true;
} }
@ -275,18 +226,13 @@ int p3MsgService::save_config()
{ {
//RsMsgItem *mi = (*mit)->clone(); //RsMsgItem *mi = (*mit)->clone();
//mi -> msgFlags |= RS_MSG_FLAGS_PENDING; //mi -> msgFlags |= RS_MSG_FLAGS_PENDING;
if (pa_out -> SendItem(*mit)) if (pa_out -> SendItem(mit->second))
{ {
written = true; written = true;
} }
} }
if (!written)
{
/* need to push something out to overwrite old data! (For WINDOWS ONLY) */
}
delete pa_out; delete pa_out;
return 1; return 1;
} }
@ -324,11 +270,11 @@ int p3MsgService::load_config()
std::cerr << "MSG_PENDING"; std::cerr << "MSG_PENDING";
std::cerr << std::endl; std::cerr << std::endl;
mitem->print(std::cerr); mitem->print(std::cerr);
msgOutgoing.push_back(mitem); msgOutgoing[mitem->msgId] = mitem;
} }
else else
{ {
imsg.push_back(mitem); imsg[mitem->msgId] = mitem;
} }
} }
else else
@ -350,7 +296,7 @@ void p3MsgService::loadWelcomeMsg()
msg -> PeerId(mConnMgr->getOwnId()); msg -> PeerId(mConnMgr->getOwnId());
msg -> sendTime = 0; msg -> sendTime = time(NULL);
msg -> subject = L"Welcome to Retroshare"; msg -> subject = L"Welcome to Retroshare";
@ -365,8 +311,344 @@ void p3MsgService::loadWelcomeMsg()
msg -> message += L"Enjoy.\n"; msg -> message += L"Enjoy.\n";
imsg.push_back(msg); msg -> msgId = getNewUniqueMsgId();
imsg[msg->msgId] = msg;
}
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
/****************************************/
/****************************************/
bool p3MsgService::getMessageSummaries(std::list<MsgInfoSummary> &msgList)
{
/* do stuff */
msgList.clear();
std::map<uint32_t, RsMsgItem *>::iterator mit;
for(mit = imsg.begin(); mit != imsg.end(); mit++)
{
MsgInfoSummary mis;
initRsMIS(mit->second, mis);
msgList.push_back(mis);
}
for(mit = msgOutgoing.begin(); mit != msgOutgoing.end(); mit++)
{
MsgInfoSummary mis;
initRsMIS(mit->second, mis);
msgList.push_back(mis);
}
return 1;
}
bool p3MsgService::getMessage(std::string mId, MessageInfo &msg)
{
std::map<uint32_t, RsMsgItem *>::iterator mit;
uint32_t msgId = atoi(mId.c_str());
mit = imsg.find(msgId);
if (mit == imsg.end())
{
mit = msgOutgoing.find(msgId);
if (mit == msgOutgoing.end())
{
return false;
}
}
/* mit valid */
initRsMI(mit->second, msg);
return true;
}
/* remove based on the unique mid (stored in sid) */
bool p3MsgService::removeMsgId(std::string mid)
{
std::map<uint32_t, RsMsgItem *>::iterator mit;
uint32_t msgId = atoi(mid.c_str());
mit = imsg.find(msgId);
if (mit != imsg.end())
{
RsMsgItem *mi = mit->second;
imsg.erase(mit);
delete mi;
msgChanged.IndicateChanged();
msgMajorChanged.IndicateChanged();
return true;
}
mit = msgOutgoing.find(msgId);
if (mit != msgOutgoing.end())
{
RsMsgItem *mi = mit->second;
msgOutgoing.erase(mit);
delete mi;
msgChanged.IndicateChanged();
msgMajorChanged.IndicateChanged();
return true;
}
return false;
}
bool p3MsgService::markMsgIdRead(std::string mid)
{
std::map<uint32_t, RsMsgItem *>::iterator mit;
uint32_t msgId = atoi(mid.c_str());
mit = imsg.find(msgId);
if (mit != imsg.end())
{
RsMsgItem *mi = mit->second;
mi -> msgFlags &= ~(RS_MSG_FLAGS_NEW);
msgChanged.IndicateChanged();
return true;
}
return false;
}
/****************************************/
/****************************************/
/* Message Items */
int p3MsgService::sendMessage(RsMsgItem *item)
{
pqioutput(PQL_DEBUG_BASIC, msgservicezone,
"p3MsgService::sendMessage()");
/* add pending flag */
item->msgFlags |=
(RS_MSG_FLAGS_OUTGOING |
RS_MSG_FLAGS_PENDING);
/* STORE MsgID */
item -> msgId = getNewUniqueMsgId();
msgOutgoing[item->msgId] = item;
return 1;
}
bool p3MsgService::MessageSend(MessageInfo &info)
{
std::list<std::string>::const_iterator pit;
for(pit = info.msgto.begin(); pit != info.msgto.end(); pit++)
{
RsMsgItem *msg = initMIRsMsg(info, *pit);
if (msg)
{
sendMessage(msg);
}
}
for(pit = info.msgcc.begin(); pit != info.msgcc.end(); pit++)
{
RsMsgItem *msg = initMIRsMsg(info, *pit);
if (msg)
{
sendMessage(msg);
}
}
for(pit = info.msgbcc.begin(); pit != info.msgbcc.end(); pit++)
{
RsMsgItem *msg = initMIRsMsg(info, *pit);
if (msg)
{
sendMessage(msg);
}
}
/* send to ourselves as well */
RsMsgItem *msg = initMIRsMsg(info, mConnMgr->getOwnId());
if (msg)
{
sendMessage(msg);
}
return true;
}
/****************************************/
/****************************************/
/****************************************/
/**** HELPER FNS For Chat/Msg/Channel Lists ************
* These aren't required to be locked, unless
* the data used is from internal stores -> then they should be.
*/
void p3MsgService::initRsMI(RsMsgItem *msg, MessageInfo &mi)
{
mi.msgflags = 0;
/* translate flags, if we sent it... outgoing */
if ((msg->msgFlags & RS_MSG_FLAGS_OUTGOING)
|| (msg->PeerId() == mConnMgr->getOwnId()))
{
mi.msgflags |= RS_MSG_OUTGOING;
}
/* if it has a pending flag, then its in the outbox */
if (msg->msgFlags & RS_MSG_FLAGS_PENDING)
{
mi.msgflags |= RS_MSG_PENDING;
}
if (msg->msgFlags & RS_MSG_FLAGS_NEW)
{
mi.msgflags |= RS_MSG_NEW;
}
mi.ts = msg->sendTime;
mi.srcId = msg->PeerId();
{
//msg->msgId;
std::ostringstream out;
out << msg->msgId;
mi.msgId = out.str();
}
std::list<std::string>::iterator pit;
for(pit = msg->msgto.ids.begin();
pit != msg->msgto.ids.end(); pit++)
{
mi.msgto.push_back(*pit);
}
for(pit = msg->msgcc.ids.begin();
pit != msg->msgcc.ids.end(); pit++)
{
mi.msgcc.push_back(*pit);
}
for(pit = msg->msgbcc.ids.begin();
pit != msg->msgbcc.ids.end(); pit++)
{
mi.msgbcc.push_back(*pit);
}
mi.title = msg->subject;
mi.msg = msg->message;
mi.attach_title = msg->attachment.title;
mi.attach_comment = msg->attachment.comment;
mi.count = 0;
mi.size = 0;
std::list<RsTlvFileItem>::iterator it;
for(it = msg->attachment.items.begin();
it != msg->attachment.items.end(); it++)
{
FileInfo fi;
fi.fname = RsDirUtil::getTopDir(it->name);
fi.size = it->filesize;
fi.hash = it->hash;
fi.path = it->path;
mi.files.push_back(fi);
mi.count++;
mi.size += fi.size;
}
}
void p3MsgService::initRsMIS(RsMsgItem *msg, MsgInfoSummary &mis)
{
mis.msgflags = 0;
/* translate flags, if we sent it... outgoing */
if ((msg->msgFlags & RS_MSG_FLAGS_OUTGOING)
|| (msg->PeerId() == mConnMgr->getOwnId()))
{
mis.msgflags |= RS_MSG_OUTGOING;
}
/* if it has a pending flag, then its in the outbox */
if (msg->msgFlags & RS_MSG_FLAGS_PENDING)
{
mis.msgflags |= RS_MSG_PENDING;
}
if (msg->msgFlags & RS_MSG_FLAGS_NEW)
{
mis.msgflags |= RS_MSG_NEW;
}
mis.srcId = msg->PeerId();
{
//msg->msgId;
std::ostringstream out;
out << msg->msgId;
mis.msgId = out.str();
}
mis.title = msg->subject;
mis.count = msg->attachment.items.size();
mis.ts = msg->sendTime;
} }
RsMsgItem *p3MsgService::initMIRsMsg(MessageInfo &info, std::string to)
{
RsMsgItem *msg = new RsMsgItem();
msg -> PeerId(to);
msg -> msgFlags = 0;
msg -> msgId = 0;
msg -> sendTime = time(NULL);
msg -> recvTime = 0;
msg -> subject = info.title;
msg -> message = info.msg;
std::list<std::string>::iterator pit;
for(pit = info.msgto.begin(); pit != info.msgto.end(); pit++)
{
msg -> msgto.ids.push_back(*pit);
}
for(pit = info.msgcc.begin(); pit != info.msgcc.end(); pit++)
{
msg -> msgcc.ids.push_back(*pit);
}
/* We don't fill in bcc (unless to ourselves) */
if (to == mConnMgr->getOwnId())
{
for(pit = info.msgbcc.begin(); pit != info.msgbcc.end(); pit++)
{
msg -> msgbcc.ids.push_back(*pit);
}
}
msg -> attachment.title = info.attach_title;
msg -> attachment.comment = info.attach_comment;
std::list<FileInfo>::iterator it;
for(it = info.files.begin(); it != info.files.end(); it++)
{
RsTlvFileItem mfi;
mfi.hash = it -> hash;
mfi.name = it -> fname;
mfi.filesize = it -> size;
msg -> attachment.items.push_back(mfi);
}
std::cerr << "p3MsgService::initMIRsMsg()" << std::endl;
msg->print(std::cerr);
return msg;
}

35
libretroshare/src/services/p3msgservice.h
View File

@ -31,12 +31,14 @@
#include <map> #include <map>
#include <iostream> #include <iostream>
#include "rsiface/rsmsgs.h"
#include "pqi/pqi.h" #include "pqi/pqi.h"
#include "pqi/pqiindic.h" #include "pqi/pqiindic.h"
#include "services/p3service.h" #include "services/p3service.h"
#include "serialiser/rsmsgitems.h" #include "serialiser/rsmsgitems.h"
#include "util/rsthreads.h"
#include "rsiface/rsiface.h"
class p3ConnectMgr; class p3ConnectMgr;
class p3MsgService: public p3Service class p3MsgService: public p3Service
@ -44,17 +46,25 @@ class p3MsgService: public p3Service
public: public:
p3MsgService(p3ConnectMgr *cm); p3MsgService(p3ConnectMgr *cm);
/* External Interface */
bool ModifiedMsgs();
bool getMessageSummaries(std::list<MsgInfoSummary> &msgList);
bool getMessage(std::string mid, MessageInfo &msg);
bool removeMsgId(std::string mid);
bool markMsgIdRead(std::string mid);
bool MessageSend(MessageInfo &info);
void loadWelcomeMsg(); /* startup message */ void loadWelcomeMsg(); /* startup message */
int sendMessage(RsMsgItem *item);
int checkOutgoingMessages(); int checkOutgoingMessages();
std::list<RsMsgItem *> &getMsgList(); std::list<RsMsgItem *> &getMsgList();
std::list<RsMsgItem *> &getMsgOutList(); std::list<RsMsgItem *> &getMsgOutList();
// cleaning up....
int removeMsgId(uint32_t mid); /* id stored in sid */
int markMsgIdRead(uint32_t mid);
int load_config(); int load_config();
int save_config(); int save_config();
@ -64,16 +74,23 @@ int status();
private: private:
int sendMessage(RsMsgItem *item);
int incomingMsgs(); int incomingMsgs();
void initRsMI(RsMsgItem *msg, MessageInfo &mi);
void initRsMIS(RsMsgItem *msg, MsgInfoSummary &mis);
RsMsgItem *initMIRsMsg(MessageInfo &info, std::string to);
std::list<RsMsgItem *> imsg;
std::list<RsMsgItem *> msgOutgoing; /* ones that haven't made it out yet! */ /* Mutex Required for stuff below */
RsMutex msgMtx;
std::map<uint32_t, RsMsgItem *> imsg;
std::map<uint32_t, RsMsgItem *> msgOutgoing; /* ones that haven't made it out yet! */
p3ConnectMgr *mConnMgr; p3ConnectMgr *mConnMgr;
// bool state flags.
public:
Indicator msgChanged; Indicator msgChanged;
Indicator msgMajorChanged; Indicator msgMajorChanged;

43
libretroshare/src/services/p3service.cc
View File

@ -26,6 +26,8 @@
#include "pqi/pqi.h" #include "pqi/pqi.h"
#include "services/p3service.h" #include "services/p3service.h"
#define SERV_DEBUG 1
void p3Service::addSerialType(RsSerialType *st) void p3Service::addSerialType(RsSerialType *st)
{ {
rsSerialiser->addSerialType(st); rsSerialiser->addSerialType(st);
@ -78,7 +80,10 @@ int p3Service::receive(RsRawItem *raw)
{ {
srvMtx.lock(); /***** LOCK MUTEX *****/ srvMtx.lock(); /***** LOCK MUTEX *****/
std::cerr << "p3Service::receive()" << std::endl; #ifdef SERV_DEBUG
std::cerr << "p3Service::receive()";
std::cerr << std::endl;
#endif
/* convert to RsServiceItem */ /* convert to RsServiceItem */
uint32_t size = raw->getRawLength(); uint32_t size = raw->getRawLength();
@ -86,11 +91,20 @@ int p3Service::receive(RsRawItem *raw)
if ((!item) || (size != raw->getRawLength())) if ((!item) || (size != raw->getRawLength()))
{ {
/* error in conversion */ /* error in conversion */
#ifdef SERV_DEBUG
std::cerr << "p3Service::receive() Error" << std::endl; std::cerr << "p3Service::receive() Error" << std::endl;
std::cerr << "p3Service::receive() Size: " << size << std::endl; std::cerr << "p3Service::receive() Size: " << size << std::endl;
std::cerr << "p3Service::receive() RawLength: " << raw->getRawLength() << std::endl; std::cerr << "p3Service::receive() RawLength: " << raw->getRawLength() << std::endl;
#endif
if (item) if (item)
{ {
#ifdef SERV_DEBUG
std::cerr << "p3Service::receive() Bad Item:";
std::cerr << std::endl;
item->print(std::cerr, 0);
std::cerr << std::endl;
#endif
delete item; delete item;
} }
} }
@ -99,6 +113,13 @@ int p3Service::receive(RsRawItem *raw)
/* if we have something - pass it on */ /* if we have something - pass it on */
if (item) if (item)
{ {
#ifdef SERV_DEBUG
std::cerr << "p3Service::receive() item:";
std::cerr << std::endl;
item->print(std::cerr, 0);
std::cerr << std::endl;
#endif
/* ensure PeerId is transferred */ /* ensure PeerId is transferred */
item->PeerId(raw->PeerId()); item->PeerId(raw->PeerId());
recv_queue.push_back(item); recv_queue.push_back(item);
@ -126,10 +147,22 @@ RsRawItem *p3Service::send()
RsItem *si = send_queue.front(); RsItem *si = send_queue.front();
send_queue.pop_front(); send_queue.pop_front();
#ifdef SERV_DEBUG
std::cerr << "p3Service::send() Sending item:";
std::cerr << std::endl;
si->print(std::cerr, 0);
std::cerr << std::endl;
#endif
/* try to convert */ /* try to convert */
uint32_t size = rsSerialiser->size(si); uint32_t size = rsSerialiser->size(si);
if (!size) if (!size)
{ {
#ifdef SERV_DEBUG
std::cerr << "p3Service::send() ERROR size == 0";
std::cerr << std::endl;
#endif
/* can't convert! */ /* can't convert! */
delete si; delete si;
srvMtx.unlock(); /***** UNLOCK MUTEX *****/ srvMtx.unlock(); /***** UNLOCK MUTEX *****/
@ -139,12 +172,20 @@ RsRawItem *p3Service::send()
RsRawItem *raw = new RsRawItem(si->PacketId(), size); RsRawItem *raw = new RsRawItem(si->PacketId(), size);
if (!rsSerialiser->serialise(si, raw->getRawData(), &size)) if (!rsSerialiser->serialise(si, raw->getRawData(), &size))
{ {
#ifdef SERV_DEBUG
std::cerr << "p3Service::send() ERROR serialise failed";
std::cerr << std::endl;
#endif
delete raw; delete raw;
raw = NULL; raw = NULL;
} }
if ((raw) && (size != raw->getRawLength())) if ((raw) && (size != raw->getRawLength()))
{ {
#ifdef SERV_DEBUG
std::cerr << "p3Service::send() ERROR serialise size mismatch";
std::cerr << std::endl;
#endif
delete raw; delete raw;
raw = NULL; raw = NULL;
} }

11
libretroshare/src/util/rsthreads.h
View File

@ -45,6 +45,17 @@ bool trylock() { return (0 == pthread_mutex_trylock(&realMutex)); }
pthread_mutex_t realMutex; pthread_mutex_t realMutex;
}; };
class RsStackMutex
{
public:
RsStackMutex(RsMutex &mtx): mMtx(mtx) { mMtx.lock(); }
~RsStackMutex() { mMtx.unlock(); }
private:
RsMutex &mMtx;
};
class RsThread; class RsThread;
/* to create a thread! */ /* to create a thread! */