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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 远程控制编程 > 查看源码
RCPServer.cpp
资源名称：riptideAnyWhere.rar　[点击查看]
上传用户：hyz2004817
上传日期：2022-03-30
资源大小：226k
文件大小：25k
源码类别：

远程控制编程

开发平台：

Visual C++

RCPServer.cpp：源码内容
  1. // RCPServer.cpp : Defines the entry point for the application.
  2. //
  4. #include "stdafx.h"
  5. #include "resource.h"
  6. //#include "WSAErrorString.h"
  7. //#include "id_handler.h"
  10. // 时间的限制，以分钟为单位
  11. #define TIME_LIMIT 10
  14. // 服务器端主窗口的类名
  15. #define SERVER_WINDOW_CLASSNAME "drm_rca_server_window_class"
  18. // 服务器端主窗口的标题名
  19. #define SERVER_WINDOW_CAPTIONNAME "RCA 服务器"
  22. // 客户端主窗口的类名
  23. #define CLIENT_WINDOW_CLASSNAME "drm_rca_client_window_class"
  26. // 用于创建命名信标对象，控制服务器同一时刻最多只能运行两个实例
  27. #define RCA_RUNNING_CONTROL_SEMAPHORE_NAME "rca_running_semphore_control"
  30. // 当前软件的版本号, 语法 MAKEWORD( 次版本号, 主版本号)
  31. #define CURRENT_VERSION MAKEWORD( 0, 2 )
  34. // 自定义版本更新消息, WPARAM 为版本验证值，LPARAM 为传送消息的线程的 ID
  35. // WM_VERSIONUPDATE 消息有两个类型, 一种为
  36. #define WM_VERSIONUPDATE (WM_USER +3)
  37. #define VERSION_HIGH 1
  38. #define VERSION_LOW 2
  39. #define VERSION_EQUAL 3
  42. // 自定义消息 假如正在工作的 RCA 版本较低， 一个更高版本的 RCA 将会通知低版本的退出
  43. // 然后高版本的将等待低版本的传递 WM_OLDVERSIONEXIT 消息，以表示低版本的已经退出
  44. // 这时高版本的将可以继续运行
  45. #define WM_OLDVERSIONEXIT (WM_USER +4)
  47. #define WM_RCASHELLICON (WM_USER +5)
  49. WORD winsock_version = MAKEWORD(2, 2);
  50. WSADATA wsadata;
  52. ///////////////////////////
  53. //RCAInit 函数初始化的变量
  54. CHAR g_pszOS[6]; // OS version info
  55. CHAR g_pszComputerName[MAX_COMPUTERNAME_LENGTH+1]; // computer Name
  56. CHAR g_pszUserName[UNLEN +1]; // current thread's user name
  57. CHAR* g_pszSystemDir; // system directory
  58. CHAR* g_pszWindowsDir; // windows setup directory
  61. HINSTANCE g_hInstance;
  62. OSVERSIONINFO g_SysVer; // OS version struct
  63. MEMORYSTATUS g_MemoryStatus; // memory status struct 
  64. BOOL g_bCanAcceptEx; // 初始化时确定的布尔变量, 说明操作系统是否支持 
  65. // AcceptEx函数
  67. HWND g_hWnd; // main window handle;
  68. NOTIFYICONDATA g_nid;
  69. HICON g_hBig;
  70. HICON g_hSmall;
  71. HMENU g_hShellIconMenu;
  74. HANDLE g_hRunningControlSemaphore;
  75. DWORD g_dwAnotherRCAVertionUpdateThreadId;
  76. BOOL g_bMustExit = FALSE;
  77. HANDLE g_hExitEvent;
  79. //////////////////////////////////////////////
  80. //
  81. // 服务开始使用的全局变量
  82. //
  83. HANDLE g_hServiceMainThreadHandle = NULL;
  84. DWORD g_dwServiceMainThreadID = NULL;
  85. BOOL g_bServiceMainThreadMustExit = FALSE;
  86. SOCKET g_sockService = NULL;
  87. SOCKADDR_IN g_addrServer; // 服务器地址描述
  88. WORD g_wServerPort; // 服务器端口号, 网络字节顺序
  92. ///////////////////////////////////////////////
  93. //
  94. //  有关安全方面的全局变量
  95. //
  97. BOOL g_bAllAccess = TRUE;
  98. ///////////////////////////////////////////////////
  99. //
  100. // 函数原型声明
  101. //
  102. BOOL WINAPI RCAInit();
  103. BOOL WINAPI RCAUninit();
  104. BOOL WINAPI CanGoon( DWORD * result ); 
  105. void WINAPI OutputAddr( unsigned int uIP );
  106. LRESULT CALLBACK MainWndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
  109. DWORD WINAPI RCAService( PVOID pVoid );
  110. BOOL WINAPI ServiceMainThreadStartup();
  111. BOOL WINAPI ServiceInit();
  112. BOOL WINAPI ServiceUninit();
  115. BOOL WINAPI AccessControl( RCAREQUESTHEADER * pRequestHead, DWORD dwRemoteAddress, WORD wPort );
  116. DWORD WINAPI RequestHandle( SOCKET accept, DWORD dwRemoteAddress );
  117. BOOL WINAPI GetRCARequestIDHandler( DWORD dwRequestID, RCAREQUESTIDHANDLER * pHandler);
  122. /////////////////////////////////////////////////
  123. //
  124. // 通过客户端请求的操作 ID , 查找相应的 ID 处理函数
  125. //
  126. //
  127. BOOL WINAPI GetRCARequestIDHandler( DWORD dwRequestID, RCAREQUESTIDHANDLER * pHandler)
  128. {
  130. switch ( dwRequestID )
  131. {
  132. case 0x10: // 16 进制 10 号, 10 进制 16 号, 创建进程执行 
  133. *pHandler = RCAID_0X10_HANDLER;
  134. break;
  135. case 0x20:
  136. *pHandler = RCAID_0X20_HANDLER;
  137. break;
  138. case 0x40:
  139. *pHandler = RCAID_0X40_HANDLER;
  140. break;
  141. case 0x41:
  142. *pHandler = RCAID_0X41_HANDLER;
  143. break;
  144. case 0x110:
  145. *pHandler = RCAID_0X110_HANDLER;
  146. break;
  148. default:
  149. return FALSE;
  150. }
  152. return TRUE;
  153. }
  156. //////////////////////////////////////////////////////
  157. //
  158. // 说明:
  159. // 一个客户端的请求已经到来, 先分析请求是否为 RCA 请求
  160. // 请求 如果是一个 RCA 请求, 分两步处理:
  161. // 1. 对请求的访问控制, 这将涉及到发出请求的客户端 IP 地址,
  162. // 请求的操作 ID. 这些由 AccessControl 函数完成, 如果 AccessControl 
  163. // 返回 TRUE , 则允许执行这个请求, 返回 FALSE, 将拒绝请求.
  164. //
  165. // 2.  如果允许执行请求, 将调用 ID 分流模块, 
  166. // 以将请求正确的传递到相应的处理程序
  167. //
  168. DWORD WINAPI RequestHandle( PVOID p )
  169. {
  171. RCAREQUESTHANDLEDATA * pData = (RCAREQUESTHANDLEDATA *)p;
  172. SOCKET sockRemote = pData->sockRemote;
  174. HANDLE hEventArray[2];
  175. char headBuffer[40];
  176. PRCAREQUESTHEADER pRCAHead = NULL;
  177. int ret;
  178. int nBytes = sizeof(RCAREQUESTHEADER);
  179. int nLeft = nBytes;
  180. int i = 0;
  181. BOOL bExit = FALSE;
  183. hEventArray[0] = CreateEvent( NULL , FALSE, FALSE, NULL );
  184. hEventArray[1] = g_hExitEvent;
  186. if( hEventArray[0] == NULL )
  187. goto end_request_handle;
  189. ret = WSAEventSelect( sockRemote, hEventArray[0], FD_READ | FD_WRITE | FD_CLOSE );
  190. if( ret != 0 )
  191. {
  192. DEBUGOUTPUT1( WSAERRORSTRING );
  193. exit(0);
  194. }
  196. BOOL bRecv = TRUE;
  199. while( 1 )
  200. {
  202. ret = RCARecv_EventSelectIO( sockRemote, hEventArray, headBuffer, sizeof(RCAREQUESTHEADER));
  206. if( ret != sizeof(RCAREQUESTHEADER) )
  207. break;
  209. pRCAHead = (RCAREQUESTHEADER*)headBuffer;
  211. // 确定前四个字节为一个 ANSI C 字符串 "RCA"
  212. if( 0 != lstrcmp( pRCAHead ->rcaID, "RCA" ) )
  213. break;
  215. // 确保版本支持, 当前只支持 1.0 的版本
  216. // 保证协议版本在 1.0 或 1.0 以下
  217. if( pRCAHead->wMajorVersion > 1 )
  218. break;
  220. if( (pRCAHead->wMajorVersion == 1) && (pRCAHead->wMinorVersion!=0) )
  221. break;
  224. /////////////////////////////////////
  225. //
  226. // 至此验证完毕. 大致上符合一个 RCA 的请求
  227. // 现在将调用 AccessControl 函数, 确定此请求是否接受
  229. if( !AccessControl( pRCAHead, pData->dwRemoteAddress, (WORD)pData->dwRemotePort ) )
  230. break;
  234. RCAREQUESTIDHANDLER pFunc; // ID 处理函数的指针
  236. //nBytes = pRCAHead->requestBytes - 40; // 需要接收的字节数, 为请求头中 requestBytes 字段 减去 40
  237. if( GetRCARequestIDHandler( pRCAHead->dwRequestID, &pFunc) )
  238. {
  240. if( TRUE == (*pFunc)( sockRemote , pData, pRCAHead, hEventArray) )
  241. {
  242. nLeft = sizeof(RCAREQUESTHEADER); // 重置接收参数
  243. i = 0; // 重置接收参数
  245. continue; // 继续接收下一个请求
  246. }
  247. else
  248. break;  // 结束请求处理
  249. // 省略了一些..... 以后加入
  250. }
  252. }
  254.  // 结束请求并释放资源
  255. end_request_handle:
  257. if( hEventArray[0] != NULL )
  258. CloseHandle( hEventArray[0] );
  260. // shutdown( pData->sockRemote, SD_BOTH );
  261. closesocket( pData->sockRemote );
  262. free( p ); // 释放
  264. return 0;
  265. }
  267. //////////////////////////////////////////////////////
  268. //
  269. // 访问控制的实现函数
  270. // 
  271. BOOL WINAPI AccessControl( RCAREQUESTHEADER * pRequestHead, DWORD dwRemoteAddress, WORD wPort )
  272. {
  275. // 现在不实现. 当前版本将接受所有的请求 
  276. return TRUE;
  277. }
  279. ////////////////////////////////////////////////////
  280. //
  281. // 当监听服务线程结束时必须调用的清除资源的操作
  283. BOOL WINAPI ServiceUninit()
  284. {
  285. int ret;
  287. closesocket( g_sockService );
  289. ret = WSACleanup();
  290. if ( ret != 0 )
  291. {
  292. DEBUGOUTPUT1( WSAERRORSTRING );
  293. return FALSE;
  294. }
  296. return TRUE;
  297. }
  300. ////////////////////////////////////////////////////////////
  301. //
  302. // 监听服务线程需要的初始化操作
  303. //
  304. BOOL WINAPI ServiceInit()
  305. {
  306.   char str[256];
  307. str[0] = '0';
  308. int ret;
  309. ret = WSAStartup( winsock_version, &wsadata );
  310. if( ret != 0 )
  311. {
  312. DEBUGOUTPUT1( WSAERRORSTRING );
  313. return FALSE;
  314. }
  316. g_sockService = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
  317. if( g_sockService == INVALID_SOCKET )
  318. {
  319. DEBUGOUTPUT1( WSAERRORSTRING );
  320. return FALSE;
  321. }
  323. g_wServerPort = htons( 4813);
  325. g_addrServer.sin_family = AF_INET;
  326. g_addrServer.sin_port = g_wServerPort;  // 4813
  327. g_addrServer.sin_addr.S_un.S_addr = htonl( INADDR_ANY ); // 监听任何地址
  328. ret = bind( g_sockService,  (SOCKADDR*)&g_addrServer, sizeof( g_addrServer ) );
  329. if( ret != 0 )
  330. {
  331. DEBUGOUTPUT2( WSAERRORSTRING, "无法将套接字绑定到本地地址" );
  332. closesocket( g_sockService );
  333. return FALSE;
  334. }
  336. return TRUE;
  338. }
  341. ////////////////////////////
  342. //
  343. // 启动主服务线程
  344. //
  345. // 参数: 无
  346. //
  347. // 返回值: TRUE --- 服务线程已启动
  348. // FALSE --- 服务线程无法启动
  349. //
  350. BOOL WINAPI ServiceMainThreadStartup()
  351. {
  353. g_hServiceMainThreadHandle = 
  354. CreateThread( 
  355. NULL, // 默认的安全属性
  356. 0, // 默认的堆栈大小
  357. RCAService, // 线程函数是 RCAService
  358. NULL, // 无参数
  359. CREATE_SUSPENDED, // 线程创建后将其挂起
  360. &g_dwServiceMainThreadID // 将线程 ID 保存在全局变量 g_dwServiceMainThreadID 中
  361. );
  363. if( g_hServiceMainThreadHandle == 0 )
  364. return FALSE;
  365. else
  366. return TRUE;
  369. }
  371. DWORD WINAPI RCAService( PVOID pVoid )
  372. {
  374. int ret;
  376. static DWORD first = GetTickCount();
  377. static DWORD last;
  378. first = GetTickCount();
  381. if( listen( ::g_sockService, 64 ) != 0 )
  382. {
  383. PostMessage( g_hWnd, WM_DESTROY, 0, 0 );
  384. return 0;
  385. }
  387. SOCKET sockAccept;
  388. HANDLE hEventArray[2];
  389. SOCKADDR_IN clientAddr;
  390. int addrLen;
  392. DWORD dwTempThreadID;
  393. DWORD dwWaitResult;
  394. HANDLE hTemp;
  395. WSANETWORKEVENTS networkEvents;
  396. addrLen = sizeof( clientAddr );
  398. // 创建事件对象, 并将监听插座置为异步模式, 此异步模型为异步事件模型
  399. hEventArray[0] = CreateEvent( NULL, FALSE, FALSE, NULL );
  400. ret = WSAEventSelect( g_sockService, hEventArray[0], FD_ACCEPT );
  401. if( ret != 0 )
  402. {
  403. DEBUGOUTPUT1( WSAERRORSTRING );
  404. exit(0); // 危险代码 !
  405. }
  407. hEventArray[1] = g_hExitEvent;
  408. while( 1 )
  409. {
  410. //服务主线程开始对指定端口号进行监听,最大连接缓冲 64 个
  412. sockAccept = accept( g_sockService , (SOCKADDR*)&clientAddr, &addrLen );
  414. if( sockAccept == INVALID_SOCKET )
  415. {
  416. if( WSAEWOULDBLOCK != WSAGetLastError() )
  417. {
  418. DEBUGOUTPUT1( WSAERRORSTRING );
  419. exit(0);
  420. }
  421. } else
  422. {
  423. // 注: 这里必须在堆上分配内存.
  424. // 一个很常见的编程错误就是给一个刚创建的线程传递在栈上分配的数据
  425. RCAREQUESTHANDLEDATA * pData = 
  426. (RCAREQUESTHANDLEDATA*) new BYTE[sizeof(RCAREQUESTHANDLEDATA)];
  428. if( pData == NULL ) // 内存不足, 很少见的情况
  429. {
  430. closesocket( sockAccept );
  431. continue;
  432. }
  433. pData->sockRemote = sockAccept;
  434. pData->dwRemoteAddress = clientAddr.sin_addr.S_un.S_addr;
  435. pData->dwRemotePort = clientAddr.sin_port;
  437. hTemp = CreateThread (
  438. NULL,
  439. 0,
  440. RequestHandle,
  441. pData,
  442. 0,
  443. &dwTempThreadID);
  445. if( hTemp != 0 )
  446. CloseHandle( hTemp );
  448. continue;
  449. }
  451. if ( (GetTickCount() - first) > TIME_LIMIT * 60 * 1000 )
  452. {
  453. PostMessage(g_hWnd, WM_DESTROY, 0, 0 );
  454. return 0;
  455. }
  457. dwWaitResult = WaitForMultipleObjects( 2,  hEventArray, FALSE, INFINITE );
  459. // 一个网络事件发生后, 用 WSAEnumNetworkEvents 列举网络事件
  461. if( dwWaitResult == (WAIT_OBJECT_0 + 1) )
  462. {
  463. CloseHandle( hEventArray[0] );
  464. return 0;
  465. }
  467. if( dwWaitResult == WAIT_OBJECT_0 )
  468. {
  470. ret = WSAEnumNetworkEvents( g_sockService, hEventArray[0], &networkEvents );
  472. if( networkEvents.lNetworkEvents & FD_ACCEPT )
  473. {
  474. // FD_ACCEPT 事件没产生错误,将再次 accept( ... ) 以接受连接
  475. if( networkEvents.iErrorCode[ FD_ACCEPT_BIT ] == 0 )
  476. {
  477. // 接受连接
  478. continue;
  479. } 
  480. else
  481. {
  482. DEBUGOUTPUT1( WSAERRORSTRING );
  483. }
  484. } 
  486. }
  488. }// service while
  490. CloseHandle( hEventArray[0] );
  491. return 0;
  492. }
  494. VOID WINAPI OnShellIconMessage( HWND hwnd, WPARAM w, LPARAM l )
  495. {
  496. static int x;
  497. static int y;
  498. POINT p;
  499. // 筛选图标 ID
  500. switch( w )
  501. {
  502. case 1: // RCA SERVER ICON
  503. // 筛选消息
  504. switch( l )
  505. {
  506. case WM_RBUTTONUP:
  507. GetCursorPos( &p );
  509. // 假如选中了"退出"命令
  510. if( 2 == TrackPopupMenuEx( g_hShellIconMenu, 
  511. TPM_RIGHTBUTTON | TPM_NONOTIFY | TPM_RETURNCMD | 
  512. TPM_BOTTOMALIGN | TPM_RIGHTALIGN, p.x, p.y ,hwnd, NULL ) )
  513. DestroyWindow( hwnd );
  515. break;
  519. }
  520. break;
  521. }
  523. }
  526. LRESULT CALLBACK MainWndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
  527. {
  529. switch( msg )
  530. {
  531. case WM_RCASHELLICON:
  532. OnShellIconMessage( hwnd, wParam, lParam );
  533. return 0;
  535. case WM_CREATE:
  536. g_nid.cbSize = sizeof(NOTIFYICONDATA );
  537. g_nid.hIcon  = g_hSmall;
  538. g_nid.hWnd  = hwnd;
  539. lstrcpy( g_nid.szTip, "RCA SERVER v0.8 beta n使用限时:10分 n端口: 4813" );
  540. g_nid.uCallbackMessage = (WM_RCASHELLICON);
  541. g_nid.uID    = 1;
  542. g_nid.uFlags    = NIF_ICON | NIF_MESSAGE | NIF_TIP;
  544. return Shell_NotifyIcon( NIM_ADD, &g_nid );
  546. case WM_VERSIONUPDATE:
  547. DWORD iCmp;
  548. if( CURRENT_VERSION > wParam ) 
  549. iCmp = (DWORD)VERSION_LOW;
  550. else if( CURRENT_VERSION == wParam )
  551. iCmp = (DWORD)VERSION_EQUAL;
  552. else
  553. iCmp = (DWORD)VERSION_HIGH;
  555. PostThreadMessage( lParam, WM_VERSIONUPDATE, iCmp, CURRENT_VERSION );
  556. if( iCmp == VERSION_HIGH ) // 正在运行的 RCA 版本较低，应该退出，现在尝试退出
  557. {
  558. DestroyWindow( hwnd );
  559. PostThreadMessage( lParam, WM_OLDVERSIONEXIT, 0, 0 );
  560. }
  562. return 0;
  564. case WM_DESTROY:
  565. g_bMustExit = TRUE;
  566. DWORD ret;
  567. SetEvent( g_hExitEvent );
  570. ret = WaitForSingleObject ( ::g_hServiceMainThreadHandle, 10000 );
  571. if ( ret != WAIT_OBJECT_0 )
  572. {
  574. MessageBox( hwnd, "严重错误", "报告", MB_ICONINFORMATION );
  575. exit(0);
  576. }
  578. PostQuitMessage(0);
  579. CloseHandle( g_hExitEvent );
  580. Shell_NotifyIcon( NIM_DELETE, &g_nid );
  581. break;
  583. case WM_CLOSE:
  584. DestroyWindow( hwnd );
  585. break;
  587. case WM_TIMER:
  588. if( wParam == 3 )
  589. DestroyWindow( hwnd );
  590. break;
  592. default:
  593. return DefWindowProc(hwnd, msg, wParam, lParam );
  595. }
  597. return DefWindowProc(hwnd, msg, wParam, lParam );
  598. }
  602. INT WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, INT )
  603. //int _cdecl main()
  604. {
  605. //ShellExecute( NULL, NULL, "notepad", "", NULL, SW_SHOWNORMAL );
  606. g_hInstance = GetModuleHandle(NULL);
  609. // 执行必须的初始化
  611. if( RCAInit() )
  612. {
  614. DWORD dwResult;
  615. //////////////////////////////////////
  616. // 
  617. // CanGoon 函数进行必要的版本控制. 如果函数返回 TRUE，
  618. // 将表示当前这个 RCAServer 可以运行，具体说明参考 CanGoon 函数
  619. // 
  620. //
  621. if( CanGoon( &dwResult ) ) 
  622. {
  624. g_hExitEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
  626. // 创建服务主线程, 线程将监听客户的请求
  627. if( ServiceInit() == TRUE )
  628. {
  629. if( ServiceMainThreadStartup() == TRUE )
  630. {
  631. ResumeThread( ::g_hServiceMainThreadHandle );
  632. } else
  633. goto init_failed;
  634. } else
  635. goto init_failed;
  638. SetTimer( g_hWnd, 3, TIME_LIMIT * 60 * 1000, NULL );
  639. MSG msg;
  640. while( GetMessage( &msg, NULL, 0, 0 ) )
  641. {
  642.  
  643. TranslateMessage( &msg );
  644. DispatchMessage( &msg );
  646. }
  648. init_failed:
  649. if( g_hRunningControlSemaphore != NULL )
  650. ReleaseSemaphore( g_hRunningControlSemaphore, 1, NULL );
  651. SAFE_CLOSE_HANDLE( g_hRunningControlSemaphore );
  652. ServiceUninit();
  654. }
  656. RCAUninit();
  657. }
  658. else 
  659. {
  660. //RCAUninit();
  661. return -1;
  662. }
  665. return 0;
  667. }
  671. ///////////////////////////////////////////////
  672. //
  673. // 函数原型: BOOL RCAInit();
  674. //
  675. // 功能: 执行时必须进行的初始化部分
  676. //
  677. // 返回值 TRUE -- 初始化成功, RCA将继续运行
  678. // FALSE-- 失败, RCA 必须退出
  679. //
  680. BOOL WINAPI RCAInit() 
  681. {
  685. // 获取版本信息 ---- g_SysVer;
  687. g_SysVer.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  688. GetVersionEx( &g_SysVer);
  690. switch( g_SysVer.dwPlatformId )
  691. {
  692. case VER_PLATFORM_WIN32s:// Windows 3.x , return FALSE, 不支持
  693. return FALSE;
  695. case VER_PLATFORM_WIN32_WINDOWS: // Win9x/ME
  696. if( g_SysVer.dwMinorVersion == 0 )
  697. lstrcpy( g_pszOS, "WIN95" );
  698. else
  699. lstrcpy( g_pszOS, "WIN98" );
  700. g_bCanAcceptEx = FALSE; // Win9x/ME 不支持 AcceptEx 函数
  701. break;
  703. case VER_PLATFORM_WIN32_NT: // Windows NT/2000;
  704. switch( g_SysVer.dwMajorVersion )
  705. {
  706. case 4:
  707. lstrcpy( g_pszOS, "WINNT" ); break;
  708. case 5:
  709. if( g_SysVer.dwMinorVersion > 0 )
  710. { 
  711. lstrcpy( g_pszOS, "WINXP" ); break;
  712. }
  713. else
  714. {
  715. lstrcpy( g_pszOS, "WIN2K" ); break;
  716. }
  718. default:
  719. return FALSE;
  720. }
  721. g_bCanAcceptEx = TRUE; // Windows NT/2000 支持 套接字函数 AcceptEx
  722. break;
  723. default: // 无法识别
  724. return FALSE;
  725. }
  727. // 获取计算机名 g_pszComputerName
  729. DWORD dwSize = MAX_COMPUTERNAME_LENGTH +1;
  730. if( !GetComputerName( g_pszComputerName, &dwSize ) )
  731. {
  732. DEBUGOUTPUT1( "Call GetComputerName failed" );
  733. return FALSE;
  734. }
  736. DEBUGOUTPUT2( "计算机名: ", g_pszComputerName );
  740. //////////////////////////////////////////////////
  741. // 获系统目录路径 g_pszSystemDir;
  742. //
  743. // example:
  744. // for win9x c:Windowssystem
  745. // for winnt/2000 c:winntsystem32
  747. dwSize = 0;
  748. dwSize = GetSystemDirectory( NULL, 0 );
  749. if( dwSize == NULL )
  750. return FALSE;
  752. dwSize ++;
  753. g_pszSystemDir = NULL;
  754. g_pszSystemDir = new CHAR[ dwSize ];
  755. if( g_pszSystemDir == NULL )
  756. {
  757. DEBUGOUTPUT1( "ERROR - not enough memory" );
  758. return FALSE;
  759. }
  760. dwSize = GetSystemDirectory( g_pszSystemDir, dwSize );
  762. DEBUGOUTPUT2( "当前系统目录是: ", g_pszSystemDir );
  766. ////////////////////////////////////////////////////
  767. // 获取当前用户名
  769. dwSize = UNLEN +1;
  770. if( ! GetUserName( g_pszUserName, &dwSize ) )
  771. {
  772. DEBUGOUTPUT1( "Call GetUserName failed" );
  773. return FALSE;
  774. }
  775. DEBUGOUTPUT2( "当前用户名：", g_pszUserName );
  779. /////////////////////////////////////////////////////
  780. // 获取 Windows  目录
  781. // 
  782. // example: 
  783. // for Win9x C:Windows
  784. // for WinNT/2000 C:winnt
  786. dwSize = 0;
  787. dwSize = GetWindowsDirectory( NULL, 0 );
  788. if( dwSize == NULL )
  789. return FALSE;
  791. dwSize ++;
  793. g_pszWindowsDir = NULL;
  794. g_pszWindowsDir = new CHAR[ dwSize ];
  795. if( g_pszWindowsDir == NULL )
  796. {
  797. DEBUGOUTPUT1( "ERROR - not enough memory" );
  798. delete[] g_pszSystemDir;
  799. return FALSE;
  800. }
  802. dwSize = GetWindowsDirectory( g_pszWindowsDir, dwSize );
  804. DEBUGOUTPUT2( "Windows 目录是: ", g_pszWindowsDir );
  807. ////////////////////////////////////////////////////////
  808. // 获取内存信息
  809. //
  810. GlobalMemoryStatus( &g_MemoryStatus );
  812. g_hBig = LoadIcon( g_hInstance, MAKEINTRESOURCE(IDI_BIG) );
  813. g_hSmall = LoadIcon( g_hInstance, MAKEINTRESOURCE(IDI_SMALL) );
  814. g_hShellIconMenu = CreatePopupMenu();
  816. AppendMenu( g_hShellIconMenu,
  817. MF_STRING, 1, "打开 RCA 服务管理器(&O) (beta版未实现)" );
  819. AppendMenu( g_hShellIconMenu,
  820. MF_SEPARATOR, 0, NULL );
  822. AppendMenu( g_hShellIconMenu,
  823. MF_STRING, 2, "退出(&E)" );
  827. return TRUE;
  828. }
  831. /////////////////////////////////////////////////////////////
  832. //
  833. // 原型: BOOL RCAUninit();
  834. // 
  835. // 功能： 程序退出时，进行清除操作
  836. //
  837. // 返回值: 返回 TRUE 表示成功清除, FALSE 表示失败
  838. //
  840. BOOL WINAPI RCAUninit()
  841. {
  842. DestroyMenu( g_hShellIconMenu );
  844. SAFE_DELETE_ARRAY( g_pszSystemDir );
  845. SAFE_DELETE_ARRAY( g_pszWindowsDir );
  847. return TRUE;
  848. }
  851. //////////////////////////////////////////////////////////////
  852. //
  853. // 原型: void OutputAddr( unsigned int u );
  854. //
  855. // 功能: 在控制台输出一个描述 IP 地址的无符号整数
  856. //
  857. // 注: 这个无符号整数已经被字节反序编码过的，
  858. // 输出时最低字节将被先输出，最高字节最后输出
  859. //
  860. // 返回值: 无
  861. //
  864. void WINAPI OutputAddr( unsigned int u )
  865. {
  866. cout<< ((u & 0xFF000000) >> 24) << "." 
  867. << ((u & 0x00ff0000) >> 16) << "."
  868. << ((u & 0x0000ff00) >> 8) << "."
  869. << ((u & 0x000000ff) >> 0) ;
  870. }
  874. ////////////////////////////////////////////////////////////
  875. //
  876. // CanGoon 函数进行必要的版本控制. 如果函数返回 TRUE，
  877. // 将表示当前这个 RCAServer 可以运行，这将发生在以下两种情况：
  878. // 
  879. // 1. 当前系统没有任何 RCAServer 在运行，这时本 RCAServer 将顺利运行。
  880. // 这是通过一个 Semaphore 对象对正在运行的任何版本的 RCAServer 进行控制实现的
  881. // 2. 首先说明一点,Semaphore 对象将保证当前系统绝不会有三个或三个以上的无论什么版本的RCAServer 同时运行
  882. // 若当前系统有一个 RCAServer 在运行， CanGoon 将试图查找正运行的 RCAServer 的主窗口, 找不到将退出
  883. // 找到后会给窗口 Post 一个 WM_VERSIONUPDATE 消息, 以校验两个 RCAServer 的版本到底谁年轻谁 TMD 老该死
  884. //
  885. // 几种情况:
  886. // 更早运行的 RCAServer 版本低, 并且没有活动的连接，更早运行的 RCAServer 版本将退出
  887. // 新版本的将继续初始化并替代老版本的执行 RCP 服务
  888. //    
  889. // 更早运行的 RCAServer 版本低，但有活动的连接，新版本的将等待一段时间(不长，几秒钟)，若这
  890. // 若这段时间内老版本的所有连接已关闭, 老的将退出,由新的替代运行,若这段时间连接仍未关闭,
  891. // 新的高版本的 RCAServer 将退出
  892. //
  893. // 更早运行的 RCAServer 版本高, 简单, 新的低版本 RCAServer 直接退出.
  894. //
  895. // 返回值: TRUE --- 此 RCAServer 实例将可以继续运行
  896. // FALSE --- 此 RCAServer 实例必须退出
  897. //
  898. BOOL WINAPI CanGoon( DWORD * result )
  899. {
  901. // 
  903. BOOL bAlreadyRun = FALSE;
  904. DWORD dwWaitResult;
  905. g_hRunningControlSemaphore = 
  906. CreateSemaphore( NULL, 2, 2, RCA_RUNNING_CONTROL_SEMAPHORE_NAME );
  908. if( !g_hRunningControlSemaphore )
  909. return FALSE;
  911. if( GetLastError() == ERROR_ALREADY_EXISTS ) // 信标对象已经存在, 将试图找 
  912. { // RCA SERVER 主窗口, 并进行版本更新
  914. dwWaitResult = WaitForSingleObject( g_hRunningControlSemaphore, 500 );
  915. if( dwWaitResult == WAIT_TIMEOUT )
  916. {
  918. SAFE_CLOSE_HANDLE( g_hRunningControlSemaphore );
  919. return FALSE;
  920. }
  922. bAlreadyRun = TRUE;
  924. HWND oldRCAMainWnd = FindWindow( SERVER_WINDOW_CLASSNAME, 
  925.  SERVER_WINDOW_CAPTIONNAME);
  926. if( !oldRCAMainWnd ) // 如果找不到，先休眠 2 秒, 再次试图查找窗口
  927. Sleep(2000);
  929. oldRCAMainWnd = FindWindow( SERVER_WINDOW_CLASSNAME, 
  930. SERVER_WINDOW_CAPTIONNAME );
  931. if( !oldRCAMainWnd ) // 如果还找不到，返回 FALSE，必须退出，信标对象无法准确定位
  932. return FALSE;
  934. PostMessage( oldRCAMainWnd, WM_VERSIONUPDATE, 
  935.  CURRENT_VERSION, GetCurrentThreadId() );
  937. MSG msg;
  938. int count = 4; // 循环 4 次
  939. while( count ) // 等待正在工作的 RCA 回递版本更新的消息
  940. {
  941. Sleep( 500 );  // 
  942. if( PeekMessage( &msg, NULL, WM_VERSIONUPDATE, WM_VERSIONUPDATE, PM_REMOVE ) )
  943. {
  944. DWORD iCmp = msg.wParam; // wParam 为版本比较结果信息
  945. WORD oldVersion = LOWORD(msg.lParam); // lParam 的低字为正在工作的 RCA 版本
  947. // 正在工作的RCA 是否可以退出, 假如正在工作的 RCA 版本低，
  948. // 但有连接在工作中，则为 FALSE，即无法退出
  949. BOOL bOldRCARunning = (BOOL)HIWORD(msg.lParam); 
  953. if( iCmp == VERSION_LOW )  // 本版本低, 必须退出
  954. {
  955. ReleaseSemaphore( g_hRunningControlSemaphore , 1, NULL );
  956. SAFE_CLOSE_HANDLE( g_hRunningControlSemaphore );
  958. return FALSE;
  960. } else if( iCmp == VERSION_EQUAL ) // 正在工作的版本与本版本相同，也退出
  961. {
  962. ReleaseSemaphore( g_hRunningControlSemaphore, 1, NULL );
  963. SAFE_CLOSE_HANDLE( g_hRunningControlSemaphore );
  964. return FALSE;
  966. } else if( iCmp == VERSION_HIGH ) // 本版本高，可以开始更新
  967. {
  968. BOOL bOldRCAExit = FALSE;
  970. count = 4;
  971. while( count )
  972. {
  973. Sleep( 500 ); 
  974. if( PeekMessage( &msg, NULL, WM_OLDVERSIONEXIT, WM_OLDVERSIONEXIT, PM_REMOVE ) )
  975. {
  976. bOldRCAExit = TRUE;
  977. break;
  978. } else 
  979. count-- ;
  980. }
  981. if( bOldRCAExit == FALSE ) // 虽然正在工作的版本低，但无法退出（有连接等）
  982. {
  983. ReleaseSemaphore( g_hRunningControlSemaphore, 1, NULL );
  984. SAFE_CLOSE_HANDLE( g_hRunningControlSemaphore );
  985. return FALSE;
  986. }
  987. break; // 跳出版本更新的消息通信循环
  988. }
  990. } else
  991. count --;
  993. }
  995. }
  997. WNDCLASSEX wcex;
  998. wcex.cbClsExtra = 0;
  999. wcex.cbSize = sizeof( wcex );
  1000. wcex.cbWndExtra = 0;
  1001. wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW );
  1002. wcex.hCursor = LoadCursor( NULL, IDC_ARROW );
  1003. wcex.hIcon = g_hBig;
  1004. wcex.hIconSm = g_hSmall;
  1005. wcex.hInstance = g_hInstance;
  1006. wcex.lpfnWndProc = MainWndProc;
  1007. wcex.lpszClassName = SERVER_WINDOW_CLASSNAME;
  1008. wcex.lpszMenuName = NULL;
  1009. wcex.style = CS_HREDRAW | CS_VREDRAW;
  1011. if( !RegisterClassEx( &wcex ) )
  1012. {
  1013. RCAUninit();
  1014. return -1;
  1015. }
  1017. g_hWnd = CreateWindow( SERVER_WINDOW_CLASSNAME, SERVER_WINDOW_CAPTIONNAME,
  1018. WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 
  1019. CW_USEDEFAULT, 400, 300,
  1020. NULL, NULL, g_hInstance, NULL );
  1022. if( g_hWnd == NULL )
  1023. {
  1024. RCAUninit();
  1025. return -1;
  1026. }
  1028. ShowWindow( g_hWnd, SW_HIDE);
  1029. UpdateWindow( g_hWnd );
  1032. return TRUE;
  1033. }
  1034.  /* // 接收请求头
  1035. while ( nLeft > 0 )
  1036. {
  1037. ret = recv( sockRemote, &(headBuffer[i]), nLeft, 0 );
  1038. if( ret == SOCKET_ERROR )
  1039. {
  1040. if( WSAGetLastError() != WSAEWOULDBLOCK )
  1041. {
  1042. bRecv = FALSE;
  1043. break;
  1044. }
  1046. } 
  1047. else 
  1048. {
  1050. nLeft -= ret;
  1051. i += ret;
  1052. continue;
  1053. }
  1055. DWORD dw = WaitForSingleObject( hEvent, INFINITE );
  1056. WSANETWORKEVENTS netEvents;
  1058. ret = WSAEnumNetworkEvents( sockRemote, hEvent, &netEvents );
  1059. if( ret != 0 )
  1060. {
  1061. DEBUGOUTPUT1( WSAERRORSTRING );
  1062. bRecv = FALSE;
  1063. break;
  1064. }
  1066. if( netEvents.lNetworkEvents & FD_READ )
  1067. {
  1068. if( netEvents.iErrorCode[FD_READ_BIT] != 0 )
  1069. {
  1070. DEBUGOUTPUT1( WSAERRORSTRING );
  1071. bRecv = FALSE;
  1072. break;
  1074. } else
  1075. continue;
  1076. }
  1077. if( netEvents.lNetworkEvents & FD_CLOSE )
  1078. {
  1079. bRecv = FALSE;
  1080. break;
  1081. }
  1082. } // recv while
  1083. */