Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2025-05-10 18:15:18 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

moved authgpg fake module to tests folder

Browse source 
fixed ficachetest and fimontest 

makefile update for serialiser for previous revision


git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@4321 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
chrisparker126 2011-06-22 21:44:40 +00:00
parent f3fbac7d77
commit f12d2c46bc
10 changed files with 117 additions and 57 deletions
Download patch file Download diff file Expand all files Collapse all files

4
libretroshare/src/tests/dbase/Makefile
View file

@ -8,10 +8,10 @@ DHT_TOP_DIR = ../../../../libbitdht/src
include $(RS_TOP_DIR)/tests/scripts/config.mk
###############################################################
TESTOBJ = fitest2.o fisavetest.o searchtest.o
TESTOBJ = fitest2.o fisavetest.o searchtest.o #ficachetest.o
#ficachetest.o
TESTS = fitest2 fisavetest searchtest
TESTS = fitest2 fisavetest searchtest #ficachetest
#ficachetest
ifeq ($(OS),Linux)

15
libretroshare/src/tests/dbase/ficachetest.cc
View file

@ -23,6 +23,7 @@
#include "dbase/cachestrapper.h"
#include "dbase/cachetest.h"
#include "pqi/p3connmgr.h"
#include <iostream>
/********************************** WINDOWS/UNIX SPECIFIC PART ******************/
@ -52,9 +53,9 @@ int main(int argc, char **argv)
RsPeerId pid2("0x0102");
RsPeerId pid3("0x0103");
p3ConnectMgr *connMgr1 = NULL;
p3ConnectMgr *connMgr2 = NULL;
p3ConnectMgr *connMgr3 = NULL;
p3ConnectMgr *connMgr1 = new p3ConnectMgr();
p3ConnectMgr *connMgr2 = connMgr1;
p3ConnectMgr *connMgr3 = connMgr1;
CacheStrapper sc1(connMgr1);
CacheStrapper sc2(connMgr2);
@ -72,15 +73,15 @@ int main(int argc, char **argv)
std::string nulldir = "";
CacheSource *csrc1 = new CacheTestSource(&sc1, nulldir);
CacheStore *cstore1 = new CacheTestStore(&ctt1, nulldir);
CacheStore *cstore1 = new CacheTestStore(&ctt1, &sc1, nulldir);
CacheId cid1(TESTID, 0);
CacheSource *csrc2 = new CacheTestSource(&sc2, nulldir);
CacheStore *cstore2 = new CacheTestStore(&ctt2, nulldir);
CacheStore *cstore2 = new CacheTestStore(&ctt2, &sc2, nulldir);
CacheId cid2(TESTID, 0);
CacheSource *csrc3 = new CacheTestSource(&sc3, nulldir);
CacheStore *cstore3 = new CacheTestStore(&ctt3, nulldir);
CacheStore *cstore3 = new CacheTestStore(&ctt3, &sc3, nulldir);
CacheId cid3(TESTID, 0);
CachePair cp1(csrc1, cstore1, cid1);
@ -183,7 +184,7 @@ void handleQuery(CacheStrapper *csp, RsPeerId pid,
std::cerr << "Cache Query from: " << pid << std::endl;
csp -> sendCacheQuery(ids, time(NULL));
//csp -> sendCacheQuery(ids, time(NULL));
for(pit = ids.begin(); pit != ids.end(); pit++)
{
std::cerr << "Cache Query for: " << (*pit) << std::endl;

17
libretroshare/src/tests/dbase/fimontest.cc
View file

@ -21,6 +21,9 @@
*
*/
#include "pqi/p3connmgr.h"
#include "retroshare/rsiface.h"
#include "dbase/cachestrapper.h"
#include "dbase/findex.h"
#include "dbase/fimonitor.h"
@ -34,7 +37,12 @@ void usage(char *name)
}
/*!
* What is tested:
* 1.
* 2.
* 3.
*/
int main(int argc, char **argv)
{
/* handle commandline arguments */
@ -73,12 +81,13 @@ int main(int argc, char **argv)
usage(argv[0]);
}
sleep(1);
//p3ConnectMgr connMgr;
NotifyBase nb;
CacheStrapper* cs = NULL;
FileIndexMonitor mon(NULL,NULL, "", "OWN ID");
FileIndexMonitor mon(cs, &nb, "", "OWN ID", std::string("."));
/* setup monitor */
mon.setPeriod(period);
mon.setSharedDirectories(rootdirs);
/* simulate running the thread */

8
libretroshare/src/tests/ft/ftfilecreatortest.cc
View file

@ -17,7 +17,7 @@ static int test_fill(ftFileCreator *creator);
int main()
{
/* use ftcreator to create a file on tmp drive */
ftFileCreator fcreator("/tmp/rs-ftfc-test.dta",100000,"hash");
ftFileCreator fcreator("/tmp/rs-ftfc-test.dta",100000,"hash", false);
test_timeout(&fcreator);
test_fill(&fcreator);
@ -32,7 +32,7 @@ int test_timeout(ftFileCreator *creator)
{
uint32_t chunk = 1000;
uint64_t offset = 0;
int max_timeout = 30;
int max_timeout = 5;
int max_offset = chunk * max_timeout;
int i;
std::cerr << "60 second test of chunk queue.";
@ -48,7 +48,7 @@ int test_timeout(ftFileCreator *creator)
std::cerr << "Allocated Offset: " << offset << " chunk: " << chunk << std::endl;
CHECK(offset <= max_offset);
sleep(1);
// sleep(1);
}
std::cerr << "Expect Repeats now";
@ -56,7 +56,7 @@ int test_timeout(ftFileCreator *creator)
for(i = 0; i < max_timeout; i++)
{
sleep(1);
// sleep(1);
creator->getMissingChunk(peer_id, size_hint, offset, chunk, toOld);
std::cerr << "Allocated Offset: " << offset << " chunk: " << chunk << std::endl;

4
libretroshare/src/tests/ft/ftfileprovidertest.cc
View file

@ -33,7 +33,7 @@ int main()
}
}
ftFileCreator *creator = new ftFileCreator(filename, size, "hash");
ftFileCreator *creator = new ftFileCreator(filename, size, "hash", true);
for(offset = 0; offset != size; offset += chunk)
{
if (!creator->addFileData(offset, chunk, data))
@ -49,7 +49,7 @@ int main()
std::cerr << std::endl;
/* load it with file provider */
creator = new ftFileCreator(filename2, size, "hash");
creator = new ftFileCreator(filename2, size, "hash", true);
ftFileProvider *provider = new ftFileProvider(filename, size, "hash");
/* create duplicate with file creator */

408
libretroshare/src/tests/pqi/authgpgtest.cc Normal file
View file

@ -0,0 +1,408 @@
/*
* libretroshare/src/ : authgpgtest.cc
*
* GPG interface for RetroShare.
*
* Copyright 2009-2010 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".
*
* This is *THE* auth manager. It provides the web-of-trust via
* gpgme, and authenticates the certificates that are managed
* by the sublayer AuthSSL.
*
*/
#include "pqi/authgpgtest.h"
AuthGPGtest::AuthGPGtest()
{
mOwnGPGId = "TEST_DUMMY_OWN_GPG_ID";
return;
}
/**
* @param ids list of gpg certificate ids (note, not the actual certificates)
*/
bool AuthGPGtest::availableGPGCertificatesWithPrivateKeys(std::list<std::string> &ids)
{
std::cerr << "AuthGPGtest::availableGPGCertificatesWithPrivateKeys()";
std::cerr << std::endl;
return true;
}
bool AuthGPGtest::printKeys()
{
std::cerr << "AuthGPGtest::printKeys()";
std::cerr << std::endl;
return true;
}
/*********************************************************************************/
/************************* STAGE 1 ***********************************************/
/*********************************************************************************/
/*****
* STAGE 1: Initialisation.... As we are switching to OpenPGP the init functions
* will be different. Just move the initialisation functions over....
*
* As GPGMe requires external calls to the GPG executable, which could potentially
* be expensive, We'll want to cache the GPG keys in this class.
* This should be done at initialisation, and saved in a map.
* (see storage at the end of the class)
*
****/
bool AuthGPGtest::active()
{
std::cerr << "AuthGPGtest::active()";
std::cerr << std::endl;
return true;
}
/* Initialize */
bool AuthGPGtest::InitAuth()
{
std::cerr << "AuthGPGtest::InitAuth()";
std::cerr << std::endl;
return true;
}
/* Init by generating new Own PGP Cert, or selecting existing PGP Cert */
int AuthGPGtest::GPGInit(const std::string& ownId)
{
std::cerr << "AuthGPGtest::GPGInit(): new OwnId: " << ownId;
std::cerr << std::endl;
mOwnGPGId = ownId;
return true;
}
bool AuthGPGtest::CloseAuth()
{
std::cerr << "AuthGPGtest::CloseAuth()";
std::cerr << std::endl;
return true;
}
bool AuthGPGtest::GeneratePGPCertificate(std::string name, std::string email, std::string passwd, std::string &pgpId, std::string &errString)
{
std::cerr << "AuthGPGtest::GeneratePGPCertificate()";
std::cerr << std::endl;
return true;
}
/*********************************************************************************/
/************************* STAGE 3 ***********************************************/
/*********************************************************************************/
/*****
* STAGE 3: These are some of the most commonly used functions in Retroshare.
*
* More commonly used functions.
*
* provide access to details in cache list.
*
****/
std::string getGPGName(const std::string &pgp_id)
{
std::cerr << "AuthGPGtest::getGPGName()";
std::cerr << std::endl;
return "DUMMY_NAME";
}
std::string getGPGEmail(const std::string &pgp_id)
{
std::cerr << "AuthGPGtest::getGPGEmail()";
std::cerr << std::endl;
return "DUMMY_EMAIL";
}
/* PGP web of trust management */
std::string AuthGPGtest::getGPGOwnId()
{
std::cerr << "AuthGPGtest::getGPGOwnId()";
std::cerr << std::endl;
return mOwnGPGId;
}
std::string AuthGPGtest::getGPGOwnName()
{
std::cerr << "AuthGPGtest::getGPGOwnName()";
std::cerr << std::endl;
return "DUMMY_OWN_NAME";
}
#if 0
std::string AuthGPGtest::getGPGOwnEmail()
{
std::cerr << "AuthGPGtest::getGPGOwnEmail()";
std::cerr << std::endl;
return "DUMMY_OWN_EMAIL";
}
#endif
bool AuthGPGtest::getGPGDetails(const std::string& id, RsPeerDetails &d)
{
std::cerr << "AuthGPGtest::getGPGDetails()";
std::cerr << std::endl;
return true;
}
bool AuthGPGtest::getGPGAllList(std::list<std::string> &ids)
{
std::cerr << "AuthGPGtest::getGPGAllList()";
std::cerr << std::endl;
return true;
}
bool AuthGPGtest::getGPGValidList(std::list<std::string> &ids)
{
std::cerr << "AuthGPGtest::getGPGValidList()";
std::cerr << std::endl;
return true;
}
bool AuthGPGtest::getGPGAcceptedList(std::list<std::string> &ids)
{
std::cerr << "AuthGPGtest::getGPGAcceptedList()";
std::cerr << std::endl;
return true;
}
bool AuthGPGtest::getGPGSignedList(std::list<std::string> &ids)
{
std::cerr << "AuthGPGtest::getGPGSignedList()";
std::cerr << std::endl;
return true;
}
bool AuthGPGtest::isGPGValid(const std::string& id)
{
std::cerr << "AuthGPGtest::isGPGValid()";
std::cerr << std::endl;
return true;
}
bool AuthGPGtest::isGPGSigned(const std::string& id)
{
std::cerr << "AuthGPGtest::isGPGSigned()";
std::cerr << std::endl;
return true;
}
bool AuthGPGtest::isGPGAccepted(const std::string& id)
{
std::cerr << "AuthGPGtest::isGPGAccepted()";
std::cerr << std::endl;
return true;
}
bool isGPGId(const std::string &id)
{
std::cerr << "AuthGPGtest::isGPGId()";
std::cerr << std::endl;
return true;
}
/*********************************************************************************/
/************************* STAGE 4 ***********************************************/
/*********************************************************************************/
/*****
* STAGE 4: Loading and Saving Certificates. (Strings and Files)
*
****/
bool AuthGPGtest::LoadCertificateFromString(const std::string& pem, std::string &gpg_id,
std::string& error_string)
{
std::cerr << "AuthGPGtest::LoadCertificateFromString()";
std::cerr << std::endl;
return true;
}
std::string AuthGPGtest::SaveCertificateToString(const std::string& id)
{
std::cerr << "AuthGPGtest::SaveCertificateToString()";
std::cerr << std::endl;
return "NOT_A_CERTIFICATE";
}
/*********************************************************************************/
/************************* STAGE 6 ***********************************************/
/*********************************************************************************/
/*****
* STAGE 6: Authentication, Trust and Signing.
*
* This is some of the harder functions, but they should have been
* done in gpgroot already.
*
****/
bool AuthGPGtest::setAcceptToConnectGPGCertificate(const std::string& gpg_id,
bool acceptance)
{
std::cerr << "AuthGPGtest::setAcceptToConnectGPGCertificate()";
std::cerr << std::endl;
return true;
}
bool AuthGPGtest::SignCertificateLevel0(const std::string& id)
{
std::cerr << "AuthGPGtest::SignCertificateLevel0()";
std::cerr << std::endl;
return true;
}
bool AuthGPGtest::RevokeCertificate(const std::string& id)
{
std::cerr << "AuthGPGtest::RevokeCertificate()";
std::cerr << std::endl;
return true;
}
virtual bool TrustCertificate(const std::string &id, int trustlvl)
{
std::cerr << "AuthGPGtest::TrustCertificate()";
std::cerr << std::endl;
return true;
}
void AuthGPGtest::run()
{
}
#if 0
bool AuthGPGtest::TrustCertificateNone(std::string id)
{
std::cerr << "AuthGPGtest::TrustCertificateNone()";
std::cerr << std::endl;
return true;
}
bool AuthGPGtest::TrustCertificateMarginally(std::string id)
{
std::cerr << "AuthGPGtest::TrustCertificateMarginally()";
std::cerr << std::endl;
return true;
}
bool AuthGPGtest::TrustCertificateFully(std::string id)
{
std::cerr << "AuthGPGtest::TrustCertificateFully()";
std::cerr << std::endl;
return true;
}
#endif
bool AuthGPGtest::TrustCertificate(std::string id, int trustlvl)
{
std::cerr << "AuthGPGtest::TrustCertificate()";
std::cerr << std::endl;
return true;
}
/*********************************************************************************/
/************************* STAGE 7 ***********************************************/
/*********************************************************************************/
/*****
* STAGE 7: Signing Data.
*
* There should also be Encryption Functions... (do later).
*
****/
#if 0
bool AuthGPGtest::SignData(std::string input, std::string &sign)
{
std::cerr << "AuthGPGtest::SignData()";
std::cerr << std::endl;
return false;
}
bool AuthGPGtest::SignData(const void *data, const uint32_t len, std::string &sign)
{
std::cerr << "AuthGPGtest::SignData()";
std::cerr << std::endl;
return false;
}
bool AuthGPGtest::SignDataBin(std::string input, unsigned char *sign, unsigned int *signlen)
{
std::cerr << "AuthGPGtest::SignDataBin()";
std::cerr << std::endl;
return false;
}
#endif
bool AuthGPGtest::SignDataBin(const void *data, const uint32_t len, unsigned char *sign, unsigned int *signlen)
{
std::cerr << "AuthGPGtest::SignDataBin()";
std::cerr << std::endl;
return true;
}
bool AuthGPGtest::VerifySignBin(const void*, uint32_t, unsigned char*, unsigned int, const std::string& withfingerprint)
{
std::cerr << "AuthGPGtest::VerifySignBin()";
std::cerr << std::endl;
return true;
}
bool AuthGPGtest::decryptText(gpgme_data_t CIPHER, gpgme_data_t PLAIN)
{
std::cerr << "AuthGPGtest::decryptText()";
std::cerr << std::endl;
return true;
}
bool AuthGPGimpl::addService(AuthGPGService *service)
{
std::cerr << "AuthGPGtest::addService()";
std::cerr << std::endl;
return true;
}
std::string AuthGPGtest::getGPGName(const std::string & pgp_id)
{
std::cerr << "AuthGPGtest::getGPGName()";
std::cerr << std::endl;
return std::string("");
}
bool AuthGPGtest::TrustCertificate(const std::string & id, int trustlvl)
{
}
bool AuthGPGtest::isGPGId(const std::string & id)
{
}
std::string AuthGPGtest::getGPGEmail(const std::string & pgp_id)
{
}
bool AuthGPGtest::encryptText(gpgme_data_t PLAIN, gpgme_data_t CIPHER)
{
std::cerr << "AuthGPGtest::encryptText()";
std::cerr << std::endl;
return false;
}

160
libretroshare/src/tests/pqi/authgpgtest.h Normal file
View file

@ -0,0 +1,160 @@
/*
* libretroshare/src/ : authgpgtest.h
*
* GPG interface for RetroShare.
*
* Copyright 2009-2010 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".
*
* This is *THE* auth manager. It provides the web-of-trust via
* gpgme, and authenticates the certificates that are managed
* by the sublayer AuthSSL.
*
*/
#ifndef RS_GPG_AUTH_TEST_HEADER
#define RS_GPG_AUTH_TEST_HEADER
#include "pqi/authgpg.h"
/* override the default AuthGPG */
void setAuthGPG(AuthGPG *newgpg);
class AuthGPGtest: public AuthGPG
{
public:
AuthGPGtest();
/**
* @param ids list of gpg certificate ids (note, not the actual certificates)
*/
virtual bool availableGPGCertificatesWithPrivateKeys(std::list<std::string> &ids);
virtual bool printKeys();
/*********************************************************************************/
/************************* STAGE 1 ***********************************************/
/*********************************************************************************/
/*****
* STAGE 1: Initialisation.... As we are switching to OpenPGP the init functions
* will be different. Just move the initialisation functions over....
*
* As GPGMe requires external calls to the GPG executable, which could potentially
* be expensive, We'll want to cache the GPG keys in this class.
* This should be done at initialisation, and saved in a map.
* (see storage at the end of the class)
*
****/
virtual bool active();
/* Initialize */
virtual bool InitAuth ();
virtual void run();
/* Init by generating new Own PGP Cert, or selecting existing PGP Cert */
virtual int GPGInit(const std::string& ownId);
virtual bool CloseAuth();
virtual bool GeneratePGPCertificate(std::string name, std::string email, std::string passwd, std::string &pgpId, std::string &errString);
/*********************************************************************************/
/************************* STAGE 3 ***********************************************/
/*********************************************************************************/
/*****
* STAGE 3: These are some of the most commonly used functions in Retroshare.
*
* More commonly used functions.
*
* provide access to details in cache list.
*
****/
virtual std::string getGPGName(const std::string &pgp_id);
virtual std::string getGPGEmail(const std::string &pgp_id);
/* PGP web of trust management */
virtual std::string getGPGOwnId();
virtual std::string getGPGOwnName();
//virtual std::string getGPGOwnEmail();
virtual bool getGPGDetails(const std::string& id, RsPeerDetails &d);
virtual bool getGPGAllList(std::list<std::string> &ids);
virtual bool getGPGValidList(std::list<std::string> &ids);
virtual bool getGPGAcceptedList(std::list<std::string> &ids);
virtual bool getGPGSignedList(std::list<std::string> &ids);
virtual bool isGPGValid(const std::string& id);
virtual bool isGPGSigned(const std::string& id);
virtual bool isGPGAccepted(const std::string& id);
virtual bool isGPGId(const std::string &id);
/*********************************************************************************/
/************************* STAGE 4 ***********************************************/
/*********************************************************************************/
/*****
* STAGE 4: Loading and Saving Certificates. (Strings and Files)
*
****/
virtual bool LoadCertificateFromString(const std::string& pem, std::string &gpg_id,
std::string& error_string);
virtual std::string SaveCertificateToString(const std::string& id);
/*********************************************************************************/
/************************* STAGE 6 ***********************************************/
/*********************************************************************************/
/*****
* STAGE 6: Authentication, Trust and Signing.
*
* This is some of the harder functions, but they should have been
* done in gpgroot already.
*
****/
virtual bool setAcceptToConnectGPGCertificate(const std::string& gpg_id,
bool acceptance); //don't act on the gpg key, use a seperate set
virtual bool SignCertificateLevel0(const std::string& id);
virtual bool RevokeCertificate(const std::string& id); /* Particularly hard - leave for later */
//virtual bool TrustCertificateNone(std::string id);
//virtual bool TrustCertificateMarginally(std::string id);
//virtual bool TrustCertificateFully(std::string id);
virtual bool TrustCertificate(const std::string &id, int trustlvl); //trustlvl is 2 for none, 3 for marginal and 4 for full trust
/*********************************************************************************/
/************************* STAGE 7 ***********************************************/
/*********************************************************************************/
/*****
* STAGE 7: Signing Data.
*
* There should also be Encryption Functions... (do later).
*
****/
//virtual bool SignData(std::string input, std::string &sign);
//virtual bool SignData(const void *data, const uint32_t len, std::string &sign);
//virtual bool SignDataBin(std::string input, unsigned char *sign, unsigned int *signlen);
virtual bool SignDataBin(const void *data, const uint32_t len, unsigned char *sign, unsigned int *signlen);
virtual bool VerifySignBin(const void*, uint32_t, unsigned char*, unsigned int, const std::string& withfingerprint);
virtual bool decryptText(gpgme_data_t CIPHER, gpgme_data_t PLAIN);
virtual bool encryptText(gpgme_data_t PLAIN, gpgme_data_t CIPHER);
//END of PGP public functions
virtual bool addService(AuthGPGService *service);
private:
std::string mOwnGPGId;
};
#endif

7
libretroshare/src/tests/serialiser/Makefile
View file

@ -13,13 +13,13 @@ TESTOBJ = tlvbase_test.o tlvbase_test2.o rstunnelitem_test.o
TESTOBJ += tlvitems_test.o tlvstack_test.o rsserial_test.o
TESTOBJ += rstlvwidetest.o tlvrandom_test.o rsturtleitem_test.o
TESTOBJ += tlvtypes_test.o support.o distribitem_test.o rsmsgitem_test.o
TESTOBJ += rsstatusitem_test.o
TESTOBJ += rsstatusitem_test.o rsconfigitem_test.o
TESTS = tlvbase_test tlvbase_test2 rstlvwidetest
TESTS += tlvitems_test tlvstack_test rstunnelitem_test
TESTS += tlvrandom_test rsserial_test rsturtleitem_test
TESTS += tlvtypes_test distribitem_test rsmsgitem_test
TESTS += rsstatusitem_test
TESTS += rsstatusitem_test rsconfigitem_test
#rsbaseitem_test
@ -66,6 +66,9 @@ rsmsgitem_test : rsmsgitem_test.o support.o
rsstatusitem_test : rsstatusitem_test.o support.o
$(CC) $(CFLAGS) -o rsstatusitem_test rsstatusitem_test.o support.o $(OBJ) $(LIBS)
rsconfigitem_test : rsconfigitem_test.o
$(CC) $(CFLAGS) -o rsconfigitem_test rsconfigitem_test.o support.o $(OBJ) $(LIBS)
###############################################################
include $(RS_TOP_DIR)/scripts/rules.mk