char *gpr_getenv(const char *name) {
size_t size;
char *result = NULL;
errno_t err;
err = getenv_s(&size, NULL, 0, name);
if (err || (size == 0)) return NULL;
result = gpr_malloc(size);
err = getenv_s(&size, result, size, name);
if (err) {
gpr_free(result);
return NULL;
}
return result;
}
ExportScene::ExportScene()
: ExportFrame(),
m_pDCCTransformer( nullptr )
{
m_Information.ExportTime = _time64( nullptr );
CHAR strDomain[50];
size_t BufferSize = ARRAYSIZE(strDomain);
getenv_s( &BufferSize, strDomain, ARRAYSIZE(strDomain), "USERDOMAIN" );
CHAR strUsername[50];
getenv_s( &BufferSize, strUsername, ARRAYSIZE(strUsername), "USERNAME" );
CHAR strTemp[256];
sprintf_s( strTemp, "%s\\%s", strDomain, strUsername );
m_Information.UserName = strTemp;
CHAR strComputerName[100];
BufferSize = ARRAYSIZE(strComputerName);
getenv_s( &BufferSize, strComputerName, ARRAYSIZE(strComputerName), "COMPUTERNAME" );
m_Information.MachineName = strComputerName;
OSVERSIONINFO OSVersion = { 0 };
OSVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
#pragma prefast (disable : 28159)
#pragma warning (suppress : 4996)
GetVersionEx( &OSVersion );
sprintf_s( strTemp, "Windows NT %u.%u build %u", OSVersion.dwMajorVersion, OSVersion.dwMinorVersion, OSVersion.dwBuildNumber );
m_Information.PlatformName = strTemp;
}
std::string SysEnv::GetVariable(std::string const& name){
size_t size;
getenv_s(&size, nullptr, 0, name.c_str());
if(size > 0){
char* tmpvar = new char[size];
errno_t result = getenv_s(&size, tmpvar, size, name.c_str());
std::string var = (result == 0 ? std::string(tmpvar) : "");
delete[] tmpvar;
return var;
}
return "";
}
std::string EnvironmentVariablesManager::GetOSVariable(const char* name) {
#ifdef WINDOWS
size_t sz = 0;
assert(getenv_s(&sz, NULL, 0, name) == 0);
if (sz == 0) return std::string();
std::vector<char> value(sz + 1);
assert(getenv_s(&sz, &value[0], sz, name) == 0);
return std::string(&value[0], sz - 1);
#else
const char* const value = std::getenv(name);
return value ? value : "";
#endif
}
int
setenv(const char *name, const char *value, int overwrite)
{
int errcode = 0;
if (!overwrite) {
size_t envsize = 0;
#ifdef HAVE_GETENV_S
errcode = getenv_s(&envsize, NULL, 0, name);
#else
if (getenv(name) == NULL)
errcode = EINVAL;
#endif
if (errcode || envsize)
return errcode;
}
#ifdef HAVE__PUTENV_S
return _putenv_s(name, value);
#else
{
size_t maxlen = strlen(name)+strlen(value)+2;
char *keyval = (char *)malloc(maxlen);
if (!keyval)
return ENOMEM;
snprintf(keyval, maxlen, "%s=%s", name, value);
return putenv(keyval);
}
#endif
}
/****************************************************************************
* GetOwnIP
*
****************************************************************************/
void GetOwnIP() {
int j;
size_t aSize;
struct hostent * pHost;
WSADATA wsdata;
WORD wVersionRequested = MAKEWORD( 2, 2 );
WSAStartup( wVersionRequested, &wsdata );
char aName[256];
char *namePtr=&aName[0];
getenv_s(&aSize,namePtr,256,"COMPUTERNAME");
CString temp=namePtr;
temp.MakeLower();
strcpy_s(applHostName,temp);
pHost = gethostbyname(applHostName);
if((pHost!=NULL)&&(pHost->h_addr_list[0]!=NULL)) {
//original went through al aliases for( i = 0; pHost!= NULL && pHost->h_addr_list[i]!= NULL; i++ ) {
CString str,addr;
for( j = 0; j < pHost->h_length; j++ ){
if( j > 0 )
str += ".";
addr.Format("%u", (unsigned int)((unsigned char*)pHost->h_addr_list[0])[j]);
str += addr;
}
strcpy_s(applHostIP,str); //Set global variable ownIP
} else {
strcpy_s(applHostIP,"127.0.0.1"); //What other option do we have..
logger(Error,"Failed to obtain Host IP address. Using 127.0.0.1.");
}
WSACleanup();
}
int git_init()
{
char path[MAX_PATH+1];
int ret;
size_t homesize;
_fmode = _O_BINARY;
_setmode(_fileno(stdin), _O_BINARY);
_setmode(_fileno(stdout), _O_BINARY);
_setmode(_fileno(stderr), _O_BINARY);
// set HOME if not set already
getenv_s(&homesize, NULL, 0, "HOME");
if (!homesize)
{
_wputenv_s(L"HOME", wget_windows_home_directory());
}
GetModuleFileName(NULL, path, MAX_PATH);
convert_slash(path);
git_extract_argv0_path(path);
g_prefix = setup_git_directory();
ret = git_config(git_default_config, NULL);
if (!homesize)
{
_putenv_s("HOME","");/* clear home evironment to avoid affact third part software*/
}
return ret;
}
std::string getEnv(const std::string &name)
{
char value[MAX_PATH] = "";
size_t envsize = 0;
getenv_s(&envsize, value, MAX_PATH, name.c_str());
return value;
}
void main( void )
{
char buffer[128];
size_t len;
if( getenv_s( &len, buffer, sizeof( buffer ), "INCLUDE" ) == 0 )
printf( "INCLUDE=%s\n", buffer );
}
std::string getEnv(const char* envVar)
{
#ifdef _MSC_VER
size_t requiredSize;
getenv_s(&requiredSize, nullptr, 0, envVar);
if (requiredSize == 0)
return std::string();
// std::string doesn't need terminating null
std::string res(requiredSize - 1, 0);
getenv_s(&requiredSize, &res[0], requiredSize, envVar);
return res;
#else
auto res = getenv(envVar);
return res ? res : std::string();
#endif
}
std::string
Broker::Options::getHome() {
std::string home;
char home_c[MAX_PATH+1];
size_t unused;
if (0 == getenv_s (&unused, home_c, sizeof(home_c), "HOME"))
home += home_c;
return home;
}
std::string OFXGetEnv( const char* e )
{
#if !defined( __GNUC__ ) && defined( WINDOWS )
std::size_t requiredSize;
getenv_s( &requiredSize, 0, 0, e );
std::vector<char> buffer( requiredSize );
if( requiredSize > 0 )
{
getenv_s( &requiredSize, &buffer.front(), requiredSize, e );
return &buffer.front();
}
return "";
#else
const char* env_value = getenv( e );
if( env_value == NULL )
return "";
return env_value;
#endif
}
bool EnvironmentVariablesManager::IsOSVariableSet(const char* name) {
#ifdef WINDOWS
size_t sz = 0;
assert(getenv_s(&sz, NULL, 0, name) == 0);
return sz > 0;
#else
const char* value = std::getenv(name);
return value != NULL && *value != '\0';
#endif
}
int setenv(QString name, QString value, bool overwrite)
{
int errcode = 0;
if(!overwrite) {
size_t envsize = 0;
errcode = getenv_s(&envsize, NULL, 0, name.toLatin1().constData());
if(errcode || envsize) return errcode;
}
// make the update
return _putenv_s(name.toLatin1().constData(), value.toLatin1().constData());
}
int setenv(const char *name, const char *value, int overwrite)
{
int errorcode = 0;
if(!overwrite) {
size_t envsize = 0;
errorcode = getenv_s(&envsize, NULL, 0, name);
if(errorcode || envsize)
return errorcode;
}
return _putenv_s(name, value);
}
static void
set_mongoc_test_host(void)
{
#ifdef _MSC_VER
size_t buflen;
if (0 != getenv_s (&buflen, MONGOC_TEST_HOST, sizeof MONGOC_TEST_HOST, "MONGOC_TEST_HOST")) {
bson_strncpy (MONGOC_TEST_HOST, "localhost", sizeof MONGOC_TEST_HOST);
}
#else
if (getenv("MONGOC_TEST_HOST")) {
bson_strncpy (MONGOC_TEST_HOST, getenv("MONGOC_TEST_HOST"), sizeof MONGOC_TEST_HOST);
} else {
bson_strncpy (MONGOC_TEST_HOST, "localhost", sizeof MONGOC_TEST_HOST);
}
#endif
}
bool SVNAdminDir::Init()
{
if (m_nInit==0)
{
m_bVSNETHack = false;
m_pool = svn_pool_create(NULL);
size_t ret = 0;
getenv_s(&ret, NULL, 0, "SVN_ASP_DOT_NET_HACK");
if (ret)
{
svn_error_clear(svn_wc_set_adm_dir("_svn", m_pool));
m_bVSNETHack = true;
}
}
m_nInit++;
return true;
}
// windows has renamed the setenv func to _putenv_s
int setenv(const char *name, const char *value, int overwrite)
{
if (!overwrite)
{
// see if env var already exists
size_t envsize = 0;
int ret = getenv_s(&envsize, NULL, 0, name);
// if exists, don't overwrite
if (ret || envsize)
{
return ret;
}
}
// set env var
return _putenv_s(name, value);
}
std::string getenv(const std::string & name)
{
#ifdef WIN32
size_t result = 0;
char buffer[1024];
if(0 != getenv_s(&result,buffer,sizeof(buffer),name.c_str())) return "";
return buffer;
#else
char *val = getenv(varname);
if(NULL == val) return "";
return val;
#endif //WIN32
}
/** 获取用户UID */
inline int32 getUserUID()
{
#if KBE_PLATFORM == PLATFORM_WIN32
// VS2005:
#if _MSC_VER >= 1400
char uid[16];
size_t sz;
return getenv_s( &sz, uid, sizeof( uid ), "UID" ) == 0 ? atoi( uid ) : 0;
// VS2003:
#elif _MSC_VER < 1400
char * uid = getenv( "UID" );
return uid ? atoi( uid ) : 0;
#endif
#else
// Linux:
char * uid = getenv( "UID" );
return uid ? atoi( uid ) : getuid();
#endif
}
STRING Port::GetEnv(const char * var)
{
STRING env;
#ifdef WIN32
size_t tLen = 0;
#ifdef UNICODE
wchar_t path[80];
wchar_t var2[256] = {0};
int size = strlen(var)+1;
mbstowcs_s(&tLen, var2, size, var, size);
_wgetenv_s(&tLen, path, 80, var2);
#else
char path[80];
getenv_s(&tLen, path, 80, var);
#endif
env = path;
#elif defined(UNIX)
char * temp = getenv(var);
env.assign(temp, temp+strlen(temp));
#endif
return env;
}
// returns the temp directory for the appropriate platform
void GetTempDirectory(string& tempDirectory) {
const char* MOSAIK_TMP = "MOSAIK_TMP";
// get hostname
char hostname[256];
uint32_t isHostname;
isHostname = gethostname( hostname, sizeof(hostname) );
#ifdef WIN32
// allocate the memory needed to store the larger variable
size_t requiredTmpSize = 0;
size_t requiredMosaikTmpSize = 0;
getenv_s(&requiredTmpSize, NULL, 0, "TMP");
getenv_s(&requiredMosaikTmpSize, NULL, 0, MOSAIK_TMP);
size_t requiredSize = max(requiredTmpSize, requiredMosaikTmpSize);
char* tmpDir = new char[requiredSize];
// get the environment variables
bool foundProblem = false;
if(requiredMosaikTmpSize != 0) {
getenv_s(&requiredMosaikTmpSize, tmpDir, requiredMosaikTmpSize, MOSAIK_TMP);
}
getenv_s(&requiredTmpSize, tmpDir, requiredTmpSize, "TMP");
tempDirectory = tmpDir;
tempDirectory += '\\';
tempDirectory += "FILEUTIL.";
if ( isHostname == 0 ) {
tempDirectory += hostname;
tempDirectory += '.';
}
char pidChar[ 16 ];
memset( pidChar, 0, sizeof(char) * 16 );
sprintf( pidChar, "%u", getpid() );
tempDirectory += pidChar;
tempDirectory += '\\';
// checks if a directory exists, creates it otherwise
CreateDir( tempDirectory.c_str() );
// clean up
delete [] tmpDir;
#else
char* tmpDir = getenv( MOSAIK_TMP );
if( tmpDir ) {
tempDirectory = tmpDir;
if( tempDirectory[ tempDirectory.size() - 1 ] != OS_DIRECTORY_SEPARATOR)
tempDirectory += OS_DIRECTORY_SEPARATOR;
} else {
tempDirectory = "/tmp/";
}
tempDirectory += "FILEUTIL.";
if ( isHostname == 0 ) {
tempDirectory += hostname;
tempDirectory += '.';
}
char pidChar[ 16 ];
memset( pidChar, 0, sizeof(char) * 16 );
sprintf( pidChar, "%u", getpid() );
tempDirectory += pidChar;
tempDirectory += OS_DIRECTORY_SEPARATOR;
// checks if a directory exists, creates it otherwise
CreateDir( tempDirectory.c_str() );
#endif
}
static JNIEnv *getNewEnv() {
JNIEnv *env; /* pointer to native method interface */
JavaVM * jvmBuf[1];
jsize nVMs;
char *debugJ4CppEnv = NULL;
char *classPathEnv = NULL;
char *jvmOptionsEnv = NULL;
#if defined(_WIN32) || defined(_WIN64)
errno_t errno_val;
size_t requiredSize;
errno_val = getenv_s( &requiredSize, NULL, 0, "DEBUG_J4CPP");
if(requiredSize > 0) {
debugJ4CppEnv = (char *) malloc(requiredSize);
errno_val = getenv_s( &requiredSize, debugJ4CppEnv, requiredSize, "DEBUG_J4CPP");
}
errno_val = getenv_s( &requiredSize, NULL, 0, "CLASSPATH");
if(requiredSize > 0) {
classPathEnv = (char *) malloc(requiredSize);
errno_val = getenv_s( &requiredSize, classPathEnv, requiredSize, "CLASSPATH");
}
errno_val = getenv_s( &requiredSize, NULL, 0, "JVM_OPTIONS");
if(requiredSize > 0) {
jvmOptionsEnv = (char *) malloc(requiredSize);
errno_val = getenv_s( &requiredSize, jvmOptionsEnv, requiredSize, "JVM_OPTIONS");
}
#else
debugJ4CppEnv = getenv("DEBUG_J4CPP");
classPathEnv = getenv("CLASSPATH");
jvmOptionsEnv = getenv("JVM_OPTIONS");
#endif
debug_j4cpp = debug_j4cpp || (debugJ4CppEnv != NULL && debugJ4CppEnv[0] != 0);
std::string str;
str += "%CLASSPATH_PREFIX%";
if (classPathEnv != NULL) {
std::string classPathEnvStr(classPathEnv);
if (debug_j4cpp) std::cout << "classPathEnv=" << classPathEnvStr << std::endl;
str += "%PATH_SEPERATOR%";
str += classPathEnvStr;
}
if (debug_j4cpp) std::cout << "str=" << str << std::endl;
#if defined(_WIN32) || defined(_WIN64)
_putenv_s("CLASSPATH", str.c_str());
#else
setenv("CLASSPATH", str.c_str(), 1);
#endif
std::string optsString;
optsString += "-Djava.class.path=";
optsString += str;
if (jvmOptionsEnv != NULL) {
std::string jvmOptionsEnvStr(jvmOptionsEnv);
if (debug_j4cpp) std::cout << "jvmOptionsEnvStr=" << jvmOptionsEnvStr << std::endl;
optsString += " ";
optsString += jvmOptionsEnvStr;
}
if (debug_j4cpp) std::cout << "optsString=" << optsString << std::endl;
jint v = JNI_GetCreatedJavaVMs(jvmBuf, 1, &nVMs);
if (nVMs > 0) {
jvm = jvmBuf[0];
jvm->GetEnv((void **) &env, JNI_VERSION_1_6);
return env;
}
JavaVMInitArgs vm_args; /* JDK/JRE 6 VM initialization arguments */
JavaVMOption* options = new JavaVMOption[1];
options[0].optionString = (char *) optsString.c_str();
vm_args.version = JNI_VERSION_1_6;
vm_args.nOptions = NULL != options[0].optionString ? 1 : 0;
vm_args.options = options;
vm_args.ignoreUnrecognized = false;
/* load and initialize a Java VM, return a JNI interface
* pointer in env */
JNI_CreateJavaVM(&jvm,
((void **) (&env)),
((void *) (&vm_args)));
delete options;
#if defined(_WIN32) || defined(_WIN64)
if(debugJ4CppEnv != NULL) {
free(debugJ4CppEnv);
debugJ4CppEnv = NULL;
}
if(classPathEnv != NULL) {
free(classPathEnv);
classPathEnv = NULL;
}
if(jvmOptionsEnv != NULL) {
free(jvmOptionsEnv);
jvmOptionsEnv = NULL;
}
#endif
registerNativeMethods(env);
// static JNINativeMethod methods[1];
// jclass loaderclass = env->FindClass("java/lang/ClassLoader");
// std::cout << "loaderclass = " << loaderclass << std::endl;
// jmethodID mid = env->GetStaticMethodID(loaderclass,"getSystemClassLoader","()Ljava/lang/ClassLoader;");
// std::cout << "mid = " << mid << std::endl;
// jobject loader = env->CallStaticObjectMethod(loaderclass,mid);
// std::cout << "loader = " << loader << std::endl;
// jclass rn_clss = env->FindClass("NativeRunnable");
// std::cout << "rn_clss = " << rn_clss << std::endl;
// if(NULL != rn_clss) {
// methods[0].name = (char *) "run";
// methods[0].signature = (char *) "()V";
// methods[0].fnPtr = (void *) Java_NativeRunnable_run;
// jint rn_ret = env->RegisterNatives(rn_clss,methods,1);
// std::cout << "rn_ret = " << rn_ret << std::endl;
// }
return env;
}
std::vector<EkayaKeyboard*>
KmflKeyboardFactory::loadKeyboards(const char * installPath)
{
std::vector<EkayaKeyboard*> keyboards;
MessageLogger::logMessage("Loading keyboards\n");
char* appDir = NULL;
size_t requiredSize;
getenv_s( &requiredSize, NULL, 0, "APPDATA");
appDir = new char[requiredSize];
if (!appDir)
return keyboards;
std::string basePath;
std::string pattern;
if (appDir)
{
getenv_s( &requiredSize, appDir, requiredSize, "APPDATA" );
basePath = std::string(appDir) + THANLWINSOFT_KMFL_DIR;
pattern = basePath + KMFL_PATTERN;
}
else
{
return keyboards;
}
HANDLE hFind = INVALID_HANDLE_VALUE;
WIN32_FIND_DATAA ffd;
// read files in user's APPDATA dir
hFind = FindFirstFileA(pattern.c_str(), &ffd);
while (INVALID_HANDLE_VALUE != hFind)
{
std::string kmflFileName = basePath + ffd.cFileName;
MessageLogger::logMessage("Loading %s\n", kmflFileName.c_str());
int kmflId = kmfl_load_keyboard((kmflFileName).c_str());
if (kmflId > -1)
{
keyboards.push_back(new KmflKeyboard(kmflId, basePath, ffd.cFileName));
}
else
{
MessageLogger::logMessage("Failed to load %s\n", kmflFileName.c_str());
}
if (FindNextFileA(hFind, &ffd) == 0) break;
}
delete [] appDir;
appDir = NULL;
// read files under Program Files
if (installPath == NULL)
{
getenv_s( &requiredSize, NULL, 0, "ProgramFiles");
appDir = new char[requiredSize];
if (!appDir)
return keyboards;
getenv_s( &requiredSize, appDir, requiredSize, "ProgramFiles" );
basePath = std::string(appDir) + THANLWINSOFT_KMFL_DIR;
}
else
{
basePath = std::string(installPath) + KMFL_DIR;
}
pattern = basePath + KMFL_PATTERN;
hFind = FindFirstFileA(pattern.c_str(), &ffd);
while (INVALID_HANDLE_VALUE != hFind)
{
std::string kmflFileName = basePath + ffd.cFileName;
MessageLogger::logMessage("Loading %s\n", kmflFileName.c_str());
int kmflId = kmfl_load_keyboard(kmflFileName.c_str());
if (kmflId > -1)
{
keyboards.push_back(new KmflKeyboard(kmflId, basePath, ffd.cFileName));
}
else
{
MessageLogger::logMessage("Failed to load %s\n", kmflFileName.c_str());
}
if (FindNextFileA(hFind, &ffd) == 0) break;
}
if (installPath == NULL)
{
delete [] appDir;
}
MessageLogger::logMessage("Loaded %d keyboards\n", keyboards.size());
return keyboards;
}
/*
* getopt_internal --
* Parse argc/argv argument vector. Called by user level routines.
*/
static int
getopt_internal(int nargc, char * const *nargv, const char *options,
const struct option *long_options, int *idx, int flags)
{
char *oli; /* option letter list index */
int optchar, short_too;
static int posixly_correct = -1;
if (options == NULL)
return (-1);
/*
* XXX Some GNU programs (like cvs) set optind to 0 instead of
* XXX using optreset. Work around this braindamage.
*/
if (optind == 0)
optind = optreset = 1;
/*
* Disable GNU extensions if POSIXLY_CORRECT is set or options
* string begins with a '+'.
*
* CV, 2009-12-14: Check POSIXLY_CORRECT anew if optind == 0 or
* optreset != 0 for GNU compatibility.
*/
if (posixly_correct == -1 || optreset != 0) {
#ifdef _MSC_VER
size_t requiredSize;
getenv_s(&requiredSize, NULL, 0, "POSIXLY_CORRECT");
posixly_correct = requiredSize > 0;
#else
posixly_correct = (getenv("POSIXLY_CORRECT") != NULL);
#endif
}
if (*options == '-')
flags |= FLAG_ALLARGS;
else if (posixly_correct || *options == '+')
flags &= ~FLAG_PERMUTE;
if (*options == '+' || *options == '-')
options++;
optarg = NULL;
if (optreset)
nonopt_start = nonopt_end = -1;
start:
if (optreset || !*place) { /* update scanning pointer */
optreset = 0;
if (optind >= nargc) { /* end of argument vector */
place = EMSG;
if (nonopt_end != -1) {
/* do permutation, if we have to */
permute_args(nonopt_start, nonopt_end,
optind, nargv);
optind -= nonopt_end - nonopt_start;
}
else if (nonopt_start != -1) {
/*
* If we skipped non-options, set optind
* to the first of them.
*/
optind = nonopt_start;
}
nonopt_start = nonopt_end = -1;
return (-1);
}
if (*(place = nargv[optind]) != '-' ||
(place[1] == '\0' && strchr(options, '-') == NULL)) {
place = EMSG; /* found non-option */
if (flags & FLAG_ALLARGS) {
/*
* GNU extension:
* return non-option as argument to option 1
*/
optarg = nargv[optind++];
return (INORDER);
}
if (!(flags & FLAG_PERMUTE)) {
/*
* If no permutation wanted, stop parsing
* at first non-option.
*/
return (-1);
}
/* do permutation */
if (nonopt_start == -1)
nonopt_start = optind;
else if (nonopt_end != -1) {
permute_args(nonopt_start, nonopt_end,
optind, nargv);
nonopt_start = optind -
(nonopt_end - nonopt_start);
nonopt_end = -1;
}
optind++;
/* process next argument */
goto start;
}
if (nonopt_start != -1 && nonopt_end == -1)
nonopt_end = optind;
/*
* If we have "-" do nothing, if "--" we are done.
*/
if (place[1] != '\0' && *++place == '-' && place[1] == '\0') {
optind++;
place = EMSG;
/*
* We found an option (--), so if we skipped
* non-options, we have to permute.
*/
if (nonopt_end != -1) {
permute_args(nonopt_start, nonopt_end,
optind, nargv);
optind -= nonopt_end - nonopt_start;
}
nonopt_start = nonopt_end = -1;
return (-1);
}
}
/*
* Check long options if:
* 1) we were passed some
* 2) the arg is not just "-"
* 3) either the arg starts with -- we are getopt_long_only()
*/
if (long_options != NULL && place != nargv[optind] &&
(*place == '-' || (flags & FLAG_LONGONLY))) {
short_too = 0;
if (*place == '-')
place++; /* --foo long option */
else if (*place != ':' && strchr(options, *place) != NULL)
short_too = 1; /* could be short option too */
optchar = parse_long_options(nargv, options, long_options,
idx, short_too);
if (optchar != -1) {
place = EMSG;
return (optchar);
}
}
if ((optchar = (int)*place++) == (int)':' ||
(optchar == (int)'-' && *place != '\0') ||
(oli = strchr(options, optchar)) == NULL) {
/*
* If the user specified "-" and '-' isn't listed in
* options, return -1 (non-option) as per POSIX.
* Otherwise, it is an unknown option character (or ':').
*/
if (optchar == (int)'-' && *place == '\0')
return (-1);
if (!*place)
++optind;
if (PRINT_ERROR)
warnx(illoptchar, optchar);
optopt = optchar;
return (BADCH);
}
if (long_options != NULL && optchar == 'W' && oli[1] == ';') {
/* -W long-option */
if (*place) /* no space */
/* NOTHING */;
else if (++optind >= nargc) { /* no arg */
place = EMSG;
if (PRINT_ERROR)
warnx(recargchar, optchar);
optopt = optchar;
return (BADARG);
} else /* white space */
place = nargv[optind];
optchar = parse_long_options(nargv, options, long_options,
idx, 0);
place = EMSG;
return (optchar);
}
if (*++oli != ':') { /* doesn't take argument */
if (!*place)
++optind;
} else { /* takes (optional) argument */
optarg = NULL;
if (*place) /* no white space */
optarg = place;
else if (oli[1] != ':') { /* arg not optional */
if (++optind >= nargc) { /* no arg */
place = EMSG;
if (PRINT_ERROR)
warnx(recargchar, optchar);
optopt = optchar;
return (BADARG);
} else
optarg = nargv[optind];
}
place = EMSG;
++optind;
}
/* dump back option letter */
return (optchar);
}
LLBC_String LLBC_Directory::HomeDir()
{
#if LLBC_TARGET_PLATFORM_WIN32
size_t requiredSize = 0;
if (getenv_s(&requiredSize, NULL, 0, "HOMEPATH") != 0)
{
LLBC_SetLastError(LLBC_ERROR_CLIB);
return LLBC_String();
}
else if (requiredSize == 0)
{
LLBC_SetLastError(LLBC_ERROR_NOT_FOUND);
return LLBC_String();
}
char *envVal = LLBC_Malloc(char, requiredSize);
if (getenv_s(&requiredSize, envVal, requiredSize, "HOMEPATH") != 0)
{
LLBC_Free(envVal);
LLBC_SetLastError(LLBC_ERROR_CLIB);
return LLBC_String();
}
LLBC_String path(envVal);
LLBC_Free(envVal);
#else // Non-Win32
char *envVal = getenv("HOME");
if (!envVal)
{
LLBC_SetLastError(LLBC_ERROR_NOT_FOUND);
return "";
}
const LLBC_String path(envVal);
#endif // Win32
#if LLBC_TARGET_PLATFORM_WIN32
const size_t pathLen = path.length();
if (path[pathLen - 1] == LLBC_SLASH_A ||
path[pathLen - 1] == LLBC_BACKLASH_A)
{
if (pathLen == 3 &&
LLBC_String::isalpha(path[0]) &&
path[1] == ':')
return path;
else
return path.substr(0, pathLen - 1);
}
else
{
return path;
}
#else // Non-Win32
const size_t pathLen = path.length();
if (path[pathLen - 1] == LLBC_SLASH_A)
{
if (pathLen == 1)
return path;
else
return path.substr(0, path.length() -1);
}
else
{
return path;
}
#endif // Win32
}
CDrvrGlobal::CDrvrGlobal() : gOdbcMsg(DRVRMSG_DLL)
{
OSVERSIONINFO VersionInformation;
void *pVersionInfo;
VS_FIXEDFILEINFO *pInfo;
UINT wInfoLen;
DWORD dwVersionInfoSz;
DWORD hFile;
unsigned long len;
WORD* langInfo;
UINT cbLang;
TCHAR tszVerStrName[128];
LPVOID lpt;
InitializeCriticalSection(&gCSObject);
InitializeCriticalSection(&gHandleCSObject);
InitializeCriticalSection(&gCollectionCSObject);
strcpy(gCapsuleName, "TRAF ODBC Driver");
len = sizeof(gComputerName);
if (GetComputerName(gComputerName, &len) == 0)
strcpy(gComputerName, "UNKNOWN");
gProcessId = GetCurrentProcessId();
//referer to the enum cnv_charset in csconvert.h
//TranslateOption <4bytes from charset,4 bytes to charset>
gUTF8_To_UTF16_TranslateOption = ((DWORD)0x00010002L);
gUTF16_To_UTF8_TranslateOption = ((DWORD)0x00020001L);
VersionInformation.dwOSVersionInfoSize = sizeof( OSVERSIONINFO );
if (GetVersionEx( &VersionInformation ) == 0)
{
gPlatformId = 0;
gMinorVersion = 0;
}
else
{
gPlatformId = VersionInformation.dwPlatformId;
gMinorVersion = VersionInformation.dwMinorVersion;
}
gClientVersion.componentId = 0; // Unknown
strcpy(gDriverDLLName, DRIVER_DLL_NAME);
if ((gModuleHandle = GetModuleHandle(DRIVER_DLL_NAME)) != NULL)
{
if (GetModuleFileName(gModuleHandle, gDriverDLLName, sizeof(gDriverDLLName)))
{
if ((dwVersionInfoSz = GetFileVersionInfoSize(gDriverDLLName, &hFile)) != 0)
{
pVersionInfo = (void *)new char[dwVersionInfoSz];
if (GetFileVersionInfo(gDriverDLLName, hFile, dwVersionInfoSz, (LPVOID)pVersionInfo)
&& VerQueryValue((LPVOID)pVersionInfo, "\\",(LPVOID *)&pInfo, &wInfoLen) )
{
gClientVersion.componentId = WIN_UNICODE_DRVR_COMPONENT;
gClientVersion.majorVersion = HIWORD(pInfo->dwProductVersionMS);
gClientVersion.minorVersion = LOWORD(pInfo->dwProductVersionMS);
gClientVersion.buildId = LOWORD(pInfo->dwFileVersionLS);
// Get the vproc in the Comments field
strncpy(gClientVproc, VprocString, sizeof(gClientVproc)-1);
gClientVproc[sizeof(gClientVproc)-1] = '\0';
}
delete[] pVersionInfo;
}
}
}
if (gClientVersion.componentId == 0)
{
gClientVersion.componentId = DRVR_COMPONENT;
gClientVersion.majorVersion = 3;
gClientVersion.minorVersion = 51;
gClientVersion.buildId = 0;
}
gCEEInitialized = FALSE;
gCEESyncEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
gCEEExecuteThread = NULL;
gDefaultTxnIsolation = SQL_TXN_READ_COMMITTED;
gWaitCursor = LoadCursor(NULL, IDC_WAIT);
gCEEMessageFilter = TRUE;
ghWindow = NULL;
gSpecial_1 = false;
loadTransportAndTranslateDll();
SecurityInitialize();
noSchemaInDSN = false; // Assume that DSN has a schema value
char envValue[STRICT_SCHEMA_ENV_VAL_SIZE];
size_t valueSize = STRICT_SCHEMA_ENV_VAL_SIZE ;
size_t returnLen=0 ;
RestrictSchema = false;
if (getenv_s(&returnLen, envValue, valueSize, "TRAFODBC-SQLTABLES-RESTRICT-DSNSCHEMA") == 0) //success
if(returnLen != 0)
RestrictSchema = true;
#ifdef TRACE_COMPRESSION
char *envTraceCompression=NULL;
gTraceCompression=false;
if( (envTraceCompression = getenv("TRAFODBC_TRACE_COMPRESSION")) != NULL)
{
if(strcmp(envTraceCompression,"1")==0)
{
gTraceCompression=true;
}
}
#endif
}
int _tmain(int argc, _TCHAR* argv[])
{
// we have three parameters
const TCHAR * src = NULL;
const TCHAR * dst = NULL;
const TCHAR * wc = NULL;
BOOL bErrOnMods = FALSE;
BOOL bErrOnUnversioned = FALSE;
BOOL bErrOnMixed = FALSE;
BOOL bQuiet = FALSE;
BOOL bUseSubWCRevIgnore = TRUE;
SubWCRev_t SubStat;
SetDllDirectory(L"");
CCrashReportTSVN crasher(L"SubWCRev " _T(APP_X64_STRING));
if (argc >= 2 && argc <= 5)
{
// WC path is always first argument.
wc = argv[1];
}
if (argc == 4 || argc == 5)
{
// SubWCRev Path Tmpl.in Tmpl.out [-params]
src = argv[2];
dst = argv[3];
if (!PathFileExists(src))
{
_tprintf(L"File '%s' does not exist\n", src);
return ERR_FNF; // file does not exist
}
}
if (argc == 3 || argc == 5)
{
// SubWCRev Path -params
// SubWCRev Path Tmpl.in Tmpl.out -params
const TCHAR * Params = argv[argc-1];
if (Params[0] == '-')
{
if (wcschr(Params, 'q') != 0)
bQuiet = TRUE;
if (wcschr(Params, 'n') != 0)
bErrOnMods = TRUE;
if (wcschr(Params, 'N') != 0)
bErrOnUnversioned = TRUE;
if (wcschr(Params, 'm') != 0)
bErrOnMixed = TRUE;
if (wcschr(Params, 'd') != 0)
{
if ((dst != NULL) && PathFileExists(dst))
{
_tprintf(L"File '%s' already exists\n", dst);
return ERR_OUT_EXISTS;
}
}
// the 'f' option is useful to keep the revision which is inserted in
// the file constant, even if there are commits on other branches.
// For example, if you tag your working copy, then half a year later
// do a fresh checkout of that tag, the folder in your working copy of
// that tag will get the HEAD revision of the time you check out (or
// do an update). The files alone however won't have their last-committed
// revision changed at all.
if (wcschr(Params, 'f') != 0)
SubStat.bFolders = TRUE;
if (wcschr(Params, 'e') != 0)
SubStat.bExternals = TRUE;
if (wcschr(Params, 'E') != 0)
SubStat.bExternalsNoMixedRevision = TRUE;
if (wcschr(Params, 'x') != 0)
SubStat.bHexPlain = TRUE;
if (wcschr(Params, 'X') != 0)
SubStat.bHexX = TRUE;
if (wcschr(Params, 'F') != 0)
bUseSubWCRevIgnore = FALSE;
}
else
{
// Bad params - abort and display help.
wc = NULL;
}
}
if (wc == NULL)
{
_tprintf(L"SubWCRev %d.%d.%d, Build %d - %s\n\n",
TSVN_VERMAJOR, TSVN_VERMINOR,
TSVN_VERMICRO, TSVN_VERBUILD,
_T(TSVN_PLATFORM));
_putts(_T(HelpText1));
_putts(_T(HelpText2));
_putts(_T(HelpText3));
_putts(_T(HelpText4));
_putts(_T(HelpText5));
return ERR_SYNTAX;
}
DWORD reqLen = GetFullPathName(wc, 0, NULL, NULL);
auto wcfullPath = std::make_unique<TCHAR[]>(reqLen + 1);
GetFullPathName(wc, reqLen, wcfullPath.get(), NULL);
// GetFullPathName() sometimes returns the full path with the wrong
// case. This is not a problem on Windows since its filesystem is
// case-insensitive. But for SVN that's a problem if the wrong case
// is inside a working copy: the svn wc database is case sensitive.
// To fix the casing of the path, we use a trick:
// convert the path to its short form, then back to its long form.
// That will fix the wrong casing of the path.
int shortlen = GetShortPathName(wcfullPath.get(), NULL, 0);
if (shortlen)
{
auto shortPath = std::make_unique<TCHAR[]>(shortlen + 1);
if (GetShortPathName(wcfullPath.get(), shortPath.get(), shortlen + 1))
{
reqLen = GetLongPathName(shortPath.get(), NULL, 0);
wcfullPath = std::make_unique<TCHAR[]>(reqLen + 1);
GetLongPathName(shortPath.get(), wcfullPath.get(), reqLen);
}
}
wc = wcfullPath.get();
std::unique_ptr<TCHAR[]> dstfullPath = nullptr;
if (dst)
{
reqLen = GetFullPathName(dst, 0, NULL, NULL);
dstfullPath = std::make_unique<TCHAR[]>(reqLen + 1);
GetFullPathName(dst, reqLen, dstfullPath.get(), NULL);
shortlen = GetShortPathName(dstfullPath.get(), NULL, 0);
if (shortlen)
{
auto shortPath = std::make_unique<TCHAR[]>(shortlen + 1);
if (GetShortPathName(dstfullPath.get(), shortPath.get(), shortlen+1))
{
reqLen = GetLongPathName(shortPath.get(), NULL, 0);
dstfullPath = std::make_unique<TCHAR[]>(reqLen + 1);
GetLongPathName(shortPath.get(), dstfullPath.get(), reqLen);
}
}
dst = dstfullPath.get();
}
std::unique_ptr<TCHAR[]> srcfullPath = nullptr;
if (src)
{
reqLen = GetFullPathName(src, 0, NULL, NULL);
srcfullPath = std::make_unique<TCHAR[]>(reqLen + 1);
GetFullPathName(src, reqLen, srcfullPath.get(), NULL);
shortlen = GetShortPathName(srcfullPath.get(), NULL, 0);
if (shortlen)
{
auto shortPath = std::make_unique<TCHAR[]>(shortlen + 1);
if (GetShortPathName(srcfullPath.get(), shortPath.get(), shortlen+1))
{
reqLen = GetLongPathName(shortPath.get(), NULL, 0);
srcfullPath = std::make_unique<TCHAR[]>(reqLen + 1);
GetLongPathName(shortPath.get(), srcfullPath.get(), reqLen);
}
}
src = srcfullPath.get();
}
if (!PathFileExists(wc))
{
_tprintf(L"Directory or file '%s' does not exist\n", wc);
if (wcschr(wc, '\"') != NULL) // dir contains a quotation mark
{
_tprintf(L"The WorkingCopyPath contains a quotation mark.\n");
_tprintf(L"this indicates a problem when calling SubWCRev from an interpreter which treats\n");
_tprintf(L"a backslash char specially.\n");
_tprintf(L"Try using double backslashes or insert a dot after the last backslash when\n");
_tprintf(L"calling SubWCRev\n");
_tprintf(L"Examples:\n");
_tprintf(L"SubWCRev \"path to wc\\\\\"\n");
_tprintf(L"SubWCRev \"path to wc\\.\"\n");
}
return ERR_FNF; // dir does not exist
}
std::unique_ptr<char[]> pBuf = nullptr;
DWORD readlength = 0;
size_t filelength = 0;
size_t maxlength = 0;
if (dst != NULL)
{
// open the file and read the contents
CAutoFile hFile = CreateFile(src, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
if (!hFile)
{
_tprintf(L"Unable to open input file '%s'\n", src);
return ERR_OPEN; // error opening file
}
filelength = GetFileSize(hFile, NULL);
if (filelength == INVALID_FILE_SIZE)
{
_tprintf(L"Could not determine file size of '%s'\n", src);
return ERR_READ;
}
maxlength = filelength+4096; // We might be increasing file size.
pBuf = std::make_unique<char[]>(maxlength);
if (pBuf == NULL)
{
_tprintf(L"Could not allocate enough memory!\n");
return ERR_ALLOC;
}
if (!ReadFile(hFile, pBuf.get(), (DWORD)filelength, &readlength, NULL))
{
_tprintf(L"Could not read the file '%s'\n", src);
return ERR_READ;
}
if (readlength != filelength)
{
_tprintf(L"Could not read the file '%s' to the end!\n", src);
return ERR_READ;
}
}
// Now check the status of every file in the working copy
// and gather revision status information in SubStat.
apr_pool_t * pool;
svn_error_t * svnerr = NULL;
svn_client_ctx_t * ctx;
const char * internalpath;
apr_initialize();
svn_dso_initialize2();
apr_pool_create_ex (&pool, NULL, abort_on_pool_failure, NULL);
svn_client_create_context2(&ctx, NULL, pool);
size_t ret = 0;
getenv_s(&ret, NULL, 0, "SVN_ASP_DOT_NET_HACK");
if (ret)
{
svn_wc_set_adm_dir("_svn", pool);
}
char *wc_utf8 = Utf16ToUtf8(wc, pool);
internalpath = svn_dirent_internal_style (wc_utf8, pool);
if (bUseSubWCRevIgnore)
{
const char *wcroot;
svnerr = svn_client_get_wc_root(&wcroot, internalpath, ctx, pool, pool);
if ((svnerr == SVN_NO_ERROR) && wcroot)
LoadIgnorePatterns(wcroot, &SubStat);
svn_error_clear(svnerr);
LoadIgnorePatterns(internalpath, &SubStat);
}
svnerr = svn_status( internalpath, //path
&SubStat, //status_baton
TRUE, //noignore
ctx,
pool);
if (svnerr)
{
svn_handle_error2(svnerr, stdout, FALSE, "SubWCRev : ");
}
TCHAR wcfullpath[MAX_PATH] = { 0 };
LPTSTR dummy;
GetFullPathName(wc, MAX_PATH, wcfullpath, &dummy);
apr_status_t e = 0;
if (svnerr)
{
e = svnerr->apr_err;
svn_error_clear(svnerr);
}
apr_terminate2();
if (svnerr)
{
if (e == SVN_ERR_WC_NOT_DIRECTORY)
return ERR_NOWC;
return ERR_SVN_ERR;
}
char wcfull_oem[MAX_PATH] = { 0 };
CharToOem(wcfullpath, wcfull_oem);
_tprintf(L"SubWCRev: '%hs'\n", wcfull_oem);
if (bErrOnMods && SubStat.HasMods)
{
_tprintf(L"Working copy has local modifications!\n");
return ERR_SVN_MODS;
}
if (bErrOnUnversioned && SubStat.HasUnversioned)
{
_tprintf(L"Working copy has unversioned items!\n");
return ERR_SVN_UNVER;
}
if (bErrOnMixed && (SubStat.MinRev != SubStat.MaxRev))
{
if (SubStat.bHexPlain)
_tprintf(L"Working copy contains mixed revisions %lX:%lX!\n", SubStat.MinRev, SubStat.MaxRev);
else if (SubStat.bHexX)
_tprintf(L"Working copy contains mixed revisions %#lX:%#lX!\n", SubStat.MinRev, SubStat.MaxRev);
else
_tprintf(L"Working copy contains mixed revisions %ld:%ld!\n", SubStat.MinRev, SubStat.MaxRev);
return ERR_SVN_MIXED;
}
if (!bQuiet)
{
if (SubStat.bHexPlain)
_tprintf(L"Last committed at revision %lX\n", SubStat.CmtRev);
else if (SubStat.bHexX)
_tprintf(L"Last committed at revision %#lX\n", SubStat.CmtRev);
else
_tprintf(L"Last committed at revision %ld\n", SubStat.CmtRev);
if (SubStat.MinRev != SubStat.MaxRev)
{
if (SubStat.bHexPlain)
_tprintf(L"Mixed revision range %lX:%lX\n", SubStat.MinRev, SubStat.MaxRev);
else if (SubStat.bHexX)
_tprintf(L"Mixed revision range %#lX:%#lX\n", SubStat.MinRev, SubStat.MaxRev);
else
_tprintf(L"Mixed revision range %ld:%ld\n", SubStat.MinRev, SubStat.MaxRev);
}
else
{
if (SubStat.bHexPlain)
_tprintf(L"Updated to revision %lX\n", SubStat.MaxRev);
else if (SubStat.bHexX)
_tprintf(L"Updated to revision %#lX\n", SubStat.MaxRev);
else
_tprintf(L"Updated to revision %ld\n", SubStat.MaxRev);
}
if (SubStat.HasMods)
{
_tprintf(L"Local modifications found\n");
}
if (SubStat.HasUnversioned)
{
_tprintf(L"Unversioned items found\n");
}
}
if (dst == NULL)
{
return 0;
}
// now parse the file contents for version defines.
size_t index = 0;
while (InsertRevision(VERDEF, pBuf.get(), index, filelength, maxlength, -1, SubStat.CmtRev, &SubStat));
index = 0;
while (InsertRevisionW(TEXT(VERDEF), (wchar_t*)pBuf.get(), index, filelength, maxlength, -1, SubStat.CmtRev, &SubStat));
index = 0;
while (InsertRevision(VERDEFAND, pBuf.get(), index, filelength, maxlength, -1, SubStat.CmtRev, &SubStat));
index = 0;
while (InsertRevisionW(TEXT(VERDEFAND), (wchar_t*)pBuf.get(), index, filelength, maxlength, -1, SubStat.CmtRev, &SubStat));
index = 0;
while (InsertRevision(VERDEFOFFSET1, pBuf.get(), index, filelength, maxlength, -1, SubStat.CmtRev, &SubStat));
index = 0;
while (InsertRevisionW(TEXT(VERDEFOFFSET1), (wchar_t*)pBuf.get(), index, filelength, maxlength, -1, SubStat.CmtRev, &SubStat));
index = 0;
while (InsertRevision(VERDEFOFFSET2, pBuf.get(), index, filelength, maxlength, -1, SubStat.CmtRev, &SubStat));
index = 0;
while (InsertRevisionW(TEXT(VERDEFOFFSET2), (wchar_t*)pBuf.get(), index, filelength, maxlength, -1, SubStat.CmtRev, &SubStat));
index = 0;
while (InsertRevision(RANGEDEF, pBuf.get(), index, filelength, maxlength, SubStat.MinRev, SubStat.MaxRev, &SubStat));
index = 0;
while (InsertRevisionW(TEXT(RANGEDEF), (wchar_t*)pBuf.get(), index, filelength, maxlength, SubStat.MinRev, SubStat.MaxRev, &SubStat));
index = 0;
while (InsertDate(DATEDEF, pBuf.get(), index, filelength, maxlength, SubStat.CmtDate));
index = 0;
while (InsertDateW(TEXT(DATEDEF), (wchar_t*)pBuf.get(), index, filelength, maxlength, SubStat.CmtDate));
index = 0;
while (InsertDate(DATEDEFUTC, pBuf.get(), index, filelength, maxlength, SubStat.CmtDate));
index = 0;
while (InsertDateW(TEXT(DATEDEFUTC), (wchar_t*)pBuf.get(), index, filelength, maxlength, SubStat.CmtDate));
index = 0;
while (InsertDate(DATEWFMTDEF, pBuf.get(), index, filelength, maxlength, SubStat.CmtDate));
index = 0;
while (InsertDateW(TEXT(DATEWFMTDEF), (wchar_t*)pBuf.get(), index, filelength, maxlength, SubStat.CmtDate));
index = 0;
while (InsertDate(DATEWFMTDEFUTC, pBuf.get(), index, filelength, maxlength, SubStat.CmtDate));
index = 0;
while (InsertDateW(TEXT(DATEWFMTDEFUTC), (wchar_t*)pBuf.get(), index, filelength, maxlength, SubStat.CmtDate));
index = 0;
while (InsertDate(NOWDEF, pBuf.get(), index, filelength, maxlength, USE_TIME_NOW));
index = 0;
while (InsertDateW(TEXT(NOWDEF), (wchar_t*)pBuf.get(), index, filelength, maxlength, USE_TIME_NOW));
index = 0;
while (InsertDate(NOWDEFUTC, pBuf.get(), index, filelength, maxlength, USE_TIME_NOW));
index = 0;
while (InsertDateW(TEXT(NOWDEFUTC), (wchar_t*)pBuf.get(), index, filelength, maxlength, USE_TIME_NOW));
index = 0;
while (InsertDate(NOWWFMTDEF, pBuf.get(), index, filelength, maxlength, USE_TIME_NOW));
index = 0;
while (InsertDateW(TEXT(NOWWFMTDEF), (wchar_t*)pBuf.get(), index, filelength, maxlength, USE_TIME_NOW));
index = 0;
while (InsertDate(NOWWFMTDEFUTC, pBuf.get(), index, filelength, maxlength, USE_TIME_NOW));
index = 0;
while (InsertDateW(TEXT(NOWWFMTDEFUTC), (wchar_t*)pBuf.get(), index, filelength, maxlength, USE_TIME_NOW));
index = 0;
while (InsertBoolean(MODDEF, pBuf.get(), index, filelength, SubStat.HasMods));
index = 0;
while (InsertBooleanW(TEXT(MODDEF), (wchar_t*)pBuf.get(), index, filelength, SubStat.HasMods));
index = 0;
while (InsertBoolean(UNVERDEF, pBuf.get(), index, filelength, SubStat.HasUnversioned));
index = 0;
while (InsertBooleanW(TEXT(UNVERDEF), (wchar_t*)pBuf.get(), index, filelength, SubStat.HasUnversioned));
index = 0;
while (InsertBoolean(MIXEDDEF, pBuf.get(), index, filelength, (SubStat.MinRev != SubStat.MaxRev) || SubStat.bIsExternalMixed));
index = 0;
while (InsertBooleanW(TEXT(MIXEDDEF), (wchar_t*)pBuf.get(), index, filelength, (SubStat.MinRev != SubStat.MaxRev) || SubStat.bIsExternalMixed));
index = 0;
while (InsertBoolean(EXTALLFIXED, pBuf.get(), index, filelength, !SubStat.bIsExternalsNotFixed));
index = 0;
while (InsertBooleanW(TEXT(EXTALLFIXED), (wchar_t*)pBuf.get(), index, filelength, !SubStat.bIsExternalsNotFixed));
index = 0;
while (InsertBoolean(ISTAGGED, pBuf.get(), index, filelength, SubStat.bIsTagged));
index = 0;
while (InsertBooleanW(TEXT(ISTAGGED), (wchar_t*)pBuf.get(), index, filelength, SubStat.bIsTagged));
index = 0;
while (InsertUrl(URLDEF, pBuf.get(), index, filelength, maxlength, SubStat.Url));
index = 0;
while (InsertUrlW(TEXT(URLDEF), (wchar_t*)pBuf.get(), index, filelength, maxlength, Utf8ToWide(SubStat.Url).c_str()));
index = 0;
while (InsertBoolean(ISINSVN, pBuf.get(), index, filelength, SubStat.bIsSvnItem));
index = 0;
while (InsertBooleanW(TEXT(ISINSVN), (wchar_t*)pBuf.get(), index, filelength, SubStat.bIsSvnItem));
index = 0;
while (InsertBoolean(NEEDSLOCK, pBuf.get(), index, filelength, SubStat.LockData.NeedsLocks));
index = 0;
while (InsertBooleanW(TEXT(NEEDSLOCK), (wchar_t*)pBuf.get(), index, filelength, SubStat.LockData.NeedsLocks));
index = 0;
while (InsertBoolean(ISLOCKED, pBuf.get(), index, filelength, SubStat.LockData.IsLocked));
index = 0;
while (InsertBooleanW(TEXT(ISLOCKED), (wchar_t*)pBuf.get(), index, filelength, SubStat.LockData.IsLocked));
index = 0;
while (InsertDate(LOCKDATE, pBuf.get(), index, filelength, maxlength, SubStat.LockData.CreationDate));
index = 0;
while (InsertDateW(TEXT(LOCKDATE), (wchar_t*)pBuf.get(), index, filelength, maxlength, SubStat.LockData.CreationDate));
index = 0;
while (InsertDate(LOCKDATEUTC, pBuf.get(), index, filelength, maxlength, SubStat.LockData.CreationDate));
index = 0;
while (InsertDateW(TEXT(LOCKDATEUTC), (wchar_t*)pBuf.get(), index, filelength, maxlength, SubStat.LockData.CreationDate));
index = 0;
while (InsertDate(LOCKWFMTDEF, pBuf.get(), index, filelength, maxlength, SubStat.LockData.CreationDate));
index = 0;
while (InsertDateW(TEXT(LOCKWFMTDEF), (wchar_t*)pBuf.get(), index, filelength, maxlength, SubStat.LockData.CreationDate));
index = 0;
while (InsertDate(LOCKWFMTDEFUTC, pBuf.get(), index, filelength, maxlength, SubStat.LockData.CreationDate));
index = 0;
while (InsertDateW(TEXT(LOCKWFMTDEFUTC), (wchar_t*)pBuf.get(), index, filelength, maxlength, SubStat.LockData.CreationDate));
index = 0;
while (InsertUrl(LOCKOWNER, pBuf.get(), index, filelength, maxlength, SubStat.LockData.Owner));
index = 0;
while (InsertUrlW(TEXT(LOCKOWNER), (wchar_t*)pBuf.get(), index, filelength, maxlength, Utf8ToWide(SubStat.LockData.Owner).c_str()));
index = 0;
while (InsertUrl(LOCKCOMMENT, pBuf.get(), index, filelength, maxlength, SubStat.LockData.Comment));
index = 0;
while (InsertUrlW(TEXT(LOCKCOMMENT), (wchar_t*)pBuf.get(), index, filelength, maxlength, Utf8ToWide(SubStat.LockData.Comment).c_str()));
CAutoFile hFile = CreateFile(dst, GENERIC_WRITE|GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, NULL, NULL);
if (!hFile)
{
_tprintf(L"Unable to open output file '%s' for writing\n", dst);
return ERR_OPEN;
}
size_t filelengthExisting = GetFileSize(hFile, NULL);
BOOL sameFileContent = FALSE;
if (filelength == filelengthExisting)
{
DWORD readlengthExisting = 0;
auto pBufExisting = std::make_unique<char[]>(filelength);
if (!ReadFile(hFile, pBufExisting.get(), (DWORD)filelengthExisting, &readlengthExisting, NULL))
{
_tprintf(L"Could not read the file '%s'\n", dst);
return ERR_READ;
}
if (readlengthExisting != filelengthExisting)
{
_tprintf(L"Could not read the file '%s' to the end!\n", dst);
return ERR_READ;
}
sameFileContent = (memcmp(pBuf.get(), pBufExisting.get(), filelength) == 0);
}
// The file is only written if its contents would change.
// this object prevents the timestamp from changing.
if (!sameFileContent)
{
SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
WriteFile(hFile, pBuf.get(), (DWORD)filelength, &readlength, NULL);
if (readlength != filelength)
{
_tprintf(L"Could not write the file '%s' to the end!\n", dst);
return ERR_READ;
}
if (!SetEndOfFile(hFile))
{
_tprintf(L"Could not truncate the file '%s' to the end!\n", dst);
return ERR_READ;
}
}
return 0;
}
