ctrldlg.cpp

来自「网络文件传输,用于显示屏控制系统」· C++ 代码 · 共 2,181 行 · 第 1/5 页

// ctrlDlg.cpp : implementation file
//

#include "stdafx.h"
#include "ctrl.h"
#include "ctrlDlg.h"
#include "pro_ser.h"
#include "Dlgchangtcport.h"
#include "Dlgchangudport.h"
#include "Dlgchangltd1.h"
#include "Dlgchangservertcport.h"
#include "Dlgchangserverudport.h"
#include "Dlgchangserverdns.h"
#include "Dlgcontcp.h"
#include "Dlginputltdpass.h"
#include "Dlgchangltdpass.h"
#include "Dlgopenlock.h"
#include "Dlgadduser.h"
#include "Dlgdeluser.h"
#include "Dlgchanguserpass.h"
#include "Dlgrename.h"
#include "Dlgdriatt.h"
#include "Dlgatt.h"
#include "Dlgrecoatt.h"
#include "Dlginsertable.h"
#include "Dlgtimerset.h"
#include "Dlgdispatt.h"
#include "Dlgupfile.h"
#include "Dlgsendctrl.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About

class CAboutDlg : public CDialog
{
public:
	CAboutDlg();

// Dialog Data
	//{{AFX_DATA(CAboutDlg)
	enum { IDD = IDD_ABOUTBOX };
	//}}AFX_DATA

	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CAboutDlg)
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
	//}}AFX_VIRTUAL

// Implementation
protected:
	//{{AFX_MSG(CAboutDlg)
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
	//{{AFX_DATA_INIT(CAboutDlg)
	//}}AFX_DATA_INIT
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CAboutDlg)
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
	//{{AFX_MSG_MAP(CAboutDlg)
		// No message handlers
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CCtrlDlg dialog
SOCKET my_tcp_sock,my_udp_sock,tcp_acc_sock,pro_udp_sock;
struct sockaddr_in my_tcp_addr,my_udp_addr,pro_send_addr,pro_rec_addr; 
SOCKET sock_arr[256];
CString strbufudp,strbuftcp,strpassword;
HTREEITEM ite[256];
unsigned char p_sock=0;
unsigned char p_sock_server=0;
unsigned int p_list_con=0;
BOOL flagudpsta=1;
BOOL flagtcpsta=1;
BOOL bit_flashdriver=0,bit_flashtable=0;
//BOOL bit_rec_table=0,bit_rec_dir=0,bit_rec_att=0;
unsigned char rec_dat[32*1024];
//unsigned char udp_dat[384*1024*1024/256];
unsigned char dat_sta=0;
	CString m_newname;
	CString m_oldname;
	CString renamepath;
 unsigned char arr_mis_pack[1600000];
	#define no_re_sta '0'   //未回应
	#define re_sta '1'      //有回应
 unsigned char re_udp_pack_sta=re_sta;//接收状态请求标志
 
//	re_udp_pack_sta=re_sta;
  #define udp_dat_star '1'   //未完成
  #define udp_rec_fin  '3'  //传输完成
 unsigned char flag_udp_send=udp_dat_star;//数据是否传输完成标志
	 		
unsigned char flag_udp;  //发起请求标志
#define star '1'         //udp 请求
#define f_connet '2'     //udp 请求回应
BOOL bit_send_thread=0;
 struct send_stru *head=NULL,*curr_send=NULL;
	CWinThread *Threadrec_close;
unsigned char send_err_cou=0;
char send_dat[3*1024*1024];
unsigned char list_cou=0;
BOOL bit_timer_ctrl=0;
BOOL bit_stop_thread=0;
unsigned char timer_ctrl=0;

UINT tcp_close(LPVOID pParam)//接收tcp 数据
{    
	 CCtrlDlg *pdlg = (CCtrlDlg *)pParam;	  
	int sock_len = sizeof(sockaddr);	 
	SOCKET recc_socket=tcp_acc_sock;
	unsigned char buf_p=p_sock;
	int rec_len;
	CFile fil_send;	 
	int sendedlen=0;
	unsigned long pack_len;
	unsigned long pack_cou=0;
 	stru_file_req *file_pack;
	struct send_stru *my;
	my=curr_send;	 
	curr_send->sta=sending;
	unsigned int file_len;
	unsigned int read_len;
	bit_send_thread=1;
	CString strinf,name;
 
  	while(1)
	{	   
	  rec_len=recv(recc_socket,(char *)rec_dat, 1600, 0); 
      if(bit_stop_thread)
	  {
		  bit_stop_thread=0;
		  pdlg->delitem(buf_p);
		  ::closesocket(recc_socket);
		  fil_send.Close();
		  bit_send_thread=0;
		  return 1;	
	  }
	  if(rec_len==SOCKET_ERROR)
	  {		   
		  pdlg->delitem(buf_p);
		  ::closesocket(recc_socket);
		  fil_send.Close();
		  bit_send_thread=0;
		  bit_stop_thread=0;
		  return 1;		 
	  }
	  else
	  {			  
		  if((rec_dat[0]==0xaa)&&(rec_dat[1]==0x55))
		  {		
			  timer_ctrl=0;
			  send_err_cou=0;
			  if(rec_dat[2]==file_dat)//数据请求
			  {					   
				  file_pack=(stru_file_req *)&rec_dat[0];
				  read_len=file_pack->pack_len;
				  if(file_pack->p_file_sock==my->p_send_sock)
				  {					  
					   int pges=(file_pack->pack_num)*pack_len/(file_len/100);
				 	   pdlg->m_gtcp.SetPos(pges+1);					   
					  if(file_pack->pack_num==pack_cou)//取出包号 如果不是顺序包	
					  {				        	
					  }
					  else
					  {
					      pack_cou=file_pack->pack_num;
						  fil_send.Seek(pack_cou*pack_len,CFile::begin);                           
					  }
					  //文件是否到尾包
					  fil_send.ReadHuge(send_dat,read_len);
					  sendedlen=send(recc_socket,(char *)&send_dat[0],read_len,0);	   				 
					  if(sendedlen==SOCKET_ERROR)
					  {					  
						  //发送中断								   
					  }
					  else
					  {	
						  //发送成功
						  //返回长度不相等处理 最后的包						  
						  //设置进度条
                         pack_cou++;
					  }				   
				  }				  
				 // ::AfxMessageBox("dat");
			  }  
			  else if(rec_dat[2]==file_req)//文件请求 第一次
			  {		 		   
				  stru_file *pro_file=(stru_file *)rec_dat;
				  pack_len=pro_file->pack_len;
				  CString strlen;
				  strlen.Format("%u",pro_file->p_file_sock);				    
				  BOOL bit_fail=0;				   
                  if(pro_file->p_file_sock==my->p_send_sock)
				  {					  
					  CString sorc_path=my->sour_path;
					  fil_send.Close();
					  int nastar=sorc_path.ReverseFind('\\');
					  int len=sorc_path.GetLength();
						  name.Empty();
						  for(int na=(nastar+1);na<len;na++)
						  {
							  name+=sorc_path.GetAt(na);
							  //sdpath+=path.GetAt(na);
						  }			
					  if(fil_send.Open(sorc_path,CFile::modeRead))
					  {
						  file_len=fil_send.GetLength();						  
						  if(file_len<pack_len)
						  {
							  read_len=file_len;						   
						  }
						  else
						  {
							  read_len=pack_len;							   
						  }
						   fil_send.ReadHuge(send_dat,read_len);
						   /*
						  if(file_len<(64*1024))
						  {
							  fil_send.Read((void *)&send_dat[0],read_len);
						  }
						  else
						  {
						   fil_send.ReadHuge((void *)&send_dat[0],read_len);
						  }
				            */
						 // char *data = new char[sendlen+1];//创建数据缓冲区						 
						  int idx=0;
						  int nrcvbuf=pack_len+1; 	 
						  //SO_SNDBUF写缓冲，读缓冲为SO_RCVBUF
						  int err=setsockopt(recc_socket,SOL_SOCKET,SO_SNDBUF,(const char *)&nrcvbuf,sizeof(int)); 
						  if (err != NO_ERROR) 
						  { 
							  bit_fail=1;
							  ::AfxMessageBox("opt");
						  } 
						  else
						  {				
							 strinf="开始发送"+name;
                             CString sttimer;
							 sttimer=pdlg->getcurrtimer();
							 strcpy((char *)my->start_timer,sttimer);
							 pdlg->addinf(strinf);
							  sendedlen=send(recc_socket,(char *)&send_dat[0],read_len,0);	   				 
							  if(sendedlen==SOCKET_ERROR)
							  {
								  bit_fail=1;
								  //发送中断								   
							  }
							  else
							  {	
								  //发送成功
								  //返回长度不相等处理
								  //设置进度条
								  pack_cou++;
							  }							   
						  }							    
					  }
					  else
					  {						   			   
						  strinf="打开文件"+name+"失败";
						  //::AfxMessageBox(sorc_path);
						  pdlg->addinf(strinf);
						  my->sta=read_file_fail;
						  bit_fail=1;
					  }					   
					  if(bit_fail)
					  {
						 // ::AfxMessageBox("fail");
						  fil_send.Close();
						  pdlg->delitem(buf_p);
						  ::closesocket(recc_socket);
						  bit_send_thread=0;
						  return 1;
					  }			
					   					      
				  }				  
			  }  
			  else if(rec_dat[2]==file_fin)//完成
			  {
				    //::AfxMessageBox("fin");				   
				    bit_send_thread=0;
				    fil_send.Close();
					::closesocket(recc_socket);
					my->sta=send_ok;
					pdlg->delitem(buf_p);
					pdlg->m_gtcp.SetPos(100);	
					strinf="发送"+name+"完成";
					//strinf="发送"+name;
                    CString sttimer;
				    sttimer=pdlg->getcurrtimer();
				    strcpy((char *)my->finish_timer,sttimer);					
					pdlg->addinf(strinf);					 
					return 1;					
			  }			   
		  }		  
	  }
	}	 
   return 1;
}
UINT tcp_rec(LPVOID pParam)//接收udp 数据
{    
	 CCtrlDlg *pdlg = (CCtrlDlg *)pParam;
	int rec_len;
	unsigned long talon=0;
//	char rec_tcp_dat[1600+1];
	int len = sizeof(sockaddr);
	unsigned char buf_p=p_sock;  
	SOCKET recc_socket=tcp_acc_sock;	 
 	int nrcvbuf=32*1024+1; 
	//写缓冲，读缓冲为SO_RCVBUF
	int err=setsockopt(recc_socket,SOL_SOCKET,SO_RCVBUF,(const char *)&nrcvbuf,sizeof(int)); 
  	while(1)
	{
	  //recv(tcp_acce_socket, recvbuf, 1500, 0);
	  rec_len=recv(recc_socket,(char *)&rec_dat[0], 32*1024, 0);
      //rec_len=recvfrom(my_tcp_sock,rec_tcp_dat, 1600, 0,NULL, NULL);
	  if(rec_len==SOCKET_ERROR)
	  {
           pdlg->delitem(buf_p);	 	  
		  return 1;		 
	  }
	  else
	  {		  
		  if((rec_dat[0]==0xaa)&&(rec_dat[1]==0x55))
		  {
		     pdlg->dowith_pro(recc_socket,rec_len,1,my_tcp_addr,buf_p);
		  }
		 // ::AfxMessageBox("red");
		  /*
		  CString str,strtime,strlen,st;
		  str.Empty();		 		 
		  pdlg->m_recedit=str;		   
          strtime=pdlg->getcurrtimer();
		  talon+=rec_len;
		  strlen.Format("%u",talon);
		  str.Empty();
		  pdlg->getiport(buf_p);
		  str="TCP-recfrom:"+strbuftcp+','+strlen+"byte,T:"+strtime; 
		  strbuftcp=str;	 
	      pdlg->updaterec_edit();
         */
	  }
	}
	return 1;
}
 
 UINT acceptconnet(LPVOID pParam)//接受tcp连接
{ 	   	 
	CCtrlDlg *pdlg = (CCtrlDlg *)pParam;
	struct sockaddr_in tcp_acc_addr;
	 if(listen(my_tcp_sock,5))
	{
	 AfxMessageBox("listen fail");
	}
	else
	{
	//	AfxMessageBox("listen ok");
	}
	int nAddrLen = sizeof(struct sockaddr_in); 
	while(1)
	{	 		 
         tcp_acc_sock=accept(my_tcp_sock,(LPSOCKADDR) &tcp_acc_addr,&nAddrLen);	 
	     if(tcp_acc_sock< 0)
		  {	 
	 	    AfxMessageBox("accept fail");
			return 1;
		  }
         else
		  {
                pdlg->isconnettcp(tcp_acc_sock,tcp_acc_addr);				 				 
		  } 		 
	} 
	 
}
  
UINT rec_pro(LPVOID pParam)//接收udp 数据
{    
	CCtrlDlg *pdlg = (CCtrlDlg *)pParam;
	int rec_len;
//	struct sockaddr_in udp_recv_addr;
	//unsigned char rec_udp_dat[1600];
//	unsigned long talon=0;
 	int len = sizeof(sockaddr); 
  	while(1)
	{
	 	rec_len=recvfrom(pro_udp_sock,(char *)rec_dat, 1600, 0,(LPSOCKADDR)&pro_rec_addr, &len);  
	 //	rec_len=recvfrom(pro_udp_sock,(char *)&pro_ord.head0, 1600, 0,(LPSOCKADDR)&pro_rec_addr, &len);  
	 // rec_len=recvfrom(my_udp_sock,rec_udp_dat, 1600, MSG_DONTROUTE,(LPSOCKADDR)&udp_recv_addr, &len);
     // rec_len=recvfrom(my_udp_sock,rec_udp_dat, 1600, 0,NULL, NULL);
	  if(rec_len==SOCKET_ERROR)
	  {
		  AfxMessageBox("recbfrom pro err !");
		  return 1;
		 // WSACleanup();
	  }
	  else
	  {			  
		  if((rec_dat[0]==0xaa)&&(rec_dat[1]==0x55))
		  {					  
				 if(pro_rec_addr.sin_addr.S_un.S_un_b.s_b4!=my_udp_addr.sin_addr.S_un.S_un_b.s_b4)
				 {					   
				  pdlg->dowith_pro(pro_udp_sock,rec_len,0,pro_rec_addr,0);
				 }
		  }
		  else if((rec_dat[0]==0x55)&&(rec_dat[1]==0xaa))
		  {
		  } 
	  }	  
	}
	return 1;
}
UINT udp_rec(LPVOID pParam)//接收udp 数据
{    
	CCtrlDlg *pdlg = (CCtrlDlg *)pParam;
	int rec_len;
	struct sockaddr_in udp_recv_addr;
//	char rec_udp_dat[1600];
	unsigned long talon=0;