Calling windows API using D

I hope one day the D language will be popular, but it's really a pity that a genius won't be successful,  comrade and collaboration lead to succeed.

 

Here I show a example how to invoke windows API using API.

Build tool:bud_win_3.04.dbg.exe

Compiler: DMD2.0

Additional MS liberary: advapi32.lib and mpr.lib with OMF format, notice that MS lib is coff format.

 

This application will check the read, write priviliege on local machine or remote host

 

 /** * abiABiValidator.d */ module abi.ABiValidator; import std.file; import std.path; import std.stdio; import std.stream; import std.string; import std.c.string; import std.c.stdlib; import std.c.windows.windows; import abi.FileUtil; /** * DMD2.0 advapi32.lib and mpr.lib are necessary * FIXME, we should check whether it is a file or folder in the future. * Authors: zealz */ class ABiValidator { private string[string] iniConfigs; private string abiPath = null; private string exePath = null; private string[int] l2Servers; private string[string] l1Images; private const string LIBPATH = "LIBPATH"; private const string DFCXACT_DIR = "DFCXACT_DIR"; private const string L2MESSAGE_DIR = "L2MESSAGE_DIR"; private const string LOC_FILE = "LOC_FILE"; this(string pExePath) { this.exePath = pExePath; } ~this(){ } private int getABiPathFromRegistry() { HKEY hkResult = null; HKEY uninstallHKey = null; //Position to uninstall node. int retCode = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SOFTWARE//Microsoft//Windows//CurrentVersion//Uninstall/0".ptr, 0, KEY_READ, &hkResult); if (retCode != 0) { //writefln("Open uninstall node error"); goto cleanup; } DWORD subKeys; retCode = RegQueryInfoKeyA(hkResult, null, null, null, &subKeys, null, null, null, null, null, null, null); if (retCode != 0) { retCode = -1; goto cleanup; } const DWORD MAX_KEY_LENGTH = 255; const DWORD MAX_VALUE_LENGTH = 16383; char[MAX_KEY_LENGTH] uninstallKeyName; char[MAX_KEY_LENGTH] uninstallKeyAttribute; char[MAX_VALUE_LENGTH] data; DWORD regType; DWORD dataLength; DWORD keyLength = MAX_KEY_LENGTH; DWORD valueLength = MAX_VALUE_LENGTH; DWORD valueCount; bool findKey = false; retCode = -1; string installPath = null; for (DWORD i = 0; i < subKeys; ++i) { installPath = null; keyLength = MAX_KEY_LENGTH; //Retrieve each program node name under uninstall node. retCode = RegEnumKeyExA(hkResult, i, uninstallKeyName.ptr, &keyLength, null, null, null, null); if (retCode != 0) continue; //Open the program node retCode = RegOpenKeyExA(hkResult, uninstallKeyName.ptr, 0, KEY_READ, &uninstallHKey); if (retCode != 0) continue; //Query the program node info. Retrieve all its value nodes. retCode = RegQueryInfoKeyA(uninstallHKey, null, null, null, null, null, null, &valueCount, null, null, null, null); if (retCode != 0) continue; for (DWORD j = 0; j < valueCount; ++j) { valueLength = MAX_VALUE_LENGTH; retCode = RegEnumValueA(uninstallHKey, j, uninstallKeyAttribute.ptr, &valueLength, null, ®Type, cast(LPBYTE)data.ptr, &dataLength); if (retCode != 0) continue; //At most of the time, the buffer to store data is enough, it will append /0 after the RegEnumValueA function call if (strcmp(uninstallKeyAttribute.ptr, "DisplayName".ptr) == 0 && regType == REG_SZ) { //writefln(std.string.toString(data.ptr)); if (strcmp(data.ptr, "ABi/0".ptr) != 0) { continue; } findKey = true; } if (strcmp(uninstallKeyAttribute.ptr, "InstallLocation/0".ptr) == 0 && regType == REG_SZ) { installPath = std.string.toString(data.ptr); //writefln(std.string.toString(data.ptr)); } } if (findKey && installPath) { this.abiPath = installPath; retCode = RETURN_SUCCESS; break; } else { retCode = -1; } } cleanup: if (uninstallHKey) RegCloseKey(uninstallHKey); if (hkResult) RegCloseKey(hkResult); return retCode; } public int validateABiConfig() { int retCode = this.getABiPathFromRegistry(); if (retCode != RETURN_SUCCESS) { this.abiPath = this.exePath; writefln("No registry for ABi, set ABi home same to ABiValidator.exe =", this.abiPath); } else { writefln("ABi home in registry =", this.abiPath); } writefln("(1)Checking abi.ini"); //Load abi.ini and check the values inside retCode = loadIniConfigs(); if (retCode != RETURN_SUCCESS) { printMessage(retCode); return retCode; } //Validate the abi.ini values retCode = validateIniConfigs(); if (retCode != RETURN_SUCCESS) { printMessage(retCode); return retCode; } writefln("/n(2)Checking LIBPATH=", this.iniConfigs[LIBPATH]); retCode = this.loadLibPath(); if (retCode != RETURN_SUCCESS) { printMessage(retCode); return retCode; } retCode = validateLibPath(); if (retCode != RETURN_SUCCESS) { printMessage(LIBPATH_L2SERVER_NOT_ACCESS); return retCode; } writefln("/n(3)Checing Resource file=", this.iniConfigs[LOC_FILE]); retCode = this.loadResource(); if (retCode != RETURN_SUCCESS) { printMessage(retCode); return retCode; } retCode = this.validateResource(); if (retCode != RETURN_SUCCESS) { printMessage(retCode); return retCode; } writefln("/n(4)Checking DFCXACT request folder=", this.iniConfigs[DFCXACT_DIR]); retCode = this.validateRequestFolder(); if (retCode != RETURN_SUCCESS) { printMessage(retCode); return retCode; } writefln("/nValidate sucessfully."); return RETURN_SUCCESS; } enum { RETURN_SUCCESS = 0, ABI_INI_MISSING = 1, ABI_INI_NOT_READ_WRITE = 2, ABI_INI_READ_WRITE_DENY = 3, ABI_INI_EMPTY = 4, ABI_INI_LIBPATH_MISSING = 5, ABI_INI_DFCXACT_DIR_MISSING = 6, ABI_INI_L2MESSAGE_DIR_MISSING = 7, ABI_INI_LOC_FILE_MISSING = 8, LIBPATH_NOT_EXIST = 9, DFCXACT_NOT_EXIST = 10, L2MESSAGE_NOT_EXIST = 11, LOC_FILE_NOT_EXIST = 12, LIBPATH_NOT_READ_WRITE = 13, LIBPATH_READ_WRITE_DENY = 14, LIBPATH_CONTENT_EMPTY = 15, LIBPATH_L2SERVER_NOT_ACCESS = 16, LIBPATH_L2SERVER_NOT_READ = 17, RESOURCE_FILE_NOT_READ_WRITE = 18, RESOURCE_FILE_READ_WRITE_DENY = 19, RESOURCE_FILE_CONTENT_EMPTY = 20, L1FOLDER_MISSING = 21, //L1FOLDER_NOT_READ_WRITE = 22, L1FOLDER_READ_WRITE_DENY = 23, DFCXACT_READ_WRITE_DENY = 24, DFCXACT_CHILDREN_NOT_READ_WRITE = 25, DFCXACT_CHILDREN_READ_WRITE_DENY = 26, } private void printMessage(int retCode, ...) { string[int] messages; messages[0] = "Success."; messages[1] = "Error:abi.ini is missing."; messages[2] = "Error:abi.ini attribute is not read and write."; messages[3] = "Error:abi.ini can not be read or written by current user."; messages[4] = "Error:abi.ini content is empty."; messages[5] = "Error:LIBPATH item is missing in abi.ini."; messages[6] = "Error:DFCXACT_DIR item is missing in abi.ini."; messages[7] = "Error:L2MESSAGE_DIR item is missing in abi.ini."; messages[8] = "Error:LOC_FILE item is missing in abi.ini."; messages[9] = "Error:LIBPATH file does not exist."; messages[10] = "Error:DFCXACT folder does not exist."; messages[11] = "Error:L2MESSAGE folder does not exist."; messages[12] = "Error:LOC_FILE does not exist."; messages[13] = "Error:LIBPATH attribute is not read and write."; messages[14] = "Error:LIBPATH can not be read or written by current user."; messages[15] = "Error:LIBPATH content is empty."; messages[16] = "Error:LIBPATH L2 server is not acceesible."; messages[17] = "Error:LIBPATH L2 server can not be read by current user."; messages[18] = "Error:Resource file not read and write."; messages[19] = "Error:Resource file can not be read and written by current user."; messages[20] = "Error:Resource file is empty."; messages[21] = "Error:L1 image folder is missing."; messages[22] = "Error:L1 image folder attribute is not read and write."; messages[23] = "Error:L1 image folder can not be read and written by current user."; messages[24] = "Error:DFCXACT folder can not be read and written by current user."; messages[25] = "Error:DFCXACT child attribute is not read and write."; messages[26] = "Error:DFCXACT child can not be read and written by current user."; writefln(messages[retCode]); //FIXME A stupid way to handle the dynamic parameters. That should be a better way. } /** * Try to load abi.ini * Returns: */ private int loadIniConfigs() { string iniPath = this.abiPath ~ r"/abi.ini"; if (!exists(iniPath)) return ABI_INI_MISSING; //C-style char array char* pIniPath = toStringz(iniPath); //Check abi.ini whether can be read or written. We must conver the D-style string to C-style string ended with 0 int retCode = access(pIniPath, 6); if (retCode != 0) { return ABI_INI_NOT_READ_WRITE; } retCode = isFileReadWritable(pIniPath); if (retCode != 0) { return ABI_INI_READ_WRITE_DENY; } pIniPath = null; //Read and load abi.ini auto iniFile = new File(iniPath); string line = null; int index = 0; string key = null; string value= null; while ((line = cast(string)iniFile.readLine()) != null) { line = strip(line); if (line.length == 0) continue; index = find(line, cast(dchar)'#'); //Whole line is comment if (index == 0) { continue; } //Trim comment else if (index > 0) { line = line[0..index]; } index = find(line, cast(dchar)'='); //Whole string is key, value is "" if(index < 0) { iniConfigs[line] = ""; } else if (index ==0) { iniConfigs[""] = line; } else { key = strip(line[0..index]); value = strip(line[index+1..line.length]); this.iniConfigs[key] = value; //writefln("%s=%s", key, value); } } iniFile.close(); //Validate the content return (this.iniConfigs.length > 0) ? RETURN_SUCCESS : ABI_INI_EMPTY; } /** * * Returns: */ private int validateIniConfigs() { if (!(LIBPATH in this.iniConfigs)) { return ABI_INI_LIBPATH_MISSING; } if (!(DFCXACT_DIR in this.iniConfigs)) { return ABI_INI_DFCXACT_DIR_MISSING; } if (!(L2MESSAGE_DIR in this.iniConfigs)) { return ABI_INI_L2MESSAGE_DIR_MISSING; } if (!(LOC_FILE in this.iniConfigs)) { return ABI_INI_LOC_FILE_MISSING; } if (!exists(this.iniConfigs[LIBPATH])) { return LIBPATH_NOT_EXIST; } if (!exists(this.iniConfigs[DFCXACT_DIR])) { return DFCXACT_NOT_EXIST; } if (!exists(this.iniConfigs[L2MESSAGE_DIR])) { return L2MESSAGE_NOT_EXIST; } if (!exists(this.iniConfigs[LOC_FILE])) { return LOC_FILE_NOT_EXIST; } return RETURN_SUCCESS; //FIXME Will validate other keys in the future. } /** * Load L2 sever image path -- LIBPATH * Returns: */ private int loadLibPath() { string libPath = this.iniConfigs[LIBPATH]; //Current user should be able to read and write LIBPATH //libPath ~= '/0'; char* pLibPath = toStringz(libPath); int retCode = access(pLibPath, 6); if (retCode != 0) { return LIBPATH_NOT_READ_WRITE; } retCode = isFileReadWritable(pLibPath); if (retCode != 0) { return LIBPATH_READ_WRITE_DENY; } auto libPathFile = new File(libPath); string line; int count = 0; while ((line = cast(string) libPathFile.readLine()) != null) { line = strip(line); if (line.length == 0) continue; this.l2Servers[this.l2Servers.length] = line; } return this.l2Servers.length <= 0 ? LIBPATH_CONTENT_EMPTY : RETURN_SUCCESS; } private int validateLibPath() { char* pL2Server = null; foreach (int i,string l2Server; this.l2Servers) { writefln("L2Server(%d)=%s", i, l2Server); //l2Server ~= '/0'; pL2Server = toStringz(l2Server); if (addWNETConnection(pL2Server) != 0) { //return i + 1; return LIBPATH_L2SERVER_NOT_ACCESS; } if (isDirReadable(pL2Server) != 0) { return LIBPATH_L2SERVER_NOT_READ; } } return RETURN_SUCCESS; } private int loadResource() { string resourcePath = this.iniConfigs[LOC_FILE]; //writefln(resourcePath); //resourcePath ~= '/0'; char* pResourcePath = toStringz(resourcePath); int retCode = access(pResourcePath, 6); if (retCode != 0) { return RESOURCE_FILE_NOT_READ_WRITE; } retCode = isFileReadWritable(pResourcePath); if (retCode != 0) { return RESOURCE_FILE_READ_WRITE_DENY; } pResourcePath = null; auto resourcePathFile = new File(resourcePath); string line; int count = 0; string[] tokens = null; while ((line = cast(string) resourcePathFile.readLine()) != null) { line = strip(line); if (line.length == 0) continue; tokens = split(line); if (tokens.length < 2) continue; this.l1Images[tokens[0]] = tokens[1]; } return this.l1Images.length <= 0 ? RESOURCE_FILE_CONTENT_EMPTY : RETURN_SUCCESS; } private int validateResource() { //writefln("L1IMAGEFOLDER SIZE=", this.l1Images.length); char* pL1ImageFolderPath = null; foreach (string l1ImageFolderName, string l1ImageFolderPath; this.l1Images) { writefln("%s=%s", l1ImageFolderName, l1ImageFolderPath); if(!exists(l1ImageFolderPath)) { return L1FOLDER_MISSING; } pL1ImageFolderPath = toStringz(l1ImageFolderPath); // if (!access(pL1ImageFolderPath, 6)) { // return L1FOLDER_NOT_READ_WRITE; // } //Read, write, delete,create,rename authority if (isDirReadWritable(pL1ImageFolderPath) != 0) { return L1FOLDER_READ_WRITE_DENY; } } return RETURN_SUCCESS; } //FIXME a better way is to return the error file and error code, but however to make it simple, only print it out now private int validateRequestFolder() { string dfcxactFolder = this.iniConfigs[DFCXACT_DIR]; if (dfcxactFolder[dfcxactFolder.length-1] != '//') dfcxactFolder ~= '//'; char* pDfcxactFolder = toStringz(dfcxactFolder); if (isDirReadWritable(pDfcxactFolder)) { return DFCXACT_READ_WRITE_DENY; } //Check DTA IN TR VR, make sure we can read write modify string[] files = listdir(dfcxactFolder); char* pFile = null; foreach (int i, string file; files) { file = dfcxactFolder ~ file; if (isfile(file)) { pFile = toStringz(file); if (access(pFile, 6) != 0) { writefln(file); return DFCXACT_CHILDREN_NOT_READ_WRITE; } if (isFileReadWritable(pFile) != 0) { writefln(file); return DFCXACT_CHILDREN_READ_WRITE_DENY; } } } files = null; //FIXME to validate its temp folder, ABi will create log there. return RETURN_SUCCESS; } } void main(char[][] args) { string exeFullPath = cast(string)args[0]; auto v = new ABiValidator(getDirName(cast(string) exeFullPath)); v.validateABiConfig(); system("pause"); }

 

/** * abiFileUtil.d */ module abi.FileUtil; private import std.c.windows.windows; private import std.stdio; private import std.c.string; extern (C) { export int access(in char* path, int mode); } extern (Windows) { //Start authority API struct ACL { BYTE AclRevision; BYTE Sbz1; WORD AclSize; WORD AceCount; WORD Sbz2; } alias ACL* PACL; alias WORD SECURITY_DESCRIPTOR_CONTROL; alias PVOID PSID; struct SECURITY_DESCRIPTOR { BYTE Revision; BYTE Sbz1; SECURITY_DESCRIPTOR_CONTROL Control; PSID Owner; PSID Group; PACL Sacl; PACL Dacl; } alias SECURITY_DESCRIPTOR* PSECURITY_DESCRIPTOR,PISECURITY_DESCRIPTOR; alias DWORD SECURITY_INFORMATION; enum { OWNER_SECURITY_INFORMATION = 0X00000001L, GROUP_SECURITY_INFORMATION = 0X00000002L, DACL_SECURITY_INFORMATION = 0X00000004L, SACL_SECURITY_INFORMATION = 0X00000008L, } export BOOL GetFileSecurityA(LPCTSTR lpFileName, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded); enum { HEAP_GENERATE_EXCEPTIONS = 0x00000004, HEAP_NO_SERIALIZE = 0x00000001, HEAP_ZERO_MEMORY = 0x00000008, } export LPVOID HeapAlloc(HANDLE hHeap, DWORD dwFlags, DWORD dwBytes); export HANDLE GetProcessHeap(); export BOOL HeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem); enum SECURITY_IMPERSONATION_LEVEL { SecurityAnonymous, SecurityIdentification, SecurityImpersonation, SecurityDelegation } export BOOL ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL ImpersonationLevel); //export HANDLE GetCurrentThread(); alias HANDLE* PHANDLE; enum { TOKEN_ASSIGN_PRIMARY = 0x0001, TOKEN_DUPLICATE = 0x0002, TOKEN_IMPERSONATE = 0x0004, TOKEN_QUERY = 0x0008, TOKEN_QUERY_SOURCE = 0x0010, TOKEN_ADJUST_PRIVILEGES = 0x0020, TOKEN_ADJUST_GROUPS = 0x0040, TOKEN_ADJUST_DEFAULT = 0x0080, } export BOOL OpenThreadToken(HANDLE ThreadHandle, DWORD DesiredAccess, BOOL OpenAsSelf, PHANDLE TokenHandle); export BOOL RevertToSelf(); struct GENERIC_MAPPING { ACCESS_MASK GenericRead; ACCESS_MASK GenericWrite; ACCESS_MASK GenericExecute; ACCESS_MASK GenericAll; } alias GENERIC_MAPPING* PGENERIC_MAPPING; export VOID MapGenericMask(PDWORD AccessMask, PGENERIC_MAPPING GenericMapping); struct LUID { DWORD LowPart; LONG HighPart; } alias LUID* PLUID; struct LUID_AND_ATTRIBUTES { LUID Luid; DWORD Attributes; } enum { ANYSIZE_ARRAY = 1, } struct PRIVILEGE_SET { DWORD PrivilegeCount; DWORD Control; LUID_AND_ATTRIBUTES Privilege[ANYSIZE_ARRAY]; } alias PRIVILEGE_SET* PPRIVILEGE_SET; export BOOL AccessCheck(PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccess, LPBOOL AccessStatus); //Start Window network API enum { RESOURCETYPE_ANY= 0x00000000, RESOURCETYPE_DISK= 0x00000001, RESOURCETYPE_PRINT= 0x00000002, } struct NETRESOURCEA { DWORD dwScope; DWORD dwType; DWORD dwDisplayType; DWORD dwUsage; LPSTR lpLocalName; LPSTR lpRemoteName; LPSTR lpComment ; LPSTR lpProvider; }; alias NETRESOURCEA* LPNETRESOURCEA; enum { CONNECT_UPDATE_PROFILE =0x00000001, CONNECT_UPDATE_RECENT =0x00000002, CONNECT_TEMPORARY =0x00000004, CONNECT_INTERACTIVE =0x00000008, CONNECT_PROMPT =0x00000010, CONNECT_NEED_DRIVE =0x00000020, CONNECT_REFCOUNT =0x00000040, CONNECT_REDIRECT =0x00000080, CONNECT_LOCALDRIVE =0x00000100, CONNECT_CURRENT_MEDIA =0x00000200, CONNECT_DEFERRED =0x00000400, CONNECT_RESERVED =0xFF000000, CONNECT_COMMANDLINE =0x00000800, CONNECT_CMD_SAVECRED =0x00001000, } export DWORD WNetAddConnection2A( LPNETRESOURCEA lpNetResource, LPCSTR lpPassword, LPCSTR lpUserName, DWORD dwFlags ); } extern (D) { enum { FILE_SECURITY_HEAP_ERROR = 1, FILE_SECURITY_ERROR = 2, FILE_SECURITY_RETRIEVE_TOKEN_ERROR = 3, FILE_SECURITY_OPEN_TOKEN_ERROR = 4, FILE_SECURITY_ACCESS_CHECK_FAIL = 5, } /** * Notice that we use windows authority token to check whether current user can access the file * Params: * filePath = * Returns: 0 is successful */ int fileAccessCheck(in char* filePath, DWORD desiredAccess/*, GENERIC_MAPPING genericMapping*/) { //Retrieve the file security descriptor DWORD nLength; GetFileSecurityA(filePath, OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION, null, 0, &nLength); PSECURITY_DESCRIPTOR pSD = cast(PSECURITY_DESCRIPTOR) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nLength); if (pSD == null) { return FILE_SECURITY_HEAP_ERROR; } if(!GetFileSecurityA(filePath, OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION, pSD, nLength, &nLength)) { //FIXME clean up? HeapFree (GetProcessHeap(), 0, pSD); return FILE_SECURITY_ERROR; } //Retrieve calling process's access token if(!ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL.SecurityImpersonation)) { HeapFree (GetProcessHeap(), 0, pSD); return FILE_SECURITY_RETRIEVE_TOKEN_ERROR; } HANDLE hToken; if(!OpenThreadToken(GetCurrentThread(), TOKEN_DUPLICATE | TOKEN_QUERY, FALSE, &hToken)) { //FIXME clean up? HeapFree (GetProcessHeap(), 0, pSD); return FILE_SECURITY_OPEN_TOKEN_ERROR; } RevertToSelf(); //test only, now test the write previlege GENERIC_MAPPING genericMapping; memset( &genericMapping, 0x00, GENERIC_MAPPING.sizeof ); genericMapping.GenericWrite = FILE_GENERIC_WRITE; genericMapping.GenericRead = FILE_GENERIC_READ; genericMapping.GenericExecute = FILE_GENERIC_EXECUTE; genericMapping.GenericAll = FILE_ALL_ACCESS; MapGenericMask (&desiredAccess, &genericMapping); PRIVILEGE_SET privilegeSet; DWORD privSetSize = PRIVILEGE_SET.sizeof; DWORD grantedAccess; BOOL bAccessGranted; if(!AccessCheck(pSD, hToken, desiredAccess, &genericMapping, &privilegeSet, &privSetSize, &grantedAccess, &bAccessGranted)) { //FIXME Clean up HeapFree (GetProcessHeap(), 0, pSD); CloseHandle (hToken); return FILE_SECURITY_ACCESS_CHECK_FAIL; } //Clean up HeapFree (GetProcessHeap(), 0, pSD); CloseHandle (hToken); return bAccessGranted !=0 ? 0 : FILE_SECURITY_ACCESS_CHECK_FAIL; } /** * Check file security whether it's readable by current user * Params: * filePath = C-style 0 ended file path * Returns: 0 is allowed */ int isFileReadable(in char* filePath) { DWORD desiredAccess = FILE_READ_DATA | FILE_READ_EA | FILE_READ_ATTRIBUTES; //GENERIC_MAPPING genericMapping; //genericMapping.GenericRead = FILE_GENERIC_READ; return fileAccessCheck(filePath, desiredAccess/*, genericMapping*/); } int isFileReadWritable(in char* filePath) { DWORD desiredAccess = FILE_READ_DATA | FILE_READ_EA | FILE_READ_ATTRIBUTES | FILE_WRITE_DATA | FILE_APPEND_DATA | FILE_WRITE_EA | FILE_WRITE_ATTRIBUTES; //GENERIC_MAPPING genericMapping; //genericMapping.GenericRead = FILE_GENERIC_READ; //genericMapping.GenericWrite = FILE_GENERIC_WRITE; return fileAccessCheck(filePath, desiredAccess/*, genericMapping*/); } int isDirReadable(in char* dirPath) { DWORD desiredAccess = FILE_READ_DATA | FILE_LIST_DIRECTORY | FILE_READ_EA | FILE_READ_ATTRIBUTES | FILE_TRAVERSE; //GENERIC_MAPPING genericMapping; //genericMapping.GenericRead = FILE_GENERIC_READ; return fileAccessCheck(dirPath, desiredAccess/*, genericMapping*/); } int isDirReadWritable(in char* dirPath) { DWORD desiredAccess = FILE_READ_DATA | FILE_LIST_DIRECTORY | FILE_READ_EA | FILE_READ_ATTRIBUTES | FILE_TRAVERSE | FILE_WRITE_EA | FILE_WRITE_ATTRIBUTES | FILE_DELETE_CHILD | FILE_ADD_SUBDIRECTORY | FILE_ADD_FILE; //GENERIC_MAPPING genericMapping; //genericMapping.GenericRead = FILE_GENERIC_READ; //genericMapping.GenericWrite = FILE_GENERIC_WRITE; return fileAccessCheck(dirPath, desiredAccess/*, genericMapping*/); } int addWNETConnection(char* remoteName) { NETRESOURCEA resource; resource.lpRemoteName = remoteName; resource.dwType = RESOURCETYPE_DISK; resource.lpProvider = null; return WNetAddConnection2A(&resource, null, null, CONNECT_INTERACTIVE); } }