#include "FileFunctions.hpp" | |
#include "AxisConfiguration.hpp" | |
#include "MissingCFunctions.hpp" | |
#include "AxisConfigurationLibraries.hpp" | |
// Client -a c:\wscc -o obj\bin -m on -th transport.dll -c channel.dll -cs sslChannel.dll -x xerces.dll -cl client.log | |
int main( int argc, char * argv[]) | |
{ | |
LIST sDLLNames; | |
int iConfigInfoArray[eConfigMax]; | |
CHOICELIST sChoiceList[] = { {PLATFORM_TRANSPORTHTTP_PATH, "HTTP Transport library", AXCONF_TRANSPORTHTTP_TAGNAME, eHTTPTransport, eClient}, | |
{PLATFORM_CHANNEL_PATH, "HTTP Channel library", AXCONF_CHANNEL_HTTP_TAGNAME, eHTTPChannel, eClient}, | |
#if WIN32 | |
{"HTTPSSLChannel.dll", "HTTP SSL Channel library", AXCONF_SSLCHANNEL_HTTP_TAGNAME, eHTTPSSLChannel, eClient}, | |
#else | |
{"libhttp_channelssl.so", "HTTP SSL Channel library", AXCONF_SSLCHANNEL_HTTP_TAGNAME, eHTTPSSLChannel, eClient}, | |
#endif | |
{PLATFORM_XMLPARSER_PATH, "Axis XML Parser library", AXCONF_XMLPARSER_TAGNAME, eXMLParser, eClientAndServer}, | |
{"SMTPTRANSPORT", "SMTP Transport library", AXCONF_TRANSPORTSMTP_TAGNAME, eSMTPTransport, eClientAndServer}, | |
{"LOG", "client trace log path (only required if you want client trace)", AXCONF_CLIENTLOGPATH_TAGNAME, eClientLog, eClient}, | |
{"WSDD", "client WSDD path", AXCONF_CLIENTWSDDFILEPATH_TAGNAME, eClientWSDD, eClient}, | |
{"LOG", "server trace log path (only required if you want server trace)", AXCONF_LOGPATH_TAGNAME, eServerLog, eServer}, | |
{"WSDD", "server WSDD path", AXCONF_WSDDFILEPATH_TAGNAME, eServerWSDD, eServer}, | |
{"", "root directory", AXCONF_NODENAME_TAGNAME, eUnknown, eServer}, | |
{"", "offset to libraries", AXCONF_LISTENPORT_TAGNAME, eUnknown, eServer}, | |
{"", "SSL Options", AXCONF_SECUREINFO_TAGNAME, eSSLOptions, eClientAndServer}, | |
{"", "progress information", 0, eUnknown, eEmpty}, | |
{"", "merge", 0, eUnknown, eEmpty}, | |
{"", "Axis configuration directory", 0, eUnknown, eEmpty}, | |
{"", "backup existing axiscpp.conf file", 0, eUnknown, eEmpty}, | |
{"", "query missing files", 0, eUnknown, eEmpty}}; | |
bool bSuccess = false; | |
LIST sFileNameList; | |
char * psDefaultParamList[eConfigMax]; | |
#if WIN32 | |
char cSlash = '\\'; | |
char * pszPackageName = "axis-c-1.6-Win32-bin\\bin"; | |
#else | |
char cSlash = '/'; | |
char * pszPackageName = "axis-c-1.6-Linux-bin/bin"; | |
#endif | |
char szAxisCpp_Deploy[256]; | |
Initialise( &sDLLNames, iConfigInfoArray, &sFileNameList, (char **) psDefaultParamList, szAxisCpp_Deploy, (int) sizeof( szAxisCpp_Deploy)); | |
switch( ReadConfigOptions( argc, argv, (char **) psDefaultParamList, cSlash)) | |
{ | |
case eEmpty: | |
{ | |
Instructions( pszPackageName); | |
break; | |
} | |
case eClient: | |
{ | |
char szAxis_Bin[256]; | |
char szAxis_Bin_Default[256]; | |
cout << "Axis Client Configuration" << endl; | |
cout << "=========================" << endl; | |
GetHomeAndLibrary( &sDLLNames, szAxisCpp_Deploy, szAxis_Bin, szAxis_Bin_Default, &sFileNameList, (char **) psDefaultParamList, pszPackageName); | |
int iChoiceCount = 0; | |
while( sChoiceList[iChoiceCount].eConfigType != eUnknown) | |
{ | |
if( sChoiceList[iChoiceCount].eConfig & eClient) | |
{ | |
if( (sChoiceList[iChoiceCount].eConfigType == eClientLog || | |
sChoiceList[iChoiceCount].eConfigType == eServerLog)) | |
{ | |
char szLog[256]; | |
bool bAskForFilename = false; | |
szLog[0] = '\0'; | |
if( sChoiceList[iChoiceCount].eConfigType == eClientLog) | |
{ | |
if( psDefaultParamList[eClientLog] == NULL) | |
{ | |
if( StringCompare( psDefaultParamList[eQueryMissingFiles], "ON")) | |
{ | |
cout << "Enter name of client trace/log file: "; | |
bAskForFilename = true; | |
} | |
} | |
else | |
{ | |
if( psDefaultParamList[eClientLog] != NULL) | |
{ | |
strcpy( szLog, psDefaultParamList[eClientLog]); | |
} | |
else | |
{ | |
strcpy( szLog, "IGNORE"); | |
} | |
} | |
} | |
else | |
{ | |
if( psDefaultParamList[eServerLog] == NULL) | |
{ | |
cout << "Enter name of server trace/log file: "; | |
bAskForFilename = true; | |
} | |
else | |
{ | |
strcpy( szLog, psDefaultParamList[eServerLog]); | |
} | |
} | |
char szFilename[512]; | |
if( szLog[0] == '\0') | |
{ | |
cin >> szLog; | |
} | |
if( StringCompare( "IGNORE", szLog)) | |
{ | |
iConfigInfoArray[sChoiceList[iChoiceCount].eConfigType] = PopulateNewDLLNameInfo( &sDLLNames, NULL, NULL, true); | |
} | |
else | |
{ | |
if( strlen( szAxisCpp_Deploy) > 0) | |
{ | |
#if WIN32 | |
sprintf( szFilename, "%s\\%s", szAxisCpp_Deploy, szLog); | |
#else | |
sprintf( szFilename, "%s/%s", szAxisCpp_Deploy, szLog); | |
#endif | |
} | |
else | |
{ | |
sprintf( szFilename, "%s", szLog); | |
} | |
iConfigInfoArray[sChoiceList[iChoiceCount].eConfigType] = PopulateNewDLLNameInfo( &sDLLNames, szLog, szFilename, true); | |
} | |
} | |
else | |
{ | |
SelectFileFromList( sChoiceList, iChoiceCount, &sDLLNames, iConfigInfoArray, (char **) psDefaultParamList, &sFileNameList, szAxisCpp_Deploy); | |
} | |
} | |
iChoiceCount++; | |
} | |
if( psDefaultParamList[eSSLOptions] != NULL) | |
{ | |
iConfigInfoArray[eSSLOptions] = PopulateNewDLLNameInfo( &sDLLNames, NULL, psDefaultParamList[eSSLOptions], true); | |
} | |
if( psDefaultParamList[eAxisConfigDir] != NULL) | |
{ | |
iConfigInfoArray[eAxisConfigDir] = PopulateNewDLLNameInfo( &sDLLNames, NULL, psDefaultParamList[eAxisConfigDir], true); | |
} | |
bSuccess = true; | |
break; | |
} | |
case eServer: | |
{ | |
char szAxis_Bin[256]; | |
char szAxis_Bin_Default[256]; | |
cout << "Axis Server Configuration" << endl; | |
cout << "=========================" << endl; | |
GetHomeAndLibrary( &sDLLNames, szAxisCpp_Deploy, szAxis_Bin, szAxis_Bin_Default, &sFileNameList, (char **) psDefaultParamList, pszPackageName); | |
bSuccess = true; | |
break; | |
} | |
case eClientAndServer: | |
{ | |
cout << "Axis Client and Server Configuration" << endl; | |
bSuccess = true; | |
break; | |
} | |
} | |
if( bSuccess) | |
{ | |
if( psDefaultParamList[eAxisConfigDir] == NULL) | |
{ | |
WriteAxisConfigFile( &sDLLNames, | |
iConfigInfoArray, | |
sChoiceList, | |
StringCompare( psDefaultParamList[eMerge], "on"), | |
szAxisCpp_Deploy, | |
cSlash, | |
StringCompare( psDefaultParamList[eBackup], "true")); | |
} | |
else | |
{ | |
WriteAxisConfigFile( &sDLLNames, | |
iConfigInfoArray, | |
sChoiceList, | |
StringCompare( psDefaultParamList[eMerge], "on"), | |
psDefaultParamList[eAxisConfigDir], | |
cSlash, | |
StringCompare( psDefaultParamList[eBackup], "true")); | |
} | |
} | |
Destroy( &sDLLNames, &sFileNameList, (char **) psDefaultParamList); | |
return (int) bSuccess; | |
} | |
ECONFIG ReadConfigOptions( int iParamCount, char * pParamArray[], char ** ppsDefaultParamList, char cSlash) | |
{ | |
ECONFIG eConfig = eEmpty; | |
OPTIONLIST sOptions[] = {{eHTTPTransport, "TH"}, | |
{eHTTPChannel, "C"}, | |
{eHTTPSSLChannel, "CS"}, | |
{eXMLParser, "X"}, | |
{eSMTPTransport, "TS"}, | |
{eClientLog, "CL"}, | |
{eClientWSDD, "CW"}, | |
{eServerLog, "SL"}, | |
{eRootDirectory, "A"}, | |
{eOffsetToLibs, "O"}, | |
{eServerWSDD, "SW"}, | |
{eSSLOptions, "SO"}, | |
{eProgressInfo, "PI"}, | |
{eAxisConfigDir, "ACD"}, | |
{eBackup, "B"}, | |
{eQueryMissingFiles, "QMF"}, | |
{eMerge, "M"}}; | |
ppsDefaultParamList[eMerge] = (char *) malloc( strlen( "off ")); | |
ppsDefaultParamList[eProgressInfo] = (char *) malloc( strlen( "normal ")); | |
ppsDefaultParamList[eBackup] = (char *) malloc( strlen( "true ")); | |
ppsDefaultParamList[eQueryMissingFiles] = (char *) malloc( strlen( "on ")); | |
strcpy( ppsDefaultParamList[eMerge], "off"); | |
strcpy( ppsDefaultParamList[eProgressInfo], "normal"); | |
strcpy( ppsDefaultParamList[eBackup], "true"); | |
strcpy( ppsDefaultParamList[eQueryMissingFiles], "on"); | |
for( int iCount = 0; iCount < iParamCount; iCount++) | |
{ | |
if( StringCompare( pParamArray[iCount], "Client")) | |
{ | |
eConfig = (ECONFIG)((int) eConfig | eClient); | |
} | |
else if( StringCompare( pParamArray[iCount], "Server")) | |
{ | |
eConfig = (ECONFIG)((int) eConfig | eServer); | |
} | |
else if( StringCompare( pParamArray[iCount], "Both")) | |
{ | |
eConfig = (ECONFIG)((int) eConfig | eClientAndServer); | |
} | |
if( *pParamArray[iCount] == '-') | |
{ | |
bool bOptionFound = false; | |
int iIndex = 0; | |
do | |
{ | |
if( !(bOptionFound = StringCompare( (pParamArray[iCount] + 1), sOptions[iIndex].pszOption))) | |
{ | |
iIndex++; | |
} | |
} while( iIndex < (eConfigMax - 1) && !bOptionFound); | |
if( bOptionFound) | |
{ | |
if( ppsDefaultParamList[sOptions[iIndex].eConfType] != NULL) | |
{ | |
free( (void *) ppsDefaultParamList[sOptions[iIndex].eConfType]); | |
} | |
iCount++; | |
if( iCount < iParamCount) | |
{ | |
if( ppsDefaultParamList[eOffsetToLibs] != NULL && | |
ppsDefaultParamList[eRootDirectory] != NULL && | |
!(sOptions[iIndex].eConfType == eClientLog || | |
sOptions[iIndex].eConfType == eServerLog || | |
sOptions[iIndex].eConfType == eBackup || | |
sOptions[iIndex].eConfType == eMerge || | |
sOptions[iIndex].eConfType == eQueryMissingFiles || | |
sOptions[iIndex].eConfType == eSSLOptions) && | |
strchr( pParamArray[iCount], cSlash) == NULL) | |
{ | |
std::string sLocation; | |
sLocation = ppsDefaultParamList[eRootDirectory]; | |
sLocation += cSlash; | |
sLocation += ppsDefaultParamList[eOffsetToLibs]; | |
sLocation += cSlash; | |
sLocation += pParamArray[iCount]; | |
ppsDefaultParamList[sOptions[iIndex].eConfType] = (char *) malloc( sLocation.length() + 1); | |
strcpy( ppsDefaultParamList[sOptions[iIndex].eConfType], sLocation.c_str()); | |
} | |
else | |
{ | |
ppsDefaultParamList[sOptions[iIndex].eConfType] = (char *) malloc( strlen( pParamArray[iCount]) + 1); | |
strcpy( ppsDefaultParamList[sOptions[iIndex].eConfType], pParamArray[iCount]); | |
} | |
} | |
} | |
else | |
{ | |
cout << "Option: " << pParamArray[iCount] << " has been ignored." << endl; | |
} | |
} | |
} | |
return eConfig; | |
} | |
void GetHomeAndLibrary( LIST * psDLLNames, char * pszAxisCpp_Deploy, char * pszAxis_Bin, char * pszAxis_Bin_Default, LIST * psFileNameList, char ** ppsDefaultParamList, char * pszPackageName) | |
{ | |
char * pszCurrentAxisCppDeployEnv = getenv( "AXISCPP_DEPLOY"); | |
if( ppsDefaultParamList[eAxisConfigDir] == NULL) | |
{ | |
if( ppsDefaultParamList[eRootDirectory] == NULL) | |
{ | |
#if WIN32 | |
cout << "Type in the Axis fully qualified directory path (e.g. C:\\Axis)" << endl | |
<< "used when Axis was unzipped (NB: this directory must also contain the" << endl | |
<< "axiscpp.conf file)."; | |
#else | |
cout << "Type in the Axis fully qualified directory path (e.g. /home/Axis)" << endl | |
<< "used when Axis was unzipped (NB: this directory must also contain the" << endl | |
<< "etc/axiscpp.conf file)."; | |
#endif | |
if( pszCurrentAxisCppDeployEnv != NULL) | |
{ | |
cout << " Type '*' to used the existing value of the environment" << endl; | |
cout << "variable (i.e. '" << pszCurrentAxisCppDeployEnv << "')."; | |
} | |
cout << endl << "AXISCPP_DEPLOY = "; | |
cin >> pszAxisCpp_Deploy; | |
if( *pszAxisCpp_Deploy == '*' && pszCurrentAxisCppDeployEnv != NULL) | |
{ | |
strcpy( pszAxisCpp_Deploy, pszCurrentAxisCppDeployEnv); | |
} | |
} | |
else | |
{ | |
strcpy( pszAxisCpp_Deploy, ppsDefaultParamList[eRootDirectory]); | |
} | |
if( ppsDefaultParamList[eOffsetToLibs] != NULL) | |
{ | |
strcpy( pszAxis_Bin, ppsDefaultParamList[eOffsetToLibs]); | |
if( !CheckAxisBinDirectoryExists( pszAxisCpp_Deploy, pszAxis_Bin, pszAxis_Bin_Default, psDLLNames, psFileNameList)) | |
{ | |
cout << "Axis binaries directory not found." << endl; | |
free( (void *) ppsDefaultParamList[eOffsetToLibs]); | |
ppsDefaultParamList[eOffsetToLibs] = NULL; | |
} | |
} | |
strcpy( pszAxis_Bin_Default, pszPackageName); | |
if( ppsDefaultParamList[eOffsetToLibs] == NULL) | |
{ | |
if( pszCurrentAxisCppDeployEnv == NULL) | |
{ | |
cout << endl << "Instruction:" << endl | |
<< "You will need to create an environment variable called " << endl | |
<< "\"AXISCPP_DEPLOY\" and set it to " << pszAxisCpp_Deploy << "." << endl | |
<< "On the command line this would be:-" << endl | |
#if WIN32 | |
<< "SET AXISCPP_DEPLOY=" << pszAxisCpp_Deploy << endl; | |
#else | |
<< "EXPORT AXISCPP_DEPLOY=" << pszAxisCpp_Deploy << endl; | |
#endif | |
} | |
cout << endl; | |
do | |
{ | |
#if WIN32 | |
cout << "Type in the directory where the Axis libraries (e.g. axis_client.dll) can be" << endl | |
<< "found. (If you type '*', it will use the default '" << pszAxis_Bin_Default << "')." << endl; | |
#else | |
cout << "Type in the directory where the Axis libraries (e.g. axis_client.so) can be" << endl | |
<< "found. (If you type '*', it will use the default '" << pszAxis_Bin_Default << "')." << endl; | |
#endif | |
cout << "Axis binaries directory = "; | |
cin >> pszAxis_Bin; | |
if( !strcmp( pszAxis_Bin, "*")) | |
{ | |
strcpy( pszAxis_Bin, pszAxis_Bin_Default); | |
} | |
} while( !CheckAxisBinDirectoryExists( pszAxisCpp_Deploy, pszAxis_Bin, pszAxis_Bin_Default, psDLLNames, psFileNameList)); | |
} | |
} | |
cout << endl << "Begin to configure the AXISCPP.CONF file." << endl; | |
} | |
void SelectFileFromList( CHOICELIST * psChoiceList, int iChoiceCount, LIST * psDLLNames, int * piConfigInfoArray, char ** ppsDefaultParamList, LIST * psFileNameList, char * pszAxisCpp_Deploy) | |
{ | |
cout << endl << "Select the filename for the " << psChoiceList[iChoiceCount].pszElementDescription << "." << endl; | |
int iDLLCount = 0; | |
LIST sDLLOffsetList; | |
bool bHTTPTransportFound = false; | |
memset( &sDLLOffsetList, 0, sizeof( LIST)); | |
do | |
{ | |
char * pszUpper = new char[strlen( psChoiceList[iChoiceCount].pszElement) + 1]; | |
strcpy( pszUpper, psChoiceList[iChoiceCount].pszElement); | |
StringToUpper( pszUpper); | |
char * pszExtn = strchr( pszUpper, '.'); | |
if( pszExtn != NULL) | |
{ | |
*pszExtn = '\0'; | |
} | |
while( iDLLCount < psDLLNames->iCount) | |
{ | |
DLLNAMEINFO * pszDLLNameInfo = ((DLLNAMEINFO *) psDLLNames->ppArray[iDLLCount]); | |
if( pszDLLNameInfo->pszDLLName != NULL && | |
strstr( pszDLLNameInfo->pszDLLName, pszUpper) != NULL) | |
{ | |
int * piDLLOffset = (int *) GetNextListElement( &sDLLOffsetList, sizeof( int)); | |
*piDLLOffset = iDLLCount; | |
cout << sDLLOffsetList.iCount << ".\t" << pszDLLNameInfo->pszDLLFilename << endl; | |
} | |
iDLLCount++; | |
} | |
free( pszUpper); | |
if( ppsDefaultParamList[psChoiceList[iChoiceCount].eConfigType] != NULL && | |
FileExists( ppsDefaultParamList[psChoiceList[iChoiceCount].eConfigType])) | |
{ | |
piConfigInfoArray[psChoiceList[iChoiceCount].eConfigType] = PopulateNewDLLNameInfo( psDLLNames, NULL, ppsDefaultParamList[psChoiceList[iChoiceCount].eConfigType], true); | |
bHTTPTransportFound = true; | |
cout << "Choices have been overridden by input parameter." << endl; | |
} | |
else | |
{ | |
if( StringCompare( ppsDefaultParamList[eQueryMissingFiles], "ON")) | |
{ | |
if( sDLLOffsetList.iCount > 0) | |
{ | |
if( sDLLOffsetList.iCount > 1) | |
{ | |
cout << "Select an index between 1 and " << sDLLOffsetList.iCount << " : "; | |
int iChoice; | |
cin >> iChoice; | |
if( iChoice < 1 || iChoice > sDLLOffsetList.iCount) | |
{ | |
cout << "Number was out of range." << endl; | |
} | |
else | |
{ | |
((DLLNAMEINFO *) psDLLNames->ppArray[*((int *) sDLLOffsetList.ppArray[iChoice - 1])])->bAddToClientConfig = true; | |
piConfigInfoArray[psChoiceList[iChoiceCount].eConfigType] = *((int *) sDLLOffsetList.ppArray[iChoice - 1]); | |
bHTTPTransportFound = true; | |
} | |
} | |
else | |
{ | |
cout << "Automatically selected " << ((DLLNAMEINFO *) psDLLNames->ppArray[*((int *) sDLLOffsetList.ppArray[0])])->pszDLLFilename << endl; | |
((DLLNAMEINFO *) psDLLNames->ppArray[*((int *) sDLLOffsetList.ppArray[0])])->bAddToClientConfig = true; | |
piConfigInfoArray[psChoiceList[iChoiceCount].eConfigType] = *((int *) sDLLOffsetList.ppArray[0]); | |
bHTTPTransportFound = true; | |
} | |
} | |
else | |
{ | |
cout << "There are no recognised file names for the type of file/library." << endl << "You will have to modify the configuration file namually." << endl << endl; | |
bHTTPTransportFound = true; | |
} | |
} | |
else | |
{ | |
bHTTPTransportFound = true; | |
} | |
} | |
} while( !bHTTPTransportFound); | |
for( int iCount = 0; iCount < sDLLOffsetList.iCount; iCount++) | |
{ | |
free( sDLLOffsetList.ppArray[iCount]); | |
} | |
} | |
void AddFilenameToList( LIST * psFileNameList, char * pszFilename) | |
{ | |
char * psList = (char *) GetNextListElement( psFileNameList, (int) strlen( pszFilename) + 1); | |
strcpy( psList, pszFilename); | |
} | |
bool FileExists( char * pszFilename) | |
{ | |
FILE * fp = fopen( pszFilename, "r"); | |
bool bSuccess = false; | |
if( fp != NULL) | |
{ | |
fclose( fp); | |
bSuccess = true; | |
} | |
return bSuccess; | |
} |