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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
WorkingThread.cpp
资源名称：proxy.zip　[点击查看]
上传用户：mingyuanzm
上传日期：2007-01-04
资源大小：117k
文件大小：21k
源码类别：

代理服务器

开发平台：

Visual C++

WorkingThread.cpp：源码内容
  1. /*
  2. * File name: WorkingThread.cpp
  3. * Version: 1.0.0.2
  4. * Programmer: A.George
  5. * Organization:
  6. * Date(start): 5.23.2000
  7. * Date(finish):
  8. * Description:
  9. Working thread.
  10. */
  11. #include "stdafx.h"
  12. #include "WorkingThread.h"
  13. #include "winsock.h"
  14. #include <stdio.h>
  15. #include <io.h>
  16. #include <afxinet.h>
  18. #define SITEBASE "g:\ag\personalproxy"
  20. /////////////////////////////////////////////////////////////////////////////
  21. int g_nConnectionCount;
  22. HANDLE g_hConnectionCount;
  23. unsigned long g_ulIpRefused[100];
  24. int g_nRefused;
  26. GLOBAL globalInfo;
  27. /////////////////////////////////////////////////////////////////////////////
  28. int (*ProcessCommand)(SOCKET sck, char* pszCommand, char* buf);
  30. /////////////////////////////////////////////////////////////////////////////
  31. BYTE Table(BYTE ot)
  32. {
  33. if(ot>=0 && ot<=25)return 'A' + ot;
  34. else if(ot>=26 && ot<=51)return 'a' + (ot-26);
  35. else if(ot>=52 && ot<=61)return '0' + (ot-52);
  36. else if(ot==62)return '+';
  37. else if(ot==63)return '/';
  38. else return '=';
  39. }
  41. void Base64(char* pszSource, char* pszCode)
  42. {
  43. BYTE ot;
  44. int i;
  45. i=0;
  46. while(pszSource[i])
  47. {
  48. ot = (0xFC & pszSource[i])>>2; *pszCode = Table(ot); i++; pszCode++;
  49. if(!pszSource[i])
  50. {
  51. ot = (0x03 & pszSource[i-1])<<4; *pszCode = Table(ot); pszCode++;
  52. break;
  53. }
  54. ot = (0x03 & pszSource[i-1])<<4 | (0xF0 & pszSource[i])>>4; *pszCode = Table(ot); pszCode++; i++;
  55. if(!pszSource[i])
  56. {
  57. ot = (0x0F & pszSource[i-1])<<2; *pszCode = Table(ot); pszCode++;
  58. break;
  59. }
  60. ot = (0x0F & pszSource[i-1])<<2 | (0xC0 & pszSource[i])>>6; *pszCode = Table(ot); pszCode++;
  61. ot = 0x3F & pszSource[i]; *pszCode = Table(ot), i++; pszCode++;
  62. }
  63. *pszCode = NULL;
  64. }
  66. BYTE GetSixBits(char* pszStr, int& i)
  67. {
  68. char c;
  70. while(1)
  71. {
  72. if(i>=strlen(pszStr))break;
  73. c = pszStr[i++];
  74. if(isupper(c)) return c-'A';
  75. else if(islower(c)) return c-'a'+26;
  76. else if(isdigit(c)) return c-'0'+52;
  77. else if(c=='+') return 62;
  78. else if(c=='/') return 63;
  79. else if(c=='=') return 0;
  80. }
  81. return 0;
  82. }
  84. void Unbase64(char* pszText, char* pszCode)
  85. {
  86. int nLen, i;
  87. BYTE bySixBits0, bySixBits1, bySixBits2, bySixBits3, c;
  89. nLen = strlen(pszCode);
  90. for(i=0; i<nLen; )
  91. {
  92. bySixBits0 = GetSixBits(pszCode, i);
  93. if(i<nLen)bySixBits1 = GetSixBits(pszCode, i);
  94. if(i<nLen)bySixBits2 = GetSixBits(pszCode, i);
  95. if(i<nLen)bySixBits3 = GetSixBits(pszCode, i);
  97. c = bySixBits0<<2 | bySixBits1>>4; *pszText = c; pszText++;
  98. c = bySixBits1<<4 | bySixBits2>>2; *pszText = c; pszText++;
  99. c = bySixBits2<<6 | bySixBits3; *pszText = c; pszText++;
  100. }
  101. *pszText = NULL;
  103. }
  105. DWORD RecvHeader(SOCKET socket, char *buf, DWORD dwSize, HTTPHEADER* pHeader)
  106. {
  107. char * pEnd, *pSize, *pType, *pLocation;
  108. int nRet, nTotal;
  110. memset(pHeader, 0, sizeof(HTTPHEADER));
  112. nTotal = 0;
  113. do{
  114. nRet = recv(socket, buf+nTotal, dwSize-nTotal, 0);
  115. if(nRet==SOCKET_ERROR)return SOCKET_ERROR;
  116. nTotal += nRet;
  117. buf[nRet] = NULL;
  118. pEnd = strstr(buf, "rnrn");
  119. if(pEnd)
  120. {
  121. pSize = strstr(buf, "Content-length: ");
  122. if(pSize)sscanf(pSize+16, "%ud", &(pHeader->dwContSize));
  123. else pHeader->dwContSize = -1;
  125. if(DWORD(pEnd-buf+4)<dwSize)
  126. pHeader->pContBegin = pEnd+4;
  127. else
  128. pHeader->pContBegin = NULL;
  129. sscanf(buf, "HTTP/%d.%d %d %s", &pHeader->nVerMajor, &pHeader->nVerMinor,
  130. &pHeader->dwHttpStatus, pHeader->pszStatus);
  132. pType = strstr(buf, "Content-type: ");
  133. if(pType)sscanf(pType+14, "%s", &(pHeader->pszType));
  135. pLocation = strstr(buf, "Location: ");
  136. if(pLocation)sscanf(pLocation+10, "s", &(pHeader->pszLocation));
  137. return nTotal;
  138. }
  139. }while(!pEnd && nRet);
  141. return nTotal;
  142. }
  144. int RecvRequest(SOCKET sck, char * buf, DWORD dwSize, REQUESTHEADER * pRequestHeader)
  145. {
  146. char * pEnd, pszCode[32], pszText[32], *pAuthorization, *pRange, *pSize;
  147. int iRet;
  148. DWORD nTotal;
  150. pRequestHeader->dwFlag = REQUEST_UNAUTHORIZED;
  152. memset(buf, 0, dwSize);
  153. nTotal = 0;
  154. do{
  155. iRet = recv(sck, buf+nTotal, dwSize-nTotal-1, 0);
  156. if(iRet==SOCKET_ERROR)
  157. {
  158. return SOCKET_ERROR;
  159. }
  161. nTotal += iRet;
  162. buf[nTotal] = NULL;
  163. pEnd = strstr(buf, "rnrn");
  164. if(pEnd)
  165. {
  166. pAuthorization = strstr(buf, "Proxy-Authorization: ");
  167. if(!pAuthorization)
  168. {
  169. pRequestHeader->pszUserPass[0] = NULL;
  170. return 0;
  171. }
  172. sscanf(pAuthorization+21, "%*s%s", pszCode);
  173. Unbase64(pszText, pszCode);
  174. if(strcmp(pszText, "user:ag"))
  175. {
  176. strcpy(pRequestHeader->pszUserPass, pszText);
  177. return 0;
  178. }
  179. else
  180. pRequestHeader->dwFlag = 0;
  181. pRequestHeader->pszAuthBegin = pAuthorization;
  182. pRequestHeader->pszAuthEnd = strstr(pAuthorization, "rn")+2;
  183. pRequestHeader->pszVirtualRes = strstr(buf, "GET "); //"http://www.personalproxy.com/");
  184. if(pRequestHeader->pszVirtualRes)
  185. {
  186. if(!strncmp(pRequestHeader->pszVirtualRes+4, "http://www.personalproxy.com", 28))
  187. {
  188. pRequestHeader->dwFlag |= VIRTUAL_RESOURCE;
  189. sscanf(pRequestHeader->pszVirtualRes+4, "%s", pRequestHeader->pszUrl);
  190. }
  191. }
  193. pRange = strstr(buf, "RANGE: bytes");
  194. if(pRange)
  195. {
  196. pRange = strstr(pRange, "=");
  197. if(pRange)
  198. {
  199. sscanf(pRange+1, "%d", &pRequestHeader->dwRange);
  200. pRequestHeader->dwFlag |= PARTIAL_CONTENT;
  201. }
  202. }
  204. pSize = strstr(buf, "Content-Length: ");
  205. if(pSize)
  206. {
  207. sscanf(pSize+16, "%d", &pRequestHeader->dwContSize);
  208. }
  209. else
  210. pRequestHeader->dwContSize = 0;
  212. pRequestHeader->pszContBegin = pEnd+4;
  214. return nTotal;
  215. }
  216. }while(!pEnd && iRet);
  218. return 0;
  219. }
  221. void UnCh(char* pszStr)
  222. {
  223. char pszLine[512];
  224. int i, j, nLen;
  225. BYTE b1, b2;
  227. i=0; j=0;
  228. nLen = strlen(pszStr);
  229. while(i<nLen)
  230. {
  231. if(pszStr[i]=='%')
  232. {
  233. i++;
  234. sscanf(pszStr+i, "%2X", &b1);
  235. i += 2;
  236. }
  237. else
  238. {
  239. pszLine[j++] = pszStr[i++];
  240. continue;
  241. }
  243. if(i>=nLen)
  244. {
  245. pszLine[j++] = b1;
  246. break;
  247. }
  249. if(pszStr[i]=='%')
  250. {
  251. i++;
  252. sscanf(pszStr+i, "%2X", &b2);
  253. i += 2;
  255. pszLine[j++] = b2;
  256. pszLine[j++] = b1;
  257. }
  258. else
  259. {
  260. pszLine[j++] = b1;
  261. pszLine[j++] = pszStr[i++];
  262. }
  263. }
  264. pszLine[j]=0;
  266. strcpy(pszStr, pszLine);
  267. }
  269. void ContentType(char* pszFile, char* pszType)
  270. {
  271. char drive[4], dir[MAX_PATH], fname[MAX_PATH], ext[16];
  272. _splitpath(pszFile, drive, dir, fname, ext);
  274. _strlwr(ext);
  275. if(strstr(pszFile, "multipart"))
  276. strcpy(pszType, "multipart/mixed");
  277. else if(!*ext)
  278. strcpy(pszType, "text/html");
  279. else if(!strcmp(ext, ".jpg"))
  280. strcpy(pszType, "image/jpeg");
  281. else if(!strcmp(ext, ".jpeg"))
  282. strcpy(pszType, "image/gif");
  283. else if(!strcmp(ext, ".htm"))
  284. strcpy(pszType, "text/html");
  285. else if(!strcmp(ext, ".html"))
  286. strcpy(pszType, "text/html");
  287. else if(!strcmp(ext, ".zip"))
  288. strcpy(pszType, "application/x-compressed");
  289. else if(!strcmp(ext, ".mpeg"))
  290. strcpy(pszType, "video/mpeg");
  291. else strcpy(pszType, "application/octet-stream");
  292. }
  294. void HttpService(char * pszUrl, SOCKET sck, char* buf, REQUESTHEADER* pRequestHeader)
  295. {
  296. CString strServer, strObject;
  297. DWORD dwService, dwSize, dwFileLen;
  298. unsigned short nPort;
  299. int iRet;
  300. char pszFile[512], pszLine[512], pszType[16];
  301. char pszCommand[128], *pQuestionMark;
  302. FILE* pFileContent;
  304. AfxParseURL(pszUrl, dwService, strServer, strObject, nPort);
  305. if(strObject=="/")
  306. sprintf(pszFile, "%s%s", SITEBASE, "\VirtualPage.html");
  307. else
  308. sprintf(pszFile, "%s%s", SITEBASE, strObject);
  310. UnCh(pszFile);
  311. // dwService 3
  312. // nPort 80
  313. // + strObject {"/count.dll?a=1&b=2"}
  314. // + strServer {"www.ms.com"}
  315. // + this 0x0012fe74 {CTryDlg hWnd=0x01460920}
  317. if(strstr(pszFile, "myextension"))
  318. {
  319. pQuestionMark = strstr(pszFile, "?");
  320. if(pQuestionMark)
  321. {
  322. strcpy(pszCommand, pQuestionMark+1);
  323. *pQuestionMark = NULL;
  324. }
  325. else
  326. * pszCommand = NULL;
  327. HMODULE hModule = LoadLibrary(pszFile);
  328. if(!hModule)
  329. {
  330. OUTPUT("requested file not foundrn");
  331. strcpy(buf, "HTTP/1.1 404 Not FoundrnTransfer-encoding: chunkedrnContent-type: text/htmlrnrn<HTML><H1>File not found</H1></HTML>");
  332. send(sck, buf, strlen(buf), 0);
  333. return;
  334. }
  335. ProcessCommand = (int(*)(unsigned int, char*, char*))GetProcAddress(hModule, "ProcessCommand");
  336. if(!ProcessCommand)
  337. {
  338. OUTPUT("ProcessCommand==NULLrn");
  339. FreeLibrary(hModule);
  340. return;
  341. }
  342. ProcessCommand(sck, pszCommand, buf);
  343. FreeLibrary(hModule);
  344. return;
  345. }
  347. pFileContent = fopen(pszFile, "rb");
  348. if(!pFileContent)
  349. {
  350. OUTPUT("requested file not foundrn");
  351. strcpy(buf, "HTTP/1.1 404 Not FoundrnTransfer-encoding: chunkedrnContent-type: text/htmlrnrn<HTML><H1>File not found</H1></HTML>");
  352. send(sck, buf, strlen(buf), 0);
  353. return;
  354. }
  356. dwFileLen = _filelength(_fileno(pFileContent));
  357. if(pRequestHeader->dwFlag & PARTIAL_CONTENT)
  358. {
  359. strcpy(buf, "HTTP/1.1 206 Partial Contentrn");
  360. strcat(buf, "Accept-ranges: bytesrn");
  362. dwSize = dwFileLen - pRequestHeader->dwRange;
  363. sprintf(pszLine, "Content-range: bytes %d-%d/%drn", pRequestHeader->dwRange, dwFileLen-1, dwFileLen);
  364. strcat(buf, pszLine);
  366. fseek(pFileContent, pRequestHeader->dwRange, SEEK_SET);
  367. }
  368. else
  369. {
  370. strcpy(buf, "HTTP/1.1 200 OKrn");
  371. dwSize = dwFileLen;
  372. }
  374. sprintf(pszLine, "Content-length: %drn", dwSize);
  375. strcat(buf, pszLine);
  376. strcpy(pszLine, "Proxy-agent: Ag-PersonalProxy/1.0rn");
  377. strcat(buf, pszLine);
  379. ContentType(pszFile, pszType);
  380. sprintf(pszLine, "Content-type: %srn", pszType);
  381. strcat(buf, pszLine);
  383. strcat(buf, "rn");
  384. send(sck, buf, strlen(buf), 0);
  386. while(!feof(pFileContent))
  387. {
  388. dwSize = fread(buf, 1, BUFFER_SIZE, pFileContent);
  389. iRet = send(sck, buf, dwSize, 0);
  390. if(iRet == SOCKET_ERROR)
  391. break;
  392. }
  393. fclose(pFileContent);
  395. return;
  396. }
  399. UINT WorkingThread(LPVOID lpVoid)
  400. {
  401. int iRet, i;
  402. char content[512], buf[BUFFER_SIZE], pszMsg[1024], pszCode[256], pszLine[512], *pEnd;
  403. WORKPARAM * pThreadParam = (WORKPARAM*)lpVoid;
  404. DWORD dwRet, dwTotal, dwSize;
  405. sockaddr_in addrProxy2nd;
  406. SOCKET sckClient;
  407. REQUESTHEADER requestHeader;
  408. HTTPHEADER httpHeader;
  409. FILE* pFileContent;
  411. dwRet = WaitForSingleObject(g_hConnectionCount, INFINITE);
  412. if(g_nConnectionCount>=80)
  413. {
  414. ReleaseSemaphore(g_hConnectionCount, 1, NULL);
  415. OUTPUT("Too many connections, limit reachedrn");
  416. strcpy(buf, "HTTP/1.1 431 Too many connections, limit reachedrn"); send(pThreadParam->sckClient , buf, strlen(buf), 0);
  417. strcpy(buf, "Proxy-agent: Ag-PersonalProxy/1.0rn"); send(pThreadParam->sckClient, buf, strlen(buf), 0);
  418. strcpy(buf, "Content-type: text/htmlrn"); send(pThreadParam->sckClient, buf, strlen(buf), 0);
  420. pFileContent = fopen("g:\ag\personalproxy\authorizationrequired.html", "rb");
  421. dwSize = _filelength(_fileno(pFileContent));
  422. sprintf(buf, "Content-length: %drn", dwSize); send(pThreadParam->sckClient, buf, strlen(buf), 0);
  423. strcpy(buf, "rn"); send(pThreadParam->sckClient, buf, strlen(buf), 0);
  425. while(!feof(pFileContent))
  426. {
  427. dwSize = fread(buf, 1, BUFFER_SIZE, pFileContent);
  428. send(pThreadParam->sckClient, buf, dwSize, 0);
  429. }
  430. closesocket(pThreadParam->sckClient);
  431. fclose(pFileContent);
  432. delete pThreadParam;
  433. return 0;
  434. }
  435. g_nConnectionCount++;
  436. ReleaseSemaphore(g_hConnectionCount, 1, NULL);
  438. while(1)
  439. {
  440. iRet = RecvRequest(pThreadParam->sckClient, buf, BUFFER_SIZE-1, &requestHeader);
  441. if(iRet==SOCKET_ERROR)
  442. {
  443. sprintf(pszMsg, "RecvRequest()=SOCKET_ERROR, WSAGetLastError()=%d", WSAGetLastError());
  444. OUTPUT(pszMsg);
  445. WaitForSingleObject(g_hConnectionCount, INFINITE);
  446. g_nConnectionCount--;
  447. ReleaseSemaphore(g_hConnectionCount, 1, NULL);
  448. delete pThreadParam;
  449. return 0;
  450. }
  451. dwTotal = iRet;
  453. for(i=0; i<g_nRefused; i++)
  454. {
  455. if(g_ulIpRefused[i]==pThreadParam->addr.sin_addr.S_un.S_addr)
  456. {
  457. OUTPUT("refused ip:");
  458. sprintf(content, "t%d.%d.%d.%drn",
  459. pThreadParam->addr.sin_addr.S_un.S_un_b.s_b1,
  460. pThreadParam->addr.sin_addr.S_un.S_un_b.s_b2,
  461. pThreadParam->addr.sin_addr.S_un.S_un_b.s_b3,
  462. pThreadParam->addr.sin_addr.S_un.S_un_b.s_b4);
  463. OUTPUT(content);
  464. strcpy(buf, "HTTP/1.1 432 Ip refusedrn"); send(pThreadParam->sckClient , buf, strlen(buf), 0);
  465. strcpy(buf, "Proxy-agent: Ag-PersonalProxy/1.0rn"); send(pThreadParam->sckClient, buf, strlen(buf), 0);
  466. strcpy(buf, "Content-type: text/htmlrn"); send(pThreadParam->sckClient, buf, strlen(buf), 0);
  467. pFileContent = fopen("g:\ag\personalproxy\notification.html", "rb");
  468. dwSize = _filelength(_fileno(pFileContent));
  469. sprintf(buf, "Content-length: %drn", dwSize); send(pThreadParam->sckClient, buf, strlen(buf), 0);
  470. strcpy(buf, "rn"); send(pThreadParam->sckClient, buf, strlen(buf), 0);
  472. dwSize = fread(buf, 1, BUFFER_SIZE, pFileContent);
  473. buf[dwSize] = NULL;
  474. sprintf(content, buf,
  475. pThreadParam->addr.sin_addr.S_un.S_un_b.s_b1,
  476. pThreadParam->addr.sin_addr.S_un.S_un_b.s_b2,
  477. pThreadParam->addr.sin_addr.S_un.S_un_b.s_b3,
  478. pThreadParam->addr.sin_addr.S_un.S_un_b.s_b4);
  479. send(pThreadParam->sckClient, content, strlen(content), 0);
  480. closesocket(pThreadParam->sckClient);
  481. fclose(pFileContent);
  482. goto _ThreadExit;
  483. }
  484. }
  485. if(requestHeader.dwFlag & REQUEST_UNAUTHORIZED)
  486. {
  487. OUTPUT("HTTP/1.1 407 Proxy authorization required agproxy.");
  488. sprintf(content, "t%st%d.%d.%d.%drn",
  489. requestHeader.pszUserPass,
  490. pThreadParam->addr.sin_addr.S_un.S_un_b.s_b1,
  491. pThreadParam->addr.sin_addr.S_un.S_un_b.s_b2,
  492. pThreadParam->addr.sin_addr.S_un.S_un_b.s_b3,
  493. pThreadParam->addr.sin_addr.S_un.S_un_b.s_b4);
  494. OUTPUT(content);
  495. //HTTP/1.0 407 Proxy authorization required
  496. strcpy(buf, "HTTP/1.1 407 Proxy authorization requiredrn"); send(pThreadParam->sckClient , buf, strlen(buf), 0);
  497. strcpy(buf, "Proxy-agent: Ag-PersonalProxy/1.0rn"); send(pThreadParam->sckClient, buf, strlen(buf), 0);
  498. strcpy(buf, "Content-type: image/jpegrn"); send(pThreadParam->sckClient, buf, strlen(buf), 0);
  499. strcpy(buf, "Proxy-authenticate: basic realm="JutAg"rn"); send(pThreadParam->sckClient, buf, strlen(buf), 0);
  500. pFileContent = fopen("g:\ag\personalproxy\Authorization.jpg", "rb");
  501. dwSize = _filelength(_fileno(pFileContent));
  502. sprintf(buf, "Content-length: %drn", dwSize); send(pThreadParam->sckClient, buf, strlen(buf), 0);
  503. strcpy(buf, "rn"); send(pThreadParam->sckClient, buf, strlen(buf), 0);
  505. while(!feof(pFileContent))
  506. {
  507. dwSize = fread(buf, 1, BUFFER_SIZE, pFileContent);
  508. send(pThreadParam->sckClient, buf, dwSize, 0);
  509. }
  510. fclose(pFileContent);
  511. continue;
  512. }
  513. break;
  514. }
  515. if(strstr(buf, "POST"))
  516. {
  517. OUTPUT(buf);
  518. OUTPUT("rn");
  519. }
  520. else
  521. {
  522. strncpy(content, buf, strstr(buf, "rn")-buf+2);
  523. content[strstr(buf, "rn")-buf] = NULL;
  524. OUTPUT(content);
  525. }
  526. sprintf(content, "t%d.%d.%d.%drn",
  527. pThreadParam->addr.sin_addr.S_un.S_un_b.s_b1,
  528. pThreadParam->addr.sin_addr.S_un.S_un_b.s_b2,
  529. pThreadParam->addr.sin_addr.S_un.S_un_b.s_b3,
  530. pThreadParam->addr.sin_addr.S_un.S_un_b.s_b4);
  531. OUTPUT(content);
  533. if(requestHeader.dwFlag & VIRTUAL_RESOURCE)
  534. {
  535. HttpService(requestHeader.pszUrl, pThreadParam->sckClient, buf, &requestHeader);
  536. goto _ThreadExit;
  537. }
  539. OUTPUT("Connecting to the second proxy.rn");
  540. addrProxy2nd.sin_family = AF_INET;
  541. addrProxy2nd.sin_port = htons(globalInfo.nPort2nd);
  542. addrProxy2nd.sin_addr.S_un.S_un_b.s_b1 = globalInfo.b1;
  543. addrProxy2nd.sin_addr.S_un.S_un_b.s_b2 = globalInfo.b2;
  544. addrProxy2nd.sin_addr.S_un.S_un_b.s_b3 = globalInfo.b3;
  545. addrProxy2nd.sin_addr.S_un.S_un_b.s_b4 = globalInfo.b4;
  547. sckClient = socket(AF_INET, SOCK_STREAM, 0);
  548. if(sckClient==INVALID_SOCKET)
  549. {
  550. closesocket(pThreadParam->sckClient);
  551. closesocket(sckClient);
  552. sprintf(pszMsg, "socket()=INVALID_SOCKET, WSAGetLastError()=%drnListening Thread terminated.rn", WSAGetLastError());
  553. OUTPUT(pszMsg);
  554. goto _ThreadExit1;
  555. }
  556. iRet = connect(sckClient, (const sockaddr*)&addrProxy2nd, sizeof(addrProxy2nd));
  557. if(iRet==SOCKET_ERROR)
  558. {
  559. closesocket(pThreadParam->sckClient);
  560. closesocket(sckClient);
  561. sprintf(pszMsg, "connect()=SOCKET_ERROR, WSAGetLastError()=%drnListening Thread terminated.rn", WSAGetLastError());
  562. OUTPUT(pszMsg);
  563. goto _ThreadExit1;
  564. }
  566. // send the data before Proxy-Authorization:
  567. send(sckClient, buf, requestHeader.pszAuthBegin-buf, 0);
  568. strncpy(pszMsg, buf, requestHeader.pszAuthBegin-buf);
  569. pszMsg[requestHeader.pszAuthBegin-buf] = NULL;
  570. // TRACE(pszMsg);
  571. // send Authorization information to the second proxy
  572. sprintf(pszMsg, "%s:%s", globalInfo.pszUser, globalInfo.pszPasswd);
  573. Base64(pszMsg, pszCode);
  574. sprintf(content, "Proxy-Authorization: Basic %s==rn", pszCode);
  575. send(sckClient, content, strlen(content), 0);
  576. // TRACE(content);
  577. // send(sckClient, requestHeader.pszAuthBegin, requestHeader.pszAuthEnd-requestHeader.pszAuthBegin, 0);
  578. strncpy(pszMsg, requestHeader.pszAuthBegin, requestHeader.pszAuthEnd-requestHeader.pszAuthBegin);
  579. pszMsg[requestHeader.pszAuthBegin, requestHeader.pszAuthEnd-requestHeader.pszAuthBegin] = NULL;
  580. // TRACE(pszMsg);
  581. // send the rest information
  582. send(sckClient, requestHeader.pszAuthEnd, strlen(requestHeader.pszAuthEnd), 0);
  583. iRet = 1;
  584. while(dwTotal<requestHeader.dwContSize && iRet)
  585. {
  586. iRet = recv(pThreadParam->sckClient, buf, BUFFER_SIZE, 0);
  587. buf[iRet] = NULL;
  588. if(iRet==SOCKET_ERROR)
  589. {
  590. sprintf(pszMsg, "while(nTotal<requestHeader.dwContSize && iRet) recv()=SOCKET_ERROR, WSAGetLastError()=%drnListening Thread terminated.rn", WSAGetLastError());
  591. OUTPUT(pszMsg);
  592. goto _ThreadExit;
  593. }
  594. if(iRet)
  595. {
  596. OUTPUT("_DEBUG_PRE_t");OUTPUT(buf);
  597. send(sckClient, buf, iRet, 0);
  598. dwTotal += iRet;
  599. }
  600. }
  601. // TRACE(requestHeader.pszAuthEnd);
  603. // waiting for response from server
  604. iRet = RecvHeader(sckClient, buf, BUFFER_SIZE, &httpHeader);
  605. send(pThreadParam->sckClient, buf, iRet, 0);
  607. if(httpHeader.dwContSize==0)
  608. {
  609. goto _ThreadExit;
  610. }
  612. dwTotal = iRet-(httpHeader.pContBegin - buf);
  613. while(dwTotal<httpHeader.dwContSize && iRet)
  614. {
  615. iRet = recv(sckClient, buf, BUFFER_SIZE, 0);
  616. if(iRet==SOCKET_ERROR)
  617. {
  618. sprintf(pszMsg, "recv()=SOCKET_ERROR, WSAGetLastError()=%drnListening Thread terminated.rn", WSAGetLastError());
  619. OUTPUT(pszMsg);
  620. goto _ThreadExit;
  621. }
  622. dwTotal += iRet;
  623. send(pThreadParam->sckClient, buf, iRet, 0);
  624. }
  626. _ThreadExit:
  627. OUTPUT("Working thread terminated.rn");
  628. closesocket(sckClient);
  629. closesocket(pThreadParam->sckClient);
  631. _ThreadExit1:
  632. WaitForSingleObject(g_hConnectionCount, INFINITE);
  633. g_nConnectionCount--;
  634. ReleaseSemaphore(g_hConnectionCount, 1, NULL);
  636. delete pThreadParam;
  637. return 0;
  638. }
  640. UINT ListeningThread(LPVOID lpVoid)
  641. {
  642. int iRet, addrLen;
  643. sockaddr_in addr, addrAccept;
  644. SOCKET sckListen, sckAccept;
  645. char pszMsg[512];
  646. int nErrCount;
  647. hostent * pEnt;
  648. WORKPARAM * pWorkParam;
  650. OUTPUT("going to create socket.rn");
  652. sckListen = socket(AF_INET, SOCK_STREAM, 0);
  653. if(sckListen==INVALID_SOCKET)
  654. {
  655. sprintf(pszMsg, "INVALID_SOCKET, WSAGetLastError()=%drnListening Thread terminated.rn", WSAGetLastError());
  656. OUTPUT(pszMsg);
  657. return 0;
  658. }
  659. OUTPUT("Listening socket created successfully.rn");
  661. iRet = gethostname(pszMsg, 256);
  662. if(iRet)
  663. {
  664. sprintf(pszMsg, "Error occur when gethostname(), WSAGetLastError()=%drnListening Thread terminated.rn", WSAGetLastError());
  665. OUTPUT(pszMsg);
  666. return 0;
  667. }
  669. pEnt =gethostbyname(pszMsg);
  670. if(!pEnt)
  671. {
  672. sprintf(pszMsg, "Error occur when gethostbyname(), WSAGetLastError()=%drnListening Thread terminated.rn", WSAGetLastError());
  673. OUTPUT(pszMsg);
  674. return 0;
  675. }
  677. addr.sin_family = AF_INET;
  678. addr.sin_port = htons(globalInfo.nPort);
  679. addr.sin_addr.S_un.S_un_b.s_b1 = pEnt->h_addr_list[0][0];
  680. addr.sin_addr.S_un.S_un_b.s_b2 = pEnt->h_addr_list[0][1];
  681. addr.sin_addr.S_un.S_un_b.s_b3 = pEnt->h_addr_list[0][2];
  682. addr.sin_addr.S_un.S_un_b.s_b4 = pEnt->h_addr_list[0][3];
  683. globalInfo._b1 = pEnt->h_addr_list[0][0];
  684. globalInfo._b2 = pEnt->h_addr_list[0][1];
  685. globalInfo._b3 = pEnt->h_addr_list[0][2];
  686. globalInfo._b4 = pEnt->h_addr_list[0][3];
  688. iRet = bind(sckListen, (const sockaddr*)&addr, sizeof(addr));
  689. if(iRet==SOCKET_ERROR)
  690. {
  691. sprintf(pszMsg, "SOCKET_ERROR, WSAGetLastError()=%d", WSAGetLastError());
  692. OUTPUT(pszMsg);
  693. return 0;
  694. }
  696. nErrCount = 0;
  697. OUTPUT("Listening...rn");
  698. iRet = listen(sckListen, SOMAXCONN);
  699. if(iRet==SOCKET_ERROR)
  700. {
  701. sprintf(pszMsg, "INVALID_SOCKET, WSAGetLastError()=%d", WSAGetLastError());
  702. OUTPUT(pszMsg);
  703. nErrCount++;
  704. if(nErrCount>=10)
  705. {
  706. sprintf(pszMsg, "nErrCount>=10, listening thread terminated.rn");
  707. return 0;
  708. }
  709. }
  710. nErrCount = 0;
  712. while(1)
  713. {
  714. addrLen = sizeof(addrAccept);
  715. sckAccept = accept(sckListen, (struct sockaddr*)&addrAccept, &addrLen);
  716. if(sckAccept==INVALID_SOCKET)
  717. {
  718. sprintf(pszMsg, "accept()=SOCKET_ERROR, WSAGetLastError()=%d", WSAGetLastError());
  719. OUTPUT(pszMsg);
  720. return 0;
  721. }
  722. OUTPUT("One client accepted successfully.rn");
  724. pWorkParam = new WORKPARAM;
  725. pWorkParam->sckClient = sckAccept;
  726. pWorkParam->addr = addrAccept;
  728. AfxBeginThread(WorkingThread, (LPVOID)pWorkParam, THREAD_PRIORITY_BELOW_NORMAL);
  729. }
  731. return 0;
  732. }