long CNumberEdit::GetNumber()
{
CString csText;
GetWindowText(csText);
return ATOL(csText);
}
/*
* -------------------------------------------------------------
* Load the child environment into parameter structure
* -------------------------------------------------------------
*/
void ojgetch_env(job_params_type *jparms)
{
/*
* Pass all information about the job via shell's environment
* The child will get those variables to obtain the info about the job.
*/
jparms->gbldir.addr = GETENV(GBLDIR_ENV);
if (jparms->gbldir.addr)
jparms->gbldir.len = STRLEN(jparms->gbldir.addr);
else
jparms->gbldir.len = 0;
jparms->input.addr = GETENV(IN_FILE_ENV);
if (jparms->input.addr)
jparms->input.len = STRLEN(jparms->input.addr);
else
jparms->input.len = 0;
jparms->output.addr = GETENV(OUT_FILE_ENV);
if (jparms->output.addr)
jparms->output.len = STRLEN(jparms->output.addr);
else
jparms->output.len = 0;
jparms->error.addr = GETENV(ERR_FILE_ENV);
if (jparms->error.addr)
jparms->error.len = STRLEN(jparms->error.addr);
else
jparms->error.len = 0;
jparms->routine.addr = GETENV(ROUTINE_ENV);
if (jparms->routine.addr)
jparms->routine.len = STRLEN(jparms->routine.addr);
else
jparms->routine.len = 0;
jparms->label.addr = GETENV(LABEL_ENV);
if (jparms->label.addr)
jparms->label.len = STRLEN(jparms->label.addr);
else
jparms->label.len = 0;
jparms->directory.addr = GETENV(CWD_ENV);
if (jparms->directory.addr)
jparms->directory.len = STRLEN(jparms->directory.addr);
else
jparms->directory.len = 0;
jparms->offset = (int)(ATOL(GETENV(OFFSET_ENV)));
}
bool ResourceBuffer::GetInt64(int64& o_nValue)
{
while (m_nCol < m_vecCol.size())
{
if (m_vecFlags[m_nCol++])
{
o_nValue = ATOL(m_vecCol[m_nCol - 1].c_str());
return true;
}
}
printf("[ERROR]:GetInt64 fail!\n");
return false;
}
bool ResourceBuffer::GetUInt32(uint32& o_nValue)
{
while (m_nCol < m_vecCol.size())
{
if (m_vecFlags[m_nCol++])
{
o_nValue = static_cast<uint32>(ATOL(m_vecCol[m_nCol - 1].c_str()));
return true;
}
}
printf("[ERROR]:GetUInt32 fail!\n");
return false;
}
// Get an unsigned numeric value. Return ERROR_INVALID_DATA if value isn't
// numeric.
NET_API_STATUS
NetpGetConfigDword(
IN LPNET_CONFIG_HANDLE ConfigHandle,
IN LPTSTR KeyWanted,
IN DWORD DefaultValue,
OUT LPDWORD ValueBuffer
)
/*++
Routine Description:
This function gets the keyword value from the configuration file.
This value is converted from a string to a DWORD (unsigned).
Arguments:
SectionPointer - Supplies the pointer to a specific section in the config
file.
KeyWanted - Supplies the string of the keyword within the specified
section to look for.
DefaultValue - Gives a default value to use if KeyWanted isn't present
in the section or if KeyWanted exists but no value is in the config
data.
ValueBuffer - Returns the numeric value of the keyword.
Return Value:
NET_API_STATUS - NERR_Success, ERROR_INVALID_DATA (if string wasn't a
valid unsigned number), or other error code.
--*/
{
NET_API_STATUS ApiStatus;
DWORD CharCount; // Count of TCHARs, not including null.
DWORD TempDword = DefaultValue;
LPTSTR ValueString;
//
// Error check the caller somewhat.
//
if (ValueBuffer == NULL) {
return (ERROR_INVALID_PARAMETER);
}
//
// Check for GP fault and set default value.
//
*ValueBuffer = DefaultValue;
if (ConfigHandle == NULL) {
return (ERROR_INVALID_PARAMETER);
}
#if defined(USE_WIN32_CONFIG)
{
DWORD dwType;
LONG Error;
NET_CONFIG_HANDLE * MyHandle = ConfigHandle; // conv from opaque type
DWORD ValueLength;
// Find out what max value length is.
ApiStatus = NetpGetConfigMaxSizes (
MyHandle,
NULL, // Don't need max keyword size.
& ValueLength); // Get max value length.
NetpAssert( ApiStatus == NO_ERROR ); // BUGBUG
// Handle empty section.
if (ValueLength == 0 ) {
return (NO_ERROR); // Default already set, so we're done. Ok!
}
// Alloc space for the value.
ValueString = NetpMemoryAllocate( ValueLength );
if (ValueString == NULL) {
return (ERROR_NOT_ENOUGH_MEMORY);
}
// Get the actual value.
Error = RegQueryValueEx (
MyHandle->WinRegKey,
KeyWanted,
NULL, // reserved
& dwType,
(LPVOID) ValueString, // out: value string (TCHARs).
& ValueLength
);
IF_DEBUG(CONFIG) {
NetpKdPrint(( PREFIX_NETLIB "NetpGetConfigDword: RegQueryValueEx("
FORMAT_LPTSTR ") returned " FORMAT_LONG ".\n",
KeyWanted, Error ));
}
if (Error == ERROR_FILE_NOT_FOUND) {
NetpMemoryFree( ValueString );
return (NO_ERROR); // Default already set, so we're done. Ok!
} else if ( Error != ERROR_SUCCESS ) {
NetpMemoryFree( ValueString );
return (Error);
}
NetpAssert( ValueString != NULL );
if (dwType == REG_SZ) {
goto ParseString; // Type is good, go parse the string.
} else if (dwType == REG_DWORD) {
NetpAssert( ValueLength == sizeof(DWORD) );
TempDword = * (LPDWORD) (LPVOID) ValueString;
goto GotValue;
} else {
NetpMemoryFree( ValueString );
IF_DEBUG(CONFIG) {
NetpKdPrint(( PREFIX_NETLIB
"NetpGetConfigDword: read unexpected reg type "
FORMAT_DWORD ".\n", dwType ));
}
return (ERROR_INVALID_DATA);
}
}
#else // ndef USE_WIN32_CONFIG
//
// Get a copy of the string from the config data.
//
ApiStatus = NetpGetConfigValue(
ConfigHandle,
KeyWanted,
& ValueString ); // Must be freed by NetApiBufferFree().
if (ApiStatus != NO_ERROR) {
//
// If KeyWanted isn't in config data, return default (and NO_ERROR).
//
if (ApiStatus == NERR_CfgParamNotFound) {
NetpAssert( *ValueBuffer == DefaultValue ); // Already set.
ApiStatus = NO_ERROR;
}
return (ApiStatus);
}
#endif
NetpAssert( ValueString != NULL );
ParseString:
//
// Do some error checking on the value string.
//
CharCount = STRLEN( ValueString );
if ( CharCount == 0 ) {
//
// If "key=" line exists (but no value), return default and say
// NO_ERROR.
//
ApiStatus = NO_ERROR;
} else if ( _wcsnicmp( ValueString, L"0x", 2 ) == 0 ) {
LPWSTR end;
TempDword = wcstoul( ValueString, &end, 16 );
if ( end - ValueString == (ptrdiff_t) CharCount ) {
ApiStatus = NO_ERROR;
} else {
NetpKdPrint(( PREFIX_NETLIB
"NetpGetConfigDword: invalid string for keyword "
FORMAT_LPTSTR " is '" FORMAT_LPTSTR "'...\n",
KeyWanted, ValueString ));
ApiStatus = ERROR_INVALID_DATA;
}
} else if ( STRSPN( ValueString, TEXT("0123456789") ) != CharCount ) {
NetpKdPrint(( PREFIX_NETLIB
"NetpGetConfigDword: invalid string for keyword "
FORMAT_LPTSTR " is '" FORMAT_LPTSTR "'...\n",
KeyWanted, ValueString ));
ApiStatus = ERROR_INVALID_DATA;
} else {
//
// Convert the string to a numeric value.
//
TempDword = (DWORD) ATOL( ValueString );
ApiStatus = NO_ERROR;
}
IF_DEBUG(CONFIG) {
NetpKdPrint(( PREFIX_NETLIB "NetpGetConfigDword: string for "
FORMAT_LPTSTR " is '" FORMAT_LPTSTR "'...\n",
KeyWanted, ValueString));
}
GotValue:
IF_DEBUG(CONFIG) {
NetpKdPrint(( PREFIX_NETLIB "NetpGetConfigDword: numeric value is "
FORMAT_DWORD ",\n", TempDword ));
NetpKdPrint((" returning ApiStatus " FORMAT_API_STATUS ".\n",
ApiStatus ));
}
(void) NetApiBufferFree( ValueString );
//
// Tell caller how things went.
//
* ValueBuffer = TempDword;
return (ApiStatus);
}
/*
* ------------------------------------------------
* Get parameters from environment variables into
* parameter structure
* ------------------------------------------------
*/
void ojchildparms(job_params_type *jparms, gcall_args *g_args, mval *arglst)
{
char *sp, *parmbuf;
char parm_string[8];
int4 argcnt, i;
error_def(ERR_STRINGOFLOW);
/* getenv() may use static buffer so for any parms we fetch a value for, rebuffer them so they
don't go away. We use malloc'd space because the stringpool garbage collector does not know
about these private (to this routine) structures and we can't use "temp stringpool space" as
is used in other modules since we will be putting the parms in the stringpool below. The
storage allocated here will be released in jobchild_init() when it is done with it.
*/
if (jparms->directory.addr = GETENV(CWD_ENV))
{
jparms->directory.len = STRLEN(jparms->directory.addr);
if (0 != jparms->directory.len)
{
parmbuf = malloc(jparms->directory.len+1);
memcpy(parmbuf, jparms->directory.addr, jparms->directory.len+1);
jparms->directory.addr = parmbuf;
}
} else
jparms->directory.len = 0;
if (jparms->gbldir.addr = GETENV(GBLDIR_ENV))
{
jparms->gbldir.len = STRLEN(jparms->gbldir.addr);
if (0 != jparms->gbldir.len)
{
parmbuf = malloc(jparms->gbldir.len+1);
memcpy(parmbuf, jparms->gbldir.addr, jparms->gbldir.len+1);
jparms->gbldir.addr = parmbuf;
}
} else
jparms->gbldir.len = 0;
if (jparms->startup.addr = GETENV(STARTUP_ENV))
{
jparms->startup.len = STRLEN(jparms->startup.addr);
if (0 != jparms->startup.len)
{
parmbuf = malloc(jparms->startup.len+1);
memcpy(parmbuf, jparms->startup.addr, jparms->startup.len+1);
jparms->startup.addr = parmbuf;
}
} else
jparms->startup.len = 0;
if (jparms->input.addr = GETENV(IN_FILE_ENV))
{
jparms->input.len = STRLEN(jparms->input.addr);
if (0 != jparms->input.len)
{
parmbuf = malloc(jparms->input.len+1);
memcpy(parmbuf, jparms->input.addr, jparms->input.len+1);
jparms->input.addr = parmbuf;
}
} else
jparms->input.len = 0;
if (jparms->output.addr = GETENV(OUT_FILE_ENV))
{
jparms->output.len = STRLEN(jparms->output.addr);
if (0 != jparms->output.len)
{
parmbuf = malloc(jparms->output.len+1);
memcpy(parmbuf, jparms->output.addr, jparms->output.len+1);
jparms->output.addr = parmbuf;
}
} else
jparms->output.len = 0;
if (jparms->error.addr = GETENV(ERR_FILE_ENV))
{
jparms->error.len = STRLEN(jparms->error.addr);
if (0 != jparms->error.len)
{
parmbuf = malloc(jparms->error.len+1);
memcpy(parmbuf, jparms->error.addr, jparms->error.len+1);
jparms->error.addr = parmbuf;
}
} else
jparms->error.len = 0;
if (jparms->routine.addr = GETENV(ROUTINE_ENV))
{
jparms->routine.len = STRLEN(jparms->routine.addr);
if (0 != jparms->routine.len)
{
parmbuf = malloc(jparms->routine.len+1);
memcpy(parmbuf, jparms->routine.addr, jparms->routine.len+1);
jparms->routine.addr = parmbuf;
}
} else
jparms->routine.len = 0;
if (jparms->label.addr = GETENV(LABEL_ENV))
{
jparms->label.len = STRLEN(jparms->label.addr);
if (0 != jparms->label.len)
{
parmbuf = malloc(jparms->label.len+1);
memcpy(parmbuf, jparms->label.addr, jparms->label.len+1);
jparms->label.addr = parmbuf;
}
} else
jparms->label.len = 0;
if (jparms->logfile.addr = GETENV(LOG_FILE_ENV))
{
jparms->logfile.len = STRLEN(jparms->logfile.addr);
if (0 != jparms->logfile.len)
{
parmbuf = malloc(jparms->logfile.len+1);
memcpy(parmbuf, jparms->logfile.addr, jparms->logfile.len+1);
jparms->logfile.addr = parmbuf;
}
} else
jparms->logfile.len = 0;
if (sp = GETENV(OFFSET_ENV))
jparms->offset = (int)(ATOL(sp));
else
jparms->offset = 0;
if (sp = GETENV(PRIORITY_ENV))
jparms->baspri = (int)(ATOL(sp));
else
jparms->baspri = 0;
if (!(sp = GETENV(GTMJCNT_ENV)))
GTMASSERT;
if (argcnt = (int)(ATOL(sp)))
{
ENSURE_STP_FREE_SPACE(argcnt * MAX_TRANS_NAME_LEN);
g_args->callargs = argcnt + 4;
g_args->truth = 1;
g_args->retval = 0;
g_args->mask = 0;
g_args->argcnt = argcnt;
memcpy(parm_string,"gtmj000",8);
for (i = 0; i < argcnt; i++)
{
if (sp = GETENV(parm_string))
{
if (!IS_STP_SPACE_AVAILABLE_PRO(STRLEN(sp)))
rts_error(VARLSTCNT(1) (ERR_STRINGOFLOW));
arglst[i].str.len = STRLEN(sp);
arglst[i].str.addr = (char *)stringpool.free;
memcpy(stringpool.free, sp, arglst[i].str.len);
stringpool.free += arglst[i].str.len;
arglst[i].mvtype = MV_STR;
} else
op_nullexp(&arglst[i]);
g_args->argval[i] = &arglst[i];
if (parm_string[6] == '9')
{
if (parm_string[5] == '9')
{
parm_string[4] = parm_string[4] + 1;
parm_string[5] = '0';
} else
parm_string[5] = parm_string[5] + 1;
parm_string[6] = '0';
} else
parm_string[6] = parm_string[6] + 1;
}
} else
g_args->callargs = 0;
}
