__int64 strtoll(
const char *nptr,
char **endptr,
int base)
{
return _strtoi64(nptr, endptr, base);
}
vint64_t atoi64_test(const AString& string, bool& success)
{
char* endptr = 0;
vint64_t result = _strtoi64(string.Buffer(), &endptr, 10);
success = endptr == string.Buffer() + string.Length() && i64toa(result) == string;
return result;
}
/*
* Parse string as int64
* valid range: -9223372036854775808 ~ 9223372036854775807
*/
bool
parse_int64(const char *value, int64 *result)
{
int64 val;
char *endptr;
if (strcmp(value, INFINITE_STR) == 0)
{
*result = LLONG_MAX;
return true;
}
errno = 0;
#ifdef WIN32
val = _strtoi64(value, &endptr, 0);
#elif defined(HAVE_LONG_INT_64)
val = strtol(value, &endptr, 0);
#elif defined(HAVE_LONG_LONG_INT_64)
val = strtoll(value, &endptr, 0);
#else
val = strtol(value, &endptr, 0);
#endif
if (endptr == value || *endptr)
return false;
if (errno == ERANGE)
return false;
*result = val;
return true;
}
AREXPORT bool ArArgumentBuilder::isArgLongLongInt(size_t whichArg) const
{
const char *str;
long long int ret;
char *endPtr;
if (whichArg > myArgc || getArg(whichArg) == NULL)
return false;
int base = 10;
str = getArg(whichArg);
// see if its a hex number
if (strlen(str) > 2 && str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
{
str = &str[2];
base = 16;
}
#ifndef _MSC_VER
ret = strtoll(str, &endPtr, base);
#else
ret = _strtoi64(str, &endPtr, base);
#endif
if (endPtr[0] == '\0' && endPtr != str)
return true;
else
return false;
}
long long int strtoll(const char *nptr, char **endptr, int base) {
#ifdef WIN32
return _strtoi64(nptr, endptr, base);
#else
return strtol(nptr, endptr, base);
#endif
}
void tool_lookup(const vdfastvector<const char *>& args, const vdfastvector<const char *>& switches, bool amd64) {
if (args.size() < 2)
help_lookup();
char *s;
sint64 addr = _strtoi64(args[1], &s, 16);
if (*s)
fail("lookup: invalid address \"%s\"", args[0]);
vdautoptr<IVDSymbolSource> pss(VDCreateSymbolSourceLinkMap());
pss->Init(VDTextAToW(args[0]).c_str());
const VDSymbol *sym = pss->LookupSymbol(addr);
if (!sym)
fail("symbol not found for address %08x", addr);
const char *fn;
int line;
if (pss->LookupLine(addr, fn, line))
printf("%08I64x %s + %x [%s:%d]\n", addr, sym->name, addr-sym->rva, fn, line);
else
printf("%08I64x %s + %x\n", addr, sym->name, addr-sym->rva);
}
static long long str_to_int(const char* str) {
#ifdef _MSC_VER
return _strtoi64(str, nullptr, 10);
#else
return std::strtoll(str, nullptr, 10);
#endif
}
inline T str2number(const char *str, int base, bool safe)
{
int errno_bak=errno;
errno=0;
char *endptr;
// _strtoi64 is available in Visual Studio, but not yet in MINGW
#ifdef _MSC_VER
const __int64 val=_strtoi64(str, &endptr, base);
#else
const long long val=strtoll(str, &endptr, base);
#endif
if(safe)
{
CHECK_RETURN(0==errno);
errno=errno_bak;
CHECK_RETURN(endptr!=str);
if(std::numeric_limits<T>::min()==0)
{
// unsigned
CHECK_RETURN(val>=0);
CHECK_RETURN(
(unsigned long long)(T)val<=
(unsigned long long)std::numeric_limits<T>::max());
}
else
{
// signed
CHECK_RETURN(val<=(long long)std::numeric_limits<T>::max());
CHECK_RETURN(val>=(long long)std::numeric_limits<T>::min());
}
}
return (T)val;
}
ev_int64_t
evutil_strtoll(const char *s, char **endptr, int base)
{
#ifdef HAVE_STRTOLL
return (ev_int64_t)strtoll(s, endptr, base);
#elif SIZEOF_LONG == 8
return (ev_int64_t)strtol(s, endptr, base);
#elif defined(WIN32) && defined(_MSC_VER) && _MSC_VER < 1300
/* XXXX on old versions of MS APIs, we only support base
* 10. */
ev_int64_t r;
if (base != 10)
return 0;
r = (ev_int64_t) _atoi64(s);
while (isspace(*s))
++s;
while (isdigit(*s))
++s;
if (endptr)
*endptr = (char*) s;
return r;
#elif defined(WIN32)
return (ev_int64_t) _strtoi64(s, endptr, base);
#else
#error "I don't know how to parse 64-bit integers."
#endif
}
// Presence/absense of strtoll and strtoull depends on the compiler rather than the target environment. For instance, MinGW
// has strtoll and strtoull and lacks _strtoi64 and _strtoui64 even though both MinGW and MVC are targeting a Windows
// environment.
SAWYER_EXPORT boost::int64_t
strtoll(const char *input, char **rest, int base) {
#ifdef _MSC_VER
return _strtoi64(input, rest, base);
#else
return ::strtoll(input, rest, base);
#endif
}
/** The basic conversion operators */
VerySimpleReadOnlyString::operator int64() const
{
#ifdef _MSC_VER
return (int64)_strtoi64(data, NULL, 10);
#else
return (int64)strtoll(data, NULL, 10);
#endif
}
static inline long long hexStrTo64(const char *s)
throw()
{
#ifdef __WINDOWS__
return (long long)_strtoi64(s,(char **)0,16);
#else
return strtoll(s,(char **)0,16);
#endif
}
int64_t
VmKdcStringToLA(
PCSTR nptr,
PSTR* endptr,
int base
)
{
return _strtoi64( nptr, endptr, base );
}
bool to_int64(char const * s, int64_t & i)
{
char * stop;
#ifdef OMIM_OS_WINDOWS_NATIVE
i = _strtoi64(s, &stop, 10);
#else
i = strtoll(s, &stop, 10);
#endif
return *stop == 0 && s != stop;
}
time_t utils::time::from_string(const std::string &data)
{
long long timestamp = _strtoi64(data.c_str(), NULL, 10);
// If it is milli timestamp
if (timestamp > 100000000000)
timestamp /= 1000;
// If conversion fails, use local time?
//if (!timestamp)
// timestamp = ::time(NULL);
return (time_t)timestamp;
}
static bool parse_integer(const char * str, T& val)
{
char * p;
long long ll;
#ifdef WIN32
ll = _strtoi64(str, &p, 10);
#else
ll = strtol(str, &p, 10);
#endif
if (p == str || (*p && ! isspace((unsigned char)*p)))
return false;
val = static_cast<T>(ll);
return true;
}
DWORD_PTR TreeImportExport::ConvertStringToDwordPtr(const char * strValue)
{
DWORD_PTR result = 0;
if (strValue)
{
#ifdef _WIN64
result = _strtoi64(strValue, NULL, 16);
#else
result = strtoul(strValue, NULL, 16);
#endif
}
return result;
}
Int64
strToInt64(const char* s, char** endptr, int base)
{
#if defined(_WIN32)
# ifdef __MINGW32__
return strToInt64Impl(s, endptr, base);
# else
return _strtoi64(s, endptr, base);
# endif
#elif defined(ICE_64)
return strtol(s, endptr, base);
#elif defined(__hpux)
return __strtoll(s, endptr, base);
#else
return strtoll(s, endptr, base);
#endif
}
static longlong my_atoll(const char *number, const char *end, int *error)
{
char buffer[255];
longlong llval= 0;
size_t i;
*error= 0;
/* set error at the following conditions:
- string contains invalid character(s)
- length > 254
- strtoll returns invalid range
*/
memcpy(buffer, number, MIN((uint)(end - number), 254));
buffer[(uint)(end - number)]= 0;
errno= 0;
#ifdef _MSC_VER
llval = _strtoi64(buffer, NULL, 10);
#else
llval= strtoll(buffer, NULL, 10);
#endif
/* check size */
if ((uint)(end - number) > 254)
{
*error= 1;
return llval;
}
/* check characters */
for (i=0; i < strlen(buffer); i++)
{
if ((buffer[i] < '0' || buffer[i] > '9') && !isspace(buffer[i]))
{
*error= 1;
return llval;
}
}
/* check strtoll result */
if (errno == ERANGE)
*error= errno;
return llval;
}
static bool HexToFloat64(const TArgInfo &info){
const TString1D &tmp = info.m_arg;
size_t n = tmp.size();
if(n){
for(size_t i=0 ; i!=n ; ++i){
uint64 x = _strtoi64(tmp[i].c_str(),NULL,16);
if(0<i){
printf(" ");
}
//printf("[%016I64x]", x);
printf("%f", *(double*)&x);
}
//printf("\n");
}
if(n==0){
return false;
}
return true;
}
int luaU_str2oid(lua_State* L)
{
const char *s1 = luaL_checkstring(L, 1);
char *s2;
double n;
UINT64 value;
n = strtod(s1, &s2);
if (s1 != s2) { /* at least one valid digit? */
while (isspace((unsigned char)(*s2))) s2++; /* skip trailing spaces */
if (*s2 == '\0') { /* no invalid trailing characters? */
value = _strtoi64(s1, &s2, 10);
memcpy(&n, &value, sizeof(UINT64));
lua_pushnumber(L, (lua_Number)n);
return 1;
}
}
lua_pushnil(L); /* else not a number */
return 1;
}
AREXPORT int ArArgumentBuilder::getArgLongLongInt(size_t whichArg,
bool *ok) const
{
bool isSuccess = false;
long long ret = 0;
const char *str = getArg(whichArg);
// If the specified arg was successfully obtained...
if (str != NULL) {
int base = 10;
// see if its a hex number
if (strlen(str) > 2 && str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
{
str = &str[2];
base = 16;
}
char *endPtr = NULL;
#ifndef _MSC_VER
ret = strtoll(str, &endPtr, base);
#else
ret = _strtoi64(str, &endPtr, base);
#endif
if (endPtr[0] == '\0' && endPtr != str) {
isSuccess = true;
}
} // end if valid arg
if (ok != NULL) {
*ok = isSuccess;
}
if (isSuccess)
return ret;
else
return 0;
} // end method getArgInt
Bool
StrUtil_StrToInt64(int64 *out, // OUT: The output value
const char *str) // IN : String to parse
{
char *ptr;
ASSERT(out);
ASSERT(str);
errno = 0;
#if defined(_WIN32)
*out = _strtoi64(str, &ptr, 0);
#elif defined(__FreeBSD__)
*out = strtoq(str, &ptr, 0);
#else
*out = strtoll(str, &ptr, 0);
#endif
return ptr[0] == '\0' && errno != ERANGE;
}
int64_t TRI_Int64String (char const* str) {
int64_t result;
char* endptr;
#if defined(TRI_HAVE_STRTOLL_R)
struct reent buffer;
#elif defined(TRI_HAVE__STRTOLL_R)
struct reent buffer;
#endif
TRI_set_errno(TRI_ERROR_NO_ERROR);
#if defined(TRI_HAVE_STRTOLL_R)
result = strtoll_r(&buffer, str, &endptr, 10);
#elif defined(TRI_HAVE__STRTOLL_R)
result = _strtoll_r(&buffer, str, &endptr, 10);
#elif defined(TRI_HAVE_STRTOI64)
result = _strtoi64(str, &endptr, 10);
#elif defined(TRI_HAVE_STRTOLL)
result = strtoll(str, &endptr, 10);
#else
#warning cannot convert string to int64
#endif
while (isspace(*endptr)) {
++endptr;
}
if (*endptr != '\0') {
TRI_set_errno(TRI_ERROR_ILLEGAL_NUMBER);
}
if (errno == ERANGE && (result == INT64_MIN || result == INT64_MAX)) {
TRI_set_errno(TRI_ERROR_NUMERIC_OVERFLOW);
}
return result;
}
long long
strtonum(const char *numstr, long long minval, long long maxval,
const char **errstrp)
{
long long ll = 0;
char *ep;
int error = 0;
struct errval {
const char *errstr;
int err;
} ev[4] = {
{ NULL, 0 },
{ "invalid", EINVAL },
{ "too small", ERANGE },
{ "too large", ERANGE },
};
ev[0].err = errno;
errno = 0;
if (minval > maxval)
error = INVALID;
else {
ll = _strtoi64(numstr, &ep, 10);
if (numstr == ep || *ep != '\0')
error = INVALID;
else if ((ll == LLONG_MIN && errno == ERANGE) || ll < minval)
error = TOOSMALL;
else if ((ll == LLONG_MAX && errno == ERANGE) || ll > maxval)
error = TOOLARGE;
}
if (errstrp != NULL)
*errstrp = ev[error].errstr;
errno = ev[error].err;
if (error)
ll = 0;
return (ll);
}
static bool ConvertNumber(const TArgInfo &info, int dst, int src){
const TString1D &tmp = info.m_arg;
size_t n = tmp.size();
if(n){
char buf[256];
for(size_t i=0 ; i!=n ; ++i){
uint64 x = _strtoi64(tmp[i].c_str(),NULL,src);
if(0<i){
printf(" ");
}
_ui64toa_s(x,buf,sizeof(buf),dst);
if(dst==16){
printf("0x");
}
printf("%s",buf);
}
//printf("\n");
}
if(n==0){
return false;
}
return true;
}
long long parseLL( const char *n ) {
long long ret;
uassert( 13307, "cannot convert empty string to long long", *n != 0 );
#if !defined(_WIN32)
char *endPtr = 0;
errno = 0;
ret = strtoll( n, &endPtr, 10 );
uassert( 13305, "could not convert string to long long", *endPtr == 0 && errno == 0 );
#elif _MSC_VER>=1600 // 1600 is VS2k10 1500 is VS2k8
size_t endLen = 0;
try {
ret = stoll( n, &endLen, 10 );
}
catch ( ... ) {
endLen = 0;
}
uassert( 13306, "could not convert string to long long", endLen != 0 && n[ endLen ] == 0 );
#else // stoll() wasn't introduced until VS 2010.
char* endPtr = 0;
ret = _strtoi64( n, &endPtr, 10 );
uassert( 13310, "could not convert string to long long", (*endPtr == 0) && (ret != _I64_MAX) && (ret != _I64_MIN) );
#endif // !defined(_WIN32)
return ret;
}
//////////
//
// Function: VAL()
// Returns a numeric or currency value from a expression.
//
//////
// Version 0.58
// Last update:
// Mar.22.2015
//////
// Change log:
// Mar.21.2015 - Initial creation by Stefano D'Amico
//////
// Parameters:
// varExpr -- Any, to convert
// varIgnoreList -- Characters to ignore
//
//////
// Returns:
// Numeric -- VAL( ) returns the numbers in the character expression from left to right until a non-numeric character is encountered.
// Leading blanks are ignored.
// VAL( ) returns 0 if the first character of the character expression is not a number, a dollar sign ($), a plus sign (+), or minus sign (-).
//////
void function_val(SReturnsParams* rpar)
{
SVariable* varExpr = rpar->ip[0];
SVariable* varIgnoreChars = rpar->ip[1];
s8 c, cCurrency, cPoint, cSeparator;
s32 lnI, lnJ, lnBuffOffset;
s64 lnValue;
f64 lfValue;
bool llAsInteger, llStillGoing, llCurrency;
SVariable* varCurrency;
SVariable* varPoint;
SVariable* varSeparator;
SVariable* result;
u32 errorNum;
bool error;
s8 buffer[64];
//////////
// Parameter 1 must be valid
//////
rpar->rp[0] = NULL;
if (!iVariable_isValid(varExpr))
{
iError_report_byNumber(_ERROR_P1_IS_INCORRECT, iVariable_get_relatedComp(varExpr), false);
return;
}
//////////
// If numeric, copy whatever's already there
//////
if (varExpr->varType >= _VAR_TYPE_NUMERIC_START && varExpr->varType <= _VAR_TYPE_NUMERIC_END)
{
// Copy The existing variable
result = iVariable_copy(varExpr, false);
if (!result)
iError_report_byNumber(_ERROR_INTERNAL_ERROR, iVariable_get_relatedComp(varExpr), false);
// Success or failure, return our result
rpar->rp[0] = result;
return;
}
//////////
// Determine what we're evaluating
//////
switch (varExpr->varType)
{
case _VAR_TYPE_NULL:
iError_report_byNumber(_ERROR_P1_IS_INCORRECT, iVariable_get_relatedComp(varExpr), false);
return;
break;
case _VAR_TYPE_LOGICAL: // 0=.F., 1=.T.
case _VAR_TYPE_DATE: // YYYYMMDD
result = iVariable_create(_VAR_TYPE_S32, NULL, true);
if (result)
{
// Populate the s32
*result->value.data_s32 = iiVariable_getAs_s32(varExpr, true, &error, &errorNum);
if (error)
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varExpr), false);
}
break;
case _VAR_TYPE_DATETIME:
// YYYYMMDDHhMmSsMss as s64
case _VAR_TYPE_DATETIMEX:
// YYYYMMDDHhMmSsNssssssss
result = iVariable_create(_VAR_TYPE_S64, NULL, true);
if (result)
{
// Populate the s64
*result->value.data_s64 = iiVariable_getAs_s64(varExpr, true, &error, &errorNum);
if (error)
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varExpr), false);
}
break;
case _VAR_TYPE_CHARACTER:
//////////
// If present, parameter 2 must be valid
//////
if (varIgnoreChars)
{
if (!iVariable_isValid(varIgnoreChars) || !iVariable_isTypeCharacter(varIgnoreChars))
{
iError_report_byNumber(_ERROR_P2_IS_INCORRECT, iVariable_get_relatedComp(varIgnoreChars), false);
return;
}
}
//////////
// Prepare our characters
//////
varCurrency = propGet_settings_Currency(_settings);
varPoint = propGet_settings_Point(_settings);
varSeparator = propGet_settings_Separator(_settings);
if (!varCurrency || !varPoint || !varSeparator)
{
// Should never happen
iError_report_byNumber(_ERROR_INTERNAL_ERROR, NULL, false);
return;
}
//////////
// Create single characters
//////
cCurrency = varCurrency->value.data_s8[0];
cPoint = varPoint->value.data_s8[0];
cSeparator = varSeparator->value.data_s8[0];
//////////
// Iterate through each character
//////
for (lnI = 0, lnBuffOffset = 0, llStillGoing = true, llCurrency = false; llStillGoing && lnI < (s32)varExpr->value.length && lnBuffOffset < (s32)sizeof(buffer) - 1; lnI++)
{
//////////
// Grab this character
//////
c = varExpr->value.data[lnI];
//////////
// Is it a character we're including in our buffer (a number, or natural number-related symbol)?
//////
if ((c >= '0' && c <= '9' ) || c == '+' || c == '-' || c == cPoint)
{
// Yes, Copy this character
buffer[lnBuffOffset++] = c;
} else {
// Are we still in a valid sequence of characters to skip?
if (c == ' ' || c == cSeparator)
{
// It's a character we're skipping naturally (space, separator symbol)
// We don't do anything here ... it's just more clear to keep this logic visible rather than inverting it. :-)
} else if (c == cCurrency) {
// We encountered the currency symbol, so the output will be currency
llCurrency = true;
} else if (varIgnoreChars) {
// We won't continue unless we're sitting on a character in the varIgnoreChars
for (lnJ = 0, llStillGoing = false; lnJ < varIgnoreChars->value.length; lnJ++)
{
// Is this one of our skip characters?
if (c == varIgnoreChars->value.data_s8[lnJ])
{
llStillGoing = true;
break;
}
}
} else {
// We're done
break;
}
}
}
// NULL terminate
buffer[lnBuffOffset] = 0;
//////////
// Convert to f64, and s64
//////
lfValue = atof(buffer);
#if defined(__GNUC__) || defined(__solaris__)
lnValue = strtoll(buffer, NULL, 10);
#else
lnValue = _strtoi64(buffer, NULL, 10);
#endif
//////////
// Is currency or not? If it's an integer value, store it as the same, otherwise use floating point
//////
if ((f64)lnValue == lfValue)
{
// We can return as an integer
llAsInteger = true;
if (llCurrency)
{
// Multiply by 10000 to obtain the 4 implied decimal places
lnValue = lnValue * 10000;
result = iVariable_create(_VAR_TYPE_CURRENCY, NULL, true);
} else {
if (lnValue < (s64)_s32_max)
{
// We can create as an s32
result = iVariable_create(_VAR_TYPE_S32, NULL, true);
} else {
// Create as an s64
result = iVariable_create(_VAR_TYPE_S64, NULL, true);
}
}
} else {
// Must return as f64
llAsInteger = false;
if (llCurrency)
{
// As currency
lfValue *= 10000.0;
result = iVariable_create(_VAR_TYPE_CURRENCY, NULL, true);
} else {
// As is
result = iVariable_create(_VAR_TYPE_F64, NULL, true);
}
}
//////////
// Store the result
//////
if (result)
{
if (llAsInteger) iVariable_setNumeric_toNumericType(result, NULL, NULL, NULL, NULL, &lnValue, NULL);
else iVariable_setNumeric_toNumericType(result, NULL, &lfValue, NULL, NULL, NULL, NULL);
}
break;
default:
// Unrecognized type
iError_report_byNumber(_ERROR_FEATURE_NOT_AVAILABLE, iVariable_get_relatedComp(varExpr), false);
return;
}
//////////
// Are we good?
//////
if (!result)
iError_report_byNumber(_ERROR_INTERNAL_ERROR, iVariable_get_relatedComp(varExpr), false);
//////////
// Return our converted result
//////
rpar->rp[0] = result;
}
//
// Target can be file name
// Arg[0]: Device number. Optional
//
// From NdasOpReadDIB, LurnRMDRead
//
int CmdViewMeta(char* target, char* arg[])
{
UINT64 Pos = 10;
int retval = 0;
SOCKET connsock;
PUCHAR data = NULL;
int iResult;
unsigned UserId;
FILE* file = NULL;
NDAS_DIB_V2 DIB_V2;
NDAS_RAID_META_DATA Rmd;
NDAS_LAST_WRITTEN_REGION_BLOCK Lwr;
UINT32 i, j;
BOOL IsTargetFile;
UINT64 DiskSectorCount;
char* str;
PNDAS_UNIT_META_DATA UnitMeta;
data = (PUCHAR) malloc(MAX_DATA_BUFFER_SIZE);
if (strcspn(target, ":") >=strlen(target)) {
IsTargetFile = TRUE;
} else {
IsTargetFile = FALSE;
}
if (IsTargetFile) {
struct __stat64 statbuff;
file = fopen(target, "r");
if (file ==NULL) {
fprintf(stderr, "Failed to open file\n");
retval = GetLastError();
goto errout;
}
iResult = _stat64(target, &statbuff);
if (iResult !=0) {
fprintf(stderr, "Failed to get stat file\n");
goto errout;
}
DiskSectorCount = statbuff.st_size/BLOCK_SIZE;
} else {
int dev;
UserId = MAKE_USER_ID(DEFAULT_USER_NUM, USER_PERMISSION_SW);
if (arg[0])
dev = (int) _strtoi64(arg[0], NULL, 0);
else
dev = 0;
if (dev==0) {
//
} else {
UserId |= 0x100;
}
if (ConnectToNdas(&connsock, target, UserId, NULL) !=0)
goto errout;
// Need to get disk info before IO
if((iResult = GetDiskInfo(connsock, iTargetID, TRUE, TRUE)) != 0) {
fprintf(stderr, "GetDiskInfo Failed...\n");
retval = iResult;
goto errout;
}
DiskSectorCount = PerTarget[iTargetID].SectorCount;
}
fprintf(stderr,"Total sector count = %I64d\n", DiskSectorCount);
// Read an NDAS_DIB_V2 structure from the NDAS Device at NDAS_BLOCK_LOCATION_DIB_V2
if (IsTargetFile) {
iResult = fseek(file, (long)((DiskSectorCount + NDAS_BLOCK_LOCATION_DIB_V2)*BLOCK_SIZE), SEEK_SET);
if (iResult != 0) {
fprintf(stderr, "fseek error\n");
goto errout;
}
iResult = (int)fread((void*)&DIB_V2, 512, 1, file);
if (iResult == 0) {
fprintf(stderr, "fread error\n");
goto errout;
}
} else {
iResult = IdeCommand(connsock, iTargetID, 0, WIN_READ, DiskSectorCount + NDAS_BLOCK_LOCATION_DIB_V2, 1, 0, sizeof(DIB_V2), (PCHAR)&DIB_V2, 0, 0);
if (iResult != 0) {
fprintf(stderr, "READ Failed.\n");
goto errout;
}
}
// Check Signature, Version and CRC informations in NDAS_DIB_V2 and accept if all the informations are correct
if(NDAS_DIB_V2_SIGNATURE != DIB_V2.Signature)
{
if (DIB_V2.Signature == 0) {
fprintf(stderr, "No DIBv2 signature. Single disk or uninitialized disk.\n");
} else {
fprintf(stderr, "V2 Signature mismatch\n");
}
goto errout;
//goto process_v1;
}
if(!IS_DIB_CRC_VALID(crc32_calc, DIB_V2))
{
fprintf(stderr, "CRC mismatch\n");
goto errout;
// goto process_v1;
}
if(NDAS_BLOCK_SIZE_XAREA != DIB_V2.sizeXArea &&
NDAS_BLOCK_SIZE_XAREA * SECTOR_SIZE != DIB_V2.sizeXArea)
{
fprintf(stderr, "Reserved size mismatch\n");
goto errout;
// goto process_v1;
}
if(DIB_V2.sizeUserSpace + DIB_V2.sizeXArea > DiskSectorCount)
{
fprintf(stderr, "Disk size mistmatch\n");
goto errout;
// goto process_v1;
}
#if 0
nTotalDiskCount = DIB_V2.nDiskCount + DIB_V2.nSpareCount;
// check DIB_V2.nDiskCount
if(!NdasOpVerifyDiskCount(DIB_V2.iMediaType, DIB_V2.nDiskCount))
goto process_v1;
#endif
// Dump DIB info
printf("DIBV2 Major Version = %d, Minor version = %d\n", DIB_V2.MajorVersion, DIB_V2.MinorVersion);
printf("User Space in sectors=%I64d, X space=%I64d\n", DIB_V2.sizeUserSpace, DIB_V2.sizeXArea);
printf("Bitmap sector per bit=%d(%fMbyte)\n", DIB_V2.iSectorsPerBit, DIB_V2.iSectorsPerBit / 2.0/1024);
switch(DIB_V2.iMediaType) {
case NMT_SINGLE: str="Single"; break;
case NMT_MIRROR: str="Mirror without repair info"; break;
case NMT_AGGREGATE: str="Aggregation"; break;
case NMT_RAID0: str="RAID0"; break;
case NMT_RAID1: str="RAID1(~3.10)"; break;
case NMT_RAID4: str="RAID4(~3.10)"; break;
case NMT_RAID1R2: str="RAID1(3.11~)"; break;
case NMT_RAID4R2: str="RAID4(3.11~)"; break;
case NMT_RAID1R3: str="RAID1(3.20~)"; break;
case NMT_RAID4R3: str="RAID4(3.20~)"; break;
case NMT_AOD: str="Append only disk"; break;
case NMT_VDVD: str="Virtual DVD"; break;
case NMT_CDROM: str="packet device, CD / DVD"; break;
case NMT_OPMEM: str="packet device, Magnetic Optical"; break;
case NMT_FLASH: str="flash card"; break;
default: str="Unknown"; break;
}
printf("Media type=%d(%s)\n", DIB_V2.iMediaType, str);
printf("Diskcount=%d, Sequence=%d, SpareCount=%d\n",
DIB_V2.nDiskCount, DIB_V2.iSequence, DIB_V2.nSpareCount);
for(i=0;i<DIB_V2.nDiskCount+DIB_V2.nSpareCount;i++) {
printf(" * Unit disk %d: ", i);
printf("MAC %02x:%02x:%02x:%02x:%02x:%02x, VID: %x, UnitNumber=%d, HwVersion=%d\n",
DIB_V2.UnitDisks[i].MACAddr[0], DIB_V2.UnitDisks[i].MACAddr[1], DIB_V2.UnitDisks[i].MACAddr[2],
DIB_V2.UnitDisks[i].MACAddr[3], DIB_V2.UnitDisks[i].MACAddr[4], DIB_V2.UnitDisks[i].MACAddr[5],
DIB_V2.UnitDisks[i].VID,
DIB_V2.UnitDisks[i].UnitNumber,
DIB_V2.UnitDiskInfos[i].HwVersion
);
}
// Show RMD info
if (IsTargetFile) {
iResult = fseek(file, (long)((DiskSectorCount + NDAS_BLOCK_LOCATION_RMD)*BLOCK_SIZE), SEEK_SET);
if (iResult != 0) {
fprintf(stderr, "fseek error\n");
goto errout;
}
iResult = (int)fread((void*)&Rmd, 512, 1, file);
if (iResult == 0) {
fprintf(stderr, "fread error\n");
goto errout;
}
} else {
iResult = IdeCommand(connsock, iTargetID, 0, WIN_READ, DiskSectorCount + NDAS_BLOCK_LOCATION_RMD, 1, 0, sizeof(Rmd), (PCHAR)&Rmd, 0, 0);
if (iResult != 0) {
fprintf(stderr, "READ Failed.\n");
goto errout;
}
}
// Check Signature, Version and CRC informations in NDAS_DIB_V2 and accept if all the informations are correct
if(NDAS_RAID_META_DATA_SIGNATURE != Rmd.Signature)
{
fprintf(stderr, "RMD Signature mismatch: %I64x\n", Rmd.Signature);
goto errout;
//goto process_v1;
}
if(!IS_RMD_CRC_VALID(crc32_calc, Rmd))
{
fprintf(stderr, "RMD CRC mismatch\n");
goto errout;
// goto process_v1;
}
printf("RAID Set ID = %08x-%04x-%04x-%02x%02x%02x%02x%02x%02x%02x%02x\n",
Rmd.guid.Data1, Rmd.guid.Data2, Rmd.guid.Data3,
Rmd.guid.Data4[0], Rmd.guid.Data4[1], Rmd.guid.Data4[2], Rmd.guid.Data4[3],
Rmd.guid.Data4[4], Rmd.guid.Data4[5], Rmd.guid.Data4[6], Rmd.guid.Data4[7]
);
printf("Config Set ID= %08x-%04x-%04x-%02x%02x%02x%02x%02x%02x%02x%02x\n",
Rmd.ConfigSetId.Data1, Rmd.ConfigSetId.Data2, Rmd.ConfigSetId.Data3,
Rmd.ConfigSetId.Data4[0], Rmd.ConfigSetId.Data4[1], Rmd.ConfigSetId.Data4[2], Rmd.ConfigSetId.Data4[3],
Rmd.ConfigSetId.Data4[4], Rmd.ConfigSetId.Data4[5], Rmd.ConfigSetId.Data4[6], Rmd.ConfigSetId.Data4[7]
);
printf("USN: %d\n", Rmd.uiUSN);
switch(Rmd.state & (NDAS_RAID_META_DATA_STATE_MOUNTED | NDAS_RAID_META_DATA_STATE_UNMOUNTED)) {
case NDAS_RAID_META_DATA_STATE_MOUNTED: str= "Mounted"; break;
case NDAS_RAID_META_DATA_STATE_UNMOUNTED: str= "Unmounted"; break;
default: str = "Unknown/Never Mounted"; break;
}
if (Rmd.state & NDAS_RAID_META_DATA_STATE_USED_IN_DEGRADED) {
printf("This member is used in degraded mode\n");
}
printf("State: %d(%s)\n", Rmd.state, str);
for(i=0;i<NDAS_DRAID_ARBITER_ADDR_COUNT;i++) {
if (Rmd.ArbiterInfo[i].Type == 0)
break;
printf("DRAID Listen Address: Type %d - %02x:%02x:%02x:%02x:%02x:%02x\n",
Rmd.ArbiterInfo[i].Type,
Rmd.ArbiterInfo[i].Addr[0], Rmd.ArbiterInfo[i].Addr[1], Rmd.ArbiterInfo[i].Addr[2],
Rmd.ArbiterInfo[i].Addr[3], Rmd.ArbiterInfo[i].Addr[4], Rmd.ArbiterInfo[i].Addr[5]
);
}
for(i=0;i<DIB_V2.nDiskCount+DIB_V2.nSpareCount;i++) {
char* DefectStr;
printf(" * Role %d: ", i);
UnitMeta = &Rmd.UnitMetaData[i];
printf("Unit index=%d Status=%d(%s%s%s%s%s%s)\n",
UnitMeta->iUnitDeviceIdx, UnitMeta->UnitDeviceStatus,
(UnitMeta->UnitDeviceStatus==0)?"Normal ":"",
(UnitMeta->UnitDeviceStatus & NDAS_UNIT_META_BIND_STATUS_NOT_SYNCED)?"Out-of-sync ":"",
(UnitMeta->UnitDeviceStatus & NDAS_UNIT_META_BIND_STATUS_SPARE)?"Spare ":"",
(UnitMeta->UnitDeviceStatus & NDAS_UNIT_META_BIND_STATUS_BAD_DISK)?"Bad disk ":"",
(UnitMeta->UnitDeviceStatus & NDAS_UNIT_META_BIND_STATUS_BAD_SECTOR)?"Bad sector ":"",
(UnitMeta->UnitDeviceStatus & NDAS_UNIT_META_BIND_STATUS_REPLACED_BY_SPARE)?"Replaced by spare ":""
);
}
//
// Dump bitmap
//
if (DIB_V2.iMediaType == NMT_RAID1R3)
{
UINT32 BitCount = (UINT32)((DIB_V2.sizeUserSpace + DIB_V2.iSectorsPerBit - 1)/DIB_V2.iSectorsPerBit);
UINT32 BmpSectorCount = (BitCount + NDAS_BIT_PER_OOS_BITMAP_BLOCK -1)/NDAS_BIT_PER_OOS_BITMAP_BLOCK;
UINT32 CurBitCount;
PNDAS_OOS_BITMAP_BLOCK BmpBuffer;
UCHAR OnBits[] = {1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7};
UINT32 BitOn, BitOnStart, BitOnEnd;
printf("\nBitmap sector per bit=0x%x, Bit count =0x%x, BmpSector count=0x%x\n",
DIB_V2.iSectorsPerBit, BitCount, BmpSectorCount);
BmpBuffer = (PNDAS_OOS_BITMAP_BLOCK) malloc(BmpSectorCount* 512);
iResult = IdeCommand(connsock, iTargetID, 0, WIN_READ, DiskSectorCount + NDAS_BLOCK_LOCATION_BITMAP, (_int16)BmpSectorCount, 0, BmpSectorCount* 512, (PCHAR)BmpBuffer, 0, 0);
if (iResult != 0) {
fprintf(stderr, "READ Failed.\n");
free(BmpBuffer);
goto errout;
}
CurBitCount = 0;
for(i=0;i<BmpSectorCount;i++) {
printf(" Bitmap sector %d, Seq head=%I64x, tail=%I64x\n", i, BmpBuffer[i].SequenceNumHead,BmpBuffer[i].SequenceNumTail);
BitOn = FALSE;
BitOnStart = BitOnEnd = 0;
for(j=0;j<NDAS_BYTE_PER_OOS_BITMAP_BLOCK * 8;j++) {
if (BitOn == FALSE && (BmpBuffer[i].Bits[j/8] & OnBits[j%8])) {
BitOn = TRUE;
BitOnStart = i * NDAS_BYTE_PER_OOS_BITMAP_BLOCK * 8 + j;
printf(" Bit on from bit %x ~ ", BitOnStart);
}
if (BitOn == TRUE && (BmpBuffer[i].Bits[j/8] & OnBits[j%8]) == 0) {
BitOn = FALSE;
BitOnEnd = i * NDAS_BYTE_PER_OOS_BITMAP_BLOCK * 8 + j;
printf("%x\n", BitOnEnd-1);
}
CurBitCount++;
if (CurBitCount >= BitCount)
break;
}
if (BitOn == TRUE) {
printf("%x\n", i * NDAS_BYTE_PER_OOS_BITMAP_BLOCK * 8 + j);
}
}
free(BmpBuffer);
}
printf("\n");
DisconnectFromNdas(connsock, UserId);
errout:
closesocket(connsock);
if (data)
free(data);
return retval;
}
// Tokenize number constants:
// 1. Integers: [-] 0[0-7]+ | 0[xX][0-9a-fA-F]+ | [0-9]+
// 2. Reals : [-] [0-9]*\.[0-9]* (e|E) [+-]? [0-9]+
int Lexer::
tokenizeNumber (void)
{
enum { NONE, INTEGER, REAL };
int numberType = NONE;
Value::NumberFactor f;
long long integer=0;
double real=0;
int och;
och = ch;
mark( );
wind( );
if ( och == '-' ) {
// This may be a negative number or the unary minus operator
// The subsequent two characters will tell us which.
if ( isdigit( ch ) ) {
// It looks like a negative number, keep reading.
och = ch;
wind();
} else if ( ch == '.' ) {
// This could be a real number or an attribute reference
// starting with dot. Look at the second character.
int ch2 = lexSource->ReadCharacter();
if ( ch2 >= 0 ) {
lexSource->UnreadCharacter();
}
if ( !isdigit( ch2 ) ) {
// It's not a real number, return a minus token.
cut();
tokenType = LEX_MINUS;
return tokenType;
}
// It looks like a negative real, keep reading.
} else {
// It's not a number, return a minus token.
cut();
tokenType = LEX_MINUS;
return tokenType;
}
}
if( och == '0' ) {
// number is octal, hex or real
if( tolower( ch ) == 'x' ) {
// get hex digits only; parse hex-digit+
numberType = INTEGER;
wind( );
if( !isxdigit( ch ) ) {
cut( );
tokenType = LEX_TOKEN_ERROR;
return( tokenType ) ;
}
while( isxdigit( ch ) ) {
wind( );
}
} else {
// get octal or real
numberType = INTEGER;
while( isdigit( ch ) ) {
wind( );
if( !isodigit( ch ) ) {
// not an octal number
numberType = REAL;
}
}
if( ch == '.' || tolower( ch ) == 'e' ) {
numberType = REAL;
} else if( numberType == REAL ) {
// non-octal digits, but not a real (no '.' or 'e')
// so, illegal octal constant
cut( );
tokenType = LEX_TOKEN_ERROR;
return( tokenType );
}
}
} else if( isdigit( och ) ) {
// decimal or real; get digits
while( isdigit( ch ) ) {
wind( );
}
numberType = ( ch=='.' || tolower( ch )=='e' ) ? REAL : INTEGER;
}
if( och == '.' || ch == '.' ) {
// fraction part of real or selection operator
if( ch == '.' ) wind( );
if( isdigit( ch ) ) {
// real; get digits after decimal point
numberType = REAL;
while( isdigit( ch ) ) {
wind( );
}
} else {
if( numberType != NONE ) {
// initially like a number, but no digit following the '.'
cut( );
tokenType = LEX_TOKEN_ERROR;
return( tokenType );
}
// selection operator
cut( );
tokenType = LEX_SELECTION;
return( tokenType );
}
}
// if we are tokenizing a real, the (optional) exponent part is left
// i.e., [eE][+-]?[0-9]+
if( numberType == REAL && tolower( ch ) == 'e' ) {
wind( );
if( ch == '+' || ch == '-' ) wind( );
if( !isdigit( ch ) ) {
cut( );
tokenType = LEX_TOKEN_ERROR;
return( tokenType );
}
while( isdigit( ch ) ) {
wind( );
}
}
if( numberType == INTEGER ) {
cut( );
long long l;
int base = 0;
if ( _useOldClassAdSemantics ) {
// Old ClassAds don't support octal or hexidecimal
// representations for integers.
base = 10;
}
#ifdef WIN32
l = _strtoi64( lexBuffer.c_str(), NULL, base );
#else
l = strtoll( lexBuffer.c_str(), NULL, base );
#endif
integer = l;
} else if( numberType == REAL ) {
cut( );
real = strtod( lexBuffer.c_str(), NULL );
} else {
/* If we've reached this point, we have a serious programming
* error: tokenizeNumber should only be called if we are
* lexing a number or a selection, and we didn't find a number
* or a selection. This should really never happen, so we
* bomb if it does. It should be reported as a bug.
*/
CLASSAD_EXCEPT("Should not reach here");
}
switch( toupper( ch ) ) {
case 'B': f = Value::B_FACTOR; wind( ); break;
case 'K': f = Value::K_FACTOR; wind( ); break;
case 'M': f = Value::M_FACTOR; wind( ); break;
case 'G': f = Value::G_FACTOR; wind( ); break;
case 'T': f = Value::T_FACTOR; wind( ); break;
default:
f = Value::NO_FACTOR;
}
if( numberType == INTEGER ) {
yylval.SetIntValue( integer, f );
yylval.SetTokenType( LEX_INTEGER_VALUE );
tokenType = LEX_INTEGER_VALUE;
} else {
yylval.SetRealValue( real, f );
yylval.SetTokenType( LEX_REAL_VALUE );
tokenType = LEX_REAL_VALUE;
}
return( tokenType );
}
