开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
GlobalFun.cpp
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：19k
源码类别：

模拟服务器

开发平台：

C/C++

GlobalFun.cpp：源码内容
  1. //-----------------------------------------//
  2. //                                         //
  3. //  File : KStdAfx.cpp              //
  4. // Author : Yang Xiaodong            //
  5. // Modified : 8/14/2002                //
  6. //                                         //
  7. //-----------------------------------------//
  8. #include "tchar.h"
  10. #include "GlobalFun.h"
  11. #include "KStdAfx.h"
  12. #include "process.h"
  14. static const TCHAR szEnter1[] = "rn";
  15. static const UINT uiEnter1 = _tcslen( szEnter1 );
  16. static const TCHAR szEnter2[] = "nr";
  17. static const UINT uiEnter2 = _tcslen( szEnter2 );
  18. static const TCHAR szEnter3[] = "r";
  19. static const UINT uiEnter3 = _tcslen( szEnter3 );
  20. static const TCHAR szEnter4[] = "n";
  21. static const UINT uiEnter4 = _tcslen( szEnter4 );
  22. static const TCHAR szTabKey[] = { 0x09, 0 };
  23. static const UINT uiTabkey = _tcslen( szTabKey );
  24. static const UINT uiTab2SpaceNum = 4;
  25. static const TCHAR szSpaceKey[] = " ";
  26. static const UINT uiSpaceKey = _tcslen( szSpaceKey );
  28. static const TCHAR szLBracket[] = "[";
  29. static const UINT uiLBracket = _tcslen( szLBracket );
  30. static const TCHAR szRBracket[] = "]";
  31. static const UINT uiRBracket = _tcslen( szRBracket );
  32. static const TCHAR szEqual[] = "=";
  33. static const UINT uiEqual = _tcslen( szEqual );
  35. static BOOL IsEnterKey( LPCTSTR lpChar,
  36. BOOL* pEnterType = NULL )
  37. {
  38. BOOL bRet = FALSE;
  40. if ( 0 == _tcsncmp( lpChar, szEnter1, uiEnter1 ) )
  41. {
  42. if ( NULL != pEnterType )
  43. {
  44. *pEnterType = TRUE;
  45. }
  46. bRet = TRUE;
  47. }
  48. else if ( 0 == _tcsncmp( lpChar, szEnter2, uiEnter2 ) )
  49. {
  50. if ( NULL != pEnterType )
  51. {
  52. *pEnterType = TRUE;
  53. }
  54. bRet = TRUE;
  55. }
  56. else if ( 0 == _tcsncmp( lpChar, szEnter3, uiEnter3 ) )
  57. {
  58. if ( NULL != pEnterType )
  59. {
  60. *pEnterType = FALSE;
  61. }
  62. bRet = TRUE;
  63. }
  64. else if ( 0 == _tcsncmp( lpChar, szEnter4, uiEnter4 ) )
  65. {
  66. if ( NULL != pEnterType )
  67. {
  68. *pEnterType = FALSE;
  69. }
  70. bRet = TRUE;
  71. }
  73. return bRet;
  74. }
  76. static long GetFirstLineLen( LPCTSTR lpszSource )
  77. {
  78. long liRet = 0;
  79. if ( NULL != lpszSource )
  80. {
  81. LPTSTR lpszAt = ( LPTSTR )lpszSource;
  82. BOOL bHasEnterKey = FALSE;
  83. while ( 0 != lpszAt[0] )
  84. {
  85. if ( (0 == _tcsncmp( lpszAt, szEnter1, uiEnter1 ) )
  86. || ( 0 == _tcsncmp( lpszAt, szEnter2, uiEnter2 ) )
  87. || ( 0 == _tcsncmp( lpszAt, szEnter3, uiEnter3 ) )
  88. || ( 0 == _tcsncmp( lpszAt, szEnter4, uiEnter4 ) ) )
  89. {
  90. bHasEnterKey = TRUE;
  91. liRet = lpszAt - lpszSource;
  92. break;
  93. }
  94. lpszAt++;
  95. }
  96. if ( !bHasEnterKey )
  97. {
  98. liRet = lpszAt - lpszSource;
  99. }
  100. }
  101. return liRet;
  102. }
  104. static BOOL GetStrInStrPos( LPCTSTR lpszSouce,
  105.    LPCTSTR lpszSearch,
  106.    long &liOffset )
  107. {
  108. BOOL bRet = FALSE;
  109. if ( ( NULL == lpszSouce )
  110. || ( NULL == lpszSearch ) )
  111. {
  112. bRet = FALSE;
  113. }
  114. else
  115. {
  116. long liSource = _tcslen( lpszSouce );
  117. long liSearch = _tcslen( lpszSearch );
  118. LPTSTR lpszAt = ( LPTSTR )( lpszSouce );
  119. for ( long i = 0; i < liSource; i++ )
  120. {
  121. if ( 0 == _tcsncmp( lpszAt, lpszSearch, liSearch ) )
  122. {
  123. bRet = TRUE;
  124. liOffset = i;
  125. break;
  126. }
  127. lpszAt++;
  128. }
  129. }
  130. return bRet;
  131. }
  133. //----------------------------------------------------------
  134. // < Function >
  135. // Name : GetPrivateProfileKeyPos
  136. // Return : int
  137. //   = -1 ---- Error;
  138. //   = 0 ---- Has no the section;
  139. //   = 1 ---- Finds out the key successfully;
  140. //   = 2 ---- Only finds out the section.
  141. // Platform : Unconcerned.
  142. //----------------------------------------------------------
  143. static int GetPrivateProfileKeyPos( LPCTSTR lpszBuf,
  144. LPCTSTR lpszAppName,
  145. LPCTSTR lpszKeyName,
  146. long &liOffset,
  147. long &liSize )
  148. {
  149. int iRet = -1;
  150. if ( ( NULL == lpszBuf )
  151. || ( NULL == lpszAppName )
  152. || ( NULL == lpszKeyName ) )
  153. {
  154. iRet = -1;
  155. }
  156. else
  157. {
  158. BOOL bSearchFlag = FALSE;
  159. LPTSTR lpszAt = ( LPTSTR )lpszBuf;
  160. long liAppName = _tcslen( lpszAppName );
  161. LPTSTR lpszModifiedAppName = new TCHAR[liAppName+3];
  162. if ( NULL != lpszModifiedAppName )
  163. {
  164. _tcscpy( lpszModifiedAppName, szLBracket );
  165. _tcscpy( lpszModifiedAppName + uiLBracket, lpszAppName );
  166. _tcscpy( lpszModifiedAppName + uiLBracket + liAppName, szRBracket );
  168. long liAppNameOffset;
  169. bSearchFlag = GetStrInStrPos( lpszBuf, lpszModifiedAppName, liAppNameOffset );
  170. if ( bSearchFlag )
  171. {
  172. lpszAt +=
  173. liAppNameOffset + liAppName + uiLBracket + uiRBracket;
  174. long liKeyNameOffset;
  175. bSearchFlag = GetStrInStrPos( lpszAt, lpszKeyName, liKeyNameOffset );
  176. if ( bSearchFlag )
  177. {
  178. liOffset =
  179. liAppNameOffset + liKeyNameOffset + liAppName + uiLBracket + uiRBracket;
  180. liSize = GetFirstLineLen( lpszAt + liKeyNameOffset );
  181. iRet = 1;
  182. }
  183. else
  184. {
  185. liOffset =
  186. liAppNameOffset + liAppName + uiLBracket + uiRBracket;
  187. liSize = 0;
  188. iRet = 2;
  189. }
  190. }
  191. else
  192. {
  193. iRet = 0;
  194. }
  195. delete []lpszModifiedAppName;
  196. }
  197. }
  198. return iRet;
  199. }
  201. static LPTSTR GetKeyValue( LPCTSTR lpszKeyLine, long &liKeyValueSize )
  202. {
  203. LPTSTR lpszRet = NULL;
  204. if ( NULL != lpszKeyLine )
  205. {
  206. long liKeySize = GetFirstLineLen( lpszKeyLine );
  207. LPTSTR lpszAt = ( LPTSTR )lpszKeyLine;
  208. BOOL bHasValue = FALSE;
  209. long i;
  210. for ( i = 0; i < liKeySize; i++ )
  211. {
  212. if ( 0 == _tcsncmp( lpszAt, szEqual, uiEqual ) )
  213. {
  214. bHasValue = TRUE;
  215. break;
  216. }
  217. lpszAt++;
  218. }
  219. if ( bHasValue )
  220. {
  221. for ( i += uiEqual, lpszAt += uiEqual; i < liKeySize; )
  222. {
  223. if ( 0 == _tcsncmp( lpszAt, szSpaceKey, uiSpaceKey ) )
  224. {
  225. lpszAt += uiSpaceKey;
  226. i += uiSpaceKey;
  227. continue;
  228. }
  229. else
  230. {
  231. if ( ( lpszAt - lpszKeyLine ) < liKeySize )
  232. {
  233. lpszRet = lpszAt;
  234. liKeyValueSize =
  235. liKeySize - ( lpszAt - lpszKeyLine );
  236. }
  237. break;
  238. }
  239. }
  240. }
  241. }
  242. return lpszRet;
  243. }
  245. //----------------------------------------------------------
  246. // < Function >
  247. // Name : KPIWritePrivateProfileString
  248. // Return : BOOL
  249. // Description : copies a string into the
  250. //   specified section of an
  251. //   initialization file.
  252. // Platform : Unconcerned.
  253. //----------------------------------------------------------
  254. BOOL KPIWritePrivateProfileString( LPCTSTR lpszAppName,  /* section name */
  255.   LPCTSTR lpszKeyName,  /* key name */
  256.   LPCTSTR lpszString,   /* string to add */
  257.   LPCTSTR lpszFileName  /* initialization file */ )
  258. {
  259. BOOL bRet = TRUE;
  260. if ( ( NULL == lpszAppName )
  261. || ( NULL == lpszKeyName )
  262. || ( NULL == lpszString )
  263. || ( NULL == lpszFileName ) )
  264. {
  265. bRet = FALSE;
  266. }
  267. else
  268. {
  269. try
  270. {
  271. FILE* pFile = fopen( lpszFileName, "rb" );
  272. long liFileSize = 0;
  273. char* lpszFileBuf = NULL;
  274. if ( NULL != pFile )
  275. {
  276. fseek( pFile, 0, SEEK_END );
  277. liFileSize = ftell( pFile );
  278. if ( liFileSize > 0 )
  279. {
  280. lpszFileBuf = new char[liFileSize+1];
  281. if ( NULL != lpszFileBuf )
  282. {
  283. fseek( pFile, 0, SEEK_SET );
  284. fread( lpszFileBuf, 1, liFileSize, pFile );
  285. lpszFileBuf[liFileSize] = 0;
  286. }
  287. else
  288. {
  289. fclose( pFile );
  290. bRet = FALSE;
  291. return bRet;
  292. }
  293. }
  294. fclose( pFile );
  295. }
  297. pFile = fopen( lpszFileName, "wb" );
  298. if ( NULL != pFile )
  299. {
  300. if ( 0 == liFileSize )
  301. {
  302. fwrite( szLBracket, 1, uiLBracket, pFile );
  303. fwrite( lpszAppName, 1, _tcslen( lpszAppName ), pFile );
  304. fwrite( szRBracket, 1, uiRBracket, pFile );
  305. fwrite( szEnter1, 1, uiEnter1, pFile );
  307. fwrite( lpszKeyName, 1, _tcslen( lpszKeyName ), pFile );
  308. fwrite( szEqual, 1, uiEqual, pFile );
  309. fwrite( lpszString, 1, _tcslen( lpszString ), pFile );
  310. fwrite( szEnter1, 1, uiEnter1, pFile );
  311. }
  312. else
  313. {
  314. long liOffset, liSize;
  315. int iResult =
  316. GetPrivateProfileKeyPos( lpszFileBuf,
  317. lpszAppName,
  318. lpszKeyName,
  319. liOffset,
  320. liSize );
  321. if ( 0 == iResult )
  322. {
  323. fwrite( lpszFileBuf, 1, liFileSize, pFile );
  324. if ( ( !IsEnterKey( &( lpszFileBuf[liFileSize-2] ) ) )
  325. && ( !IsEnterKey( &( lpszFileBuf[liFileSize-3] ) ) ) )
  326. {
  327. fwrite( szEnter1, 1, uiEnter1, pFile );
  328. }
  330. fwrite( szLBracket, 1, uiLBracket, pFile );
  331. fwrite( lpszAppName, 1, _tcslen( lpszAppName ), pFile );
  332. fwrite( szRBracket, 1, uiRBracket, pFile );
  333. fwrite( szEnter1, 1, uiEnter1, pFile );
  335. fwrite( lpszKeyName, 1, _tcslen( lpszKeyName ), pFile );
  336. fwrite( szEqual, 1, uiEqual, pFile );
  337. fwrite( lpszString, 1, _tcslen( lpszString ), pFile );
  338. fwrite( szEnter1, 1, uiEnter1, pFile );
  339. bRet = TRUE;
  340. }
  341. else if ( 1 == iResult )
  342. {
  343. fwrite( lpszFileBuf, 1, liOffset, pFile );
  344. long liKeyLen =
  345. GetFirstLineLen( &( lpszFileBuf[liOffset] ) );
  346. LPTSTR lpszKeyTemp = new TCHAR[liKeyLen+1];
  347. memcpy( lpszKeyTemp, &( lpszFileBuf[liOffset] ), liKeyLen * sizeof( TCHAR ) );
  348. lpszKeyTemp[liKeyLen] = 0;
  349. long liKeyValueSize;
  350. if ( NULL != GetKeyValue( lpszKeyTemp, liKeyValueSize ) )
  351. {
  352. fwrite( lpszKeyTemp, 1, liKeyLen - liKeyValueSize, pFile );
  353. fwrite( lpszString, 1, _tcslen( lpszString ), pFile );
  354. fwrite( &( lpszFileBuf[liOffset+liKeyLen] ), 1, liFileSize - liOffset - liKeyLen, pFile );
  355. }
  356. else
  357. {
  358. fwrite( &( lpszFileBuf[liOffset] ), 1, liFileSize - liOffset, pFile );
  359. }
  361. delete []lpszKeyTemp;
  362. bRet = TRUE;
  363. }
  364. else if ( 2 == iResult )
  365. {
  366. fwrite( lpszFileBuf, 1, liOffset, pFile );
  367. fwrite( szEnter1, 1, uiEnter1, pFile );
  368. fwrite( lpszKeyName, 1, _tcslen( lpszKeyName ), pFile );
  369. fwrite( szEqual, 1, uiEqual, pFile );
  370. fwrite( lpszString, 1, _tcslen( lpszString ), pFile );
  371. if ( !IsEnterKey( &( lpszFileBuf[liOffset] ) ) )
  372. {
  373. fwrite( szEnter1, 1, uiEnter1, pFile );
  374. }
  375. fwrite( &( lpszFileBuf[liOffset] ), 1, liFileSize - liOffset, pFile );
  376. bRet = TRUE;
  377. }
  378. else
  379. {
  380. bRet = FALSE;
  381. }
  382. }
  384. fclose( pFile );
  385. }
  386. else
  387. {
  388. bRet = FALSE;
  389. }
  391. if ( NULL != lpszFileBuf )
  392. {
  393. delete []lpszFileBuf;
  394. }
  395. }
  396. catch(...)
  397. {
  398. bRet = FALSE;
  399. }
  400. }
  402. return bRet;
  403. }
  405. //----------------------------------------------------------
  406. // < Function >
  407. // Name : KPIGetPrivateProfileString
  408. // Return : DWORD
  409. //   The return value is the number of
  410. //   characters copied to the buffer,
  411. //   not including the terminating null
  412. //   character.
  413. // Description : retrieves a string from
  414. //   the specified section in
  415. //   an initialization file.
  416. // Platform : Unconcerned.
  417. //----------------------------------------------------------
  418. DWORD KPIGetPrivateProfileString( LPCTSTR lpszAppName, /* section name(Input) */
  419.  LPCTSTR lpszKeyName, /* key name(Input) */
  420.  LPCTSTR lpszDefault, /* default string(Input) */
  421.  LPTSTR lpszReturnedString, /* destination buffer(Output) */
  422.  DWORD dwSize, /* size of destination buffer(Input) */
  423.  LPCTSTR lpszFileName /* initialization file name(Input) */ )
  424. {
  425. DWORD dwRet = 0;
  427. if ( ( NULL == lpszAppName )
  428. || ( NULL == lpszKeyName )
  429. || ( NULL == lpszDefault )
  430. || ( NULL == lpszFileName ) )
  431. {
  432. return dwRet;
  433. }
  435. BOOL bDefault = FALSE;
  437. try
  438. {
  439. FILE* pFile = fopen( lpszFileName, "rb" );
  440. if ( NULL != pFile )
  441. {
  442. fseek( pFile, 0, SEEK_END );
  443. long liFileSize = ftell( pFile );
  444. char* lpszFileBuf = NULL;
  445. if ( liFileSize > 0 )
  446. {
  447. lpszFileBuf = new char[liFileSize+1];
  448. if ( NULL != lpszFileBuf )
  449. {
  450. fseek( pFile, 0, SEEK_SET );
  451. fread( lpszFileBuf, 1, liFileSize, pFile );
  452. lpszFileBuf[liFileSize] = 0;
  454. long liOffset, liSize;
  455. int iResult =
  456. GetPrivateProfileKeyPos( lpszFileBuf,
  457. lpszAppName,
  458. lpszKeyName,
  459. liOffset,
  460. liSize );
  461. if ( 1 == iResult )
  462. {
  463. long liKeyLen =
  464. GetFirstLineLen( &( lpszFileBuf[liOffset] ) );
  465. LPTSTR lpszKeyTemp = new TCHAR[liKeyLen+1];
  466. memcpy( lpszKeyTemp, &( lpszFileBuf[liOffset] ), liKeyLen * sizeof( TCHAR ) );
  467. lpszKeyTemp[liKeyLen] = 0;
  468. long liKeyValueSize;
  469. LPTSTR lpszKeyValue =
  470. GetKeyValue( lpszKeyTemp, liKeyValueSize );
  471. if ( NULL != lpszKeyValue )
  472. {
  473. dwRet = liKeyValueSize;
  474. DWORD dwCopyLen =
  475. dwSize <= liKeyValueSize ? dwSize : liKeyValueSize;
  476. if ( NULL != lpszReturnedString )
  477. {
  478. memcpy( lpszReturnedString, lpszKeyValue, dwCopyLen );
  479. if ( dwSize > dwCopyLen )
  480. {
  481. lpszReturnedString[dwCopyLen] = 0;
  482. }
  483. }
  484. }
  485. else
  486. {
  487. bDefault = TRUE;
  488. }
  490. delete []lpszKeyTemp;
  491. }
  492. else
  493. {
  494. bDefault = TRUE;
  495. }
  496. delete []lpszFileBuf;
  497. }
  498. }
  499. fclose( pFile );
  500. }
  501. else
  502. {
  503. bDefault = TRUE;
  504. }
  505. }
  506. catch(...)
  507. {
  508. bDefault = TRUE;
  509. }
  511. if (bDefault)
  512. {
  513. dwRet = _tcslen( lpszDefault );
  514. DWORD dwCopyLen =
  515. dwSize <= dwRet ? dwSize : dwRet;
  516. if ( NULL != lpszReturnedString )
  517. {
  518. memcpy( lpszReturnedString, lpszDefault, dwCopyLen );
  519. if ( dwSize > dwCopyLen )
  520. {
  521. lpszReturnedString[dwCopyLen] = 0;
  522. }
  523. }
  524. }
  526. return dwRet;
  527. }
  529. //----------------------------------------------------------
  530. // < Function >
  531. // Name : KPIWaitForSingleObject
  532. // Return : DWORD
  533. //   = 0 ---- failed;
  534. //   = 1 ---- The state of the specified
  535. //      object is signaled;
  536. //   = 2 ---- time out;
  537. //   = ... ---- Not defined.
  538. // Platform : Windows 9X/NT/2000/Later
  539. //----------------------------------------------------------
  540. DWORD KPIWaitForSingleObject( HANDLE hHandle, DWORD dwMilliseconds )
  541. {
  542. DWORD dwRet = 0;
  543. DWORD dwResult = WaitForSingleObject( hHandle, dwMilliseconds );
  544. switch ( dwResult )
  545. {
  546. case WAIT_FAILED:
  547. dwRet = 0;
  548. break;
  549. case WAIT_OBJECT_0:
  550. dwRet = 1;
  551. break;
  552. case WAIT_TIMEOUT:
  553. dwRet = 2;
  554. break;
  555. default:
  556. dwRet = 0;
  557. break;
  558. }
  559. return dwRet;
  560. }
  562. //----------------------------------------------------------
  563. // < Function >
  564. // Name : KPICloseHandle
  565. // Return : BOOL
  566. // Platform : Windows 9X/NT/2000/Later
  567. //----------------------------------------------------------
  568. BOOL KPICloseHandle( HANDLE hObject )
  569. {
  570. BOOL bRet = FALSE;
  571. bRet = CloseHandle( hObject );
  572. return bRet;
  573. }
  575. //----------------------------------------------------------
  576. // < Function >
  577. // Name : KPITerminateThread
  578. // Return : BOOL
  579. // Platform : Windows 9X/NT/2000/Later
  580. //----------------------------------------------------------
  581. BOOL KPITerminateThread( HANDLE hThread, DWORD dwExitCode )
  582. {
  583. BOOL bRet = FALSE;
  584. bRet = TerminateThread( hThread, dwExitCode );
  585. return bRet;
  586. }
  588. //----------------------------------------------------------
  589. // < Function >
  590. // Name : KPICreateThread
  591. // Return : HANDLE
  592. //   Returns 0 if function is failed;
  593. //   Returns the handle of new thread if
  594. //   function is successful.
  595. // Description : Creates a thread to execute within
  596. //   the virtual address space of the
  597. //   calling process.
  598. // Platform : Windows 9X/NT/2000/Later
  599. //----------------------------------------------------------
  600. HANDLE KPICreateThread( LPTHREAD_START_ROUTINE lpStartAddress, /* thread function */
  601.    LPVOID lpParameter, /* thread argument */
  602.    LPDWORD lpThreadId /* thread identifier */ )
  603. {
  604. typedef unsigned ( __stdcall *start_address )( void * );
  606. HANDLE hRet = NULL;
  608. DWORD dwThreadId = 0;
  609. if (lpThreadId == NULL)
  610. lpThreadId = &dwThreadId; 
  612. hRet = 
  613. (HANDLE)_beginthreadex( NULL, 0, (start_address)lpStartAddress, lpParameter, 0, (unsigned*)lpThreadId);
  615. return hRet;
  616. }
  618. SOCKET KPICreateUDPSocket( int iPort )
  619. {
  620. SOCKET s = INVALID_SOCKET;
  622. // The follow code is used to initialize
  623. // the environment for Windows OS platform
  624. // and should be removed or changed when
  625. // replanted to other platforms.
  626. //------>BEGIN
  627. WORD wVersionRequired = MAKEWORD(1,1);
  628. WSADATA WSAdata;
  629. if ( 0 != WSAStartup( wVersionRequired, &WSAdata ) )
  630. {
  631. s = INVALID_SOCKET;
  632. return s;
  633. }
  634. //<------END
  636. s = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
  637. if ( INVALID_SOCKET == s )
  638. {
  639. return s;
  640. }
  642. SOCKADDR_IN local;
  643. local.sin_family = AF_INET;
  644. local.sin_port = htons( ( short )( iPort ) );
  645. local.sin_addr.s_addr = htonl( INADDR_ANY );
  646. if ( bind( s, ( SOCKADDR* )( &local ), sizeof( local ) )
  647. == SOCKET_ERROR )
  648. {
  649. closesocket( s );
  650. s = INVALID_SOCKET;
  651. return s;
  652. }
  654. WSACleanup(); // Needed on Windows OS platforms.
  656. return s;
  657. }
  659. HANDLE KPICreateEvent( LPSECURITY_ATTRIBUTES lpEventAttributes, /* SD */
  660.   BOOL bManualReset, /* reset type */
  661.   BOOL bInitialState, /* initial state */
  662.   LPCTSTR lpszName /* object name */ )
  663. {
  664. HANDLE hRet = NULL;
  666. hRet = CreateEvent( lpEventAttributes, bManualReset, bInitialState, lpszName );
  668. return hRet;
  669. }
  671. BOOL KPISetEvent( HANDLE hEvent/* handle to event */ )
  672. {
  673. BOOL bRet = FALSE;
  675. bRet = SetEvent( hEvent );
  677. return bRet;
  678. }
  680. BOOL KPIResetEvent( HANDLE hEvent/* handle to event */ )
  681. {
  682. BOOL bRet = FALSE;
  684. bRet = ResetEvent( hEvent );
  686. return bRet;
  687. }
  689. void KPIGetExePath( LPSTR lpExePath, DWORD dwSize )
  690. {
  691. if ( lpExePath )
  692. {
  693. memset( lpExePath, 0, dwSize );
  694. GetModuleFileName( NULL, lpExePath, dwSize );
  695. DWORD dwEndAt;
  696. dwEndAt = strlen( lpExePath ) - 1;
  697. while ( dwEndAt >= 1 )
  698. {
  699. if ( lpExePath[dwEndAt-1] == '\' )
  700. {
  701. lpExePath[dwEndAt] = 0;
  702. break;
  703. }
  704. dwEndAt--;
  705. }
  706. }
  707. }
  709. HANDLE KPICreateMutex( LPSECURITY_ATTRIBUTES lpMutexAttributes, /* SD */
  710.   BOOL bInitialOwner, /* initial owner */
  711.   LPCTSTR lpName /* object name */ )
  712. {
  713. return CreateMutex( lpMutexAttributes, bInitialOwner, lpName );
  714. }
  716. BOOL KPIReleaseMutex( HANDLE hMutex )
  717. {
  718. return ReleaseMutex( hMutex );
  719. }
  721. unsigned long KPIHash( char* pStr, unsigned long ulModel, unsigned long ulBaseNum )
  722. {
  723. assert( ( NULL != pStr ) && ( 0 < ulModel ) );
  724.     unsigned long i = 0;
  725.     unsigned long j = 1;
  726.     while ( *pStr )
  727. {
  728. i += ( ( unsigned char )*pStr ) * j++;
  729. pStr++;
  730. }
  731.     return ( i % ulModel + ulBaseNum );
  732. }
  734. void KPIPrintToFile( const TCHAR* lpszFilePath, const TCHAR* lpszFmt, ... )
  735. {
  736. if ( ( NULL == lpszFilePath )
  737. || ( NULL == lpszFmt ) )
  738. {
  739. return;
  740. }
  742. FILE* pF = fopen( lpszFilePath, "a+b" );
  743. if ( NULL != pF )
  744. {
  745. fseek( pF, 0, SEEK_END );
  747. va_list args;
  748. va_start( args, lpszFmt );
  749. vfprintf( pF, lpszFmt, args );
  750. va_end ( args );
  752. fclose( pF );
  753. }
  754. }
  756. void KPIPrintToFile( FILE* pFile, const TCHAR* lpszFmt, ... )
  757. {
  758. if ( ( NULL == pFile )
  759. || ( NULL == lpszFmt ) )
  760. {
  761. return;
  762. }
  764. va_list args;
  765. va_start( args, lpszFmt );
  766. vfprintf( pFile, lpszFmt, args );
  767. va_end ( args );
  768. }