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

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