static void AddEnvironmentVariable(struct environment* env,const char* varName, const char* valueString) { size_t len; size_t envSize = MAX_PATH - (env->p_head-env->env); StringCbCopyA(env->p_head, envSize, varName); StringCbCatA(env->p_head, envSize, "="); StringCbCatA(env->p_head, envSize, valueString); StringCbCatA(env->p_head, envSize, "\0"); len = strnlen_s(env->p_head, envSize); env->p_head += (len + 1); }
__inline void TraceA(const char *format, ...) { if(g_bDebug) { if (format) { va_list arglist; char str[4096]; va_start(arglist, format); StringCchVPrintfA(str, sizeof(str), format, arglist); StringCbCatA(str, sizeof(str), "\n"); if (g_fLogFile) { FILE *fout = fopen(g_fLogFile, "a+t"); if (fout) { fprintf(fout, str); fclose(fout); } } printf(str); if (g_bDebugString) { OutputDebugStringA(str); } va_end(arglist); } } }
static void dump(const char *name, const void *ptr, size_t siz) { char buf[256], sz[16]; StringCbCopyA(buf, sizeof(buf), name); StringCbCatA(buf, sizeof(buf), ": "); const BYTE *pb = reinterpret_cast<const BYTE *>(ptr); while (siz--) { StringCbPrintfA(sz, sizeof(sz), "%02X ", *pb++); StringCbCatA(buf, sizeof(buf), sz); } trace("%s\n", buf); }
int mkfulldir_internal (char *path) { char *token; struct _stat st; static char tokpath[_MAX_PATH]; static char trail[_MAX_PATH]; StringCbCopyA (tokpath, _MAX_PATH, path); trail[0] = '\0'; token = strtok (tokpath, "\\/"); if (tokpath[0] == '\\' && tokpath[1] == '\\') { /* unc */ trail[0] = tokpath[0]; trail[1] = tokpath[1]; trail[2] = '\0'; if (token) { StringCbCatA (trail, _MAX_PATH, token); StringCbCatA (trail, _MAX_PATH, "\\"); token = strtok (NULL, "\\/"); if (token) { /* get share name */ StringCbCatA (trail, _MAX_PATH, token); StringCbCatA (trail, _MAX_PATH, "\\"); } token = strtok (NULL, "\\/"); } } if (tokpath[1] == ':') { /* drive letter */ StringCbCatA (trail, _MAX_PATH, tokpath); StringCbCatA (trail, _MAX_PATH, "\\"); token = strtok (NULL, "\\/"); } while (token != NULL) { int x; StringCbCatA (trail, _MAX_PATH, token); x = _mkdir (trail); StringCbCatA (trail, _MAX_PATH, "\\"); token = strtok (NULL, "\\/"); } return _stat (path, &st); }
SC_HANDLE register_service_exA( SC_HANDLE scm_handle, PCSTR test_name, PCSTR service_name, // LPCSTR lpServiceName, PCSTR extra_args OPTIONAL, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCSTR lpLoadOrderGroup OPTIONAL, LPDWORD lpdwTagId OPTIONAL, LPCSTR lpDependencies OPTIONAL, LPCSTR lpServiceStartName OPTIONAL, LPCSTR lpPassword OPTIONAL) { SC_HANDLE service; CHAR service_cmd[MAX_PATH+150]; /* Retrieve our full path */ if (!GetModuleFileNameA(NULL, service_cmd, MAX_PATH)) { skip("GetModuleFileNameW failed with error %lu!\n", GetLastError()); return NULL; } /* * Build up our custom command line. The first parameter is the test name, * the second parameter is the flag used to decide whether we should start * as a service. */ StringCbCatA(service_cmd, sizeof(service_cmd), " "); StringCbCatA(service_cmd, sizeof(service_cmd), test_name); StringCbCatA(service_cmd, sizeof(service_cmd), " "); StringCbCatA(service_cmd, sizeof(service_cmd), service_name); if (extra_args) { StringCbCatA(service_cmd, sizeof(service_cmd), " "); StringCbCatA(service_cmd, sizeof(service_cmd), extra_args); } trace("service_cmd \"%s\"\n", service_cmd); service = CreateServiceA(scm_handle, service_name, service_name, dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl, service_cmd, lpLoadOrderGroup, lpdwTagId, lpDependencies, lpServiceStartName, lpPassword); if (!service && GetLastError() == ERROR_ACCESS_DENIED) { skip("Not enough access right to create service.\n"); return NULL; } ok(service != NULL, "CreateService failed: %lu\n", GetLastError()); return service; }
BOOL FormatNtfs (int driveNo, int clusterSize) { char dllPath[MAX_PATH] = {0}; WCHAR dir[8] = { (WCHAR) driveNo + 'A', 0 }; PFORMATEX FormatEx; HMODULE hModule; int i; if (GetSystemDirectory (dllPath, MAX_PATH)) { StringCbCatA(dllPath, sizeof(dllPath), "\\fmifs.dll"); } else StringCbCopyA(dllPath, sizeof(dllPath), "C:\\Windows\\System32\\fmifs.dll"); hModule = LoadLibrary (dllPath); if (hModule == NULL) return FALSE; if (!(FormatEx = (PFORMATEX) GetProcAddress (GetModuleHandle ("fmifs.dll"), "FormatEx"))) { FreeLibrary (hModule); return FALSE; } StringCbCatW (dir, sizeof(dir), L":\\"); FormatExError = TRUE; // Windows sometimes fails to format a volume (hosted on a removable medium) as NTFS. // It often helps to retry several times. for (i = 0; i < 50 && FormatExError; i++) { FormatExError = FALSE; FormatEx (dir, FMIFS_HARDDISK, L"NTFS", L"", TRUE, clusterSize * FormatSectorSize, FormatExCallback); } // The device may be referenced for some time after FormatEx() returns Sleep (4000); FreeLibrary (hModule); return FormatExError? FALSE : TRUE; }
/* create a new log, taking a name and a size in entries (not words) */ osi_log_t *osi_LogCreate(char *namep, size_t size) { osi_log_t *logp; osi_fdType_t *typep; char tbuffer[256]; LARGE_INTEGER bigFreq; LARGE_INTEGER bigTemp; LARGE_INTEGER bigJunk; if (osi_Once(&osi_logOnce)) { QueryPerformanceFrequency(&bigFreq); if (bigFreq.LowPart == 0 && bigFreq.HighPart == 0) osi_logFreq = 0; else { /* turn frequency into ticks per 10 micros */ bigTemp.LowPart = 100000; bigTemp.HighPart = 0; osi_logTixToMicros = 10; bigFreq = LargeIntegerDivide(bigFreq, bigTemp, &bigJunk); /* check if resolution is too fine or to gross for this to work */ if (bigFreq.HighPart > 0 || bigFreq.LowPart < 8) osi_logFreq = 0; /* too big to represent as long */ else osi_logFreq = bigFreq.LowPart; } /* done with init */ osi_EndOnce(&osi_logOnce); } logp = malloc(sizeof(osi_log_t)); memset(logp, 0, sizeof(osi_log_t)); { size_t namelen = strlen(namep) + 1; logp->namep = malloc(namelen * sizeof(char)); StringCchCopyA(logp->namep, namelen, namep); } osi_QAdd((osi_queue_t **) &osi_allLogsp, &logp->q); /* compute size we'll use */ if (size == 0) size = osi_logSize; /* handle init for this size */ logp->alloc = size; logp->datap = malloc(size * sizeof(osi_logEntry_t)); /* init strings array */ logp->maxstringindex = size/3; logp->stringindex = 0; logp->stringsp = malloc(logp->maxstringindex * OSI_LOG_STRINGSIZE); /* and sync */ thrd_InitCrit(&logp->cs); StringCbCopyA(tbuffer, sizeof(tbuffer), "log:"); StringCbCatA(tbuffer, sizeof(tbuffer), namep); typep = osi_RegisterFDType(tbuffer, &osi_logFDOps, logp); if (typep) { /* add formatting info */ osi_AddFDFormatInfo(typep, OSI_DBRPC_REGIONINT, 0, "Thread ID", OSI_DBRPC_HEX); osi_AddFDFormatInfo(typep, OSI_DBRPC_REGIONSTRING, 1, "Time (mics)", 0); } return logp; }
// печатает в буфер key_name_buffer текстовое описание нажатой комбинации кнопок // Кодировка ANSI (для экономии места, всё равно названия клавиш английские) VOID HwHotKeys_PrintFullKeyname(DWORD scancode) { key_name_buffer[0] = 0; if (!scancode) // если нулевой сканкод - то пустую строку делаем. { return; } if (scancode & key_flag_sl) // L_Shift { StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_SL); StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + "); } if (scancode & key_flag_sr) // R_Shift { StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_SR); StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + "); } if (scancode & key_flag_ss) // Shift { StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_SS); StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + "); } if (scancode & key_flag_cl) // L_Ctrl { StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_CL); StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + "); } if (scancode & key_flag_cr) // R_Ctrl { StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_CR); StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + "); } if (scancode & key_flag_cc) // Ctrl { StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_CC); StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + "); } if (scancode & key_flag_al) // L_Alt { StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_AL); StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + "); } if (scancode & key_flag_ar) // R_Alt { StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_AR); StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + "); } if (scancode & key_flag_aa) // Alt { StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_AA); StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + "); } if (scancode & key_flag_wl) // L_Win { StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_WL); StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + "); } if (scancode & key_flag_wr) // R_Win { StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_WR); StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + "); } if (scancode & key_flag_ww) // Win { StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_WW); StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + "); } if ((scancode & 0x1FF) < sizeof(key_tab)) // защита от ошибочных данных - чтобы не выйти из таблицы имён. { StringCbCatA(key_name_buffer, sizeof(key_name_buffer), key_tab[(scancode & 0x1FF)]); } else { StringCbCatA(key_name_buffer, sizeof(key_name_buffer), "out of range"); } INT_PTR tmp1 = mir_strlen(key_name_buffer); // допечатываем в конеце строки сканкод - для удобства работы с пока ещё не известными (безимянными) кнопками StringCbPrintfA(key_name_buffer + tmp1, sizeof(key_name_buffer) - tmp1, " (%03X)", (scancode & 0x1FF)); return; }
int getAFSServer(const char *service, const char *protocol, const char *cellName, unsigned short afsdbPort, /* network byte order */ int *cellHostAddrs, char cellHostNames[][MAXHOSTCHARS], unsigned short ports[], /* network byte order */ unsigned short ipRanks[], int *numServers, int *ttl) { #ifndef DNSAPI_ENV SOCKET commSock; SOCKADDR_IN sockAddr; PDNS_HDR pDNShdr; char buffer[BUFSIZE]; char query[1024]; int rc; #ifdef DEBUG fprintf(stderr, "getAFSServer: cell %s, cm_dnsEnabled=%d\n", cellName, cm_dnsEnabled); #endif *numServers = 0; *ttl = 0; #if !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x0500) if (cm_dnsEnabled == -1) { /* not yet initialized, eg when called by klog */ cm_InitDNS(1); /* assume enabled */ } #endif if (cm_dnsEnabled == 0) { /* possibly we failed in cm_InitDNS above */ fprintf(stderr, "DNS initialization failed, disabled\n"); return -1; } if (service == NULL || protocol == NULL || cellName == NULL) { fprintf(stderr, "invalid input\n"); return -1; } sockAddr = setSockAddr(dns_addr, DNS_PORT); commSock = socket( AF_INET, SOCK_DGRAM, 0 ); if ( commSock < 0 ) { /*afsi_log("socket() failed\n");*/ fprintf(stderr, "getAFSServer: socket() failed, errno=%d\n", errno); return (-1); } StringCbCopyA(query, sizeof(query), cellName); if (query[strlen(query)-1] != '.') { StringCbCatA(query, sizeof(query), "."); } rc = send_DNS_AFSDB_Query(query,commSock,sockAddr, buffer); if (rc < 0) { closesocket(commSock); fprintf(stderr,"getAFSServer: send_DNS_AFSDB_Query failed\n"); return -1; } pDNShdr = get_DNS_Response(commSock,sockAddr, buffer); /*printReplyBuffer_AFSDB(pDNShdr);*/ if (pDNShdr) processReplyBuffer_AFSDB(commSock, pDNShdr, cellHostAddrs, cellHostNames, ports, ipRanks, numServers, ttl); closesocket(commSock); if (*numServers == 0) return(-1); else return 0; #else /* DNSAPI_ENV */ PDNS_RECORD pDnsCell, pDnsIter, pDnsVol, pDnsVolIter, pDnsCIter; int i; char query[1024]; *numServers = 0; *ttl = 0; if (service == NULL || protocol == NULL || cellName == NULL) return -1; #ifdef AFS_FREELANCE_CLIENT if ( cm_stricmp_utf8N(cellName, "Freelance.Local.Root") == 0 ) return -1; #endif /* AFS_FREELANCE_CLIENT */ /* query the SRV _afs3-vlserver._udp records of cell */ StringCbPrintf(query, sizeof(query), "_%s._%s.%s", service, protocol, cellName); if (query[strlen(query)-1] != '.') { StringCbCatA(query, sizeof(query), "."); } if (DnsQuery_A(query, DNS_TYPE_SRV, DNS_QUERY_STANDARD, NULL, &pDnsCell, NULL) == ERROR_SUCCESS) { /* go through the returned records */ for (pDnsIter = pDnsCell;pDnsIter; pDnsIter = pDnsIter->pNext) { /* if we find an SRV record, we found the service */ if (pDnsIter->wType == DNS_TYPE_SRV) { StringCbCopyA(cellHostNames[*numServers], sizeof(cellHostNames[*numServers]), pDnsIter->Data.SRV.pNameTarget); ipRanks[*numServers] = pDnsIter->Data.SRV.wPriority; ports[*numServers] = htons(pDnsIter->Data.SRV.wPort); (*numServers)++; if (!*ttl) *ttl = pDnsIter->dwTtl; if (*numServers == AFSMAXCELLHOSTS) break; } } for (i=0;i<*numServers;i++) cellHostAddrs[i] = 0; /* now check if there are any A records in the results */ for (pDnsIter = pDnsCell; pDnsIter; pDnsIter = pDnsIter->pNext) { if(pDnsIter->wType == DNS_TYPE_A) /* check if its for one of the service */ for (i=0;i<*numServers;i++) if(cm_stricmp_utf8(pDnsIter->pName, cellHostNames[i]) == 0) cellHostAddrs[i] = pDnsIter->Data.A.IpAddress; } for (i=0;i<*numServers;i++) { /* if we don't have an IP yet, then we should try resolving the afs3-vlserver hostname in a separate query. */ if (!cellHostAddrs[i]) { if (DnsQuery_A(cellHostNames[i], DNS_TYPE_A, DNS_QUERY_STANDARD, NULL, &pDnsVol, NULL) == ERROR_SUCCESS) { for (pDnsVolIter = pDnsVol; pDnsVolIter; pDnsVolIter=pDnsVolIter->pNext) { /* if we get an A record, keep it */ if (pDnsVolIter->wType == DNS_TYPE_A && cm_stricmp_utf8(cellHostNames[i], pDnsVolIter->pName)==0) { cellHostAddrs[i] = pDnsVolIter->Data.A.IpAddress; break; } /* if we get a CNAME, look for a corresponding A record */ if (pDnsVolIter->wType == DNS_TYPE_CNAME && cm_stricmp_utf8(cellHostNames[i], pDnsVolIter->pName)==0) { for (pDnsCIter=pDnsVolIter; pDnsCIter; pDnsCIter=pDnsCIter->pNext) { if (pDnsCIter->wType == DNS_TYPE_A && cm_stricmp_utf8(pDnsVolIter->Data.CNAME.pNameHost, pDnsCIter->pName)==0) { cellHostAddrs[i] = pDnsCIter->Data.A.IpAddress; break; } } if (cellHostAddrs[i]) break; /* TODO: if the additional section is missing, then do another lookup for the CNAME */ } } /* we are done with the service lookup */ DnsRecordListFree(pDnsVol, DnsFreeRecordListDeep); } } } DnsRecordListFree(pDnsCell, DnsFreeRecordListDeep); } else { /* query the AFSDB records of cell */ StringCbCopyA(query, sizeof(query), cellName); if (query[strlen(query)-1] != '.') { StringCbCatA(query, sizeof(query), "."); } if (DnsQuery_A(query, DNS_TYPE_AFSDB, DNS_QUERY_STANDARD, NULL, &pDnsCell, NULL) == ERROR_SUCCESS) { /* go through the returned records */ for (pDnsIter = pDnsCell;pDnsIter; pDnsIter = pDnsIter->pNext) { /* if we find an AFSDB record with Preference set to 1, we found a service instance */ if (pDnsIter->wType == DNS_TYPE_AFSDB && pDnsIter->Data.Afsdb.wPreference == 1) { StringCbCopyA(cellHostNames[*numServers], sizeof(cellHostNames[*numServers]), pDnsIter->Data.Afsdb.pNameExchange); ipRanks[*numServers] = 0; ports[*numServers] = afsdbPort; (*numServers)++; if (!*ttl) *ttl = pDnsIter->dwTtl; if (*numServers == AFSMAXCELLHOSTS) break; } } for (i=0;i<*numServers;i++) cellHostAddrs[i] = 0; /* now check if there are any A records in the results */ for (pDnsIter = pDnsCell; pDnsIter; pDnsIter = pDnsIter->pNext) { if(pDnsIter->wType == DNS_TYPE_A) /* check if its for one of the service */ for (i=0;i<*numServers;i++) if(cm_stricmp_utf8(pDnsIter->pName, cellHostNames[i]) == 0) cellHostAddrs[i] = pDnsIter->Data.A.IpAddress; } for (i=0;i<*numServers;i++) { /* if we don't have an IP yet, then we should try resolving the service hostname in a separate query. */ if (!cellHostAddrs[i]) { if (DnsQuery_A(cellHostNames[i], DNS_TYPE_A, DNS_QUERY_STANDARD, NULL, &pDnsVol, NULL) == ERROR_SUCCESS) { for (pDnsVolIter = pDnsVol; pDnsVolIter; pDnsVolIter=pDnsVolIter->pNext) { /* if we get an A record, keep it */ if (pDnsVolIter->wType == DNS_TYPE_A && cm_stricmp_utf8(cellHostNames[i], pDnsVolIter->pName)==0) { cellHostAddrs[i] = pDnsVolIter->Data.A.IpAddress; break; } /* if we get a CNAME, look for a corresponding A record */ if (pDnsVolIter->wType == DNS_TYPE_CNAME && cm_stricmp_utf8(cellHostNames[i], pDnsVolIter->pName)==0) { for (pDnsCIter=pDnsVolIter; pDnsCIter; pDnsCIter=pDnsCIter->pNext) { if (pDnsCIter->wType == DNS_TYPE_A && cm_stricmp_utf8(pDnsVolIter->Data.CNAME.pNameHost, pDnsCIter->pName)==0) { cellHostAddrs[i] = pDnsCIter->Data.A.IpAddress; break; } } if (cellHostAddrs[i]) break; /* TODO: if the additional section is missing, then do another lookup for the CNAME */ } } /* we are done with the service lookup */ DnsRecordListFree(pDnsVol, DnsFreeRecordListDeep); } } } DnsRecordListFree(pDnsCell, DnsFreeRecordListDeep); } } if ( *numServers > 0 ) return 0; else return -1; #endif /* DNSAPI_ENV */ }
CToshHandler::CToshHandler(TToshParams& aParams) { iParams = aParams; memset(&iDevInfo,0,sizeof(iDevInfo)); memset(&iPrevDevInfoList,0,sizeof(iPrevDevInfoList)); iOpenedObexApi = false; iCID = 0; iSDPSSRESULT = NULL; iRFCOMMCID = 0; // iHFile = 0; GetModuleFileName(AfxGetInstanceHandle(), iTmpObexFilePath, MAX_PATH); /* Search backward. */ CHAR ch('\\'); CHAR* pdest = strrchr( iTmpObexFilePath, ch ); if( pdest != NULL ) { if( MAX_PATH > pdest - iTmpObexFilePath) *(pdest+1) = NULL; } StringCbCatA(iTmpObexFilePath,MAX_PATH,KWmxpJarPathRelativeToReleaseExe); //////////prepare tosh bt sdp struct iWmxpToshSDPPattern in ram iWmxpToshSDPPattern = NULL; iWmxpToshSDPPatternSize = 0; BTUUIDINFO aBTUUIDINFO; aBTUUIDINFO.wUUIDType = 128; ((unsigned char*)&(aBTUUIDINFO.BtUUID))[0] = 0x2b; ((unsigned char*)&(aBTUUIDINFO.BtUUID))[1] = 0xc2; ((unsigned char*)&(aBTUUIDINFO.BtUUID))[2] = 0xb9; ((unsigned char*)&(aBTUUIDINFO.BtUUID))[3] = 0x2e; ((unsigned char*)&(aBTUUIDINFO.BtUUID))[4] = 0x39; ((unsigned char*)&(aBTUUIDINFO.BtUUID))[5] = 0x92; ((unsigned char*)&(aBTUUIDINFO.BtUUID))[6] = 0x11; ((unsigned char*)&(aBTUUIDINFO.BtUUID))[7] = 0xdc; ((unsigned char*)&(aBTUUIDINFO.BtUUID))[8] = 0x83; ((unsigned char*)&(aBTUUIDINFO.BtUUID))[9] = 0x14; ((unsigned char*)&(aBTUUIDINFO.BtUUID))[10] = 0x08; ((unsigned char*)&(aBTUUIDINFO.BtUUID))[11] = 0x00; ((unsigned char*)&(aBTUUIDINFO.BtUUID))[12] = 0x20; ((unsigned char*)&(aBTUUIDINFO.BtUUID))[13] = 0x0c; ((unsigned char*)&(aBTUUIDINFO.BtUUID))[14] = 0x9a; ((unsigned char*)&(aBTUUIDINFO.BtUUID))[15] = 0x66; //BTUUIDLIST aBTUUIDLIST; cannot static because the declaration was BTUUIDINFO BtUUIDInfo[]; so we need to alloc for the first one too BTUUIDLIST* aPBTUUIDLIST = (PBTUUIDLIST) malloc(sizeof(BTUUIDLIST) + sizeof(BTUUIDINFO)); aPBTUUIDLIST->dwUUIDInfoNum=1; memcpy(&(aPBTUUIDLIST->BtUUIDInfo[0]) ,&aBTUUIDINFO, sizeof(BTUUIDINFO)); iWmxpToshSDPPattern = NULL; iWmxpToshAttrIdList = NULL; iMemSDP_SSA_Result = NULL; long status; if(BtMakeServiceSearchPattern2(aPBTUUIDLIST, &iWmxpToshSDPPatternSize, &iWmxpToshSDPPattern, &status)) { ;//ok //ShowHex(iWmxpToshSDPPattern,iWmxpToshSDPPatternSize); BTUNIVATTRIBUTE mask = 0; mask |= TOSBTAPI_ATR_PROTOCOLDESCRIPTORLIST; mask |= TOSBTAPI_ATR_SERVICERECORDHANDLE; if(BtMakeAttributeIDList2(mask, &iWmxpToshAttrIdListSize, &iWmxpToshAttrIdList, &iStatus)) mydebug::log("th164"); else { AfxMessageBox("BtMakeAttributeIDList2 failed"); delete iWmxpToshAttrIdList; iWmxpToshAttrIdList = NULL; } } else { AfxMessageBox("BtMakeServiceSearchPattern2 failed"); delete iWmxpToshSDPPattern; iWmxpToshSDPPattern = NULL; } if(iWmxpToshSDPPattern ==NULL || aPBTUUIDLIST==NULL) AfxMessageBox("SearchPattern or UUID list generation failed"); mydebug::log("th165"); free(aPBTUUIDLIST); mydebug::log("th166"); //////////////////////////// }
// Creates a volume header in memory int CreateVolumeHeaderInMemory (HWND hwndDlg, BOOL bBoot, char *header, int ea, int mode, Password *password, int pkcs5_prf, char *masterKeydata, PCRYPTO_INFO *retInfo, unsigned __int64 volumeSize, unsigned __int64 hiddenVolumeSize, unsigned __int64 encryptedAreaStart, unsigned __int64 encryptedAreaLength, uint16 requiredProgramVersion, uint32 headerFlags, uint32 sectorSize, BOOL bWipeMode) { unsigned char *p = (unsigned char *) header; static KEY_INFO keyInfo; int nUserKeyLen = password->Length; PCRYPTO_INFO cryptoInfo = crypto_open (); static char dk[MASTER_KEYDATA_SIZE]; int x; int retVal = 0; int primaryKeyOffset; if (cryptoInfo == NULL) return ERR_OUTOFMEMORY; memset (header, 0, TC_VOLUME_HEADER_EFFECTIVE_SIZE); VirtualLock (&keyInfo, sizeof (keyInfo)); VirtualLock (&dk, sizeof (dk)); /* Encryption setup */ if (masterKeydata == NULL) { // We have no master key data (creating a new volume) so we'll use the TrueCrypt RNG to generate them int bytesNeeded; switch (mode) { default: bytesNeeded = EAGetKeySize (ea) * 2; // Size of primary + secondary key(s) } if (!RandgetBytes (hwndDlg, keyInfo.master_keydata, bytesNeeded, TRUE)) return ERR_CIPHER_INIT_WEAK_KEY; } else { // We already have existing master key data (the header is being re-encrypted) memcpy (keyInfo.master_keydata, masterKeydata, MASTER_KEYDATA_SIZE); } // User key memcpy (keyInfo.userKey, password->Text, nUserKeyLen); keyInfo.keyLength = nUserKeyLen; keyInfo.noIterations = get_pkcs5_iteration_count (pkcs5_prf, FALSE, bBoot); // User selected encryption algorithm cryptoInfo->ea = ea; // User selected PRF cryptoInfo->pkcs5 = pkcs5_prf; cryptoInfo->bTrueCryptMode = FALSE; // Mode of operation cryptoInfo->mode = mode; // Salt for header key derivation if (!RandgetBytes (hwndDlg, keyInfo.salt, PKCS5_SALT_SIZE, !bWipeMode)) return ERR_CIPHER_INIT_WEAK_KEY; // PBKDF2 (PKCS5) is used to derive primary header key(s) and secondary header key(s) (XTS) from the password/keyfiles switch (pkcs5_prf) { case SHA512: derive_key_sha512 (keyInfo.userKey, keyInfo.keyLength, keyInfo.salt, PKCS5_SALT_SIZE, keyInfo.noIterations, dk, GetMaxPkcs5OutSize()); break; case SHA256: derive_key_sha256 (keyInfo.userKey, keyInfo.keyLength, keyInfo.salt, PKCS5_SALT_SIZE, keyInfo.noIterations, dk, GetMaxPkcs5OutSize()); break; case RIPEMD160: derive_key_ripemd160 (keyInfo.userKey, keyInfo.keyLength, keyInfo.salt, PKCS5_SALT_SIZE, keyInfo.noIterations, dk, GetMaxPkcs5OutSize()); break; case WHIRLPOOL: derive_key_whirlpool (keyInfo.userKey, keyInfo.keyLength, keyInfo.salt, PKCS5_SALT_SIZE, keyInfo.noIterations, dk, GetMaxPkcs5OutSize()); break; default: // Unknown/wrong ID TC_THROW_FATAL_EXCEPTION; } /* Header setup */ // Salt mputBytes (p, keyInfo.salt, PKCS5_SALT_SIZE); // Magic mputLong (p, 0x56455241); // Header version mputWord (p, VOLUME_HEADER_VERSION); cryptoInfo->HeaderVersion = VOLUME_HEADER_VERSION; // Required program version to handle this volume mputWord (p, requiredProgramVersion != 0 ? requiredProgramVersion : TC_VOLUME_MIN_REQUIRED_PROGRAM_VERSION); // CRC of the master key data x = GetCrc32(keyInfo.master_keydata, MASTER_KEYDATA_SIZE); mputLong (p, x); // Reserved fields p += 2 * 8; // Size of hidden volume (if any) cryptoInfo->hiddenVolumeSize = hiddenVolumeSize; mputInt64 (p, cryptoInfo->hiddenVolumeSize); cryptoInfo->hiddenVolume = cryptoInfo->hiddenVolumeSize != 0; // Volume size cryptoInfo->VolumeSize.Value = volumeSize; mputInt64 (p, volumeSize); // Encrypted area start cryptoInfo->EncryptedAreaStart.Value = encryptedAreaStart; mputInt64 (p, encryptedAreaStart); // Encrypted area size cryptoInfo->EncryptedAreaLength.Value = encryptedAreaLength; mputInt64 (p, encryptedAreaLength); // Flags cryptoInfo->HeaderFlags = headerFlags; mputLong (p, headerFlags); // Sector size if (sectorSize < TC_MIN_VOLUME_SECTOR_SIZE || sectorSize > TC_MAX_VOLUME_SECTOR_SIZE || sectorSize % ENCRYPTION_DATA_UNIT_SIZE != 0) { TC_THROW_FATAL_EXCEPTION; } cryptoInfo->SectorSize = sectorSize; mputLong (p, sectorSize); // CRC of the header fields x = GetCrc32 (header + TC_HEADER_OFFSET_MAGIC, TC_HEADER_OFFSET_HEADER_CRC - TC_HEADER_OFFSET_MAGIC); p = header + TC_HEADER_OFFSET_HEADER_CRC; mputLong (p, x); // The master key data memcpy (header + HEADER_MASTER_KEYDATA_OFFSET, keyInfo.master_keydata, MASTER_KEYDATA_SIZE); /* Header encryption */ switch (mode) { default: // The secondary key (if cascade, multiple concatenated) memcpy (cryptoInfo->k2, dk + EAGetKeySize (cryptoInfo->ea), EAGetKeySize (cryptoInfo->ea)); primaryKeyOffset = 0; } retVal = EAInit (cryptoInfo->ea, dk + primaryKeyOffset, cryptoInfo->ks); if (retVal != ERR_SUCCESS) return retVal; // Mode of operation if (!EAInitMode (cryptoInfo)) return ERR_OUTOFMEMORY; // Encrypt the entire header (except the salt) EncryptBuffer (header + HEADER_ENCRYPTED_DATA_OFFSET, HEADER_ENCRYPTED_DATA_SIZE, cryptoInfo); /* cryptoInfo setup for further use (disk format) */ // Init with the master key(s) retVal = EAInit (cryptoInfo->ea, keyInfo.master_keydata + primaryKeyOffset, cryptoInfo->ks); if (retVal != ERR_SUCCESS) return retVal; memcpy (cryptoInfo->master_keydata, keyInfo.master_keydata, MASTER_KEYDATA_SIZE); switch (cryptoInfo->mode) { default: // The secondary master key (if cascade, multiple concatenated) memcpy (cryptoInfo->k2, keyInfo.master_keydata + EAGetKeySize (cryptoInfo->ea), EAGetKeySize (cryptoInfo->ea)); } // Mode of operation if (!EAInitMode (cryptoInfo)) return ERR_OUTOFMEMORY; #ifdef VOLFORMAT if (showKeys && !bInPlaceEncNonSys) { BOOL dots3 = FALSE; int i, j; j = EAGetKeySize (ea); if (j > NBR_KEY_BYTES_TO_DISPLAY) { dots3 = TRUE; j = NBR_KEY_BYTES_TO_DISPLAY; } MasterKeyGUIView[0] = 0; for (i = 0; i < j; i++) { char tmp2[8] = {0}; StringCbPrintfA (tmp2, sizeof(tmp2), "%02X", (int) (unsigned char) keyInfo.master_keydata[i + primaryKeyOffset]); StringCbCatA (MasterKeyGUIView, sizeof(MasterKeyGUIView), tmp2); } HeaderKeyGUIView[0] = 0; for (i = 0; i < NBR_KEY_BYTES_TO_DISPLAY; i++) { char tmp2[8]; StringCbPrintfA (tmp2, sizeof(tmp2), "%02X", (int) (unsigned char) dk[primaryKeyOffset + i]); StringCbCatA (HeaderKeyGUIView, sizeof(HeaderKeyGUIView), tmp2); } if (dots3) { DisplayPortionsOfKeys (hHeaderKey, hMasterKey, HeaderKeyGUIView, MasterKeyGUIView, !showKeys); } else { SendMessage (hMasterKey, WM_SETTEXT, 0, (LPARAM) MasterKeyGUIView); SendMessage (hHeaderKey, WM_SETTEXT, 0, (LPARAM) HeaderKeyGUIView); } } #endif // #ifdef VOLFORMAT burn (dk, sizeof(dk)); burn (&keyInfo, sizeof (keyInfo)); *retInfo = cryptoInfo; return 0; }
khm_int32 KHMAPI khm_krb5_find_ccache_for_identity(khm_handle ident, krb5_context *pctx, void * buffer, khm_size * pcbbuf) { krb5_context ctx = 0; krb5_ccache cache = 0; krb5_error_code code; apiCB * cc_ctx = 0; struct _infoNC ** pNCi = NULL; int i; khm_int32 t; wchar_t * ms = NULL; khm_size cb; krb5_timestamp expiration = 0; krb5_timestamp best_match_expiration = 0; char best_match_ccname[256] = ""; khm_handle csp_params = NULL; khm_handle csp_plugins = NULL; if (!buffer || !pcbbuf) return KHM_ERROR_GENERAL; ctx = *pctx; if (!pcc_initialize || !pcc_get_NC_info || !pcc_free_NC_info || !pcc_shutdown) goto _skip_cc_iter; code = pcc_initialize(&cc_ctx, CC_API_VER_2, NULL, NULL); if (code) goto _exit; code = pcc_get_NC_info(cc_ctx, &pNCi); if (code) goto _exit; for(i=0; pNCi[i]; i++) { if (pNCi[i]->vers != CC_CRED_V5) continue; code = (*pkrb5_cc_resolve)(ctx, pNCi[i]->name, &cache); if (code) continue; /* need a function to check the cache for the identity * and determine if it has valid tickets. If it has * the right identity and valid tickets, store the * expiration time and the cache name. If it has the * right identity but no valid tickets, store the ccache * name and an expiration time of zero. if it does not * have the right identity don't save the name. * * Keep searching to find the best cache available. */ if (KHM_SUCCEEDED(khm_get_identity_expiration_time(ctx, cache, ident, &expiration))) { if ( expiration > best_match_expiration ) { best_match_expiration = expiration; StringCbCopyA(best_match_ccname, sizeof(best_match_ccname), "API:"); StringCbCatA(best_match_ccname, sizeof(best_match_ccname), pNCi[i]->name); expiration = 0; } } if(ctx != NULL && cache != NULL) (*pkrb5_cc_close)(ctx, cache); cache = 0; } _skip_cc_iter: if (KHM_SUCCEEDED(kmm_get_plugins_config(0, &csp_plugins))) { khc_open_space(csp_plugins, L"Krb5Cred\\Parameters", 0, &csp_params); khc_close_space(csp_plugins); csp_plugins = NULL; } #ifdef DEBUG if (csp_params == NULL) { assert(FALSE); } #endif if (csp_params && KHM_SUCCEEDED(khc_read_int32(csp_params, L"MsLsaList", &t)) && t) { code = (*pkrb5_cc_resolve)(ctx, "MSLSA:", &cache); if (code == 0 && cache) { if (KHM_SUCCEEDED(khm_get_identity_expiration_time(ctx, cache, ident, &expiration))) { if ( expiration > best_match_expiration ) { best_match_expiration = expiration; StringCbCopyA(best_match_ccname, sizeof(best_match_ccname), "MSLSA:"); expiration = 0; } } } if (ctx != NULL && cache != NULL) (*pkrb5_cc_close)(ctx, cache); cache = 0; } if (csp_params && khc_read_multi_string(csp_params, L"FileCCList", NULL, &cb) == KHM_ERROR_TOO_LONG && cb > sizeof(wchar_t) * 2) { wchar_t * t; char ccname[MAX_PATH + 6]; ms = PMALLOC(cb); #ifdef DEBUG assert(ms); #endif khc_read_multi_string(csp_params, L"FileCCList", ms, &cb); for(t = ms; t && *t; t = multi_string_next(t)) { StringCchPrintfA(ccname, ARRAYLENGTH(ccname), "FILE:%S", t); code = (*pkrb5_cc_resolve)(ctx, ccname, &cache); if (code) continue; if (KHM_SUCCEEDED(khm_get_identity_expiration_time(ctx, cache, ident, &expiration))) { if ( expiration > best_match_expiration ) { best_match_expiration = expiration; StringCbCopyA(best_match_ccname, sizeof(best_match_ccname), ccname); expiration = 0; } } if (ctx != NULL && cache != NULL) (*pkrb5_cc_close)(ctx, cache); cache = 0; } PFREE(ms); } _exit: if (csp_params) khc_close_space(csp_params); if (pNCi) (*pcc_free_NC_info)(cc_ctx, &pNCi); if (cc_ctx) (*pcc_shutdown)(&cc_ctx); if (best_match_ccname[0]) { if (*pcbbuf = AnsiStrToUnicode((wchar_t *)buffer, *pcbbuf, best_match_ccname)) { *pcbbuf = (*pcbbuf + 1) * sizeof(wchar_t); return KHM_ERROR_SUCCESS; } } return KHM_ERROR_GENERAL; }
BOOL CALLBACK ExpandVolSizeDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam) { static EXPAND_VOL_THREAD_PARAMS *pVolExpandParam; WORD lw = LOWORD (wParam); switch (msg) { case WM_INITDIALOG: { char szTemp[4096]; pVolExpandParam = (EXPAND_VOL_THREAD_PARAMS*)lParam; EnableWindow (GetDlgItem (hwndDlg, IDC_SIZEBOX), !pVolExpandParam->bIsDevice); EnableWindow (GetDlgItem (hwndDlg, IDC_KB), !pVolExpandParam->bIsDevice); EnableWindow (GetDlgItem (hwndDlg, IDC_MB), !pVolExpandParam->bIsDevice); EnableWindow (GetDlgItem (hwndDlg, IDC_GB), !pVolExpandParam->bIsDevice); EnableWindow (GetDlgItem (hwndDlg, IDC_TB), !pVolExpandParam->bIsDevice); EnableWindow (GetDlgItem (hwndDlg, IDC_INIT_NEWSPACE), !(pVolExpandParam->bIsLegacy && pVolExpandParam->bIsDevice)); SendDlgItemMessage (hwndDlg, IDC_INIT_NEWSPACE, BM_SETCHECK, pVolExpandParam->bInitFreeSpace ? BST_CHECKED : BST_UNCHECKED, 0); if (!pVolExpandParam->bIsDevice) SetCurrentVolSize(hwndDlg,pVolExpandParam->oldSize); SendMessage (GetDlgItem (hwndDlg, IDC_BOX_HELP), WM_SETFONT, (WPARAM) hBoldFont, (LPARAM) TRUE); GetSpaceString(szTemp,sizeof(szTemp),pVolExpandParam->oldSize,pVolExpandParam->bIsDevice); SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_VOLUME_OLDSIZE), szTemp); SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_VOLUME_NAME), pVolExpandParam->szVolumeName); SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_FILE_SYSTEM), szFileSystemStr[pVolExpandParam->FileSystem]); if (pVolExpandParam->bIsDevice) { GetSpaceString(szTemp,sizeof(szTemp),pVolExpandParam->newSize,TRUE); } else { char szHostFreeStr[256]; SetWindowText (GetDlgItem (hwndDlg, IDT_NEW_SIZE), ""); GetSpaceString(szHostFreeStr,sizeof(szHostFreeStr),pVolExpandParam->hostSizeFree,FALSE); StringCbPrintfA (szTemp,sizeof(szTemp),"%s available on host drive", szHostFreeStr); } SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_VOLUME_NEWSIZE), szTemp); // set help text if (pVolExpandParam->bIsDevice) { StringCbPrintfA (szTemp,sizeof(szTemp),"This is a device-based VeraCrypt volume.\n\nThe new volume size will be choosen automatically as the size of the host device."); if (pVolExpandParam->bIsLegacy) StringCbCatA(szTemp,sizeof(szTemp)," Note: filling the new space with random data is not supported for legacy volumes."); } else { StringCbPrintfA (szTemp, sizeof(szTemp),"Please specify the new size of the VeraCrypt volume (must be at least %I64u KB larger than the current size).",TC_MINVAL_FS_EXPAND/1024); } SetWindowText (GetDlgItem (hwndDlg, IDC_BOX_HELP), szTemp); } return 0; case WM_COMMAND: if (lw == IDCANCEL) { EndDialog (hwndDlg, lw); return 1; } if (lw == IDOK) { char szTemp[4096]; pVolExpandParam->bInitFreeSpace = IsButtonChecked (GetDlgItem (hwndDlg, IDC_INIT_NEWSPACE)); if (!pVolExpandParam->bIsDevice) // for devices new size is set by calling function { GetWindowText (GetDlgItem (hwndDlg, IDC_SIZEBOX), szTemp, sizeof (szTemp)); pVolExpandParam->newSize = _atoi64(szTemp) * GetSizeBoxMultiplier(hwndDlg); } EndDialog (hwndDlg, lw); return 1; } return 0; } return 0; }