int main (int argc, char **argv)
{
OTLog::vOutput(0, "\n\nWelcome to Open Transactions... Test Server -- version %s\n"
"(transport build: OTMessage -> TCP -> SSL)\n"
"IF YOU PREFER TO USE XmlRpc with HTTP, then rebuild from main folder like this:\n\n"
"cd ..; make clean; make rpc\n\n",
OTLog::Version());
// -----------------------------------------------------------------------
// This object handles all the actual transaction notarization details.
// (This file you are reading is a wrapper for OTServer, which adds the transport layer.)
OTServer theServer;
// -----------------------------------------------------------------------
#ifdef _WIN32
WSADATA wsaData;
WORD wVersionRequested = MAKEWORD( 2, 2 );
int err = WSAStartup( wVersionRequested, &wsaData );
/* Tell the user that we could not find a usable */
/* Winsock DLL. */
OT_ASSERT_MSG((err == 0), "WSAStartup failed!\n");
/* Confirm that the WinSock DLL supports 2.2. */
/* Note that if the DLL supports versions greater */
/* than 2.2 in addition to 2.2, it will still return */
/* 2.2 in wVersion since that is the version we */
/* requested. */
bool bWinsock = (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2);
/* Tell the user that we could not find a usable */
/* WinSock DLL. */
if (!bWinsock) WSACleanup(); // do cleanup.
OT_ASSERT_MSG((!bWinsock), "Could not find a usable version of Winsock.dll\n");
/* The Winsock DLL is acceptable. Proceed to use it. */
/* Add network programming using Winsock here */
/* then call WSACleanup when done using the Winsock dll */
OTLog::vOutput(0,"The Winsock 2.2 dll was found okay\n");
#endif
OTLog::vOutput(0, "\n\nWelcome to Open Transactions, version %s.\n\n", OTLog::Version());
// -----------------------------------------------------------------------
// The beginnings of an INI file!!
#ifndef _WIN32 // if UNIX (NOT windows)
wordexp_t exp_result;
wordexp(OT_INI_FILE_DEFAULT, &exp_result, 0);
const OTString strIniFileDefault(exp_result.we_wordv[0]);
wordfree(&exp_result);
#else
const OTString strIniFileDefault(OT_INI_FILE_DEFAULT);
#endif
OTString strPath(SERVER_PATH_DEFAULT);
{
CSimpleIniA ini;
SI_Error rc = ini.LoadFile(strIniFileDefault.Get());
if (rc >=0)
{
const char * pVal = ini.GetValue("paths", "server_path", SERVER_PATH_DEFAULT); // todo stop hardcoding.
if (NULL != pVal)
{
strPath.Set(pVal);
OTLog::vOutput(0, "Reading ini file (%s). \n Found Server data_folder path: %s \n",
strIniFileDefault.Get(), strPath.Get());
}
else
{
strPath.Set(SERVER_PATH_DEFAULT);
OTLog::vOutput(0, "Reading ini file (%s): \n Failed reading Server data_folder path. Using: %s \n",
strIniFileDefault.Get(), strPath.Get());
}
}
else
{
strPath.Set(SERVER_PATH_DEFAULT);
OTLog::vOutput(0, "Unable to load ini file (%s) to find data_folder path\n Will assume that server data_folder is at path: %s \n",
strIniFileDefault.Get(), strPath.Get());
}
}
// -----------------------------------------------------------------------
OTString strCAFile, strDHFile, strKeyFile;
//, strSSLPassword;
if (argc < 1)
{
OTLog::vOutput(0, "\n==> USAGE: %s [absolute_path_to_data_folder]\n\n"
// OTLog::vOutput(0, "\n==> USAGE: %s <SSL-password> [absolute_path_to_data_folder]\n\n"
#if defined (FELLOW_TRAVELER)
// "(Password defaults to '%s' if left blank.)\n"
"(Folder defaults to '%s' if left blank.)\n"
#else
"The test password is always 'test'.\n"
"OT will try to read the data_folder path from your ini file. If you prefer\n"
"to specify it at the command line, and you want to see the exact path, type:\n"
" cd data_folder && pwd && cd ..\n"
#endif
"\n\n", argv[0]
#if defined (FELLOW_TRAVELER)
// , KEY_PASSWORD,
, strPath.Get()
#endif
);
#if defined (FELLOW_TRAVELER)
// strSSLPassword.Set(KEY_PASSWORD);
OTLog::SetMainPath(strPath.Get());
#else
exit(1);
#endif
}
else if (argc < 2)
{
// strSSLPassword.Set(argv[1]);
OTLog::SetMainPath(strPath.Get());
}
else
{
// strSSLPassword.Set(argv[1]);
OTLog::SetMainPath(argv[1]); // formerly [2]
}
OTLog::vOutput(0, "Using as path to data folder: %s\n", OTLog::Path());
strCAFile. Format("%s%s%s", OTLog::Path(), OTLog::PathSeparator(), CA_FILE);
strDHFile. Format("%s%s%s", OTLog::Path(), OTLog::PathSeparator(), DH_FILE);
strKeyFile.Format("%s%s%s", OTLog::Path(), OTLog::PathSeparator(), KEY_FILE);
// -----------------------------------------------------------------------
// Init loads up server's nym so it can decrypt messages sent in envelopes.
// It also does various other initialization work.
//
// (Envelopes prove that ONLY someone who actually had the server contract,
// and had loaded it into his wallet, could ever connect to the server or
// communicate with it. And if that person is following the contract, there
// is only one server he can connect to, and one key he can use to talk to it.)
OTLog::Output(0,
"\n\nNow loading the server nym, which will also ask you for a password, to unlock\n"
"its private key. (Default password is \"test\".)\n");
// Initialize SSL -- This MUST occur before any Private Keys are loaded!
SFSocketGlobalInit(); // Any app that uses OT has to initialize SSL first.
theServer.Init(); // Keys, etc are loaded here.
// -----------------------------------------------------------------------
// We're going to listen on the same port that is listed in our server contract.
//
//
OTString strHostname; // The hostname of this server, according to its own contract.
int nPort=0; // The port of this server, according to its own contract.
OT_ASSERT_MSG(theServer.GetConnectInfo(strHostname, nPort),
"Unable to find my own connect info (which is in my server contract BTW.)\n");
const int nServerPort = nPort;
// -----------------------------------------------------------------------
SFSocket *socket = NULL;
listOfConnections theConnections;
// Alloc Socket
socket = SFSocketAlloc();
OT_ASSERT_MSG(NULL != socket, "SFSocketAlloc Failed\n");
// Initialize SSL Socket
int nSFSocketInit = SFSocketInit(socket,
strCAFile.Get(),
strDHFile.Get(),
strKeyFile.Get(),
strSSLPassword.Get(),
NULL);
OT_ASSERT_MSG(nSFSocketInit >= 0, "SFSocketInit Context Failed\n");
// Listen on Address/Port
int nSFSocketListen = SFSocketListen(socket, INADDR_ANY, nServerPort);
OT_ASSERT_MSG(nSFSocketListen >= 0, "nSFSocketListen Failed\n");
theServer.ActivateCron();
do
{
SFSocket * clientSocket = NULL;
// Accept Client Connection
if (NULL != (clientSocket = SFSocketAccept(socket)))
{
OTClientConnection * pClient = new OTClientConnection(*clientSocket, theServer);
theConnections.push_back(pClient);
OTLog::Output(0, "Accepting new connection.\n");
}
// READ THROUGH ALL CLIENTS HERE, LOOP A LIST
// AND process in-buffer onto our list of messages.
OTClientConnection * pConnection = NULL;
for (listOfConnections::iterator ii = theConnections.begin();
ii != theConnections.end(); ++ii)
{
if (pConnection = *ii)
{
// Here we read the bytes from the pipe into the client's buffer
// As necessary this function also processes those bytes into OTMessages
// and adds them to the Input List for that client.
pConnection->ProcessBuffer();
}
}
// Now loop through them all again, and process their messages onto the reply list.
pConnection = NULL;
for (listOfConnections::iterator ii = theConnections.begin();
ii != theConnections.end(); ++ii)
{
if (pConnection = *ii)
{
OTMessage * pMsg = NULL;
while (pMsg = pConnection->GetNextInputMessage())
{
OTMessage * pReply = new OTMessage;
OT_ASSERT(NULL != pReply);
if (theServer.ProcessUserCommand(*pMsg, *pReply, pConnection))
{
OTLog::vOutput(0, "Successfully processed user command: %s.\n",
pMsg->m_strCommand.Get());
pConnection->AddToOutputList(*pReply);
}
else
{
OTLog::Output(0, "Unable to process user command in XML, or missing payload, in main.\n");
delete pReply;
pReply = NULL;
}
// I am responsible to delete this here.
delete pMsg;
pMsg = NULL;
}
}
}
// Now loop through them all again, and process their replies down the pipe
pConnection = NULL;
for (listOfConnections::iterator ii = theConnections.begin();
ii != theConnections.end(); ++ii)
{
if (pConnection = *ii)
{
OTMessage * pMsg = NULL;
while (pMsg = pConnection->GetNextOutputMessage())
{
pConnection->ProcessReply(*pMsg);
// I am responsible to delete this here.
delete pMsg;
pMsg = NULL;
}
}
}
// The Server now processes certain things on a regular basis.
// This method call is what gives it the opportunity to do that.
theServer.ProcessCron();
// Now go to sleep for a tenth of a second.
// (Main loop processes ten times per second, currently.)
OTLog::SleepMilliseconds(100); // 100 ms == (1 second / 10)
} while (1);
// Close and Release Socket Resources
SFSocketRelease(socket);
#ifdef _WIN32
WSACleanup();
#endif
return(0);
}
int main (int argc, char * const argv[])
{
if (argc < 4)
{
printf("\n\nUsage: createmint server_id server_user_id asset_type_id \n\n"
"For now, expiration dates are automatically set:\n"
"-- FROM: Today, Now.\n"
"-- TO: 6 months from now.\n\n"
"It is recommended that you issue a new series (create a new mint) every 3 months for each\n"
"asset type, so that there is a 3-month overlap. In the future, this will be configured inside\n"
"the contracts themselves.\n\n"
"Server ID needs to match the Server ID from notaryServer.xml\n"
"Server user ID needs to match the Server User ID from notaryServer.xml\n"
"Asset Type ID needs to match the Asset ID (aka Hashed Contract ID) of the currency contract.\n\n"
// "The path to the data folder is necessary for initialization of the OT library.\n\n"
// "(You probably want to use ~/.ot/server_data as your data folder.)\n\n"
);
return 0;
}
// **************************************************************************
class __OTcreatemint_RAII
{
public:
__OTcreatemint_RAII()
{
if(!OTLog::Init(SERVER_CONFIG_KEY,0)) { assert(false); }; // setup the logger.
OTLog::vOutput(0, "\n\nWelcome to Open Transactions -- 'createmint', version %s\n",
OTLog::Version());
// ------------------------------------
#ifdef _WIN32
WSADATA wsaData;
WORD wVersionRequested = MAKEWORD( 2, 2 );
int err = WSAStartup( wVersionRequested, &wsaData );
/* Tell the user that we could not find a usable */
/* Winsock DLL. */
OT_ASSERT_MSG((err == 0), "WSAStartup failed!\n");
/* Confirm that the WinSock DLL supports 2.2. */
/* Note that if the DLL supports versions greater */
/* than 2.2 in addition to 2.2, it will still return */
/* 2.2 in wVersion since that is the version we */
/* requested. */
bool bWinsock = (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2);
/* Tell the user that we could not find a usable */
/* WinSock DLL. */
if (!bWinsock) WSACleanup(); // do cleanup.
OT_ASSERT_MSG((!bWinsock), "Could not find a usable version of Winsock.dll\n");
/* The Winsock DLL is acceptable. Proceed to use it. */
/* Add network programming using Winsock here */
/* then call WSACleanup when done using the Winsock dll */
OTLog::vOutput(0,"The Winsock 2.2 dll was found okay\n");
#endif
// ------------------------------------
// SIGNALS
//
#if defined(OT_SIGNAL_HANDLING)
//
OTLog::SetupSignalHandler(); // <===== SIGNALS
//
// This is optional! You can always remove it using the OT_NO_SIGNAL_HANDLING
// option, and plus, the internals only execute once anyway. (It keeps count.)
#endif
// ------------------------------------
//
// OT Server Path:
//
{
bool bSetupPathsSuccess = false;
if(!OTDataFolder::Init(SERVER_CONFIG_KEY)) { OT_ASSERT(false); }
else
bSetupPathsSuccess = true;
OT_ASSERT_MSG(bSetupPathsSuccess, "main(): Assert failed: Failed to set OT Path");
}
// -----------------------------------------------------------------------
OTCrypto::It()->Init(); // (OpenSSL gets initialized here.)
// ------------------------------------
}
~__OTcreatemint_RAII()
{
// We clean these up in reverse order from the Init function, which just seems
// like the best default, in absence of any brighter ideas.
//
OTCrypto::It()->Cleanup(); // (OpenSSL gets cleaned up here.)
// ------------------------------------
#ifdef _WIN32
WSACleanup(); // Corresponds to WSAStartup() in InitOTAPI().
#endif
// ------------------------------------
}
};
// --------------------------------------------
__OTcreatemint_RAII the_createmint_cleanup;
// **************************************************************************
OTServer theServer;
// -----------------------------------------
int nReturnVal = 0;
OTString strServerID(argv[1]),
strServerNymID(argv[2]),
strAssetTypeID(argv[3]);
OTIdentifier ASSET_TYPE_ID(strAssetTypeID),
SERVER_ID(strServerID);
// std::string strDataFolderPath(argv[4]), strNotaryFile("notaryServer.xml");
OTLog::vOutput(0,
"\nNow loading the server nym, which will also ask you for a password, to unlock\n"
"its private key. (Default password is \"%s\".)\n", KEY_PASSWORD);
// Keys, etc are loaded here. ===> Assumes main path is set! <===
//
theServer.Init(true); //bool bReadOnly=false by default (We don't want to overwrite anything if the ACTUAL server is running...)
// NOTE: I copied some code in here from xmlrpcxx_server.cpp, including the above
// call to theServer.Init(), which has the InitDefaultStorage inside of it, and
// which uses OTLog::Path(), which the above new code should be setting properly
// before theServer.Init() actually gets called. (So this should work....)
//
// bool bSuccessInitDefault = OTDB::InitDefaultStorage(OTDB_DEFAULT_STORAGE,
// OTDB_DEFAULT_PACKER, strDataFolderPath, strNotaryFile);
// if (!bSuccessInitDefault)
// {
// OTLog::vError("\n\n%s: Failed invoking OTDB::InitDefaultStorage with path: %s and main filename: %s\n\n",
// __FUNCTION__, strDataFolderPath.c_str(), strNotaryFile.c_str());
// return 0;
// }
// -----------------------------------------
OTString strMintPath;
bool bFileIsPresent = false;
int nSeries = 0;
for (nSeries = 0; nSeries < 10000; ++nSeries)
{
// struct stat st;
OTString strFilename;
strFilename.Format("%s%s%d", strAssetTypeID.Get(), ".", nSeries);
bFileIsPresent = OTDB::Exists(OTFolders::Mint().Get(),
strServerID.Get(),
strFilename.Get());
// Old Code
//strMintPath.Format("%s%s%s%s%s%s%s%s%d",
// OTLog::Path(),
// OTLog::PathSeparator(),
// OTFolders::Mint().Get(),
// OTLog::PathSeparator(),
// strServerID.Get(),
// OTLog::PathSeparator(),
// strAssetTypeID.Get(), ".", nSeries);
//bFileIsPresent = (stat(strMintPath.Get(), &st) == 0);
if (!bFileIsPresent)
break;
}
// if bFileIsPresent is STILL true, that means we got all the way up to 1000 and the
// file was present every time.
// Geez, there must be 10000 mints on this computer. At one new Mint per 3 months,
// that's 4 per year, that's 2500 years already!!
//
if (bFileIsPresent)
{
OTLog::Output(0, "\n\nThis program automatically finds the next series, up to 10000. You\n"
"have reached 10000. You will have to change the source code of this\n"
"program in order to continue. Sorry.\n\n");
return 0;
}
// ---------------------------------------------------------------------
// nSeries now contains the number we need to use for the next series.
// and strMintPath now contains the correct file path.
OTMint * pMint = new OTMint(strServerID, strServerNymID, strAssetTypeID);
OT_ASSERT(NULL != pMint);
OTString strSeries; strSeries.Format("%s%d", ".", nSeries);
if (pMint->LoadMint(strSeries.Get()))
{
OTLog::Output(0, "\n\nSorry, that mint already exists. Delete it first if you wish to re-create it.\n\n");
}
else
{
OTLog::vOutput(0, "\n\nMint file does not (yet) exist for series %d and asset type:\n%s\n Creating......\n\n",
nSeries, strAssetTypeID.Get());
// TODO: read the denominations out of the asset contract itself, instead of hardcoding them here.
// Calculate FROM as Today, Now,
// then calculate TO as 6 months from now,
// and EXPIRATION as 3 months from now.
//
// TODO: Let these numbers be configured either in server operator contract, or issuer contract.
// In the meantime, 3 and 6 months are good enough.
OTPseudonym theNym;
theNym.SetIdentifier(strServerNymID);
// 1 hour == 3600 Seconds
// 1 day == 86400 Seconds
// 30 days == 2592000 Seconds
// 3 months == 7776000 Seconds
// 6 months == 15552000 Seconds
// This part requires the server operator to enter his passphrase.
// Which is why the server can't just fire it off automatically and
// make a mint available to the client. The client has to wait a day or
// until the operator is able to run this script and type the passphrase.
if (theNym.Loadx509CertAndPrivateKey())
{
const time_t CURRENT_TIME = time(NULL),
VALID_TO = CURRENT_TIME + 15552000, // Tokens generated by this mint are valid from today until 6 months from today
MINT_EXPIRATION = CURRENT_TIME + 7776000; // The mint itself will expire in 3 months from today, and be replaced with a new one.
pMint->GenerateNewMint(nSeries, CURRENT_TIME, VALID_TO, MINT_EXPIRATION, ASSET_TYPE_ID, SERVER_ID,
// penny, nickel, dime, quarter, $1, $5, $10, $20, $100, $1000
theNym, 1, 5, 10, 25, 100, 500, 1000, 2000, 10000, 100000);
// should be: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536
// ---------------------------------------
// OTString strFilename;// strPUBLICFilename;
// strFilename. Format("%s%s%s", strServerID.Get(), OTLog::PathSeparator(), strAssetTypeID.Get());
// strPUBLICFilename. Format("%s%s%s%sPUBLIC",strServerID.Get(), OTLog::PathSeparator(), strAssetTypeID.Get(), ".");
if (!OTDataFolder::IsInitialized()) { OT_ASSERT(false); };
OTString strServerFolder(""), strMintFolder("");
if (!OTPaths::AppendFolder(strMintFolder, OTDataFolder::Get(),OTFolders::Mint())) { OT_ASSERT(false); }; // mint/
if (!OTPaths::AppendFolder(strServerFolder, strMintFolder, strServerID.Get())) { OT_ASSERT(false); }; // mint/serverID
bool bFolderCreated;
if (OTPaths::BuildFolderPath(strServerFolder,bFolderCreated))
{
// -------------------------------------------------------------------
// This causes the next serialization to save the private, not just public, keys.
pMint->SetSavePrivateKeys(); // <== PRIVATE MINT VERSION.
pMint->SignContract(theNym);
pMint->SaveContract();
pMint->SaveMint(); // save the private mint file as: path/mints/server_id/Asset_TypeID (overwriting the last "current mint"...)
pMint->SaveMint(strSeries.Get()); // save the private mint file as: path/mints/server_id/Asset_TypeID.nSeries (These accumulate.)
// When the server needs to reference the "current" private keys, then it just loads the
// mint without specifying the series number. Since this file is overwritten with each new
// mint, it is thus always the latest one. (Similarly, the latest public is always asset_id.PUBLIC)
// On the other hand, if I need to load the keys for a specific series, (since more than one may be
// redeemable, even if only the latest one is being issued) then they are all also saved by series
// number, which is not overwritten with each new mint, but accumulates.
// That is why above, you see me save the mint twice in two different files, and below you see
// it being saved with the .PUBLIC appending to the filename.
// pMint->SaveContract(OTFolders::Mint().Get(), strFilename.Get()); // save the mint file.
// -------------------------------------------------------------------
// Now I sign it again, to get the private keys out of there.
pMint->ReleaseSignatures();
pMint->SignContract(theNym);
pMint->SaveContract();
pMint->SaveMint(".PUBLIC"); // save the public mint file.
// pMint->SaveContract(OTFolders::Mint().Get(), strPUBLICFilename.Get()); // save the public mint file.
nReturnVal = 1;
OTLog::Output(0, "\nDone.\n\n");
}
else
OTLog::Output(0, "\n\nError calling OTLog::ConfirmOrCreateFolder() for path/mints/server_id\n\n");
}
else
OTLog::Output(0, "\n\nError calling theNym.Loadx509CertAndPrivateKey()\n\n");
} // Mint file doesn't exist yet (therefore the above block creates it...)
return nReturnVal;
}
// *********************************************************************************************************
//
//
// *** SERVER MAIN ***
//
//
// The MAIN function for the server software, which starts up the ZMQ listener, as well
// as well as the Open Transactions library and the OT Server object.
//
// After initialization, this function becomes the "main loop" of OT server.
//
int main(int argc, char* argv[])
{
OTLog::vOutput(0, "\n\nWelcome to Open Transactions... Test Server -- version %s\n"
"(transport build: OTMessage -> OTEnvelope -> ZMQ )\n\n", OTLog::Version());
// WINSOCK WINDOWS
// -----------------------------------------------------------------------
#ifdef _WIN32
WORD wVersionRequested;
WSADATA wsaData;
int err;
/* Use the MAKEWORD(lowbyte, highbyte) macro declared in Windef.h */
wVersionRequested = MAKEWORD(2, 2);
err = WSAStartup(wVersionRequested, &wsaData);
if (err != 0) {
/* Tell the user that we could not find a usable */
/* Winsock DLL. */
printf("WSAStartup failed with error: %d\n", err);
return 1;
}
/* Confirm that the WinSock DLL supports 2.2. */
/* Note that if the DLL supports versions greater */
/* than 2.2 in addition to 2.2, it will still return */
/* 2.2 in wVersion since that is the version we */
/* requested. */
if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
/* Tell the user that we could not find a usable */
/* WinSock DLL. */
printf("Could not find a usable version of Winsock.dll\n");
WSACleanup();
return 1;
}
else
printf("The Winsock 2.2 dll was found okay\n");
/* The Winsock DLL is acceptable. Proceed to use it. */
/* Add network programming using Winsock here */
/* then call WSACleanup when done using the Winsock dll */
#endif
// ***********************************************************************
// INITIALIZATION and CLEANUP (for the OT library, and for this server application.)
//
class __ot_server_
{
OTServer * m_pServer;
public:
OTServer * GetServer() { return m_pServer; }
// -----------------------------------
__ot_server_() : m_pServer(NULL) // INIT
{
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
// OTLog class exists on both client and server sides.
// #define OT_NO_SIGNAL_HANDLING if you want to turn off OT's signal handling.
//
#if defined(OT_SIGNAL_HANDLING)
OTLog::SetupSignalHandler(); // This is optional! (I, of course, am using it in this test app...)
#endif
// -----------------------------------------------------------------------
// I instantiate this here (instead of globally) so that I am assured that any globals and other
// setup is already done before we instantiate the server object itself.
//
OT_ASSERT_MSG(NULL == m_pServer, "server main(): ASSERT: NULL == m_pServer.");
m_pServer = new OTServer;
//
// (This .cpp file you are currently reading is a wrapper for OTServer,
// which adds the transport layer.)
//
OT_ASSERT_MSG(NULL != m_pServer, "server main(): ASSERT: Unable to instantiate OT server.\n");
OTString pathUserAppDataPath, pathIniFileLocation;
pathUserAppDataPath = GetRoamingAppDataLocation();
pathIniFileLocation.Format("%s%s%s", pathUserAppDataPath.Get(), OTLog::PathSeparator(), SERVER_INI_FILE_DEFAULT);
OTString pathOTServerDataLocation;
OTLog::vOutput(0, "\nFound ot_init.cfg in: \n %s \nNow checking to see if it contains the OT Server path...", pathIniFileLocation.Get());
// Read the File, If successful use result
if (false == GetOTAppDataFolderLocation(pathIniFileLocation, pathOTServerDataLocation))
{
OTLog::vOutput(0, "Path not found... Will attempt default!... \n");
// Not successfull will will assume it is in default location:
pathOTServerDataLocation.Format("%s%s%s", pathUserAppDataPath.Get(), OTLog::PathSeparator(), SERVER_PATH_DEFAULT);
};
OTLog::vOutput(0, " %s \n", pathOTServerDataLocation.Get());
OTLog::SetMainPath(pathOTServerDataLocation.Get()); // <============ SET MAIN PATH
OTLog::vOutput(0, "Using server_data path: %s\n", OTLog::Path());
// -----------------------------------------------------------------------
OTCrypto::It()->Init(); // <========== (OpenSSL gets initialized here.)
}
// ****************************************
//
~__ot_server_() // CLEANUP
{
OTLog::vOutput(0, "\n\n OT version %s, shutting down and cleaning up.\n",
OTLog::Version());
// ------------------------------
if (NULL != m_pServer)
delete m_pServer;
m_pServer = NULL;
// ------------------------------
// We clean these up in reverse order from the Init function, which just seems
// like the best default, in absence of any brighter ideas.
//
OTCrypto::It()->Cleanup(); // <======= (OpenSSL gets cleaned up here.)
// -------------------------
// (This is at the bottom, since we do the cleanup in the
// reverse order from initialization.)
#ifdef _WIN32
WSACleanup();
#endif
}
};
// ***********************************************************************
//
// INSTANTIATE and INITIALIZE...
//
// (Cleanup happens automatically when this object goes out of scope.)
//
__ot_server_ the_server_obj;
OTServer * pServer = the_server_obj.GetServer();
OT_ASSERT(NULL != pServer);
// -----------------------------------------------------------------------
// OTString strCAFile, strDHFile, strKeyFile; //, strSSLPassword;
// strCAFile. Format("%s%s%s", OTLog::Path(), OTLog::PathSeparator(), CA_FILE);
// strDHFile. Format("%s%s%s", OTLog::Path(), OTLog::PathSeparator(), DH_FILE);
// strKeyFile.Format("%s%s%s", OTLog::Path(), OTLog::PathSeparator(), KEY_FILE);
// -----------------------------------------------------------------------
//
// UPDATE: This was moved to OTLog::OT_Init(), which is called above, by the
// nested cleanup class.
//
// Initialize SSL -- This MUST occur before any Private Keys are loaded!
// SSL_library_init();
// SSL_load_error_strings();
// -----------------------------------------------------------------------
// OTServer::Init loads up server's nym so it can decrypt messages sent in
// envelopes. It also does various other initialization work.
//
// (Envelopes prove that ONLY someone who actually had the server contract,
// and had loaded it into his wallet, could ever connect to the server or
// communicate with it. And if that person is following the contract, there
// is only one server he can connect to, and one key he can use to talk to it.)
//
OTLog::vOutput(0,
"\nNow loading the server nym, which will also ask you for a password, to unlock\n"
"its private key. (Default password is \"%s\".)\n", KEY_PASSWORD);
pServer->Init(); // Keys, etc are loaded here. ===> Assumes main path is set! <===
// -----------------------------------------------------------------------
// We're going to listen on the same port that is listed in our server contract.
//
//
OTString strHostname; // The hostname of this server, according to its own contract.
int nPort=0; // The port of this server, according to its own contract.
const bool bConnectInfo = pServer->GetConnectInfo(strHostname, nPort);
OT_ASSERT_MSG(bConnectInfo, "server main: Unable to find my own connect info (which SHOULD be in my server contract, BTW.) Perhaps you failed trying to open that contract? Have you tried the test password? (\"test\")\n");
const int nServerPort = nPort;
// -----------------------------------------------------------------------
// OT CRON
//
// A heartbeat for recurring transactions, such as markets, payment plans,
// and smart contracts.
pServer->ActivateCron();
// NOTE: Currently we trigger OT Cron's processing internally, but there's no reason why, in the
// future, we can't make an actual cron job that triggers a script, that fires a message
// to OT, causing OT to process its Cron (even if we were single-threaded we could do this...)
//
// Have to put some thought into it...
//
// Wouldn't require much security, since OT can still be smart enough not to process cron any
// more often than X minutes, no matter HOW many times the ProcessCron script fires.
// Thing is, though, that with this setup, we can't really guarantee that cron will EVER be
// triggered -- whereas the way OT is now, at least we know it WILL fire every X seconds.
//
// --------------------------------------
//
// NETWORK
//
// Prepare our context and listening socket...
OTSocket theSocket;
OTString strBindPath; strBindPath.Format("%s%d", "tcp://*:", nServerPort);
theSocket.Listen(strBindPath);
// ******************************************************************************************
//
// *** MAIN LOOP ***
//
do // ---------------------------
{
// =-=-=- HEARTBEAT -=-=-=
//
// The Server now processes certain things on a regular basis.
// ProcessCron is what gives it the opportunity to do that.
// All of the Cron Items (including market trades, payment plans, smart contracts...)
// they all have their hooks here...
//
pServer->ProcessCron(); // Internally this is smart enough to know how often to actually activate itself.
// Most often it just returns doing nothing (waiting for its timer.)
// -----------------------------------------------------------------------
// Wait for client http requests (and process replies out to them.)
// ----------------------------------------------------------------------
// Number of requests to process per heartbeat: OTServer::GetHeartbeatNoRequests()
//
// Loop: process up to 10 client requests, then sleep for 1/10th second.
// That's a total of 100 requests per second. Can the computers handle it?
// Is it too much or too little? Todo: load testing.
//
// Then: check for shutdown flag.
//
// Then: go back to the top ("do") and repeat the loop.... process cron,
// process 10 client requests, sleep, check for shutdown, etc.
//
//
Timer t; // start timer
t.start();
const double tick1 = t.getElapsedTimeInMilliSec();
// -----------------------------------------------------
//
// PROCESS X NUMBER OF REQUESTS (THIS PULSE.)
//
// Theoretically the "number of requests" that we process EACH PULSE.
// (The timing code here is still pretty new, need to do some load testing.)
//
for (int i = 0; i < /*10*/OTServer::GetHeartbeatNoRequests(); i++)
{
std::string str_Message;
// With 100ms heartbeat, receive will try 100 ms, then 200 ms, then 400 ms, total of 700.
// That's about 15 Receive() calls every 10 seconds. Therefore if I want the ProcessCron()
// to trigger every 10 seconds, I need to set the cron interval to roll over every 15 heartbeats.
// Therefore I will be using a real Timer for Cron, instead of the damn intervals.
//
bool bReceived = theSocket.Receive(str_Message);
if (bReceived)
{
std::string str_Reply; // Output.
if (str_Message.length() <= 0)
{
OTLog::Error("server main: Received a message, but of 0 length or less. Weird. (Skipping it.)\n");
}
else // ------------------------------------
{
// true == YES, DISCONNECT m_pSocket, something must have gone wrong.
// false == NO, do NOT disconnect m_pSocket, everything went wonderfully!
//
const bool bShouldDisconnect = ProcessMessage_ZMQ(*pServer, str_Message, str_Reply); // <================== PROCESS the message!
// --------------------------------------------------
if ((str_Reply.length() <= 0) || bShouldDisconnect)
{
OTLog::vOutput(0, "server main: ERROR: Unfortunately, not every client request is "
"legible or worthy of a server response. :-) "
"Msg:\n\n%s\n\n", str_Message.c_str());
theSocket.Listen();
}
else
{
bool bSuccessSending = theSocket.Send(str_Reply); // <===== SEND THE REPLY
if (false == bSuccessSending)
OTLog::vError("server main: Socket ERROR: failed while trying to send reply "
"back to client! \n\n MESSAGE:\n%s\n\nREPLY:\n%s\n\n",
str_Message.c_str(), str_Reply.c_str());
// --------------------------------------------------
}
}
}
} // for
// -----------------------------------------------------------------------
//
// IF the time we had available wasn't all used up -- if some of it is still
// available, then SLEEP until we reach the NEXT PULSE. (In practice, we will
// probably use TOO MUCH time, not too little--but then again OT isn't ALWAYS
// processing a message. There could be plenty of dead time in between...)
//
const double tick2 = t.getElapsedTimeInMilliSec();
const long elapsed = static_cast<long>(tick2 - tick1);
long lSleepMS = 0;
if (elapsed < /*100*/OTServer::GetHeartbeatMsBetweenBeats())
{
lSleepMS = OTServer::GetHeartbeatMsBetweenBeats() - elapsed;
// Now go to sleep.
// (The main loop processes ten times per second, currently.)
OTLog::SleepMilliseconds(lSleepMS); // 100 ms == (1 second / 10)
}
// -----------------------------------------------------------------------
// ARTIFICIAL LIMIT:
// 10 requests per heartbeat, 10 rounds per second == 100 requests per second.
//
// *** ONE HUNDRED CLIENT MESSAGES PER SECOND is the same as:
//
// 6000 PER MINUTE == 360,000 PER HOUR == 8,640,000 PER DAY***
//
// Speeding it up is just a matter of adjusting the above numbers, and LOAD TESTING,
// to see if OT can handle it. (Not counting optimization of course.)
//
// -----------------------------------------------------------------------
if (pServer->IsFlaggedForShutdown())
{
OTLog::Output(0, "main: OT Server is shutting down gracefully....\n");
break;
}
} while (1); // (MAIN LOOP)
// ------------------------------------
return 0;
}
int main (int argc, char **argv)
{
OTLog::vOutput(0, "\n\nWelcome to Open Transactions... Test Server -- version %s\n"
"(transport build: OTMessage -> TCP -> SSL)\n"
"NOTE: IF YOU PREFER TO USE XmlRpc with Http transport, then rebuild using:\n"
"\"make -f Makefile.rpc\" (but make sure the client is built the same way.)\n\n",
OTLog::Version());
// -----------------------------------------------------------------------
// This object handles all the actual transaction notarization details.
// (This file you are reading is a wrapper for OTServer, which adds the transport layer.)
OTServer theServer;
// -----------------------------------------------------------------------
#ifdef _WIN32
WSADATA wsaData;
WORD wVersionRequested = MAKEWORD( 2, 2 );
int nWSA = WSAStartup( wVersionRequested, &wsaData );
OT_ASSERT_MSG(0 != nWSA, "Error calling WSAStartup.\n");
#endif
OTLog::vOutput(0, "\n\nWelcome to Open Transactions, version %s.\n\n", OTLog::Version());
// -----------------------------------------------------------------------
OTString strCAFile, strDHFile, strKeyFile, strSSLPassword;
if (argc < 2)
{
OTLog::vOutput(0, "Usage: transaction <SSL-password> <data_folder path>\n\n"
"(Password defaults to '%s' if left blank on the command line.)\n"
"(Folder defaults to '%s' if left blank.)\n", KEY_PASSWORD, SERVER_PATH_DEFAULT);
strSSLPassword.Set(KEY_PASSWORD);
OTLog::SetMainPath(SERVER_PATH_DEFAULT);
}
else if (argc < 3)
{
OTLog::vOutput(0, "Usage: transaction <SSL-password> <data_folder path>\n\n"
"(Folder defaults to '%s' if left blank.)\n", SERVER_PATH_DEFAULT);
strSSLPassword.Set(argv[1]);
OTLog::SetMainPath(SERVER_PATH_DEFAULT);
}
else
{
strSSLPassword.Set(argv[1]);
OTLog::SetMainPath(argv[2]);
}
strCAFile. Format("%s%s%s", OTLog::Path(), OTLog::PathSeparator(), CA_FILE);
strDHFile. Format("%s%s%s", OTLog::Path(), OTLog::PathSeparator(), DH_FILE);
strKeyFile.Format("%s%s%s", OTLog::Path(), OTLog::PathSeparator(), KEY_FILE);
// -----------------------------------------------------------------------
// Init loads up server's nym so it can decrypt messages sent in envelopes.
// It also does various other initialization work.
//
// (Envelopes prove that ONLY someone who actually had the server contract,
// and had loaded it into his wallet, could ever connect to the server or
// communicate with it. And if that person is following the contract, there
// is only one server he can connect to, and one key he can use to talk to it.)
OTLog::Output(0,
"\n\nNow loading the server nym, which will also ask you for a password, to unlock\n"
"its private key. (Default password is \"test\".)\n");
// Initialize SSL -- This MUST occur before any Private Keys are loaded!
SFSocketGlobalInit(); // Any app that uses OT has to initialize SSL first.
theServer.Init(); // Keys, etc are loaded here.
// -----------------------------------------------------------------------
// We're going to listen on the same port that is listed in our server contract.
//
//
OTString strHostname; // The hostname of this server, according to its own contract.
int nPort=0; // The port of this server, according to its own contract.
OT_ASSERT_MSG(theServer.GetConnectInfo(strHostname, nPort),
"Unable to find my own connect info (which is in my server contract BTW.)\n");
const int nServerPort = nPort;
// -----------------------------------------------------------------------
SFSocket *socket = NULL;
listOfConnections theConnections;
// Alloc Socket
socket = SFSocketAlloc();
OT_ASSERT_MSG(NULL != socket, "SFSocketAlloc Failed\n");
// Initialize SSL Socket
int nSFSocketInit = SFSocketInit(socket,
strCAFile.Get(),
strDHFile.Get(),
strKeyFile.Get(),
strSSLPassword.Get(),
NULL);
OT_ASSERT_MSG(nSFSocketInit >= 0, "SFSocketInit Context Failed\n");
// Listen on Address/Port
int nSFSocketListen = SFSocketListen(socket, INADDR_ANY, nServerPort);
OT_ASSERT_MSG(nSFSocketListen >= 0, "nSFSocketListen Failed\n");
theServer.ActivateCron();
do
{
SFSocket * clientSocket = NULL;
// Accept Client Connection
if (NULL != (clientSocket = SFSocketAccept(socket)))
{
OTClientConnection * pClient = new OTClientConnection(*clientSocket, theServer);
theConnections.push_back(pClient);
OTLog::Output(0, "Accepting new connection.\n");
}
// READ THROUGH ALL CLIENTS HERE, LOOP A LIST
// AND process in-buffer onto our list of messages.
OTClientConnection * pConnection = NULL;
for (listOfConnections::iterator ii = theConnections.begin();
ii != theConnections.end(); ++ii)
{
if (pConnection = *ii)
{
// Here we read the bytes from the pipe into the client's buffer
// As necessary this function also processes those bytes into OTMessages
// and adds them to the Input List for that client.
pConnection->ProcessBuffer();
}
}
// Now loop through them all again, and process their messages onto the reply list.
pConnection = NULL;
for (listOfConnections::iterator ii = theConnections.begin();
ii != theConnections.end(); ++ii)
{
if (pConnection = *ii)
{
OTMessage * pMsg = NULL;
while (pMsg = pConnection->GetNextInputMessage())
{
OTMessage * pReply = new OTMessage;
OT_ASSERT(NULL != pReply);
if (theServer.ProcessUserCommand(*pMsg, *pReply, pConnection))
{
OTLog::vOutput(0, "Successfully processed user command: %s.\n",
pMsg->m_strCommand.Get());
pConnection->AddToOutputList(*pReply);
}
else
{
OTLog::Output(0, "Unable to process user command in XML, or missing payload, in main.\n");
delete pReply;
pReply = NULL;
}
// I am responsible to delete this here.
delete pMsg;
pMsg = NULL;
}
}
}
// Now loop through them all again, and process their replies down the pipe
pConnection = NULL;
for (listOfConnections::iterator ii = theConnections.begin();
ii != theConnections.end(); ++ii)
{
if (pConnection = *ii)
{
OTMessage * pMsg = NULL;
while (pMsg = pConnection->GetNextOutputMessage())
{
pConnection->ProcessReply(*pMsg);
// I am responsible to delete this here.
delete pMsg;
pMsg = NULL;
}
}
}
// The Server now processes certain things on a regular basis.
// This method call is what gives it the opportunity to do that.
theServer.ProcessCron();
// Now go to sleep for a tenth of a second.
// (Main loop processes ten times per second, currently.)
OTLog::SleepMilliseconds(100); // 100 ms == (1 second / 10)
} while (1);
// Close and Release Socket Resources
SFSocketRelease(socket);
#ifdef _WIN32
WSACleanup();
#endif
return(0);
}
// true == YES, DISCONNECT m_pSocket, something must have gone wrong.
// false == NO, do NOT disconnect m_pSocket, everything went wonderfully!
//
bool ProcessMessage_ZMQ(OTServer & theServer, const std::string & str_Message, std::string & str_Reply)
{
if (str_Message.size() < 1)
return false;
const char * szFunc = "ProcessMessage_ZMQ";
// --------------------
// return value.
std::string resultString = ""; // Whatever we put in this string is what will get returned.
// First we grab the client's message
OTASCIIArmor ascMessage;
ascMessage.MemSet(str_Message.data(), str_Message.size());
// ------------------
//
// OTPayload thePayload;
// thePayload.SetPayloadSize(str_Message.size());
// memcpy((void*)thePayload.GetPayloadPointer(), str_Message.data(), str_Message.size());
// ----------------------------------------------------------------------
// OTLog::vError("Envelope: \n%s\n Size: %ld\n", ascMessage.Get(), ascMessage.GetLength());
bool bReturnVal = false; // "false" == no, do NOT disconnect. No errors. ("True" means YES, DISCONNECT!)
OTMessage theMsg, theReply; // we'll need these in a sec...
// OTEnvelope theEnvelope(ascMessage);
OTEnvelope theEnvelope;
if (false == theEnvelope.SetAsciiArmoredData(ascMessage))
{
OTLog::vError("%s: Error retrieving envelope.\n", szFunc);
bReturnVal = true; // disconnect the socket!
}
else
{ // Now the base64 is decoded and the envelope is in binary form again.
OTLog::vOutput(2, "%s: Successfully retrieved envelope from ZMQ message...\n", szFunc);
OTString strEnvelopeContents;
// OTString strPubkeyPath("TESTPUBKEY.txt");
// theServer.GetServerNym().SavePublicKey(strPubkeyPath);
// Decrypt the Envelope.
if (false == theEnvelope.Open(theServer.GetServerNym(), strEnvelopeContents)) // now strEnvelopeContents contains the decoded message.
{
OTLog::vError("%s: Unable to open envelope.\n", szFunc);
bReturnVal = true; // disconnect the socket!
}
else
{
// All decrypted--now let's load the results into an OTMessage.
// No need to call theMsg.ParseRawFile() after, since
// LoadContractFromString handles it.
//
if (strEnvelopeContents.Exists() && theMsg.LoadContractFromString(strEnvelopeContents))
{
theReply.m_strCommand.Format("@%s", theMsg.m_strCommand.Get());
theReply.m_strNymID = theMsg.m_strNymID; // UserID
theReply.m_strServerID = theMsg.m_strServerID; // ServerID, a hash of the server contract.
theReply.m_bSuccess = false; // The default reply. In fact this is probably superfluous.
// In case you want to see all the incoming messages...
// OTLog::vOutput(0, "%s\n\n", strEnvelopeContents.Get());
// By constructing this without a socket, I put it in ZMQ mode, instead of tcp/ssl.
OTClientConnection theClient(theServer);
// By optionally passing in &theClient, the client Nym's public key will be
// set on it whenever verification is complete. (So for the reply, I'll
// have the key and thus I'll be able to encrypt reply to the recipient.)
if (false == theServer.ProcessUserCommand(theMsg, theReply, &theClient))
{
const OTString s1(theMsg), s2(theReply);
OTLog::vOutput(0, "%s: Unable to process user command.\n\n ********** "
"REQUEST:\n\n%s\n\n ********** RESPONSE:\n\n%s\n\n", szFunc, s1.Get(), s2.Get());
// NOTE: normally you would even HAVE a true or false if we're in this block. ProcessUserCommand()
// is what tries to process a command and then sets false if/when it fails. Until that point, you
// wouldn't get any server reply. I'm now changing this slightly, so you still get a reply (defaulted
// to success==false.) That way if a client needs to re-sync his request number, he will get the false
// and therefore know to resync the # as his next move, vs being stuck with no server reply (and thus
// stuck with a bad socket.)
// We sign the reply here, but not in the else block, since it's already signed in cases where
// ProcessUserCommand() is a success, by the time that call returns.
theReply.m_bSuccess = false; // Since the process call definitely failed, I'm making sure this here is definitely set to false (even though it probably was already.)
theReply.SignContract(theServer.GetServerNym());
theReply.SaveContract();
}
else // At this point the reply is ready to go, and theClient has the public key of the recipient...
OTLog::vOutput(1, "%s: Successfully processed user command: %s.\n", szFunc, theMsg.m_strCommand.Get());
// -------------------------------------------------
// The transaction is now processed (or not), and the server's reply message is in theReply.
// Let's seal it up to the recipient's nym (in an envelope) and send back to the user...
//
OTEnvelope theRecipientEnvelope;
bool bSealed = theClient.SealMessageForRecipient(theReply, theRecipientEnvelope);
if (false == bSealed)
{
OTLog::vOutput(0, "%s: Unable to seal envelope. (No reply will be sent.)\n", szFunc);
bReturnVal = true; // disconnect the socket!
}
else
{
// OTPayload theReplyPayload;
// theReplyPayload.SetEnvelope(theRecipientEnvelope);
// resultString = ascReply.Get();
// resultString.assign(theReplyPayload.GetPayloadPointer(), theReplyPayload.GetPayloadSize());
OTASCIIArmor ascReply;
if (theRecipientEnvelope.GetAsciiArmoredData(ascReply))
resultString.assign(ascReply.Get(), ascReply.GetLength());
}
}
else
{
OTLog::vError("%s: Error loading message from envelope contents:\n\n%s\n\n",
szFunc, strEnvelopeContents.Get());
bReturnVal = true; // disconnect the socket!
}
}
}
// ----------------------------------------------------------------------
str_Reply = resultString;
return bReturnVal;
} // ProcessMessage_ZMQ
