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

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

远程控制编程

开发平台：

Visual C++

RCAClientLibrary.cpp：源码内容
  2. #include "stdafx.h"
  5. BOOL 
  6. WINAPI 
  7. DecodeFromJPEGBuffer(
  8.   BYTE * lpJpgBuffer,
  9.   DWORD  dwJpgBufferSize,
  10.   BYTE** lppRgbBuffer,
  11.   DWORD* lpdwWidth,
  12.   DWORD* lpdwHeight,
  13.   DWORD* lpdwNumberOfChannels
  14.   )
  15.  {
  16.  
  17. BOOL  bres;
  18. IJLERR  jerr;
  19. DWORD  dwWholeImageSize;
  20. BYTE*  lpTemp = NULL;
  22. // Allocate the IJL JPEG_CORE_PROPERTIES structure.
  23. JPEG_CORE_PROPERTIES jcprops;
  25. bres = TRUE;
  27. __try
  28. {
  29. // Initialize the Intel(R) JPEG Library.
  30. jerr = ijlInit(&jcprops);
  31. if(IJL_OK != jerr)
  32. {
  33. bres = FALSE;
  34. __leave;
  35. } 
  36.  
  37. // Get information on the JPEG image
  38. // (i.e., width, height, and channels).
  40. jcprops.JPGFile = NULL;
  41. jcprops.JPGBytes = lpJpgBuffer;
  42. jcprops.JPGSizeBytes = dwJpgBufferSize;
  43. jerr = ijlRead(&jcprops, IJL_JBUFF_READPARAMS);
  44. if(IJL_OK != jerr)
  45. {
  46. bres = FALSE;
  47. __leave;
  48. }
  49. // Set the JPG color space ... this will always be
  50. // somewhat of an educated guess at best because JPEG
  51. // is "color blind" (i.e., nothing in the bit stream
  52. // tells you what color space the data was encoded from).
  53. // However, in this example we assume that we are
  54. // reading JFIF files which means that 3 channel images
  55. // are in the YCbCr color space and 1 channel images are
  56. // in the Y color space.
  57. switch(jcprops.JPGChannels)
  58. {
  59. case 1:
  60. {
  61. jcprops.JPGColor = IJL_G;
  62. jcprops.DIBColor = IJL_RGB;
  63. jcprops.DIBChannels = 3;
  64. break;
  65. }
  66. case 3:
  67. {
  68. jcprops.JPGColor = IJL_YCBCR;
  69. jcprops.DIBColor = IJL_RGB;
  70. jcprops.DIBChannels = 3;
  71. break;
  72. }
  73. default:
  74. {
  75. // This catches everything else, but no
  76. // color twist will be performed by the IJL.
  78. jcprops.JPGColor = IJL_OTHER;
  79. jcprops.DIBColor = IJL_OTHER;
  80. jcprops.DIBChannels = jcprops.JPGChannels;
  81. break;
  82. }
  83. }
  84. // Compute size of desired pixel buffer.
  85. dwWholeImageSize = jcprops.JPGWidth * jcprops.JPGHeight *
  86. jcprops.DIBChannels;
  87. // Allocate memory to hold the decompressed image data.
  88. lpTemp = new BYTE [dwWholeImageSize];
  89. if(NULL == lpTemp)
  90. {
  91. bres = FALSE;
  92. __leave;
  93. }
  94. // Set up the info on the desired DIB properties.
  95. jcprops.DIBWidth = jcprops.JPGWidth;
  96. jcprops.DIBHeight = jcprops.JPGHeight;
  97. jcprops.DIBPadBytes = 0;
  98. jcprops.DIBBytes = lpTemp;
  99. // Now get the actual JPEG image data into the pixel buffer.
  100. jerr = ijlRead(&jcprops, IJL_JBUFF_READWHOLEIMAGE);
  101. if(IJL_OK != jerr)
  102. {
  103. bres = FALSE;
  104. __leave;
  105. }
  106. } // __try
  107. __finally
  108. {
  109. if(FALSE == bres)
  110. {
  111. if(NULL != lpTemp)
  112. {
  113. delete [] lpTemp;
  114. lpTemp = NULL;
  115. }
  116. }
  118. // Clean up the Intel(R) JPEG Library.
  119. ijlFree(&jcprops);
  120. *lpdwWidth = jcprops.DIBWidth;
  121. *lpdwHeight = jcprops.DIBHeight;
  122. *lpdwNumberOfChannels = jcprops.DIBChannels;
  123. *lppRgbBuffer = lpTemp;
  125. } // __finally
  128. return bres;
  129.  } // DecodeFromJPEGBuffer()
  132.  //----------------------------------------------------------
  133.  // An example using the Intel(R) JPEG Library:
  134.  // -- Encode Windows DIB to JPEG buffer.
  135.  //----------------------------------------------------------
  136.  BOOL WINAPI EncodeToJPEGBuffer(
  137.  BYTE* lpRgbBuffer,
  138.  DWORD dwWidth,
  139.  DWORD dwHeight,
  140.  BYTE** lppJpgBuffer,
  141.  DWORD* lpdwJpgBufferSize,
  142.  int iQuality
  143. )
  144. {
  145.  BOOL bres;
  146.  IJLERR jerr;
  147.  DWORD dwRgbBufferSize;
  148.  BYTE* lpTemp;
  150.  // Allocate the IJL JPEG_CORE_PROPERTIES structure.
  151.  JPEG_CORE_PROPERTIES jcprops;
  152.  bres = TRUE;
  153.  __try
  154.  {
  155.  // Initialize the Intel(R) JPEG Library.
  157.  jerr = ijlInit(&jcprops);
  158.  if(IJL_OK != jerr)
  159.  {
  160.  bres = FALSE;
  161.  __leave;
  162.  }
  163.  dwRgbBufferSize = dwWidth * dwHeight * 3;
  164.  lpTemp = new BYTE [dwRgbBufferSize];
  165.  if(NULL == lpTemp)
  166.  {
  167.  bres = FALSE;
  168.  __leave;
  169.  }
  170.  // Set up information to write from the pixel buffer.
  171.  jcprops.DIBWidth = dwWidth;
  172.  jcprops.DIBHeight = dwHeight; // Implies a bottom-up DIB.
  173.  jcprops.DIBBytes = lpRgbBuffer;
  174.  jcprops.DIBPadBytes = 0;
  175.  jcprops.DIBChannels = 3;
  176.  jcprops.DIBColor = IJL_RGB;
  177.  jcprops.JPGWidth = dwWidth;
  178.  jcprops.JPGHeight = dwHeight;
  179.  jcprops.JPGFile = NULL;
  180.  jcprops.JPGBytes = lpTemp;
  181.  jcprops.JPGSizeBytes = dwRgbBufferSize;
  182.  jcprops.JPGChannels = 3;
  183.  jcprops.JPGColor = IJL_YCBCR;
  184.  jcprops.JPGSubsampling = IJL_411; // 4:1:1 subsampling.
  185.  jcprops.jquality = (iQuality>=0)&&(iQuality<=100) ? iQuality : 50; // Select "good" image quality
  186.  // Write the actual JPEG image from the pixel buffer.
  187.  jerr = ijlWrite(&jcprops,IJL_JBUFF_WRITEWHOLEIMAGE);
  188.  if(IJL_OK != jerr)
  189.  {
  190.  bres = FALSE;
  191.  __leave;
  192.  }
  193.  } // __try
  194.  __finally
  195.  {
  196.  if(FALSE == bres)
  197.  {
  198.  if(NULL != lpTemp)
  199.  {
  200.  delete[] lpTemp;
  201.  lpTemp = NULL;
  202.  }
  203.  }
  204.  *lppJpgBuffer = lpTemp;
  205.  *lpdwJpgBufferSize = jcprops.JPGSizeBytes;
  206.  // Clean up the Intel(R) JPEG Library.
  207.  ijlFree(&jcprops);
  208.  }
  209.  return bres;
  210.  } // EncodeToJPEGBuffer()
  213. ////////////////////////////////////////
  214. //
  215. // SOCKET 异步 IO 帮助函数, 异步模型为 "事件选择模型"
  216. //
  217. // 参数:
  218. // SOCKET s:
  219. // 套接字 s 是一个已成功连接的套接字, 并至少使用 FD_READ 标志作为
  220. // 参数 lNetworkEvents 调用了 WSAEventSelect 成功地将套接字置为异步事件选择模型
  221. //
  222. // HANDLE hEvent: 
  223. // 一个用于网络 IO 事件通知的事件句柄. 
  224. //
  225. // char * buf:
  226. // 接收数据缓冲
  227. //
  228. // int len:
  229. // 接收数据缓冲总长度
  230. //
  231. // BOOL * bExit:
  232. // BOOL 变量的指针, 应用程序可以修改这个值. 这个函数调用 WaitForSingleObject 等待 
  233. // dwMilliseconds 毫秒后, 将检测 bExit 的值, 若为 bExit 为 TRUE, 函数将立即返回.
  234. // 返回时是不管等待是否成功的,或说不论等待结果是 WAIT_TIMEOUT 或者 WAIT_OBJECT_0,
  235. // 都会返回, 只要 bExit 为 TRUE
  236. //
  237. //
  238. // DWORD dwMilliseconds:
  239. // 函数将使用这个值作为第二个参数,调用 WaitForSingleObject. 以毫秒为单位
  240. // INFINITE 为无限等待
  241. //
  242. // 返回值:
  243. // 若第一次调用接收函数时, 连接出现问题, 则返回 0 
  244. //
  245. // 若第一次调用接收函数成功后,以后无论发生任何错误都返回一个整型值,
  246. // 描述已接收了多少数据
  247. //
  248. // 如果返回值与参数 len 相等, 说明成功发送出了所有数据, 若不等,可能是网络错误造成, 
  249. // 也可能是 bExit 被设为 TRUE 后接收操作被强制中断
  251. INT
  252. WINAPI RCARecv_EventSelectIO( 
  253. SOCKET s, 
  254. HANDLE hEventArray[2],
  255. char* buf,
  256. const int len
  257. )
  258. {
  259. if( (buf == NULL) || (len==0) )
  260. return FALSE;
  262. int ret;
  263. DWORD dwret;
  264. int count = len;
  265. int index = 0;
  266. WSANETWORKEVENTS ns;
  268. while( count > 0 )
  269. {
  270. ret = recv( s, &(buf[index]), count, 0 );
  272. if( ret == SOCKET_ERROR )
  273. {
  274. // 如果发送错误,并且错误代码不是"被阻塞", 则返回 FALSE ( 发生了网络错误 )
  275. if( WSAGetLastError() != WSAEWOULDBLOCK )
  276. return len - count;
  278. } else if( ret == 0 )
  279. {
  280. return len - count ;
  282. } else 
  283. {
  284. // 如果成功发送, 则更新缓冲偏移字节数和待发总字节数
  285. index += ret;
  286. count -= ret;
  287. continue;
  288. }
  290. dwret = WaitForMultipleObjects( 
  291. 2, hEventArray, FALSE, INFINITE );
  293. switch ( dwret )
  294. {
  295. case WAIT_FAILED:
  296. return len - count;
  298. case WAIT_OBJECT_0:
  299. break;
  301. case WAIT_OBJECT_0 + 1:
  302. return len - count;
  304. case WAIT_TIMEOUT:
  305. break;
  306. }
  308. ret = WSAEnumNetworkEvents( s, hEventArray[0], &ns );
  310. if( ret == SOCKET_ERROR )
  311. {
  312. return len - count;
  313. }
  315. if( ns.lNetworkEvents & FD_READ )
  316. {
  317. if( ns.iErrorCode[ FD_READ_BIT] != 0 )
  318. {
  319. return len - count;
  320. }
  321. else
  322. {
  323. continue; // 回到循环开始处,再次接收数据(此时,绝对可以接收数据)
  324. }
  325. }
  327. if( ns.lNetworkEvents & FD_CLOSE )
  328. {
  329. return len - count;
  330. }
  331. }
  333. return len - count;
  334. }
  339. ////////////////////////////////////////
  340. //
  341. // SOCKET 异步 IO 帮助函数, 异步模型 事件选择模型
  342. //
  343. // 参数:
  344. // SOCKET s:
  345. // 套接字 s 是一个已成功连接的套接字, 并至少使用 FD_WRITE 标志作为
  346. // 参数 lNetworkEvents 调用了 WSAEventSelect 成功地将套接字置为异步事件选择模型
  347. //
  348. // HANDLE hEvent: 
  349. // 一个用于网络 IO 事件通知的事件句柄. 
  350. //
  351. // char * buf:
  352. // 待发数据缓冲
  353. //
  354. // int len:
  355. // 待发数据缓冲总长度
  356. //
  357. // BOOL * bExit:
  358. // BOOL 变量的指针, 应用程序可以修改这个值. 这个函数调用 WaitForSingleObject 等待 
  359. // dwMilliseconds 毫秒后, 将检测 bExit 的值, 若为 bExit 为 TRUE, 函数将立即返回.
  360. // 返回时是不管等待是否成功的,或说不论等待结果是 WAIT_TIMEOUT 或者 WAIT_OBJECT_0,
  361. // 都会返回, 只要 bExit 为 TRUE
  362. //
  363. //
  364. // DWORD dwMilliseconds:
  365. // 函数将使用这个值作为第二个参数,调用 WaitForSingleObject. 以毫秒为单位
  366. // INFINITE 为无限等待
  367. //
  368. // 返回值:
  369. // 若第一次调用发送函数时, 连接出现问题, 则返回 0 
  370. //
  371. // 若第一次调用发送函数成功后,以后无论发生任何错误都返回一个整型值,
  372. // 描述已发送了多少数据
  373. //
  374. // 如果返回值与参数 len 相等, 说明成功发送出了所有数据, 若不等,可能是网络错误造成, 
  375. // 也可能是 bExit 被设为 TRUE 后发送操作被强制中断
  376. INT 
  377. WINAPI RCASend_EventSelectIO( 
  378. SOCKET s, 
  379. HANDLE hEventArray[2],
  380. char* buf,
  381. const int len
  382. )
  383. {
  384. if( (buf == NULL) || (len==0) )
  385. return FALSE;
  387. int ret;
  388. int count = (int)len;
  389. int index =0;
  390. DWORD dwret;
  391. WSANETWORKEVENTS ns;
  393. while( count > 0 )
  394. {
  396. ret = send( s, &(buf[index]), count, 0 );
  398. if( ret == SOCKET_ERROR )
  399. {
  400. // 如果发送错误,并且错误代码不是"被阻塞", 则返回 FALSE ( 发生了网络错误 )
  401. if( WSAGetLastError() != WSAEWOULDBLOCK )
  402. return len - count;
  403. }
  404. else
  405. {
  406. // 如果成功发送, 则更新缓冲偏移字节数和待发总字节数
  407. cout << ret << endl;
  409. index += ret;
  410. count -= ret;
  411. continue;
  412. }
  414. // 到这里,说明没而待发缓冲区可供使用, 在 AsyncEvent IO 模型中, 可以等待事件通知的到来
  415. // 现在根据 dwMilliseconds 来待待事件通知
  416. dwret = WaitForMultipleObjects( 
  417. 2,  hEventArray, FALSE, INFINITE );
  418. switch( dwret )
  419. {
  420. case WAIT_FAILED:
  421. case WAIT_OBJECT_0 + 1:
  422. return len - count;
  424. case WAIT_OBJECT_0:
  425. break;
  427. case WAIT_TIMEOUT:
  428. continue;
  429. }
  431. ret = WSAEnumNetworkEvents( s, hEventArray[0], &ns );
  433. if( ns.lNetworkEvents & FD_WRITE )
  434. {
  435. if( ns.iErrorCode[ FD_WRITE_BIT] != 0 )
  436. return (len - count);
  437. else
  438. continue; // 回到前边,再次发送数据(此时,绝对可以发送数据)
  439. }
  441. if( ret == SOCKET_ERROR )
  442. return (len - count);
  444. if( ns.lNetworkEvents & FD_CLOSE )
  445. return (len - count);
  446. }
  448. return len - count;
  449. }
  455. ///////////////////////////////////////////
  456. //
  457. // 获得整个屏幕的象素信息
  458. //
  459. // 参数: 
  460. //
  461. // pbmi[in,out] -- BITMAPINFO 结构指针, 函数成功调用后会填充这个结构,这个结构反映了象素信息
  462. //
  463. // x, y, w, h;  矩形的左上角座标, 以及宽高. 如果这些参数不合法,将被修整为合法参数
  464. //
  465. // pBits[in,out] -- void 指针, 函数调用成功后,pBits 将被象素值填充. 如果 pBits 为NULL,
  466. // 函数将修改 dwBufferSize 参数, 指明需要多少缓冲存放象素值
  467. //
  468. //  dwBufferSize -- [in, out] 指明 pBits 的大小. 如果函数成功调用后, dwBufferSize 将会被修改, 
  469. // 指明实际拷贝的象素字节数
  470. // 返回值:
  471. //  BOOL 类型, 函数调用成功后, 将返回 TRUE; 失败,将返回 FALSE;
  472. // 
  473. HBITMAP 
  474. WINAPI GetDCPixel_BMP (
  475. HDC hdc,
  476. int  x,
  477. int  y,
  478. int  w,
  479. int  h,
  480. int zw,
  481. int zh,
  482. WORD wBitCount,
  483. VOID ** pBits,
  484. BITMAPINFOHEADER * pbmih, // 当色深为 8 时, 包含颜色表
  485. DWORD * pdwBitmapInfoSize
  486. )
  487. {
  488. int width = 0;
  489. int height;
  491. // 确定 DC 是而效的, 并获得 DC 的宽高(以像素为单位)
  492. width = GetDeviceCaps( hdc, HORZRES);
  493. if( width == 0 )
  494. return NULL;
  495. height = GetDeviceCaps( hdc, VERTRES);
  497. // 修整请求的矩形
  498. x = (x<0)||(x>(width-1)) ? 0 : x;
  499. x = (y<0)||(y>(height-1)) ? 0 : y;
  501. w = (w>(width-x)) || (w<1) ?  width - x : w;
  502. h = (h>(height-y)) || (h<1) ?  height - y : h;
  504. zw = zw <= 0 ? w : zw;
  505. zh = zh <= 0 ? h : zh;
  507. // 修整请求的色深
  508. if( wBitCount <= 8 )
  509. wBitCount = 8;
  510. else if( wBitCount <=16 )
  511. wBitCount = 16;
  512. else if( wBitCount <= 24 )
  513. wBitCount = 24;
  514. else if( wBitCount >=32 )
  515. wBitCount = 32;
  518. // 计算存储图象所需空间的大小
  519. //DWORD tmp = (((w * wBitCount) +31) & ~31) / 8 * h;
  522. if( pbmih != NULL )
  523. {
  524. if( wBitCount == 8 )
  525. {
  526. if( *pdwBitmapInfoSize < (sizeof(RGBQUAD)*256 + sizeof(BITMAPINFOHEADER) ))
  527. return NULL;
  528. } 
  529. else 
  530. {
  531. if( *pdwBitmapInfoSize < sizeof( BITMAPINFOHEADER) )
  532. return NULL;
  533. }
  535. } 
  536. else
  537. {
  538. *pdwBitmapInfoSize = (sizeof(RGBQUAD)*256 + sizeof(BITMAPINFOHEADER) );
  539. return NULL;
  540. }
  543. HBITMAP bmp;
  544. PVOID pTmp = NULL;
  545. BITMAPINFO bmi;
  546. bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  547. bmi.bmiHeader.biWidth = zw;
  548. bmi.bmiHeader.biHeight = zh;
  549. bmi.bmiHeader.biPlanes = 1;
  550. bmi.bmiHeader.biBitCount = wBitCount;
  551. bmi.bmiHeader.biCompression = BI_RGB;
  552. bmi.bmiHeader.biSizeImage = 0;
  553. bmi.bmiHeader.biXPelsPerMeter = 0;
  554. bmi.bmiHeader.biYPelsPerMeter = 0;
  555. bmi.bmiHeader.biClrUsed = 0;
  556. bmi.bmiHeader.biClrImportant = 0;
  559. // create a DIB section bitmap;
  560.     bmp = CreateDIBSection( hdc, &bmi, DIB_RGB_COLORS, &pTmp, NULL, 0 );
  561. if( bmp == NULL )
  562. return NULL;
  564. // set the out param pBits to image buffer pTmp;
  565. *pBits = pTmp;
  567. HDC hdcMem = CreateCompatibleDC( hdc );
  568. if( hdcMem == NULL)
  569. {
  570. DeleteObject(bmp);
  571. return NULL;
  572. }
  574. SelectObject( hdcMem, bmp );
  575. StretchBlt( hdcMem, 0, 0, zw, zh, hdc, x, y, w, h, SRCCOPY );
  576. //BitBlt( hdc, 0, 0,w, h, hdcMem, 0, 0, SRCCOPY );
  578. DIBSECTION ds;
  579. GetObject( bmp, sizeof(ds), (PVOID)&ds );
  581. //cout << ds.dsBmih.biClrUsed << endl;
  582. if( ds.dsBm.bmBitsPixel == 8 )
  583. {
  585. int clrGetNum;
  586. SelectObject( hdcMem, bmp );
  587. clrGetNum = GetDIBColorTable( hdcMem, 0, ds.dsBmih.biClrUsed, 
  588. (RGBQUAD*)(sizeof(BITMAPINFOHEADER) +(char*)pbmih ) ); 
  589. if(  0 == clrGetNum )
  590. {
  591. DeleteDC( hdcMem );
  592. DeleteObject( bmp );
  593. return NULL;
  594. }
  596. }
  598. CopyMemory( (void*)pbmih, &(ds.dsBmih), sizeof(BITMAPINFOHEADER) );
  599. // 计算并输出图像所需存储空间的大小
  600. //cout << (((w * wBitCount) +31) & ~31) / 8 * h << endl;
  602. DeleteDC( hdcMem );
  603. return bmp;
  604. }
  607. VOID
  608. WINAPI InitResponseHead(
  609. PRCARESPONSEHEADER prresh,
  610. DWORD dwStatusCode,
  611. DWORD dwSize
  612. )
  613. {
  614. lstrcpy( prresh->rcaID, "RCA" );
  615. prresh->dwStatusCode = dwStatusCode;
  616. prresh->dwTotalBytes = dwSize;
  618. }
  621. char ___s[256];
  623. char * WINAPI WSAErrorString( int WSAError )
  624. {
  625. switch( WSAError )
  626. {
  628. case WSAEACCES: // 10013
  629. lstrcpy( ___s, "拒绝访问 10013" ); 
  630. break;
  632. case WSAEADDRINUSE: // 10048 
  633. lstrcpy( ___s, "地址已经使用 10048" );
  634. break;
  636. case WSAEADDRNOTAVAIL: // 10049
  637. lstrcpy( ___s, "请求的地址无效 10049" );
  638. break;
  640. case WSAEAFNOSUPPORT: // 10047
  641. lstrcpy( ___s, "地址家族不支持 10047" );
  642. break;
  644. case WSAEALREADY: // 10037
  645. lstrcpy( ___s, "操作已经在进行中 10037" );
  646. break;
  648. case WSAECONNABORTED: // 10053
  649. lstrcpy( ___s, "软件原因连接被中断 10053" );
  650. break;
  652. case WSAECONNREFUSED: // 10061
  653. lstrcpy( ___s, "连接被拒绝 10061" );
  654. break;
  656. case WSAECONNRESET: // 10054
  657. lstrcpy( ___s, "连接被重置 10054" );
  658. break;
  660. case WSAEDESTADDRREQ: // 10039
  661. lstrcpy( ___s, "必须指定目的地址 10039" );
  662. break;
  664. case WSAEFAULT:
  665. lstrcpy( ___s, "地址错误 10014" );
  666. break;
  668. case WSAEHOSTDOWN:
  669. lstrcpy( ___s, "远程主机死机了( 蓝屏?) 10064" );
  670. break;
  673. case WSAEHOSTUNREACH:
  674. lstrcpy( ___s, "无法找到主机 10065" );
  675. break;
  677. case WSAEINPROGRESS:
  678. lstrcpy( ___s, "阻塞操作正在进行 10036" );
  679. break;
  681. case WSAEINTR:
  682. lstrcpy( ___s, "阻塞操作被打断 10004" );
  683. break;
  685. case WSAEINVAL:
  686. lstrcpy( ___s, "参数无效 10022" );
  687. break;
  689. case WSAEISCONN:
  690. lstrcpy( ___s, "套接字已经连接 10056" );
  691. break;
  693. case WSAEMFILE:
  694. lstrcpy( ___s, "打开的套接字太多 10024" );
  695. break;
  697. case WSAEMSGSIZE:
  698. lstrcpy( ___s, "消息太长 10040" );
  699. break;
  701. case WSAENETDOWN:
  702. lstrcpy( ___s, "网络系统, 网络接口, 本地网络有错误 10050" );
  703. break;
  705. case WSAENETRESET:
  706. lstrcpy( ___s, "保持活动的连接在操作中出现错误 10052" );
  707. break;
  709. case WSAENETUNREACH:
  710. lstrcpy( ___s, "网络无法到达 10051" );
  711. break;
  713. case WSAENOBUFS:
  714. lstrcpy( ___s, "没有可用的缓冲区 10055" );
  715. break;
  717. case WSAENOPROTOOPT:
  718. lstrcpy( ___s, "错误的协议选项 10042" );
  719. break;
  721. case WSAENOTCONN:
  722. lstrcpy( ___s, "套接字没有连接 10057" );
  723. break;
  725. case WSAENOTSOCK:
  726. lstrcpy( ___s, "套接字句柄无效 10038" );
  727. break;
  729. case WSAEOPNOTSUPP:
  730. lstrcpy( ___s, "操作不支持 10045" );
  731. break;
  733. case WSAEPFNOSUPPORT:
  734. lstrcpy( ___s, "协议族不支持 10046" );
  735. break;
  737. case WSAEPROCLIM:
  738. lstrcpy( ___s, "使用 WinSock 的进程太多 10067" );
  739. break;
  741. case WSAEPROTONOSUPPORT:
  742. lstrcpy( ___s, "协议不支持 10043" );
  743. break;
  745. case WSAEPROTOTYPE:
  746. lstrcpy( ___s, "协议类型错误 10041" );
  747. break;
  749. case WSAESHUTDOWN:
  750. lstrcpy( ___s, "套接字关闭后无法进行发送操作 10058" );
  751. break;
  753. case WSAESOCKTNOSUPPORT:
  754. lstrcpy( ___s, "套接字类型不支持 10044" );
  755. break;
  757. case WSAETIMEDOUT:
  758. lstrcpy( ___s, "连接超时 10060" );
  759. break;
  761. case WSATYPE_NOT_FOUND:
  762. lstrcpy( ___s, "指定的类没有发现 10109" );
  763. break;
  765. case WSAEWOULDBLOCK:
  766. lstrcpy( ___s, "资源暂时无法获得 10035" );
  767. break;
  769. case WSAHOST_NOT_FOUND:
  770. lstrcpy( ___s, "主机没有发现 11001" );
  771. break;
  773. case WSA_INVALID_HANDLE:
  774. lstrcpy( ___s, "无效句柄 (OS dependent)" );
  775. break;
  777. case WSA_INVALID_PARAMETER:
  778. lstrcpy( ___s, "无效参数 (OS dependent)" );
  779. break;
  781. // case WSAINVALIDPROCTABLE:
  782. // lstrcpy( ___s, "无效的过程表 (OS dependent)" );
  783. // break;
  785. // case WSAINVALIDPROVIDER:
  786. // lstrcpy( ___s, "无效的提供者版本 (OS dependent)" );
  787. // break;
  789. case WSA_IO_INCOMPLETE:
  790. lstrcpy( ___s, "重叠 I/O 事件对象不在通知状态 (OS dependent)" );
  791. break;
  793. case WSA_IO_PENDING:
  794. lstrcpy( ___s, "重叠操作将在过后完成 (OS dependent)" );
  795. break;
  797. case WSA_NOT_ENOUGH_MEMORY:
  798. lstrcpy( ___s, "内存不足 (OS dependent) " );
  799. break;
  801. case WSANOTINITIALISED:
  802. lstrcpy( ___s, "WSAStartup 函数没有成功的调用 10093" );
  803. break;
  805. case WSANO_DATA:
  806. lstrcpy( ___s, "请求的名字有效, 但没有请求的数据记录 11004" );
  807. break;
  809. case WSANO_RECOVERY:
  810. lstrcpy( ___s, "无法回复错误, 可能服务器数据库文件没有发现，也可能是服务器返回了错误 11003" );
  811. break;
  813. // case WSAPROVIDERFAILEDINIT:
  814. // lstrcpy( ___s, "无法初始化服务提供者 (OS dependent)" );
  815. // break;
  817. case WSASYSCALLFAILURE:
  818. lstrcpy( ___s, "系统调用失败 (OS dependent)" );
  819. break;
  821. case WSASYSNOTREADY:
  822. lstrcpy( ___s, "网络子系统错误 10091" );
  823. break;
  825. case WSATRY_AGAIN:
  826. lstrcpy( ___s, "Nonauthoritative host not found. please try again later 11002" );
  827. break;
  829. case WSAVERNOTSUPPORTED:
  830. lstrcpy( ___s, "请求的版本不支持 10092" );
  831. break;
  833. case WSAEDISCON:
  834. lstrcpy( ___s, "从容关闭正在进行中 10101" );
  835. break;
  837. case WSA_OPERATION_ABORTED:
  838. lstrcpy( ___s, "重叠操作被中断 (OS dependent)" );
  839. break;
  841. default:
  842. lstrcpy( ___s, "未知错误" );
  844. }
  845. return ___s;
  846. }
  848. BOOL WINAPI CreateEventSelectSocket( 
  849. SOCKET * s,
  850. HANDLE * hEvent,
  851. LONG     lEventFlags
  852. )
  853. {
  855. int ret;
  856. *s = socket( AF_INET, SOCK_STREAM, 0 );
  857. if( *s == INVALID_SOCKET )
  858. return FALSE;
  860. *hEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
  861. if( *hEvent == NULL )
  862. {
  863. closesocket( *s );
  864. return FALSE;
  865. }
  867. ret = WSAEventSelect( *s, *hEvent, lEventFlags );
  868. if( ret == SOCKET_ERROR )
  869. {
  870. closesocket( *s );
  871. CloseHandle( hEvent );
  872. return FALSE;
  873. }
  875. return TRUE;
  876. }
  878. BOOL
  879. WINAPI
  880. RCAConnect_EventSelectIO(
  881. SOCKET s,
  882. HANDLE hEventArray[2],
  883. sockaddr* addr,
  884. UINT uExitMsg
  885. )
  886. {
  887. int ret;
  888. BOOL bSunc = FALSE;
  889. DWORD dwRet;
  890. WSANETWORKEVENTS ns;
  892. while(1)
  893. {
  894. ret = connect( s, addr, sizeof(sockaddr) );
  895. if( ret == SOCKET_ERROR )
  896. {
  897. if( WSAGetLastError() != WSAEWOULDBLOCK )
  898. return FALSE;
  899. }
  900. else
  901. {
  902. return TRUE;
  903. }
  905. while(1)
  906. {
  907. dwRet = WaitForMultipleObjects( 2,  hEventArray, FALSE, INFINITE );
  909. if( dwRet == (WAIT_OBJECT_0 + 1 ) )
  910. {
  911. return FALSE;
  912. }
  914. ret = WSAEnumNetworkEvents( s, hEventArray[0],  &ns );
  915. if( ret == SOCKET_ERROR )
  916. break;
  918. if( ns.lNetworkEvents & FD_CONNECT )
  919. {
  920. if( ns.iErrorCode[ FD_CONNECT_BIT ] != 0 )
  921. {
  922. return FALSE;
  923. }
  924. else
  925. return TRUE;
  926. }
  927. }
  928. }
  930. // never run to here;
  931. return TRUE;
  932. }
  935. VOID
  936. WINAPI
  937. InitRCARequestHead (
  938. RCAREQUESTHEADER * rreqh,
  939. WORD wMajorVersion, // 主版本号
  940. WORD wMinorVersion, // 次版本号
  941. DWORD dwRequestID,
  942. DWORD dwRequestBytes
  943. )
  944. {
  945. rreqh->dwRequestID = dwRequestID;
  946. rreqh->requestBytes = dwRequestBytes;
  947. rreqh->wMajorVersion = wMajorVersion;
  948. rreqh->wMinorVersion = wMinorVersion;
  950. lstrcpy( rreqh->rcaID, "RCA" );
  951. }
  955. BOOL 
  956. WINAPI
  957. RCASendRequest_0X10_EventSelectIO(
  958. SOCKET s,
  959. HANDLE hEventArray[2],
  960. HWND hwnd,
  961. PSTR pOperation,
  962. PSTR pFile,
  963. PSTR pParameters,
  964. PSTR pDirectory,
  965. INT nShowCmd
  966. )
  967. {
  968. DWORD dwCountSize;
  969. INT ret;
  970. DWORD nOperation = lstrlen( pOperation ) +1;
  971. DWORD nFile = lstrlen( pFile ) +1;
  972. DWORD nParameters = lstrlen( pParameters ) +1;
  973. DWORD nDirectory = lstrlen( pDirectory ) +1;
  974. dwCountSize = 
  975. 4 + // hwnd
  976. 4 + nOperation + // pOperation
  977. 4 + nFile + // pFile
  978. 4 + nParameters + // pParameters
  979. 4 + nDirectory + // pDirectory
  980. 4; // nShowCmd
  982. RCAREQUESTHEADER rreqh;
  983. InitRCARequestHead( &rreqh, 1, 0, 0x10, dwCountSize + sizeof(RCAREQUESTHEADER) );
  985. // 发送请求头
  986. ret = RCASend_EventSelectIO( s, hEventArray, (char*)&rreqh, sizeof(RCAREQUESTHEADER));
  987. if( ret != sizeof(RCAREQUESTHEADER) )
  988. return FALSE;
  990. ret = RCASend_EventSelectIO( s, hEventArray, (char*)&hwnd, sizeof(HWND));
  991. if( ret != sizeof(HWND) )
  992. return FALSE;
  995. if( nOperation == 0 )
  996. ret = RCASend_EventSelectIO( s, hEventArray, (char*)&nOperation, sizeof(int));
  997. else {
  998. ret = RCASend_EventSelectIO( s, hEventArray, (char*)&nOperation, sizeof(int));
  999. if( ret != sizeof(int) )
  1000. return FALSE;
  1001. ret = RCASend_EventSelectIO( s, hEventArray, (char*)pOperation, nOperation);
  1002. if( ret != nOperation )
  1003. return FALSE;
  1004. }
  1006. if( nFile == 0 )
  1007. ret = RCASend_EventSelectIO( s, hEventArray, (char*)&nFile, sizeof(int));
  1008. else {
  1009. ret = RCASend_EventSelectIO( s, hEventArray, (char*)&nFile, sizeof(int));
  1010. if( ret != sizeof(int) )
  1011. return FALSE;
  1012. ret = RCASend_EventSelectIO( s, hEventArray, (char*)pFile, nFile);
  1013. if( ret != nFile )
  1014. return FALSE;
  1015. }
  1017. if( nParameters == 0 )
  1018. ret = RCASend_EventSelectIO( s, hEventArray, (char*)&nParameters, sizeof(int));
  1019. else {
  1020. ret = RCASend_EventSelectIO( s, hEventArray, (char*)&nParameters, sizeof(int));
  1021. if( ret != sizeof(int) )
  1022. return FALSE;
  1023. ret = RCASend_EventSelectIO( s, hEventArray, (char*)pParameters, nParameters);
  1024. if( ret != nParameters )
  1025. return FALSE;
  1026. }
  1028. if( nDirectory == 0 )
  1029. ret = RCASend_EventSelectIO( s, hEventArray, (char*)&nDirectory, sizeof(int));
  1030. else {
  1031. ret = RCASend_EventSelectIO( s, hEventArray, (char*)&nDirectory, sizeof(int));
  1032. if( ret != sizeof(int) )
  1033. return FALSE;
  1034. ret = RCASend_EventSelectIO( s, hEventArray, (char*)pDirectory, nDirectory);
  1035. if( ret != nDirectory )
  1036. return FALSE;
  1037. }
  1039. return TRUE;
  1040. }
  1043. BOOL
  1044. WINAPI
  1045. RCASendRequest_0X20_EventSelectIO(
  1046. SOCKET s,
  1047. HANDLE hEventArray[2],
  1048. RCAGETIMAGEDATA * pgm
  1049. )
  1050. {
  1051. if( pgm->dwImageFormat != IMAGE_FORMAT_BMP )
  1052. if( pgm->dwImageFormat != IMAGE_FORMAT_JPEG )
  1053. return FALSE;
  1056. // DWORD dwRet;
  1057. int ret;
  1059. RCAREQUESTHEADER rreqh;
  1060. rreqh.dwRequestID = 0x20;
  1061. rreqh.requestBytes = sizeof(rreqh) + sizeof(RCAGETIMAGEDATA);
  1062. rreqh.wMajorVersion = 1;
  1063. rreqh.wMinorVersion = 0;
  1065. lstrcpy( rreqh.rcaID, "RCA" );
  1067. ret = RCASend_EventSelectIO( s, hEventArray, (char*)&rreqh, sizeof(RCAREQUESTHEADER));
  1068. if( ret != sizeof( RCAREQUESTHEADER ) )
  1069. return FALSE;
  1071. ret = RCASend_EventSelectIO( s, hEventArray, (char*)pgm, sizeof(RCAGETIMAGEDATA));
  1072. if( ret != sizeof( RCAGETIMAGEDATA ) )
  1073. return FALSE;
  1075. return TRUE;
  1076. }
  1080. HBITMAP
  1081. WINAPI
  1082. RCARecvImageData(
  1083. SOCKET s,
  1084. HANDLE hEventArray[2],
  1085. DWORD dwImageFormat 
  1086. )
  1087. {
  1089. int ret;
  1090. // DWORD dwRet;
  1091. RCARESPONSEHEADER rresh;
  1094. // 接收响应头
  1095. ret = RCARecv_EventSelectIO( s, hEventArray, (char*)&rresh, 
  1096. sizeof(RCARESPONSEHEADER));
  1097. if ( ret != sizeof(RCARESPONSEHEADER) )
  1098. return FALSE;
  1100. DWORD dwRecvCount = rresh.dwTotalBytes - sizeof(rresh);
  1101. if ( dwRecvCount <= 0 )
  1102. return FALSE;
  1104. // 分配内存, 接收剩余的像素数据
  1105. char * buf = (char*)new BYTE[dwRecvCount];
  1106. if ( buf == NULL )
  1107. return FALSE;
  1109. // 接收图象数据
  1110. ret = RCARecv_EventSelectIO( s, hEventArray, buf, dwRecvCount);
  1111. if ( ret != dwRecvCount )
  1112. return FALSE;
  1114. if ( dwImageFormat == IMAGE_FORMAT_BMP )
  1115. {
  1116. // 通过 BMP 格式的数据创建 HBITMAP
  1118. PBITMAPFILEHEADER pbmfh = (PBITMAPFILEHEADER)buf;
  1120. HDC hdc = CreateDC( "DISPLAY", NULL, NULL, NULL );
  1121. if( hdc == NULL )
  1122. {
  1123. delete[] buf;
  1124. return FALSE;
  1125. }
  1128. PBYTE pBits = (PBYTE)buf;
  1129. pBits += pbmfh->bfOffBits;
  1130. PBITMAPINFO pbmih = (PBITMAPINFO) ( pbmfh+1 );
  1131. PVOID p;
  1132. HBITMAP hbm = CreateDIBSection( hdc, pbmih, DIB_RGB_COLORS, &p, NULL, NULL );
  1133. if ( hbm == NULL )
  1134. {
  1135. DeleteDC( hdc );
  1136. delete[] buf;
  1137. return FALSE;
  1138. }
  1140. CopyMemory( p, pBits, pbmih->bmiHeader.biSizeImage );
  1143. DeleteDC( hdc );
  1144. delete[] buf;
  1146. return hbm;
  1148. } else if ( dwImageFormat == IMAGE_FORMAT_JPEG )
  1149. {
  1151. // 创建 DC 以备在上面绘制 JPEG 像素
  1152. HDC hdc = CreateDC( "DISPLAY" , NULL, NULL, NULL);
  1153. if ( hdc == NULL )
  1154. {
  1155. delete[] buf;
  1156. return FALSE;
  1157. }
  1159. PBYTE pJPEGBuffer = (PBYTE)buf; // JPEG 缓冲区
  1160. DWORD dwJPEGBufferSize = rresh.dwTotalBytes - 40; // JPEG 缓冲区大小
  1161. BYTE* pRGBBuffer = NULL;
  1162. DWORD width; // 图象宽
  1163. DWORD   height; // 图象高
  1164. DWORD channels; // 图象颜色通道数目
  1166. if ( FALSE == DecodeFromJPEGBuffer( pJPEGBuffer, dwJPEGBufferSize,
  1167. &pRGBBuffer, &width, &height, &channels ) )
  1168. {
  1169. delete[] buf;
  1170. DeleteDC( hdc );
  1172. return FALSE;
  1173. }
  1175. BITMAPINFO bmi;
  1176. bmi.bmiHeader.biSize = sizeof(bmi);
  1177. bmi.bmiHeader.biBitCount = 24;
  1178. bmi.bmiHeader.biClrImportant = 0;
  1179. bmi.bmiHeader.biClrUsed = 0;
  1180. bmi.bmiHeader.biCompression = BI_RGB;
  1181. bmi.bmiHeader.biWidth = width;
  1182. bmi.bmiHeader.biHeight = height;
  1183. bmi.bmiHeader.biPlanes = 1;
  1184. bmi.bmiHeader.biSizeImage = width * height * 3;
  1185. bmi.bmiHeader.biXPelsPerMeter = 0;
  1186. bmi.bmiHeader.biYPelsPerMeter = 0;
  1188. bmi.bmiColors[0].rgbRed = (BYTE)0xff;
  1189. bmi.bmiColors[0].rgbGreen = (BYTE)0xff;
  1190. bmi.bmiColors[0].rgbBlue = (BYTE)0xff;
  1191. bmi.bmiColors[0].rgbReserved = (BYTE)0x0;
  1193. PVOID p=NULL;
  1194. HBITMAP hbm = CreateDIBSection( hdc, &bmi, DIB_RGB_COLORS, &p, NULL, NULL );
  1195. if( hbm == NULL )
  1196. {
  1197. DeleteDC( hdc );
  1198. delete[] buf;
  1199. delete[] pRGBBuffer;
  1201. return FALSE;
  1202. }
  1204. CopyMemory( p, pRGBBuffer, bmi.bmiHeader.biSizeImage );
  1206. DeleteDC( hdc );
  1207. delete[] buf;
  1208. delete[] pRGBBuffer;
  1210. return hbm;
  1211. }
  1212. // never run to here
  1213. return NULL;
  1214. }
  1218. BOOL
  1219. WINAPI
  1220. RCASendMouseInput_EventSelectIO(
  1221. SOCKET s,
  1222. HANDLE hEventArray[2],
  1223. RCAMOUSEINPUT * pMouseInput,
  1224. DWORD dwArraySize
  1225. )
  1226. {
  1228. if ( dwArraySize > 20 )
  1229. return FALSE;
  1231. int ret;
  1232. RCAREQUESTHEADER rreqh;
  1233. InitRCARequestHead( &rreqh, 1, 0, 0x40, 
  1234. sizeof(rreqh) + sizeof(RCAMOUSEINPUT) * dwArraySize );
  1236. ret = RCASend_EventSelectIO( s, hEventArray, (char*)&rreqh, sizeof(rreqh));
  1237. if( ret != sizeof(rreqh) )
  1238. return FALSE;
  1240. ret = RCASend_EventSelectIO( s, hEventArray, (char*)pMouseInput, 
  1241.  sizeof(RCAMOUSEINPUT)*dwArraySize );
  1242. if( ret != sizeof(RCAMOUSEINPUT) * dwArraySize )
  1243. return FALSE;
  1245. return TRUE;
  1246. }
  1249. BOOL
  1250. WINAPI
  1251. RCASendKeybdInput_EventSelectIO(
  1252. SOCKET s,
  1253. HANDLE hEventArray[2],
  1254. RCAKEYBDINPUT * pKeybdInput,
  1255. DWORD dwArraySize
  1256. )
  1257. {
  1258. if( dwArraySize > 20 )
  1259. return FALSE;
  1261. int ret;
  1262. DWORD dwSize = sizeof(RCAKEYBDINPUT) * dwArraySize;
  1264. RCAREQUESTHEADER rreqh;
  1265. InitRCARequestHead( &rreqh, 1, 0, 0x41, dwSize + sizeof(rreqh) );
  1267. ret = RCASend_EventSelectIO( s, hEventArray, (char*)&rreqh, sizeof(rreqh));
  1268. if( ret != sizeof(rreqh ) )
  1269. return FALSE;
  1271. ret = RCASend_EventSelectIO( s, hEventArray, (char*)pKeybdInput, dwSize);
  1272. if( ret != dwSize )
  1273. return FALSE;
  1275. return TRUE;
  1276. }
  1280. BOOL
  1281. WINAPI
  1282. CreateMouseInput(
  1283. RCAMOUSEINPUT* pmi,
  1284. UINT msg,
  1285. WPARAM w,
  1286. LPARAM l,
  1287. float fWidthScale,
  1288. float fHeightScale
  1289. )
  1290. {
  1291. pmi->dwExtraInfo = 0;
  1292. pmi->mouseData = 0;
  1293. pmi->time = 0;
  1295. switch( msg )
  1296. {
  1297. case WM_MOUSEMOVE:
  1298. pmi->dwFlags = MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE;
  1299. pmi->dx = (LONG)(( w & 0x0000ffff ) * fWidthScale);
  1300. pmi->dy = (LONG)(( w >> 16 ) * fHeightScale );
  1301. return TRUE;
  1303. case WM_LBUTTONDOWN:
  1304. pmi->dwFlags = MOUSEEVENTF_LEFTDOWN;
  1305. return TRUE;
  1307. case WM_RBUTTONDOWN:
  1308. pmi->dwFlags = MOUSEEVENTF_RIGHTDOWN;
  1309. return TRUE;
  1311. case WM_LBUTTONUP:
  1312. pmi->dwFlags = MOUSEEVENTF_LEFTUP;
  1313. return TRUE;
  1315. case WM_RBUTTONUP:
  1316. pmi->dwFlags = MOUSEEVENTF_RIGHTUP;
  1317. return TRUE;
  1319. default:
  1320. break;
  1321. }
  1323. return FALSE;
  1324. }
  1327. BOOL
  1328. WINAPI
  1329. CreateKeybdInput(
  1330. RCAKEYBDINPUT* pbi,
  1331. UINT msg,
  1332. WPARAM w,
  1333. LPARAM l
  1334. )
  1335. {
  1336. pbi->dwExtraInfo = 0;
  1337. pbi->time  = 0;
  1338. pbi->wScan  = 0;
  1340. switch( msg )
  1341. {
  1342. case WM_KEYDOWN:
  1343. pbi->wVk = (WORD)w;
  1344. pbi->dwFlags = 0;
  1345. return TRUE;
  1347. case WM_KEYUP:
  1348. pbi->wVk = (WORD)w;
  1349. pbi->dwFlags = KEYEVENTF_KEYUP;
  1350. return TRUE;
  1352. default:
  1353. break;
  1354. }
  1356. return FALSE;
  1358. }