TCP发送文件（转）

001	//文件传送线程//服务器发送文件，客户端发送文件消息

002	UINT threadSendFile( LPVOID pvar)

003

{

004	CDlgSendMessage *pDlg = (CDlgSendMessage *) pvar;

005

006	CFile m_fSendfile;

007	m_fSendfile.Close();

008

009	if (!m_fSendfile.Open(pDlg->m_sendfilepath, CFile::modeRead | CFile::typeBinary))

010

{

011	AfxMessageBox( "打开文件失败！" );

012	return false ;

013

}

014

015

016	SOCKET sSendMsg; //客户端套接字

017	SOCKADDR_IN inetAddr;

018	sSendMsg = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);

019

020	if (INVALID_SOCKET == sSendMsg)

021

{

022	AfxMessageBox( "创建客户端发送套接字失败！" );

023	m_fSendfile.Close();

024

return 0;

025

}

026

027	inetAddr.sin_family = AF_INET;

028	inetAddr.sin_port = htons(PUB_MSG_PORT);

029	inetAddr.sin_addr.s_addr= inet_addr(pDlg->m_receiveip); //为接受文件者IP

030

031

032

033

034	if (SOCKET_ERROR == connect(sSendMsg, (SOCKADDR *)&inetAddr, sizeof (SOCKADDR_IN))) //为接受文件者

035

{

036

037

038	AfxMessageBox( "对方不在线，不存在监听套接字失败！" );

039	closesocket(sSendMsg);

040	m_fSendfile.Close();

041

return 0;

042

}

043

044	char buff[MAX_BUF_SIZE] = "" ;

045	CString strMsgSend( "1001/" );

046	CString strSize;

047

048

//计算文件大小

049	if (pDlg->m_fiSendFile.nFileSizeLow / (1024 * 1024) != 0)

050

{

051	strSize.Format( "%.2fMB" , pDlg->m_fiSendFile.nFileSizeLow / (1024.0 * 1024));

052

}

053

else

054

{

055	strSize.Format( "%.2fKB" , pDlg->m_fiSendFile.nFileSizeLow / (1024.0));

056

}

057

058	memcpy (buff, pDlg->m_fiSendFile.szFileTitle, sizeof (pDlg->m_fiSendFile.szFileTitle));

059	strMsgSend += buff;

060	strMsgSend += "/" ;

061	strMsgSend += strSize;

062	strMsgSend += "/" ;

063	//发送文件标题，文件大小//作为客户端发消息和接受套接字

064

065

066	if (SOCKET_ERROR == send(sSendMsg, strMsgSend.GetBuffer(0), strMsgSend.GetLength(), 0))

067

{

068	AfxMessageBox( "发送消息失败！: threadSendFile" );

069	closesocket(sSendMsg);

070	m_fSendfile.Close();

071

return 0;

072

}

073

074	memset (buff, 0, MAX_BUF_SIZE);

075

076

077	if (SOCKET_ERROR == recv(sSendMsg, buff, MAX_BUF_SIZE, 0)) //收到对方反馈信息//收到同意接受信息

078

{

079	AfxMessageBox( "接收消息失败！: threadSendFile" );

080	closesocket(sSendMsg);

081	m_fSendfile.Close();

082

return 0;

083

}

084

085

086	//解析对方的确认信息

087	CString strCmd;

088	strCmd += buff;

089	strCmd = strCmd.Left(4);

090	int iCmd = -1;

091	iCmd = atoi (strCmd);

092	if (MSG_ACCEPT != iCmd)

093

{

094	AfxMessageBox( "对方拒绝接收文件！: threadSendFile" );

095	closesocket(sSendMsg);

096	m_fSendfile.Close();

097

098	return false ; //

099

}

100

101	//对方同意接收文件，开始发送

102

103

104	//创建服务器 发送文件socket, 打开FILE_PORT

105	SOCKET sSendFile; //监听套接字

106	SOCKET sAccept; //发送接受套接字

107	SOCKADDR_IN inetAddrSendFile;

108	SOCKADDR_IN inetAddrAccept;

109

110	sSendFile = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);

111	if (INVALID_SOCKET == sSendFile)

112

{

113	AfxMessageBox( "创建套接字错误！: threadSendFile" );

114	closesocket(sSendMsg);

115	m_fSendfile.Close();

116

return 0;

117

}

118

119	inetAddrSendFile.sin_addr.s_addr = htonl(INADDR_ANY);

120	inetAddrSendFile.sin_port    = htons(PUB_FILE_PORT);

121	inetAddrSendFile.sin_family    = AF_INET;

122

123	if (SOCKET_ERROR == bind(sSendFile, (SOCKADDR *)&inetAddrSendFile, sizeof (SOCKADDR)))

124

{

125	AfxMessageBox( "绑定套接字错误！: threadSendFile" );

126	closesocket(sSendMsg);

127	closesocket(sSendFile);

128	m_fSendfile.Close();

129

return 0;

130

}

131

132	if (SOCKET_ERROR == listen(sSendFile, 5))

133

{

134	AfxMessageBox( "监听错误！: threadSendFile" );

135	closesocket(sSendMsg);

136	closesocket(sSendFile);

137	m_fSendfile.Close();

138

return 0;

139

}

140

141	int iLen = sizeof (SOCKADDR);

142	sAccept = accept(sSendFile, (SOCKADDR *)&inetAddrAccept, &iLen);

143

144	if (INVALID_SOCKET == sAccept)

145

{

146	AfxMessageBox( "accept socket error occurred！: threadSendFile" );

147	closesocket(sSendMsg);

148	closesocket(sSendFile);

149	m_fSendfile.Close();

150

return 0;

151

}

152

153	//发送文件信息给对方

154	char buffInfo[MAX_BUF_SIZE] = "" ;

155	memcpy (buffInfo, &pDlg->m_fiSendFile, sizeof (pDlg->m_fiSendFile));

156	send(sAccept, buffInfo, sizeof (pDlg->m_fiSendFile), 0);

157	memset (buffInfo, 0, MAX_BUF_SIZE);

158

159	//对方同意接收huozebujieshou，开始传送

160

161	recv(sAccept, buffInfo, MAX_BUF_SIZE, 0); //对方不保持就不往下走

162

163

//循环发送文件

164	DWORD dwRead = 0;

165	DWORD dwCurrentRead = 0;

166	BYTE *bReadBuff = new BYTE [MAX_BUF_SIZE];

167

168

//设置发送进度

169

170

171	while (dwRead < pDlg->m_fiSendFile.nFileSizeLow)

172

{

173	dwCurrentRead = 0;

174	memset (bReadBuff, 0, MAX_BUF_SIZE);

175	dwCurrentRead = m_fSendfile.Read(bReadBuff, MAX_BUF_SIZE); //读数据到缓冲区

176	if (SOCKET_ERROR == send(sAccept, ( char *)bReadBuff, dwCurrentRead, 0)) //发送数据

177

{

178	AfxMessageBox( "文件发送中断！: threadSendFile" ); //如果对方取消持，发送方也也一直往下走

179	closesocket(sSendMsg);

180	closesocket(sSendFile);

181	m_fSendfile.Close();

182

break ;

183

}

184

185	dwRead += dwCurrentRead; //已经发送数据

186	CString   str;

187	str.Format( "%d" ,   dwRead);

188	AfxMessageBox( "已经发送" +str);

189

190

}

191	AfxMessageBox( "发送完成" );

192	delete bReadBuff; //释放堆内存

193

//结束时处理

194	m_fSendfile.Close(); //文件关闭

195	if (INVALID_SOCKET != sAccept)

196

{

197	closesocket(sAccept); //关闭接受套接字

198

}

199	if (INVALID_SOCKET != sSendFile)

200

{

201	closesocket(sSendFile); //关闭发送套接字

202

}

203

204

205	AfxEndThread(0);

206

207

return 1;

208

}

209

210	//客户端文件接收线程

211	UINT threadRecvFile( LPVOID pvar)

212

{

213

214	char * m_sip=( char *)pvar;

215	SOCKET sFileRecv;

216	SOCKADDR_IN inetAddr;

217

218	//新建一个客户socket，连接文件 发送方服务器 接收文件

219	sFileRecv = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);

220	if (INVALID_SOCKET == sFileRecv)

221

{

222	AfxMessageBox( "创建套接字失败 : threadRecvFile" );

223	AfxEndThread(0);

224

return 0;

225

}

226

227	inetAddr.sin_family    = AF_INET;

228	inetAddr.sin_port    = htons(PUB_FILE_PORT);

229	inetAddr.sin_addr.s_addr = inet_addr(m_sip);

230

231

232	if (SOCKET_ERROR == connect(sFileRecv, (SOCKADDR *)&inetAddr, sizeof (SOCKADDR))) //连接服务器IP

233

{

234	AfxMessageBox( "连接对方主机错误 : threadRecvFile" );

235	closesocket(sFileRecv);

236	AfxEndThread(0);

237

return 0;

238

}

239

240

//接收文件信息

241	FileInfo fiRecvFile;

242

243	if (SOCKET_ERROR == recv(sFileRecv, ( char *)&fiRecvFile, sizeof (FileInfo), 0))

244

{

245	AfxMessageBox( "接收文件信息错误 : threadRecvFile" );

246	closesocket(sFileRecv);

247	AfxEndThread(0);

248

return 0;

249

}

250

251	CString strFileInfo;

252	double nfileSize = 0.0;

253	if (fiRecvFile.nFileSizeLow / (1024 * 1024) != 0)

254

{

255	nfileSize = fiRecvFile.nFileSizeLow / (1024 * 1024);

256	strFileInfo.Format( "正在接收文件.../n 来自[%s], /n文件名[%s] 大小:[%.2f]MB" ,

257	inet_ntoa(inetAddr.sin_addr), fiRecvFile.szFileTitle, nfileSize);

258

}

259

else

260

{

261	nfileSize = fiRecvFile.nFileSizeLow / (1024);

262	strFileInfo.Format( "正在接收文件.../n 来自[%s], /n文件名[%s] 大小:[%.2f]KB" ,

263	inet_ntoa(inetAddr.sin_addr), fiRecvFile.szFileTitle, nfileSize);

264

}

265

266

267

268	CFileDialog fdlgSave( FALSE,NULL,fiRecvFile.szFileTitle,

269	OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT,

270	_T( "所有 (*.*)|*.*|" ));

271

272	char buff[MAX_BUF_SIZE] = "" ;

273	CAcModuleResourceOverride thisResource;

274	if (fdlgSave.DoModal() != IDOK)

275

{

276

277	sprintf (buff, "%d" , MSG_REJECT);

278	send(sFileRecv, buff, sizeof (buff), 0);

279	closesocket(sFileRecv); //导致发送文件中端

280	AfxEndThread(0);

281

}

282

283	CString strFilePath;

284	strFilePath = fdlgSave.GetPathName();

285

286	CFile fRecvedFile(strFilePath, CFile::modeCreate | CFile::modeWrite | CFile::typeBinary);

287

288	DWORD dwTotalRead;

289	DWORD dwCurrentRead;

290

291	dwTotalRead   = 0; //接收总字节

292	dwCurrentRead = 0; //此次接收字节

293	BYTE *dataBuff = new BYTE [MAX_BUF_SIZE]; //分配堆内存缓冲

294

295

//开始接收

296	memset (buff, 0, sizeof (buff));

297	sprintf (buff, "%d" , MSG_BEGIN);

298	send(sFileRecv, buff, sizeof (buff), 0);

299

300

301	while (dwTotalRead < fiRecvFile.nFileSizeLow)

302

{

303	dwCurrentRead = 0;

304	memset (dataBuff, 0, MAX_BUF_SIZE);

305

306	dwCurrentRead = recv(sFileRecv, ( char *)dataBuff, MAX_BUF_SIZE, 0);

307	if (0 == dwCurrentRead || SOCKET_ERROR == dwCurrentRead)

308

{

309	CString strFileRecvInfo;

310	strFileRecvInfo.Format( "接收：%s失败！" , fiRecvFile.szFileTitle);

311

312

break ;

313

}

314	fRecvedFile.Write(dataBuff, dwCurrentRead);

315	dwTotalRead += dwCurrentRead;

316	//   CString str;

317	//   str.Format("%d",dwTotalRead);

318	//   AfxMessageBox("已经接受"+str);

319

320	double iCompleted = 0.0;

321	iCompleted = (dwTotalRead * 1.0) / fiRecvFile.nFileSizeLow;

322	iCompleted *= 10.0;

323	CString strSavedInfo;

324	strSavedInfo.Format( "%d" , iCompleted);

325

326

}

327

328	delete dataBuff; //释放堆内存

329

330	CString strFileRecvInfo;

331	strFileRecvInfo.Format( "接收：%s完成！" , fiRecvFile.szFileTitle);

332	AfxMessageBox(strFileRecvInfo);

333

334	if (sFileRecv != INVALID_SOCKET)

335

{

336	closesocket(sFileRecv);

337

}

338

339

//关闭文件

340	fRecvedFile.Close();

341

//清空文件信息

342	// memset(&pDlg->m_fiSendFile, 0, sizeof(pDlg->m_fiSendFile));

343

//

344	AfxEndThread(0);

345

return 1;

346

}

347

348	//服务监听线程//建立服务器模型

349	UINT threadServer( LPVOID pvar)

350

{

351

352	SOCKADDR_IN inetAddr;

353	SOCKADDR_IN inetAccept;

354	SOCKET sAccept;

355	SOCKET MySock;

356	//服务器监听套接字MYSOCK;

357

358

359	MySock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);

360	if (INVALID_SOCKET == MySock)

361

{

362	AfxMessageBox( "套接字创建失败！" );

363	return FALSE;

364

}

365

366	inetAddr.sin_family = AF_INET;

367	inetAddr.sin_port = htons(PUB_MSG_PORT);   //消息监听端口

368	//inetAddr.sin_port = 0;

369	inetAddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);

370

371

//绑定

372	if (INVALID_SOCKET == bind(MySock, (SOCKADDR *)&inetAddr, sizeof (SOCKADDR)))

373

{

374	AfxMessageBox( "套接字绑定错误 : threadServer！" );

375	closesocket(MySock);

376

return 0;

377

}

378

379

//监听

380	if (0 != listen(MySock, 5))

381

{

382	AfxMessageBox( "套接字监听错误 : threadServer！" );

383

return 0;

384

}

385

386	//    AfxMessageBox("消息服务启动成功");

387

388

//accept

389	int ilen = sizeof (SOCKADDR_IN);

390

391	while (TRUE)

392	{ //服务器会话套接字

393

394	sAccept = accept(MySock, (SOCKADDR *)&inetAccept, &ilen);

395

396	if (INVALID_SOCKET == sAccept)

397

{

398	AfxMessageBox( "接受套接字失败 : threadServer!" );

399

return 0;

400

}

401

402	//启动消息处理线程处理新到达的消息

403

404	//分配堆内存，存放客户socket信息

405	SocketInfo *psInfo = new SocketInfo;

406	memset (psInfo, 0, sizeof (SocketInfo));

407	psInfo->sNow   = sAccept;

408	psInfo->inetAddr = inetAccept; //客户机的地址

409

410	AfxBeginThread(threadRecvMsg, ( LPVOID )psInfo);

411

} //while

412

413

return 1;

414

}

415

416	//服务器处理 消息处理线程，新消息到达后启动，处理完毕关闭

417	UINT threadRecvMsg( LPVOID pvar)

418

{

419	SocketInfo *psockInfo = (SocketInfo *)pvar;

420	SocketInfo sockInfo = *psockInfo;

421	delete psockInfo; //释放堆内存

422	//每个线程里都有单独的内存，必须释放才能引用，实际上是子线程偷了父线程的内存

423

424

425	int iRecv = -1;

426	char buff[MAX_BUF_SIZE] = "" ;

427	char szMsg[256] = "" ;

428

429

//开始接收消息

430	iRecv = recv(sockInfo.sNow, buff, sizeof (buff), 0); //

431	if (SOCKET_ERROR == iRecv)

432

{

433	closesocket(sockInfo.sNow);

434	AfxMessageBox( "接收消息出错！: threadRecvMsg" );

435	AfxEndThread(0);

436

}

437

438	//1001/暴风影音2007.exe/32MB/

439	strcpy (szMsg, buff);

440	int itype = 0;

441	CString strTemp;

442	CString strInMsg;

443	strTemp += szMsg;

444	strInMsg += szMsg;

445	strTemp = strTemp.Left(4);

446	itype = atoi (strTemp);

447

448	//判断是否为文件到达消息

449	if (MSG_NEW_FILE == itype)

450

{

451

452	CString strMsgInfo;

453	CString strHost;

454	CString strFileName;

455	CString strSize;

456

457

int i, j;

458

i = 0;

459

j = 0;

460	i = strInMsg.Find( "/" );

461	j = strInMsg.Find( "/" , i + 1);

462

463

//取得文件名称

464	strFileName = strInMsg.Mid(i + 1, j - i - 1);

465	strInMsg.TrimRight( "/" );

466

//取得文件大小

467	strSize = strInMsg.Right(strInMsg.GetLength() - strInMsg.ReverseFind( '/' ) - 1);

468

469	strMsgInfo.Format( "[文件来源:%s]/n[文件名称:%s]/n[文件大小:%s]" , inet_ntoa(sockInfo.inetAddr.sin_addr), strFileName, strSize);

470	strMsgInfo += "/n同意接收吗？" ;

471	CAcModuleResourceOverride thisResource;

472	if (IDYES == MessageBox(NULL, strMsgInfo, "新消息" , MB_YESNO))

473

{

474	char buffSend[MAX_BUF_SIZE] = "" ;

475	char sztemp[20] = "" ;

476	itoa(MSG_ACCEPT, sztemp, 10);

477	strcpy (buffSend, sztemp);

478

479	//发送同意接收消息给对方

480	if (SOCKET_ERROR == send(sockInfo.sNow, buffSend, sizeof (buffSend), 0))

481

{

482	AfxMessageBox( "发送消息失败 : threadRecvMsg" );

483	closesocket(sockInfo.sNow);

484	AfxEndThread(0);

485

} //if

486

487

488	char * senderip;

489	senderip=inet_ntoa(sockInfo.inetAddr.sin_addr);

490	//启动文件接收线程

491	AfxBeginThread(threadRecvFile, ( LPVOID )senderip);

492

493

494

} //if

495

else

496

{

497	char buffSend[MAX_BUF_SIZE] = "" ;

498	char sztemp[20] = "" ;

499	itoa(MSG_REJECT, sztemp, 10);

500	strcpy (buffSend, sztemp);

501

502	//发送拒绝接收消息给对方

503	if (SOCKET_ERROR == send(sockInfo.sNow, buffSend, sizeof (buffSend), 0))

504

{

505	AfxMessageBox( "发送消息失败 : threadRecvMsg" );

506	closesocket(sockInfo.sNow);

507	AfxEndThread(0);

508

} //if

509

} //else

510

511

} //if

512

else

513

{

514	AfxMessageBox( "无法识别的消息" );

515

} //else

516

517

518

return 0;

519

}