Esempio n. 1
0
//  open/close/state socket device
e_int32 Socket_Open(socket_t **socket_ptr, const char *socket_addr,
		const e_uint32 port, e_int32 type) {
	int sockfd;
	int snd_size = 0; /* 发送缓冲区大小 */
	socklen_t optlen; /* 选项值长度 */
	socket_t *skt = (socket_t *) malloc(sizeof(socket_t));
	e_assert(skt, E_ERROR_BAD_ALLOCATE);
	memset(skt, 0, sizeof(socket_t));

	//保证经过网络初始化
	Socket_Init();

	/*创建服务器端套接字--IPv4协议*/
	switch (type) {
	case E_SOCKET_TCP:
		/*面向连接通信,TCP协议*/
		sockfd = socket(PF_INET, SOCK_STREAM, 0);
		break;
	case E_SOCKET_UDP:
		/*无连接,UDP协议*/
		sockfd = socket(PF_INET, SOCK_DGRAM, 0);
		break;
	case E_SOCKET_NAME:
		sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
		break;
	}
	/*check sockfd*/
	if (e_failed(sockfd)) {
		free(skt);
		return E_ERROR_IO;
	}

	/*
	 * 先读取缓冲区设置的情况
	 * 获得原始发送缓冲区大小
	 */
	optlen = sizeof(snd_size);
	if (getsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &snd_size, &optlen) < 0) {
		DMSG((STDOUT,"获取发送缓冲区大小错误\n"));
		skt->send_max_size = ~0;
	} else {
//		DMSG((STDOUT,"获取发送缓冲区大小:%d\n",snd_size));
		skt->send_max_size = snd_size;
	}

	//默认是非阻塞通讯
	fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFL) | O_NONBLOCK);
	/*存储附加信息*/
	skt->priv = (void *) sockfd;
	if (socket_addr != NULL)
		hd_strncpy(skt->ip_address, socket_addr, sizeof(skt->ip_address));

	skt->port = port;
	skt->type = type;
	skt->state = E_OK;
	skt->last_error = E_OK;
	(*socket_ptr) = skt;
	return E_OK;
}
Esempio n. 2
0
// =============================================================================
// 函数功能:ModuleInstall_DjyIp
//          TcpIP协议栈初始化
// 输入参数:para,无意义
// 输出参数:无
// 返回值  :目前无意义
// 说明    :1,先初始化基础性质的模块
//       2,再初始化协议层的模块
//       3,再初始化具体协议
//       4,当上述四部完成的时候,应该可以注册网卡、注册ROUT以及套接字编程了
// =============================================================================
ptu32_t ModuleInstall_DjyIp(ptu32_t para)
{
	//数据包管理模块的初始化,只有初始化完毕后才存在协议栈的数据包的管理
	extern bool_t Pkg_Init(void);
	if(false == Pkg_Init())
	{
		printk("DJY_NETSTACK_INIT: Pkg Init Failed\n\r");
		goto TCPIP_INITERR;
	}
	else
	{
		printk("DJY_NETSTACK_INIT: Pkg Init  Success\n\r");
	}
	//ROUT表的初始化,初始化完毕后才可以添加链路
	extern bool_t  Rout_Init(void);
	if(false == Rout_Init())
	{
		printk("DJY_NETSTACK_INIT: Rout Init Failed\n\r");
		goto TCPIP_INITERR;

		//初始化失败,应该采取点措施
	}
	else
	{
		printk("DJY_NETSTACK_INIT: Rout Init  Success\n\r");
	}
	//设备抽象接口,初始化后才可以注册网卡
	extern bool_t NetDev_Init(void);
	if(false == NetDev_Init())
	{
		printk("DJY_NETSTACK_INIT: NetDev Init Failed\n\r");
		//初始化失败,应该采取点措施
		goto TCPIP_INITERR;

	}
	else
	{
		printk("DJY_NETSTACK_INIT: NetDev Init  Success\n\r");
	}
	//链路层初始化,完毕之后可以注册ARP RARP IP等网络协议的处理函数
	extern bool_t Link_Init(void);
	if(false == Link_Init())
	{
		printk("DJY_NETSTACK_INIT: Link Init Failed\n\r");
		//初始化失败,应该采取点措施
		goto TCPIP_INITERR;

	}
	else
	{
		printk("DJY_NETSTACK_INIT: Link Init  Success\n\r");
	}
	//ARP协议初始化
	extern bool_t Arp_Init(void);
	if(false == Arp_Init())
	{
		printk("DJY_NETSTACK_INIT: Arp Init Failed\n\r");
		//初始化失败,应该采取点措施
		goto TCPIP_INITERR;

	}
	else
	{
		printk("DJY_NETSTACK_INIT: Arp Init  Success\n\r");
	}
	
	//IP协议初始化
	extern bool_t Ip_Init(ptu32_t para);
	if(false == Ip_Init((ptu32_t)0))
	{
		printk("DJY_NETSTACK_INIT: Ip Init Failed\n\r");
		//初始化失败,应该采取点措施
		goto TCPIP_INITERR;

	}
	else
	{
		printk("DJY_NETSTACK_INIT: Ip Init  Success\n\r");
	}
	//传输层初始化
	extern bool_t TPL_Init(ptu32_t para);
	if(false == TPL_Init((ptu32_t)0))
	{
		printk("DJY_NETSTACK_INIT: TPL Init Failed\n\r");
		//初始化失败,应该采取点措施
		goto TCPIP_INITERR;

	}
	else
	{
		printk("DJY_NETSTACK_INIT: TPL Init  Success\n\r");
	}

	//socket初始化
	extern bool_t Socket_Init(ptu32_t para);
	if(false == Socket_Init((ptu32_t)0))
	{
		printk("DJY_NETSTACK_INIT: Socket Init Failed\n\r");
		//初始化失败,应该采取点措施
		goto TCPIP_INITERR;

	}
	else
	{
		printk("DJY_NETSTACK_INIT: Socket Init  Success\n\r");
	}
	//TCP协议初始化
	extern bool_t Tcp_Init(ptu32_t para);

	if(false == Tcp_Init((ptu32_t)0))
	{
		printk("DJY_NETSTACK_INIT: Tcp Init Failed\n\r");
		//初始化失败,应该采取点措施
		goto TCPIP_INITERR;

	}
	else
	{
		printk("DJY_NETSTACK_INIT: Tcp Init  Success\n\r");
	}
	//udp proto init
	bool_t Udp_Init(ptu32_t para);
	if(false == Udp_Init((ptu32_t)0))
	{
		printk("DJY_NETSTACK_INIT: Udp Init Failed\n\r");
		//初始化失败,应该采取点措施
		goto TCPIP_INITERR;

	}
	else
	{
		printk("DJY_NETSTACK_INIT: Udp Init  Success\n\r");
	}
	//ICMP协议初始化
	extern bool_t Icmp_Init(ptu32_t para);
	if(false == Icmp_Init((ptu32_t)0))
	{
		printk("DJY_NETSTACK_INIT: Icmp Init Failed\n\r");
		//初始化失败,应该采取点措施
		goto TCPIP_INITERR;

	}
	else
	{
		printk("DJY_NETSTACK_INIT: Icmp Init  Success\n\r");
	}
	printk("*********DJY TCP/IP INIT SUCCESS************************\n\r");
	return 0;

TCPIP_INITERR:
	printk("*********DJY TCP/IP INIT  FAILED************************\n\r");
	return -1;
}
void SeverSocket(void) 
{
 SOCKET sockSrv;                                   //服务器套接字号
 SOCKADDR_IN addrClient;                           //连接上的客户端ip地址
 int len=sizeof(SOCKADDR);                         //SOCKADDR结构体大小
 int flag=0;                                       //存储接收到的STB消息类型
 FILE * fpReadIn=NULL;                             // 文件指针
 unsigned char sendbuffer[BUF_SIZE];               //发送缓冲区
 unsigned char*pfile_buf=NULL;                     //存储文件的缓冲区指针
 unsigned long file_len=0;                         //文件长度
 int send_len=0;                                   //发送的数据长度
 int ver_len=0;                                    //版本数据的长度(最大19个字节)


 ReadFileAble=READFILE;                                                   //文件标识置为“正在读入”
 pfile_buf = ( unsigned char *) malloc (FLIE_BUFFER_SIZE);
 if(pfile_buf==NULL)
 {
    LogDisplay("内存分配失败!\r\n");
	return;
 }
 if(ReadFileProcess( &ver_len, pfile_buf, &file_len,fpReadIn )<0)
	return;
 sockSrv=Socket_Init();                      //服务器sokcet连接初始化
 LogDisplay("监听STB连接请求\r\n\r\n");
 if(( listen(sockSrv,20))!=0)
 {
	sprintf(Print_Buf,"监听失败!%d\r\n", WSAGetLastError());
	LogDisplay(Print_Buf);
	closesocket(sockSrv);
    free(pfile_buf);
	return ;
 }

 while(1)
 { 	  
	LogDisplay("等待STB连接!waiting...\r\n");
    memset(sendbuffer,0,sizeof(sendbuffer));
	ReadFileAble=WAITACCEPT;									//文件标识置为“等待连接”
	if(QuerySocketReadble( sockSrv,&ver_len,pfile_buf,&file_len,fpReadIn)<0)
	{
		free(pfile_buf);
		return;
	}
	SOCKET sockConn=accept(sockSrv,(SOCKADDR*)&addrClient,&len);// 接受客户端连接,获取客户端的ip地址
	if(sockConn==INVALID_SOCKET)
	{
	  sprintf(Print_Buf,"accept无效连接!%d \r\n",WSAGetLastError());
	  LogDisplay(Print_Buf);
	  continue;
	}

    ReadFileAble=CONNECTING;									//发送数据期间无法读入文件

    LogDisplay("收到STB连接请求!\r\n");
	sprintf(Print_Buf,"发送升级流版本号:%s \r\n",Ver_Buf);
	LogDisplay(Print_Buf);
	Ver_Buf[ver_len]=ver_len+1;									//在Ver_buf最后填写总的数据长度(包括最后一位)
    if((send_len=send(sockConn,(char*)Ver_Buf,ver_len+1,0))<0)
	{ 
		LogDisplay("版本号发送失败!\r\n");
		closesocket(sockConn);								    //断开连接
		closesocket(sockSrv);
		free(pfile_buf);
		return ;
	} 
	Ver_Buf[ver_len]=0;		                                     //解决发送一次后版本号尾部乱码问题
	LogDisplay("等待STB确认信息...\r\n"); 
    flag=Receive_StbInfo(sockConn);
	if(flag==CLOSED_ID)
	{ 
	   LogDisplay("机顶盒程序版本已经最新\r\n");
	   LogDisplay("释放连接\r\n\r\n");
	   closesocket(sockConn);
	   continue;
	}
	if(flag<0)
	{
	   LogDisplay("接受STB信息失败!\r\n");
	   LogDisplay("释放连接\r\n\r\n");
	   closesocket(sockConn);
	   continue;
	}
    /***************发送文件,接受STB消息*****************/
	flag=0;
    flag=FileSend(pfile_buf,file_len,sockConn);
	if(flag==RESEND_ID)
 	{
		LogDisplay("释放连接\r\n\r\n");
		closesocket(sockConn);
	}
	if(flag==CLOSED_ID)
 	{
		LogDisplay("机顶盒端接收完毕\r\n");
		LogDisplay("释放连接\r\n\r\n");
		closesocket(sockConn);
	}
	if(flag<0)
	{
		LogDisplay("连接错误,释放连接\r\n\r\n");
		closesocket(sockConn);
	}
 }

}