{

// Don't do anything if it isn't necessary

if (MCStringGetLength(p_legacy) < (MAX_PATH - 1))

{

r_nt = MCValueRetain(p_legacy);

return;

}

// UNC and local paths are treated differently

if (MCStringGetCharAtIndex(p_legacy, 0) == '\\' && MCStringGetCharAtIndex(p_legacy, 1) == '\\')

{

// Check that an explicit NT path isn't already being specified

if (MCStringGetCharAtIndex(p_legacy, 2) == '?' // Legacy paths namespace

|| MCStringGetCharAtIndex(p_legacy, 2) == '.') // Device paths namespace

{

r_nt = MCValueRetain(p_legacy);

return;

}

// UNC path

MCStringRef t_temp;

/* UNCHECKED */ MCStringCreateMutable(0, t_temp);

/* UNCHECKED */ MCStringAppend(t_temp, MCSTR("\\\\?\\UNC\\"));

/* UNCHECKED */ MCStringAppendSubstring(t_temp, p_legacy, MCRangeMake(2, MCStringGetLength(p_legacy) - 2));

/* UNCHECKED */ MCStringCopyAndRelease(t_temp, r_nt);

}

else

{

// Local path

/* UNCHECKED */ MCStringFormat(r_nt, "\\\\?\\%@", p_legacy);

}

{

// Check for the leading NT path characters

if (MCStringBeginsWithCString(p_nt, (const char_t*)"\\\\?\\UNC\\", kMCStringOptionCompareCaseless))

{

MCStringRef t_temp;

/* UNCHECKED */ MCStringMutableCopySubstring(p_nt, MCRangeMake(8, MCStringGetLength(p_nt) - 8), t_temp);

/* UNCHECKED */ MCStringPrepend(t_temp, MCSTR("\\\\"));

/* UNCHECKED */ MCStringCopyAndRelease(t_temp, r_legacy);

}

else if (MCStringBeginsWithCString(p_nt, (const char_t*)"\\\\?\\", kMCStringOptionCompareCaseless))

{

/* UNCHECKED */ MCStringCopySubstring(p_nt, MCRangeMake(4, MCStringGetLength(p_nt) - 4), r_legacy);

}

else

{

// Not an NT-style path, no changes required.

r_legacy = MCValueRetain(p_nt);

}

{

// Device paths are opened as "COM<n>:" where <n> is an integer

if (MCStringBeginsWithCString(p_path, (const char_t*)"COM", kMCStringOptionCompareCaseless)

&& MCStringGetCharAtIndex(p_path, MCStringGetLength(p_path) - 1) == ':')

{

// Serial ports live in the NT device namespace (but don't have a ':' suffix)

MCStringRef t_temp;

return MCStringCreateMutable(0, t_temp)

&& MCStringAppend(t_temp, MCSTR("\\\\.\\"))

&& MCStringAppendSubstring(t_temp, p_path, MCRangeMake(0, MCStringGetLength(p_path) - 1))

&& MCStringCopyAndRelease(t_temp, r_device_path);

}

else

return MCStringCopy(p_path, r_device_path);

{

if (!wsainited)

{

WORD request = MAKEWORD(1,1);

WSADATA wsaData;

if (WSAStartup(request, (LPWSADATA)&wsaData))

MCresult->sets("can't find a usable winsock.dll");

else

{

wsainited = True;

// OK-2009-02-24: [[Bug 7628]]

MCresult -> sets("");

#ifdef _WINDOWS_DESKTOP

if (!MCnoui)

sockethwnd = CreateWindowA(MC_WIN_CLASS_NAME, "MCsocket", WS_POPUP, 0, 0,

8, 8, NULL, NULL, MChInst, NULL);

#endif

}

}

MCS_seterrno(0);

return wsainited;

{

uint32_t t_amount;

DWORD t_read;

if (!ReadFile(p_pipe, &t_amount, sizeof(uint32_t), &t_read, NULL) ||

t_read != sizeof(uint32_t))

return false;

void *t_buffer;

t_buffer = malloc(t_amount);

if (t_buffer == nil)

return false;

if (!ReadFile(p_pipe, t_buffer, t_amount, &t_read, NULL) ||

t_read != t_amount)

return false;

r_data = t_buffer;

r_data_length = t_amount;

return true;

{

DWORD t_written;

if (!WriteFile(p_pipe, &p_count, sizeof(p_count), &t_written, NULL) ||

t_written != 4)

return false;

if (!WriteFile(p_pipe, p_data, p_count, &t_written, NULL) ||

t_written != p_count)

return false;

return true;

{

DWORD t_flags;

int t_result;

t_result = GetNamedPipeInfo((HANDLE)p_handle, &t_flags, NULL, NULL, NULL);

return t_result != 0;

{

// We can safely assume that the kernel dll is loaded!

HMODULE t_module;

t_module = GetModuleHandleA("Kernel32.dll");

if (t_module == NULL)

return -1;

// Resolve the symbol

void *t_ptr;

t_ptr = GetProcAddress(t_module, "GetProcessIdOfThread");

if (t_ptr == NULL)

return -1;

// Call it

return ((GetProcessIdOfThreadPtr)t_ptr)(p_thread);

{

uindex_t t_length = MCStringGetLength(p_path);

uindex_t t_offset = t_length;

if (!MCStringFirstIndexOfChar(p_path, '\\', 0, kMCStringOptionCompareExact, t_offset))

{

t_offset = t_length;

}

return MCStringCopySubstring(p_path, MCRangeMake(0, t_offset), r_root) &&

MCStringCopySubstring(p_path, MCRangeMake(t_offset + 1, t_length), r_key);

{

// only copy components out if they are present - <ROOT>\<KEY>\<VALUE>, <ROOT>\<VALUE>, <ROOT>

// (components may be empty)

bool t_success = true;

uindex_t t_length = MCStringGetLength(p_path);

uindex_t t_path_offset = t_length;

uindex_t t_value_offset = t_length;

if (MCStringLastIndexOfChar(p_path, '\\', t_length, kMCStringOptionCompareExact, t_value_offset))

{

if (MCStringFirstIndexOfChar(p_path, '\\', 0, kMCStringOptionCompareExact, t_path_offset))

{

if (t_value_offset > t_path_offset)

t_success = t_success && MCStringCopySubstring(p_path, MCRangeMake(t_path_offset + 1, t_value_offset - t_path_offset - 1), r_key);

}

t_success = t_success && MCStringCopySubstring(p_path, MCRangeMake(t_value_offset + 1, t_length - t_value_offset - 1), r_value);

}

return t_success && MCStringCopySubstring(p_path, MCRangeMake(0, t_path_offset), r_root);

{

for (uindex_t i = 0 ; i < ELEMENTS(Regkeys) ; i++)

{

if (MCStringIsEqualToCString(p_root, Regkeys[i].token, kMCCompareCaseless))

{

r_hkey = Regkeys[i].key;

return true;

}

}

return false;

{

for (uindex_t i = 0 ; i < ELEMENTS(Regkeys) ; i++)

{

if (MCStringIsEqualToCString(p_root, Regkeys[i].token, kMCCompareCaseless))

{

r_hkey = Regkeys[i].key;

if (MCmajorosversion >= 0x0501)

x_access_mode |= Regkeys[i].mode;

return true;

}

}

return false;

{

for (uindex_t i = 0 ; i < ELEMENTS(RegDatatypes) ; i++)

{

if (p_type == RegDatatypes[i].type)

{

r_string = MCSTR(RegDatatypes[i].token);

return true;

}

}

// SN-2014-11-18: [[ Bug 14052 ]] Avoid to return a nil string (the result is not checked anyway).

r_string = MCValueRetain(kMCEmptyString);

return false;

{

if (p_string != nil)

{

for (uindex_t i = 0; i < ELEMENTS(RegDatatypes); i++)

{

if (MCStringIsEqualToCString(p_string, RegDatatypes[i].token, kMCCompareCaseless))

return (MCSRegistryValueType)RegDatatypes[i].type;

}

}

return kMCSRegistryValueTypeSz;

{

MCAutoRegistryKey(void)

{

m_key = NULL;

}

~MCAutoRegistryKey(void)

{

if (m_key != NULL)

RegCloseKey(m_key);

}

HKEY operator = (HKEY value)

{

MCAssert(m_key == NULL);

m_key = value;

return m_key;

}

HKEY* operator & (void)

{

MCAssert(m_key == NULL);

return &m_key;

}

HKEY operator * (void) const

{

return m_key;

}

HKEY m_key;

{

for (uindex_t i = 0 ; i < ELEMENTS(sysfolderlist) ; i++)

{

if (MCNameIsEqualTo(p_folder, *(sysfolderlist[i].token)))

{

return MCNumberCreateWithUnsignedInteger(sysfolderlist[i].winfolder, r_csidl);

}

}

return false;

{

DWORD nread;

uint32_t t_bufsize = READ_PIPE_SIZE;

char* t_buffer = new char[t_bufsize];

while (process -> ihandle != NULL)

{

if (!PeekNamedPipe(process -> ihandle -> GetFilePointer(), NULL, 0, NULL, &nread, NULL))

break;

if (nread == 0)

{

if (WaitForSingleObject(process -> phandle, 0) != WAIT_TIMEOUT)

break;

Sleep(100);

continue;

}

if (!ReadFile(process -> ihandle -> GetFilePointer(), (LPVOID)t_buffer,

t_bufsize, &nread, NULL)

|| nread == 0)

break;

/* UNCHECKED */ process -> ohandle -> Write(t_buffer, nread);

}

delete[] t_buffer;

MCNotifyPush(readThreadDone, nil, false, false);

return 0;

{

// NOTE:

// Get/SetCurrentDirectory are not supported by Windows in multithreaded environments

MCAutoArray<unichar_t> t_buffer;

// Retrieve the length of the current directory

DWORD t_path_len = GetCurrentDirectoryW(0, NULL);

/* UNCHECKED */ t_buffer.New(t_path_len);

DWORD t_result = GetCurrentDirectoryW(t_path_len, t_buffer.Ptr());

if (t_result == 0 || t_result >= t_path_len)

{

// Something went wrong

return false;

}

return MCStringCreateWithChars(t_buffer.Ptr(), t_result, r_path);

{

MCAutoStringRefAsWString t_path_wstr;

/* UNCHECKED */ t_path_wstr.Lock(p_path);

// MW-2010-10-22: [[ Bug 8259 ]] Use a proper Win32 API function - otherwise network shares don't work.

DWORD t_attrs;

t_attrs = GetFileAttributesW(*t_path_wstr);

if (t_attrs == INVALID_FILE_ATTRIBUTES)

return false;

return p_is_file == ((t_attrs & FILE_ATTRIBUTE_DIRECTORY) == 0);

{

#ifdef /* MCS_exists_dsk_w32 */ LEGACY_SYSTEM

char *newpath = MCS_resolvepath(path);

//MS's stat() fails if there is a trailing '\\'. Workaround is to delete it

// MW-2004-04-20: [[ Purify ]] If *newpath == 0 then we should return False

if (*newpath == '\0')

{

delete newpath;

return False;

}

// MW-2008-01-15: [[ Bug 4981 ]] - It seems that stat will fail for checking

// a folder 'C:' and requires that it be 'C:\'

if (strlen(newpath) == 2 && newpath[1] == ':')

{

// newpath is of form "<driveletter>:"

char *t_modified_path;

t_modified_path = new char[strlen(newpath) + 2];

strcpy(t_modified_path, newpath);

strcat(t_modified_path, "\\");

delete newpath;

newpath = t_modified_path;

// newpath is of form "<driverletter>:\"

}

// OK-2007-12-05 : Bug 5555, modified to allow paths with trailing backslashes on Windows.

if ((newpath[strlen(newpath) - 1] == '\\' || newpath[strlen(newpath) - 1] == '/')

&& (strlen(newpath) != 3 || newpath[1] != ':'))

newpath[strlen(newpath) - 1] = '\0';

// MW-2010-10-22: [[ Bug 8259 ]] Use a proper Win32 API function - otherwise network shares don't work.

DWORD t_attrs;

t_attrs = GetFileAttributesA(newpath);

delete newpath;

if (t_attrs == INVALID_FILE_ATTRIBUTES)

return False;

return file == ((t_attrs & FILE_ATTRIBUTE_DIRECTORY) == 0);

#endif /* MCS_exists_dsk_w32 */

// MW-2004-04-20: [[ Purify ]] If *newpath == 0 then we should return False

if (MCStringGetLength(p_path) == 0)

return False;

// MW-2008-01-15: [[ Bug 4981 ]] - It seems that stat will fail for checking

// a folder 'C:' and requires that it be 'C:\'

// TODO: still necessary with GetFileAttributes instead of stat?

/*if (MCStringGetLength(p_path) == 2 && MCStringGetCharAtIndex(p_path, 1) == ':')

// OK-2007-12-05 : Bug 5555, modified to allow paths with trailing backslashes on Windows.

// TODO: still necessary with GetFileAttributes instead of stat?

uindex_t t_path_len = MCStringGetLength(p_path);

unichar_t t_last_char = MCStringGetCharAtIndex(p_path, t_path_len - 1);

if ((t_last_char == '\\' || t_last_char == '/') &&

!(t_path_len == 3 && MCStringGetCharAtIndex(p_path, 1) == ':'))

{

MCAutoStringRef t_trimmed_string;

return MCStringCopySubstring(p_path, MCRangeMake(0, t_path_len - 1), &t_trimmed_string) &&

MCS_native_path_exists(*t_trimmed_string, p_is_file);

}

return MCS_native_path_exists(p_path, p_is_file);

{

MCAutoStringRef t_path;

if (!MCStringMutableCopy(p_base, &t_path))

return false;

if (MCStringGetCharAtIndex(p_base, MCStringGetLength(p_base) - 1) != p_separator &&

!MCStringAppendChars(*t_path, &p_separator, 1))

return false;

if (!MCStringAppend(*t_path, p_component))

return false;

r_path = MCValueRetain(*t_path);

return true;

{

MCAutoListRef t_list;

ULONG t_buffer_size = 0;

MCAutoBlock<byte_t> t_buffer;

FIXED_INFO *t_fixed_info = nil;

errno = GetNetworkParams(t_fixed_info, &t_buffer_size);

if (errno == ERROR_NO_DATA)

{

r_list = MCValueRetain(kMCEmptyList);

return true;

}

else if (errno != ERROR_BUFFER_OVERFLOW)

return false;

if (!t_buffer.Allocate(t_buffer_size))

return false;

if (!MCListCreateMutable('\n', &t_list))

return false;

t_fixed_info = (FIXED_INFO*)*t_buffer;

MCMemoryClear(t_fixed_info, t_buffer_size);

errno = GetNetworkParams(t_fixed_info, &t_buffer_size);

if (errno == ERROR_SUCCESS)

{

IP_ADDR_STRING *t_addr_string = &t_fixed_info->DnsServerList;

while (t_addr_string != nil && t_addr_string->IpAddress.String[0] != '\0')

{

if (!MCListAppendCString(*t_list, t_addr_string->IpAddress.String))

return false;

t_addr_string = t_addr_string->Next;

}

}

return MCListCopy(*t_list, r_list);

{

MCAutoStringRef t_key, t_type, t_error;

MCAutoValueRef t_value;

t_key = MCSTR(NAMESERVER_REG_KEY);

if (!MCS_query_registry(*t_key, &t_value, &t_type, &t_error))

return false;

if (!MCStringIsEmpty(*t_error))

{

r_list = MCValueRetain(kMCEmptyList);

return true;

}

// If the type is wrong, abort

if (MCValueGetTypeCode(*t_value) != kMCValueTypeCodeString)

return false;

MCStringRef t_string = (MCStringRef)*t_value;

MCAutoListRef t_list;

if (!MCListCreateMutable('\n', &t_list))

return false;

const unichar_t *t_chars;

uindex_t t_char_count;

t_chars = MCStringGetCharPtr(t_string);

t_char_count = MCStringGetLength(t_string);

uindex_t t_start = 0;

for (uindex_t i = 0; i < t_char_count; i++)

{

if (t_chars[i] == ' ' || t_chars[i] == ',' || t_chars[i] == '\n')

{

MCAutoStringRef t_substring;

if (!MCStringCopySubstring(t_string, MCRangeMake(t_start, i - t_start), &t_substring) ||

!MCListAppend(*t_list, *t_substring))

return false;

t_start = i + 1;

}

}

if (t_start < t_char_count)

{

MCAutoStringRef t_final_string;

if (!MCStringCopySubstring(t_string, MCRangeMake(t_start, MCStringGetLength(t_string) - t_start), &t_final_string) ||

!MCListAppend(*t_list, *t_final_string))

return false;

}

return MCListCopy(*t_list, r_list);

{

MCAutoStringRefAsWString t_document_wstr;

/* UNCHECKED */ t_document_wstr.Lock(p_document);

// MW-2011-02-01: [[ Bug 9332 ]] Adjust the 'show' hint to normal to see if that makes

// things always appear on top...

int t_result;

t_result = (int)ShellExecuteW(NULL, L"open", *t_document_wstr, NULL, NULL, SW_SHOWNORMAL);

if (t_result < 32)

{

switch(t_result)

{

case ERROR_BAD_FORMAT:

case SE_ERR_ACCESSDENIED:

case SE_ERR_FNF:

case SE_ERR_PNF:

case SE_ERR_SHARE:

case SE_ERR_DLLNOTFOUND:

MCresult -> sets("can't open file");

break;

case SE_ERR_ASSOCINCOMPLETE:

case SE_ERR_NOASSOC:

MCresult -> sets("no association");

break;

case SE_ERR_DDEBUSY:

case SE_ERR_DDEFAIL:

case SE_ERR_DDETIMEOUT:

MCresult -> sets("request failed");

break;

case 0:

case SE_ERR_OOM:

MCresult -> sets("no memory");

break;

}

}

else

MCresult -> clear();

{

virtual bool MCISendString(MCStringRef p_command, MCStringRef& r_result, bool& r_error)

{

MCAutoStringRefAsWString t_command_wstr;

/* UNCHECKED */ t_command_wstr.Lock(p_command);

DWORD t_error_code;

WCHAR t_buffer[256];

t_buffer[0] = '\0';

t_error_code = mciSendStringW(*t_command_wstr, t_buffer, 255, NULL);

r_error = t_error_code != 0;

if (!r_error)

{

size_t t_length;

if (SUCCEEDED(StringCchLengthW(t_buffer, 256, &t_length)))

return MCStringCreateWithChars(t_buffer, t_length, r_result);

}

size_t t_length;

return mciGetErrorStringW(t_error_code, t_buffer, 255) &&

SUCCEEDED(StringCchLengthW(t_buffer, 256, &t_length)) &&

MCStringCreateWithChars(t_buffer, t_length, r_result);

}

virtual bool QueryRegistry(MCStringRef p_key, MCValueRef& r_value, MCStringRef& r_type, MCStringRef& r_error)

{

MCAutoStringRef t_root, t_key, t_value;

r_value = r_error = nil;

//key = full path info such as: HKEY_LOCAL_MACHINE\\Software\\..\\valuename

if (!MCS_registry_split_key(p_key, &t_root, &t_key, &t_value))

return false;

if (*t_value == nil)

{

/* RESULT */ //MCresult->sets("no key");

r_error = MCSTR("no key");

r_value = MCValueRetain(kMCEmptyString);

return true;

}

if (*t_key == nil)

t_key = kMCEmptyString;

HKEY t_hkey;

MCAutoRegistryKey t_regkey;

uint32_t t_access_mode = KEY_READ;

MCAutoStringRefAsWString t_key_wstr;

/* UNCHECKED */ t_key_wstr.Lock(*t_key);

if (!MCS_registry_root_to_hkey(*t_root, t_hkey, t_access_mode) ||

(RegOpenKeyExW(t_hkey, *t_key_wstr, 0, t_access_mode, &t_regkey) != ERROR_SUCCESS))

{

/* RESULT */ //MCresult->sets("bad key");

r_error = MCSTR("bad key");

return true;

}

LONG err = 0;

MCAutoArray<BYTE> t_buffer;

DWORD t_buffer_len = 0;

DWORD t_type;

MCAutoStringRefAsWString t_value_wstr;

/* UNCHECKED */ t_value_wstr.Lock(*t_value);

//determine the size of value buffer needed

err = RegQueryValueExW(*t_regkey, *t_value_wstr, 0, NULL, NULL, &t_buffer_len);

if (err == ERROR_SUCCESS)

{

if (!t_buffer.New(t_buffer_len))

return false;

if ((err = RegQueryValueExW(*t_regkey, *t_value_wstr, 0, &t_type, t_buffer.Ptr(), &t_buffer_len))

== ERROR_SUCCESS && t_buffer_len > 0)

{

// Sets the type

MCS_registry_type_to_string(t_type, r_type);

// Convert the value from the registry to the appropriate value type

switch (t_type)

{

case REG_LINK:

if (!MCStringCreateWithChars((const unichar_t*)t_buffer.Ptr(), t_buffer_len/2, (MCStringRef&)r_value))

return false;

break;

case REG_EXPAND_SZ:

case REG_MULTI_SZ:

case REG_SZ:

{

DWORD t_unicode_len;

t_unicode_len = t_buffer_len / 2;

unichar_t *t_chars = (unichar_t*)t_buffer.Ptr();

// Get rid of any trailing NULL character

while(t_unicode_len > 0 && t_chars[t_unicode_len - 1] == '\0')

t_unicode_len -= 1;

if (t_type == REG_MULTI_SZ && t_unicode_len < t_buffer_len / 2)

t_unicode_len += 1;

return MCStringCreateWithChars((unichar_t*)t_buffer.Ptr(), t_unicode_len, (MCStringRef&)r_value);

}

case REG_NONE:

{

// No data. Return an empty string ref as the nearest equivalent

r_value = MCValueRetain(kMCEmptyString);

break;

}

case REG_DWORD:

case REG_QWORD:

case REG_BINARY:

default:

{

// Binary or unsupported type. Return as a binary blob

// (For compatibility with existing scripts, DWORD and QWORD are binary)

MCAutoDataRef t_data;

if (!MCDataCreateWithBytes((const byte_t*)t_buffer.Ptr(), t_buffer_len, (MCDataRef&)t_data))

return false;

r_value = MCValueRetain(*t_data);

break;

}

}

}

}

else if (err == ERROR_FILE_NOT_FOUND)

{

// The query may have been for a value that is really a key, either

// with or without a default/un-named value attached to it. Try

// opening the path to the value as a key.

MCAutoStringRef t_alt_key;

MCAutoStringRefAsWString t_alt_key_wstr;

if (MCStringIsEmpty(*t_key))

t_alt_key = *t_value;

else

/* UNCHECKED */ MCStringFormat(&t_alt_key, "%@\\%@", *t_key, *t_value);

/* UNCHECKED */ t_alt_key_wstr.Lock(*t_alt_key);

MCAutoRegistryKey t_alt_regkey;

err = RegOpenKeyExW(t_hkey, *t_alt_key_wstr, 0, t_access_mode, &t_alt_regkey);

if (err == ERROR_SUCCESS)

{

// Key exists

r_value = MCValueRetain(kMCEmptyString);

MCS_registry_type_to_string(REG_NONE, r_type);

}

}

if (err != ERROR_SUCCESS)

{

errno = err;

r_error = MCSTR("can't find key");

return true;

}

return true;

}

virtual bool SetRegistry(MCStringRef p_key, MCValueRef p_value, MCSRegistryValueType p_type, MCStringRef& r_error)

{

MCAutoStringRef t_root, t_key, t_value;

HKEY t_root_hkey;

if (!MCS_registry_split_key(p_key, &t_root, &t_key, &t_value))

return false;

if (!MCS_registry_root_to_hkey(*t_root, t_root_hkey))

{

/* RESULT */ //MCresult->sets("bad key");

r_error = MCSTR("bad key");

return true;

}

if (*t_key == nil)

{

/* RESULT */ //MCresult->sets("bad key specified");

r_error = MCSTR("bad key specified");

return true;

}

MCAutoRegistryKey t_regkey;

DWORD t_keystate;

MCAutoStringRefAsWString t_key_wstr;

/* UNCHECKED */ t_key_wstr.Lock(*t_key);

if (RegCreateKeyExW(t_root_hkey, *t_key_wstr, 0, NULL, REG_OPTION_NON_VOLATILE,

KEY_ALL_ACCESS, NULL, &t_regkey, &t_keystate) != ERROR_SUCCESS)