/*
* Return ptr to string representing a human readable error code from the
* lttng_error_code enum.
*
* These code MUST be negative in other to treat that as an error value.
*/
LTTNG_HIDDEN
const char *error_get_str(int32_t code)
{
code = -code;
if (code < LTTNG_OK || code > LTTNG_ERR_NR) {
code = LTTNG_ERR_NR;
}
return error_string_array[ERROR_INDEX(code)];
}
//-----------------------------------------------------------------------------
// program entry point.
//-----------------------------------------------------------------------------
int main(int argc, char *argv[], char *envp[]) {
//-------------------------------------------------------------------------
// Generic variables.
//-------------------------------------------------------------------------
int ret = -1;
PENERGY_DATA p = NULL;
PL_STATUS plret = PL_FAILURE;
unsigned long long value = 0;
char buffer[ENERGY_INPUT_LINE_MAX_SIZE] = { '\0' };
#ifdef __PL_WINDOWS__
BOOL bret = FALSE;
#endif // __PL_WINDOWS__
//-------------------------------------------------------------------------
// ESRV instance handling variables.
//-------------------------------------------------------------------------
char esrv_config_file_name_buffer[PL_MAX_PATH] = { '\0' };
int f_esrv_guid = 0;
int f_esrv_pid = 0;
char *env = NULL;
//-------------------------------------------------------------------------
// Variables used to build ESRV start command -- if we have to.
//-------------------------------------------------------------------------
char esrv_command_buffer[PL_MAX_PATH] = { '\0' };
//-------------------------------------------------------------------------
// Variables used to remove ESRV PL after use -- if we started it.
//-------------------------------------------------------------------------
char esrv_pl_path_name[PL_MAX_PATH] = { '\0' };
#ifdef __PL_WINDOWS__
char current_path_name[PL_MAX_PATH] = { '\0' };
char esrv_pl_config_file_name[PL_MAX_PATH] = { '\0' };
struct _finddata_t find_files;
intptr_t file = 0;
#endif // __PL_WINDOWS__
#if defined (__PL_LINUX__) || (__PL_SOLARIS__) || (__PL_MACOSX__)
DIR *directory = NULL;
struct dirent *file = NULL;
char file_name[PL_MAX_PATH] = { '\0' };
#endif // __PL_LINUX__ || __PL_SOLARIS__ || __PL_MACOSX__
//-------------------------------------------------------------------------
// Variables used to read ESRV's sartup output -- used to get the GUID
//-------------------------------------------------------------------------
char *pc = NULL;
char *token = NULL;
int input_line_count = 0;
char esrv_guid[ENERGY_GUID_LENGHT_IN_CHARACTERS + 1] = { '\0' };
#ifdef __PL_WINDOWS__
DWORD esrv_pid = 0;
HANDLE esrv_handle = NULL;
DWORD bytes_read = 0;
#endif // __PL_WINDOWS__
#if defined (__PL_LINUX__) || (__PL_SOLARIS__) || (__PL_MACOSX__)
pid_t esrv_pid = 0;
#endif // __PL_LINUX__ || __PL_SOLARIS__ || __PL_MACOSX__
//-------------------------------------------------------------------------
// Signal handler variables.
//-------------------------------------------------------------------------
#if defined (__PL_LINUX__) || (__PL_SOLARIS__) || (__PL_MACOSX__)
struct sigaction sa;
#endif // __PL_LINUX__ || __PL_SOLARIS__ || __PL_MACOSX__
//--------------------------------------------------------------------------
//-------------------------------------------------------------------------
// Retrive the energy structure address.
//-------------------------------------------------------------------------
p = &energy_data;
assert(p != NULL);
//-------------------------------------------------------------------------
// Initialize the energy data structure.
//-------------------------------------------------------------------------
memset(p, 0, sizeof(ENERGY_DATA));
p->argc = argc;
p->argv = argv;
p->channel = ENERGY_DEFAULT_CHANNEL;
p->esrv_pld = PL_INVALID_DESCRIPTOR;
p->esrv_status = ESRV_STATUS_NOT_RUNNING;
//-------------------------------------------------------------------------
// Parse user input.
//-------------------------------------------------------------------------
plret = parser(&energy_data);
if(plret != PL_SUCCESS) {
_ERROR("Unable to make sense of user input.");
} else {
if((p->f_help == 1) || (p->f_version == 1)) {
goto done;
}
}
//-------------------------------------------------------------------------
// Check for inconsistent user input.
//-------------------------------------------------------------------------
if(
(
(p->f_guid == 1) &&
(p->f_guid_shell_variable)
)
) {
_ERROR(
"Incompatible ESRV instance designation. Please use --guid or --guid_shell_variable option."
);
}
if(p->f_command == 0) {
_ERROR(
"You need to specify a command. Use energy --help for details."
);
}
//-------------------------------------------------------------------------
// Select the ESRV instance to use.
// Note:
// If no ESRV id is provided, then an instance is started and ended
// by the program.
// Note:
// If GUID is provided, build the pl_config.ini full path name for the
// attach.
// Note:
// If CONFIG is provided, then do nothing, we are ready to attach.
//-------------------------------------------------------------------------
memset(
esrv_config_file_name_buffer,
0,
sizeof(esrv_config_file_name_buffer)
);
if(p->f_guid == 1) {
memcpy(
esrv_config_file_name_buffer,
ENERGY_ESRV_PL_CONFIG_FILE_ROOT,
strlen(ENERGY_ESRV_PL_CONFIG_FILE_ROOT)
);
strncat(
esrv_config_file_name_buffer,
ESRV_APPLICATION_NAME,
strlen(ESRV_APPLICATION_NAME)
);
strncat(
esrv_config_file_name_buffer,
ENERGY_ESRV_PL_CONFIG_FILE_UNDERSCORE,
strlen(ENERGY_ESRV_PL_CONFIG_FILE_UNDERSCORE)
);
strncat(
esrv_config_file_name_buffer,
p->esrv_guid,
strlen(p->esrv_guid)
);
strncat(
esrv_config_file_name_buffer,
ENERGY_ESRV_PL_CONFIG_FILE_NAME,
strlen(ENERGY_ESRV_PL_CONFIG_FILE_NAME)
);
goto attach_to_esrv;
}
if(p->f_guid_shell_variable == 1) {
memcpy(
esrv_config_file_name_buffer,
ENERGY_ESRV_PL_CONFIG_FILE_ROOT,
strlen(ENERGY_ESRV_PL_CONFIG_FILE_ROOT)
);
strncat(
esrv_config_file_name_buffer,
ESRV_APPLICATION_NAME,
strlen(ESRV_APPLICATION_NAME)
);
strncat(
esrv_config_file_name_buffer,
ENERGY_ESRV_PL_CONFIG_FILE_UNDERSCORE,
strlen(ENERGY_ESRV_PL_CONFIG_FILE_UNDERSCORE)
);
strncat(
esrv_config_file_name_buffer,
p->esrv_guid_shell_variable_value,
strlen(p->esrv_guid_shell_variable_value)
);
strncat(
esrv_config_file_name_buffer,
ENERGY_ESRV_PL_CONFIG_FILE_NAME,
strlen(ENERGY_ESRV_PL_CONFIG_FILE_NAME)
);
goto attach_to_esrv;
}
//-------------------------------------------------------------------------
// Because it is easier to type energy -- command than energy --guid xxx --
// command, we check for the existence of a ENERGY_ESRV_DEFAULT_GUID_SHELL_-
// -VARIABLE shell variable. If it exist and has a valid GUID, then it is
// used. If no such variable exist, then energy continues by starting its
// own instance of ESRV.
//-------------------------------------------------------------------------
env = getenv(ENERGY_ESRV_DEFAULT_GUID_SHELL_VARIABLE);
if(env != NULL) {
ret = plh_filter_uuid_string(env);
if(ret != PL_FAILURE) {
memcpy(
esrv_config_file_name_buffer,
ENERGY_ESRV_PL_CONFIG_FILE_ROOT,
strlen(ENERGY_ESRV_PL_CONFIG_FILE_ROOT)
);
strncat(
esrv_config_file_name_buffer,
ESRV_APPLICATION_NAME,
strlen(ESRV_APPLICATION_NAME)
);
strncat(
esrv_config_file_name_buffer,
ENERGY_ESRV_PL_CONFIG_FILE_UNDERSCORE,
strlen(ENERGY_ESRV_PL_CONFIG_FILE_UNDERSCORE)
);
strncat(
esrv_config_file_name_buffer,
env,
strlen(env)
);
strncat(
esrv_config_file_name_buffer,
ENERGY_ESRV_PL_CONFIG_FILE_NAME,
strlen(ENERGY_ESRV_PL_CONFIG_FILE_NAME)
);
goto attach_to_esrv;
}
}
//-------------------------------------------------------------------------
// Build ESRV binary name and command line
// Note:
// cli_buffer holds the ESRV binary name and the command line options.
// if the command and the arguments are provided separately to
// CreateProcess then the argv count is erroneous in the started
// process and ESRV fails the cli parsing.
//-------------------------------------------------------------------------
memset(
esrv_command_buffer,
0,
sizeof(esrv_command_buffer)
);
strncpy(
esrv_command_buffer,
ENERGY_ESRV_BINARY_NAME,
strlen(ENERGY_ESRV_BINARY_NAME)
);
if(p->f_esrv_options == 1) {
strncat(
esrv_command_buffer,
p->esrv_options,
strlen(p->esrv_options)
);
} else {
strncat(
esrv_command_buffer,
ENERGY_ESRV_DEFAULT_OPTIONS,
strlen(ENERGY_ESRV_DEFAULT_OPTIONS)
);
}
strncat(
esrv_command_buffer,
ENERGY_ESRV_SHELL_OPTION,
strlen(ENERGY_ESRV_SHELL_OPTION)
);
//-------------------------------------------------------------------------
// Start an ESRV instance in a child process.
//-------------------------------------------------------------------------
#ifdef __PL_WINDOWS__
p->fp_esrv = _popen(
esrv_command_buffer,
"rt"
);
#endif // __PL_WINDOWS__
#if defined (__PL_LINUX__) || (__PL_SOLARIS__) || (__PL_MACOSX__)
p->fp_esrv = popen(
esrv_command_buffer,
"r"
);
#endif // __PL_LINUX__ || __PL_SOLARIS__ || __PL_MACOSX__
if(p->fp_esrv == NULL) {
_ERROR("Unable to start ESRV.");
}
//-------------------------------------------------------------------------
// Retrieve the ESRV's instance PID and GUID.
//-------------------------------------------------------------------------
do {
pc = fgets(
buffer,
sizeof(buffer),
p->fp_esrv
);
if(pc != NULL) {
switch(++input_line_count) {
case ENERGY_ESRV_GUID_LINE:
//---------------------------------------------------------
// extract ESRV's GUID and save it
//---------------------------------------------------------
token = strtok(
buffer,
ENERGY_ESRV_GUID_TOKEN_SEPARATORS
);
while(token != NULL) {
if(strncmp(
token,
ENERGY_ESRV_PRE_GUID_TOKEN,
strlen(ENERGY_ESRV_PRE_GUID_TOKEN)
) == 0) {
token = strtok(
NULL,
ENERGY_ESRV_GUID_TOKEN_TERMINATOR
);
memset(
esrv_guid,
0,
sizeof(esrv_guid)
);
strncpy(
esrv_guid,
token,
strlen(token)
);
f_esrv_guid = 1;
break;
}
token = strtok(
NULL,
ENERGY_ESRV_GUID_TOKEN_SEPARATORS
);
}
break;
case ENERGY_ESRV_PID_LINE:
//---------------------------------------------------------
// extract ESRV's PID and save it.
//---------------------------------------------------------
token = strtok(
buffer,
ENERGY_ESRV_PID_TOKEN_SEPARATORS
);
while(token != NULL) {
if(strncmp(
token,
ENERGY_ESRV_PRE_PID_TOKEN,
strlen(ENERGY_ESRV_PRE_PID_TOKEN)
) == 0) {
token = strtok(
NULL,
ENERGY_ESRV_PID_TOKEN_TERMINATOR
);
#ifdef __PL_WINDOWS__
esrv_pid = (DWORD)atoi(token);
#endif // __Pl_WINDOWS__
#if defined (__PL_LINUX__) || (__PL_SOLARIS__) || (__PL_MACOSX__)
esrv_pid = (pid_t)atoi(token);
#endif // __PL_LINUX__ || __PL_SOLARIS__ || __PL_MACOSX__
assert(esrv_pid != 0);
f_esrv_pid = 1;
goto pid_found;
}
token = strtok(
NULL,
ENERGY_ESRV_GUID_TOKEN_SEPARATORS
);
}
break;
default:
break;
}
} else {
//-----------------------------------------------------------------
// Likely the ESRV launch has failed, let's signal this error.
//-----------------------------------------------------------------
_ERROR("ESRV likely failed to start.");
}
} while(pc != NULL);
//-------------------------------------------------------------------------
// Likely the ESRV launch has failed, let's signal this error.
//-------------------------------------------------------------------------
_ERROR("ESRV likely failed to start.");
pid_found:
//-------------------------------------------------------------------------
// Check and build the pl_config.ini file to attach to.
//-------------------------------------------------------------------------
assert((f_esrv_guid == 1) && (f_esrv_pid == 1));
memset(
esrv_config_file_name_buffer,
0,
sizeof(esrv_config_file_name_buffer)
);
memcpy(
esrv_config_file_name_buffer,
ENERGY_ESRV_PL_CONFIG_FILE_ROOT,
strlen(ENERGY_ESRV_PL_CONFIG_FILE_ROOT)
);
strncat(
esrv_config_file_name_buffer,
ESRV_APPLICATION_NAME,
strlen(ESRV_APPLICATION_NAME)
);
strncat(
esrv_config_file_name_buffer,
ENERGY_ESRV_PL_CONFIG_FILE_UNDERSCORE,
strlen(ENERGY_ESRV_PL_CONFIG_FILE_UNDERSCORE)
);
strncat(
esrv_config_file_name_buffer,
esrv_guid,
strlen(esrv_guid)
);
memset(
esrv_pl_path_name,
0,
sizeof(esrv_pl_path_name)
);
strncpy(
esrv_pl_path_name,
esrv_config_file_name_buffer,
strlen(esrv_config_file_name_buffer)
);
strncat(
esrv_config_file_name_buffer,
ENERGY_ESRV_PL_CONFIG_FILE_NAME,
strlen(ENERGY_ESRV_PL_CONFIG_FILE_NAME)
);
attach_to_esrv:
//-------------------------------------------------------------------------
// Attach to the identified instance of ESRV and read settings.
//-------------------------------------------------------------------------
p->esrv_pld = pl_attach(esrv_config_file_name_buffer);
if(p->esrv_pld == PL_INVALID_DESCRIPTOR) {
_ERROR("Unable to attach to the specified ESRV instance.");
}
//-------------------------------------------------------------------------
// read-in esrv's configuration:
// - ESRV Status (running or not)
// - ESRV Channel count
// - ESRV Version (not used)
// - ESRV energy in joule counter's precision
// Note:
// since each channel holds esrv's configuration counters, we read the
// first channel to read the channel count. ESRV has always at least
// one channel, so the read is safe
// Note:
// Channel count is zero count, therefore the --.
//-------------------------------------------------------------------------
plret = pl_read(
p->esrv_pld,
&p->channels,
ESRV_COUNTER_CHANNELS_INDEX
);
if(plret != PL_SUCCESS) {
_ERROR("Unable to read the ESRV channels count counter.");
}
if(p->channel > p->channels) {
WARNING(
"The requested channel does not exist in the specified ESRV instance. Will use default channel (1)."
);
p->channel = 1;
}
p->channel--;
//-------------------------------------------------------------------------
// Now that the channels count is known, we can read the requested ESRV channel
//-------------------------------------------------------------------------
plret = pl_read(
p->esrv_pld,
&p->status,
(p->channel * ESRV_BASE_COUNTERS_COUNT) + ESRV_COUNTER_STATUS_INDEX
);
if(plret != PL_SUCCESS) {
_ERROR("Unable to read the ESRV status counter.");
}
if(p->status != ESRV_STATUS_RUNNING) {
_ERROR("The specified ESRV instance doesn't seem to be alive.");
}
plret = pl_read(
p->esrv_pld,
&p->version,
(p->channel * ESRV_BASE_COUNTERS_COUNT) + ESRV_COUNTER_VERSION_INDEX
);
if(plret != PL_SUCCESS) {
_ERROR("Unable to read the ESRV version counter.");
}
plret = pl_read(
p->esrv_pld,
&value,
(p->channel * ESRV_BASE_COUNTERS_COUNT) + ESRV_COUNTER_ENERGY_JOULES_DECIMALS_INDEX
);
if(plret != PL_SUCCESS) {
_ERROR(
"Unable to read the ESRV energy in Joule(s) counter's .decimal suffix counter."
);
}
p->energy_data_multiplier = pow(
10.0,
(double)value
);
//-------------------------------------------------------------------------
// Install signal handler.
//-------------------------------------------------------------------------
#ifdef __PL_WINDOWS__
bret = SetConsoleCtrlHandler(
(PHANDLER_ROUTINE)signal_handler,
TRUE
);
if(bret == 0) {
#endif // __PL_WINDOWS__
#if defined (__PL_LINUX__) || (__PL_SOLARIS__) || (__PL_MACOSX__)
sa.sa_handler = signal_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
ret = sigaction(
SIGINT,
&sa,
NULL
);
if(ret == -1) {
#endif // __PL_LINUX__ || __PL_SOLARIS__ || __PL_MACOSX__
_ERROR("Unable to install the signal handler.");
}
//-------------------------------------------------------------------------
// Read start energy.
//-------------------------------------------------------------------------
plret = pl_read(
p->esrv_pld,
&p->start_energy_data,
(p->channel * ESRV_BASE_COUNTERS_COUNT) + ESRV_COUNTER_ENERGY_JOULES_INDEX
);
if(plret != PL_SUCCESS) {
_ERROR("Unable to read start energy value.");
}
//-------------------------------------------------------------------------
// Run command.
//-------------------------------------------------------------------------
#ifdef __PL_WINDOWS__
p->fp = _popen(
p->command,
"rt"
);
#endif // __PL_WINDOWS__
#if defined (__PL_LINUX__) || (__PL_SOLARIS__) || (__PL_MACOSX__)
p->fp = popen(
p->command,
"r"
);
#endif // __PL_LINUX__ || __PL_SOLARIS__ || __PL_MACOSX__
if(p->fp == NULL) {
_ERROR("Unable to execute command.");
}
//-------------------------------------------------------------------------
// Echo command output to stdout.
// Note:
// With some verbose commands, the extra processing on the output may
// consume extra energy (buffer[strlen(buffer) - 1] = '\0';). Remove
// this cosmetic processing if this becomes an issue.
//-------------------------------------------------------------------------
while(p->f_interrupted == 0) {
pc = fgets(
buffer,
sizeof(buffer),
p->fp
);
if(pc != NULL) {
buffer[strlen(buffer) - 1] = '\0';
puts(buffer);
} else {
break;
}
}
//-------------------------------------------------------------------------
// Read end energy and close ESRV PL.
//-------------------------------------------------------------------------
plret = pl_read(
p->esrv_pld,
&p->end_energy_data,
(p->channel * ESRV_BASE_COUNTERS_COUNT) + ESRV_COUNTER_ENERGY_JOULES_INDEX
);
if(plret != PL_SUCCESS) {
_ERROR("Unable to read end energy value.");
}
plret = pl_close(p->esrv_pld);
if(plret != PL_SUCCESS) {
_ERROR("Unable to close ESRV instance's PL.");
}
//-------------------------------------------------------------------------
// End command.
//-------------------------------------------------------------------------
if(p->f_interrupted == 0) {
if(feof(p->fp)) {
#ifdef __PL_WINDOWS__
_pclose(p->fp);
#endif // __PL_WINDOWS__
#if defined (__PL_LINUX__) || (__PL_SOLARIS__) || (__PL_MACOSX__)
pclose(p->fp);
#endif // __PL_LINUX__ || __PL_SOLARIS__ || __PL_MACOSX__
} else {
_ERROR("Unable to completely read command's output.");
}
}
//-------------------------------------------------------------------------
// Compute energy consumed.
//-------------------------------------------------------------------------
p->consumed_energy_in_joules = (double)(
p->end_energy_data -
p->start_energy_data
) /
p->energy_data_multiplier
;
p->consumed_energy_in_kwhs =
p->consumed_energy_in_joules /
ONE_KWH_IN_JOULES
;
//-------------------------------------------------------------------------
// Report consumed energy.
//-------------------------------------------------------------------------
fprintf(
stdout,
"\nEnergy: [%g] Joule(s) - [%g] kWh(s).\n",
p->consumed_energy_in_joules,
p->consumed_energy_in_kwhs
);
//-------------------------------------------------------------------------
// close the ESRV instance's process and remove its PL
//-------------------------------------------------------------------------
if(
(f_esrv_guid == 1) &&
(f_esrv_pid == 1)
) {
#ifdef __PL_WINDOWS__
esrv_handle = OpenProcess(
PROCESS_TERMINATE,
FALSE,
esrv_pid
);
assert(esrv_handle != NULL);
bret = TerminateProcess(
esrv_handle,
0
);
assert(bret != FALSE);
//---------------------------------------------------------------------
// reset last ESRV instance's flags and ids
//---------------------------------------------------------------------
esrv_handle = NULL;
#endif // __PL_WINDOWS__
#if defined (__PL_LINUX__) || (__PL_SOLARIS__) || (__PL_MACOSX__)
ret = kill(
esrv_pid,
SIGTERM
);
assert(ret != -1);
#endif // __PL_LINUX__ || __PL_SOLARIS__ || __PL_MACOSX__
f_esrv_guid = 0;
f_esrv_pid = 0;
esrv_pid = 0;
//---------------------------------------------------------------------
// close last ESRV instance's output stream
//---------------------------------------------------------------------
#ifdef __PL_WINDOWS__
_pclose(p->fp_esrv);
#endif // __PL_WINDOWS__
#if defined (__PL_LINUX__) || (__PL_SOLARIS__) || (__PL_MACOSX__)
pclose(p->fp_esrv);
#endif // __PL_LINUX__ || __PL_SOLARIS__ || __PL_MACOSX__
//---------------------------------------------------------------------
// Delete ESRV instance's PL.
//---------------------------------------------------------------------
#ifdef __PL_WINDOWS__
pc = _getcwd(
current_path_name,
sizeof(current_path_name)
);
assert(pc != NULL);
ret = _chdir(esrv_pl_path_name);
assert(ret != -1);
file = _findfirst(
"*",
&find_files
);
do {
if(
(
strcmp(
find_files.name,
"."
) != 0
) &&
(
strcmp(
find_files.name,
".."
) != 0
)
) {
ret = -1;
do {
ret = remove(find_files.name);
} while(ret == -1);
}
} while(
_findnext(
file,
&find_files
) == 0);
ret = _findclose(file);
assert(ret != -1);
ret = _chdir(current_path_name);
assert(ret != -1);
ret = -1;
do {
ret = _rmdir(esrv_pl_path_name);
} while(ret == -1);
#endif // __PL_WINDOWS__
#if defined (__PL_LINUX__) || (__PL_SOLARIS__) || (__PL_MACOSX__)
directory = opendir(esrv_pl_path_name);
assert(directory != NULL);
file = readdir(directory);
while(file != NULL) {
if(
(
strcmp(
file->d_name,
"."
) != 0
) &&
(
strcmp(
file->d_name,
".."
) != 0
)
) {
memset(
file_name,
0,
sizeof(file_name)
);
strncat(
file_name,
esrv_pl_path_name,
strlen(esrv_pl_path_name)
);
strncat(
file_name,
"/",
strlen("/")
);
strncat(
file_name,
file->d_name,
strlen(file->d_name)
);
ret = -1;
do {
ret = unlink(file_name);
} while(ret != -1);
}
file = readdir(directory);
}
closedir(directory);
ret = -1;
do {
ret = rmdir(esrv_pl_path_name);
} while(ret != -1);
#endif // __PL_LINUX__ || __PL_SOLARIS__ || __PL_MACOSX__
}
done:
return(PL_SUCCESS);
error:
return(PL_FAILURE);
}
/*-----------------------------------------------------------------------------
Function: parser
Purpose : parse user input to set energy data structure
In : pointer to energy data structure
Out : updated energy data structure
Return : status
History
-------------------------------------------------------------------------------
Date : Author Modification
-------------------------------------------------------------------------------
01/28/2010 Jamel Tayeb Creation.
*/
int parser(PENERGY_DATA p) {
//-------------------------------------------------------------------------
// Parsing variables.
//-------------------------------------------------------------------------
int i = 0;
int j = 0;
int value = 0;
char buffer[PL_MAX_PATH] = { '\0' };
char *options[OPTION_STRINGS_COUNT] = { OPTION_STRINGS };
#ifdef __PL_WINDOWS__
size_t st_ret = 0;
#endif // __PL_WINDOWS__
PL_STATUS ret = PL_FAILURE;
//-------------------------------------------------------------------------
// String to upper case variables.
//-------------------------------------------------------------------------
#if defined (__PL_LINUX__) || (__PL_SOLARIS__) || (__PL_MACOSX__)
size_t k = 0;
size_t l = 0;
char *pc = NULL;
char c = '\0';
#endif // __PL_LINUX__ || __PL_SOLARIS__ || __PL_MACOSX__
assert(p != NULL);
for(i = 1; i < p->argc; i++) {
memset(buffer, 0, sizeof(buffer));
strncpy(buffer, p->argv[i], sizeof(buffer));
#ifdef __PL_WINDOWS__
_strupr(buffer);
#endif // __PL_WINDOWS__
#if defined (__PL_LINUX__) || (__PL_SOLARIS__) || (__PL_MACOSX__)
pc = buffer;
l = strlen(buffer);
for(k = 0; k < l; k++) {
c = *pc;
*pc++ = (char)toupper(c);
}
#endif// __PL_LINUX__ || __PL_SOLARIS__ || __PL_MACOSX__
for(j = 0; j < OPTION_STRINGS_COUNT; j++) {
if(strncmp(buffer, options[j], strlen(options[j])) == 0) {
switch(j) {
//---------------------------------------------------------
// [-H] option.
//---------------------------------------------------------
case H_ID:
case HELP_ID:
fprintf(
stdout,
HELP_STRING,
ENERGY_APPLICATION_NAME,
ENERGY_APPLICATION_NAME,
ENERGY_APPLICATION_NAME,
ENERGY_ESRV_DEFAULT_GUID_SHELL_VARIABLE,
ENERGY_APPLICATION_NAME,
ENERGY_APPLICATION_NAME,
ENERGY_APPLICATION_NAME
);
p->f_help = 1;
goto parser_done;
break;
//---------------------------------------------------------
// [-V] option.
//---------------------------------------------------------
case V_ID:
case VERSION_ID:
p->f_version = 1;
fprintf(
stdout,
"%s: version %s.%s.%s\n",
ENERGY_APPLICATION_NAME,
ENERGY_VERSION_MAJOR,
ENERGY_VERSION_MINOR,
ENERGY_VERSION_REVISION
);
fprintf(
stdout,
"Using PL helper version %s.%s.%s\n",
PL_HELPER_VERSION_MAJOR,
PL_HELPER_VERSION_MINOR,
PL_HELPER_VERSION_REVISION
);
fprintf(
stdout,
"Using PL version %s.%s.%s(%s)",
PL_VERSION_MAJOR,
PL_VERSION_MINOR,
PL_VERSION_REVISION,
PL_VERSION_OS
);
fprintf(stdout, "\n");
goto parser_done;
break;
//---------------------------------------------------------
// [-G <string>] option.
//---------------------------------------------------------
case G_ID:
case GUID_ID:
if(i + 1 >= p->argc) {
ERROR_INDEX(
"Missing argument after token [%s] in position [%d].",
p->argv[i],
i + 1
);
}
p->f_guid = 1;
i++;
p->esrv_guid = p->argv[i];
ret = plh_filter_uuid_string(p->esrv_guid);
if(ret == PL_FAILURE) {
memset(buffer, 0, sizeof(buffer));
sprintf(
buffer,
"Guid [%s] does not seem to be a valig guid.",
p->esrv_guid
);
_ERROR(buffer);
}
goto parser_skip;
break;
//---------------------------------------------------------
// [-X <string>] option.
//---------------------------------------------------------
case X_ID:
case GUID_SHELL_VARIABLE_ID:
if(i + 1 >= p->argc) {
ERROR_INDEX(
"Missing argument after token [%s] in position [%d].",
p->argv[i],
i + 1
);
}
p->f_guid_shell_variable = 1;
i++;
p->esrv_guid_shell_variable = p->argv[i];
p->esrv_guid_shell_variable_value = getenv(p->esrv_guid_shell_variable);
if(p->esrv_guid_shell_variable_value == NULL) {
memset(buffer, 0, sizeof(buffer));
sprintf(
buffer,
"Environment variable [%s] does not exist.",
p->esrv_guid_shell_variable
);
_ERROR(buffer);
} else {
ret = plh_filter_uuid_string(p->esrv_guid_shell_variable_value);
if(ret == PL_FAILURE) {
memset(buffer, 0, sizeof(buffer));
sprintf(
buffer,
"Environment variable [%s] value [%s] does not seem to be a valig guid.",
p->esrv_guid_shell_variable,
p->esrv_guid_shell_variable_value
);
_ERROR(buffer);
}
}
goto parser_skip;
break;
//---------------------------------------------------------
// [-N <integer>] option.
//---------------------------------------------------------
case N_ID:
case CHANNEL_ID:
if(i + 1 >= p->argc) {
ERROR_INDEX(
"Missing argument after token [%s] in position [%d].",
p->argv[i],
i + 1
);
}
i++;
p->channel = (unsigned int)atoi(p->argv[i]);
if(value == 0) {
value = ENERGY_DEFAULT_CHANNEL;
}
p->f_channel = 1;
goto parser_skip;
break;
//---------------------------------------------------------
// [-E <string>] option.
//---------------------------------------------------------
case E_ID:
case ESRV_OPTIONS_ID:
if(i + 1 >= p->argc) {
ERROR_INDEX(
"Missing argument after token [%s] in position [%d].",
p->argv[i],
i + 1
);
}
p->f_esrv_options = 1;
i++;
p->esrv_options = p->argv[i];
goto parser_skip;
break;
//---------------------------------------------------------
// -- separator id.
//---------------------------------------------------------
case SEPARATOR_ID:
if(i + 1 >= p->argc) {
ERROR_INDEX(
"Missing argument after token [%s] in position [%d].",
p->argv[i],
i + 1
);
}
i++;
memset(p->command, 0, sizeof(p->command));
strncpy(p->command, p->argv[i], strlen(p->argv[i]));
while(++i < p->argc) {
strncat(p->command, " ", strlen(" "));
strncat(p->command, p->argv[i], strlen(p->argv[i]));
}
p->f_command = 1;
goto parser_done;
break;
//---------------------------------------------------------
// Unknown option.
//---------------------------------------------------------
default:
ERROR_INDEX(
"Unable to make sense of token [%s] in position [%d].",
buffer,
j
);
}
}
} // for j
_ERROR("Unable to make sense of options. Use --help option for help.");
goto error;
parser_skip:
;
} // for i
parser_done:
//-------------------------------------------------------------------------
// Return status.
//-------------------------------------------------------------------------
return(PL_SUCCESS);
error:
return(PL_FAILURE);
}
