[文章信息] 作者:张晓明 杨建华 钱名海时间:2003-06-28出处:PCVC责任编辑:方舟 [文章导读] 在Windows 95环境下，基于TCP/IP协议，用Winsock完成了话音的一端—端传输
摘要：在Windows 95环境下，基于TCP/IP协议，用Winsock完成了话音的端到端传输。采用双套接字技术，阐述了主要函数的使用要点，以及基于异步选择机制的应用方法。同时，给出了相应的实例程序。
一、引言
Windows 95作为微机的 *** 作系统，已经完全融入了网络与通信功能，不仅可以建立纯Windows 95环境下的“对等网络”，而且支持多种协议，如TCP/IP、IPX/SPX、NETBUI等。在TCP/IP协议组中，TPC是一种面向连接的协义，为用户提供可靠的、全双工的字节流服务，具有确认、流控制、多路复用和同步等功能，适于数据传输。UDP协议则是无连接的，每个分组都携带完整的目的地址，各分组在系统中独立传送。它不能保证分组的先后顺序，不进行分组出错的恢复与重传，因此不保证传输的可靠性，但是，它提供高传输效率的数据报服务，适于实时的语音、图像传输、广播消息等网络传输。
Winsock接口为进程间通信提供了一种新的手段，它不但能用于同一机器中的进程之间通信，而且支持网络通信功能。随着Windows 95的推出。Winsock已经被正式集成到了Windows系统中，同时包括了16位和32位的编扮巧程接口。而Winsock的开发工具也可以在Borland C++4.0、Visual C++2.0这些C编译器中找到，主要由一个名为winsock.h的头文件和动态连接库winsock.dll或wsodk32.dll组成，这两种动态连接库分别用于Win16和Win32的应用程序。
本文针对话音的全双工传输要求，采用UDP协议实现了实时网络通信。使用VisualC++2.0编译环境，其动态连接库名为wsock32.dll。
二、主要函数的使用要点
通过建立双套接字，可以很方搏缺敬便地实现全双工网络通信。
1.套接字建立函数：
SOCKET socket(int family,int type,int protocol)
对于UDP协议，写为：
SOCKRET s
s=socket(AF_INET,SOCK_DGRAM,0)
或s=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP)
为了建立两个套接字，必须实现地址的重复绑定，即，当一个套接字已经绑定到某本地地址后，为了让另一个套接字重复使用该地址，必须为调用bind()函数绑定第二个套接字之前，通过函数setsockopt()为该套接字设置SO_REUSEADDR套接字选项。通过函数getsockopt()可获得套接字选项设置状态。需要注意的是，两个套接字所对应的端口号不能相同。 此外，还涉及到套接字缓冲区的设置问题，按规定，每个区的设置范围是：不小于512个字节，大大于8k字节，根据需要，文中选用了4k字节。
2.套接字绑定函数
int bind(SOCKET s,struct sockaddr_in*name,int namelen)
s是刚才创建好的套接字，name指向描述通讯对象的结构体的指针，namelen是该结构体的长度。该结构体中的分量包括：IP地址(对应name.sin_addr.s_addr)、端口号(name.sin_port)、地址类型(name.sin_family，一般都赋成AF_INET，表示是internet地址)。
(1)IP地址的填写方法：在全双工通信中，要把用户名对应的点分表示法地基慎址转换成32位长整数格式的IP地址，使用inet_addr()函数。
(2)端口号是用于表示同一台计算机不同的进程(应用程序)，其分配方法有两种：1)进程可以让系统为套接字自动分配一端口号，只要在调用bind前将端口号指定为0即可。由系统自动分配的端口号位于1024~5000之间，而1~1023之间的任一TCP或UDP端口都是保留的，系统不允许任一进程使用保留端口，除非其有效用户ID是零(超级用户)。
2)进程可为套接字指定一特定端口。这对于需要给套接字分配一众所端口的服务器是很有用的。指定范围为1024和65536之间。可任意指定。
在本程序中，对两个套接字的端口号规定为2000和2001，前者对应发送套接字，后者对应接收套接字。
端口号要从一个16位无符号数(u_short类型数)从主机字节顺序转换成网络字节顺序，使用htons()函数。
根据以上两个函数，可以给出双套接字建立与绑定的程序片断。
//设置有关的全局变量
SOCKET sr,ss
HPSTR sockBufferS,sockBufferR
HANDLE hSendData,hReceiveData
DWROD dwDataSize=1024*4
struct sockaddr_in therel.there2
#DEFINE LOCAL_HOST_ADDR 200.200.200.201
#DEFINE REMOTE_HOST-ADDR 200.200.200.202
#DEFINE LOCAL_HOST_PORT 2000
#DEFINE LOCAL_HOST_PORT 2001
//套接字建立函数
BOOL make_skt(HWND hwnd)
{
struct sockaddr_in here,here1
ss=socket(AF_INET,SOCK_DGRAM,0)
sr=socket(AF_INET,SOCK_DGRAM,0)
if((ss==INVALID_SOCKET)||(sr==INVALID_SOCKET))
{
MessageBox(hwnd,“套接字建立失败!”，“”,MB_OK)
return(FALSE)
}
here.sin_family=AF_INET
here.sin_addr.s_addr=inet_addr(LOCAL_HOST_ADDR)
here.sin_port=htons(LICAL_HOST_PORT)
//another socket
herel.sin_family=AF_INET
herel.sin_addr.s_addr(LOCAL_HOST_ADDR)
herel.sin_port=htons(LOCAL_HOST_PORT1)
SocketBuffer()//套接字缓冲区的锁定设置
setsockopt(ss,SOL_SOCKET,SO_SNDBUF,(char FAR*)sockBufferS,dwDataSize)
if(bind(ss,(LPSOCKADDR)&here,sizeof(here)))
{
MessageBox(hwnd,“发送套接字绑定失败!”，“”，MB_OK)
return(FALSE)
}
setsockopt(sr SQL_SOCKET,SO_RCVBUF|SO_REUSEADDR,(char FAR*)
sockBufferR,dwDataSize)
if(bind(sr,(LPSOCKADDR)&here1,sizeof(here1)))
{
MessageBox(hwnd,“接收套接字绑定失败!”，“”，MB_OK)
return(FALSE)
}
return(TRUE)
}
//套接字缓冲区设置
void sockBuffer(void)
{
hSendData=GlobalAlloc(GMEM_MOVEABLE|GMEM_SHARE,dwDataSize)
if(!hSendData)
{
MessageBox(hwnd,“发送套接字缓冲区定位失败!”，NULL,
MB_OK|MB_ICONEXCLAMATION)
return
}
if((sockBufferS=GlobalLock(hSendData)==NULL)
{
MessageBox(hwnd,“发送套接字缓冲区锁定失败!”，NULL,
MB_OK|MB_ICONEXCLAMATION)
GlobalFree(hRecordData[0]
return
}
hReceiveData=globalAlloc(GMEM_MOVEABLE|GMEM_SHARE,dwDataSize)
if(!hReceiveData)
{
MessageBox(hwnd,"“接收套接字缓冲区定位败!”，NULL
MB_OK|MB_ICONEXCLAMATION)
return
}
if((sockBufferT=Globallock(hReceiveData))=NULL)
MessageBox(hwnd,"发送套接字缓冲区锁定失败!”，NULL,
MB_OK|MB_ICONEXCLAMATION)
GlobalFree(hRecordData[0])
return
}
{
3.数据发送与接收函数；
int sendto(SOCKET s.char*buf,int len,int flags,struct sockaddr_in to,int
tolen)
int recvfrom(SOCKET s.char*buf,int len,int flags,struct sockaddr_in
fron,int*fromlen)
其中，参数flags一般取0。
recvfrom()函数实际上是读取sendto()函数发过来的一个数据包，当读到的数据字节少于规定接收的数目时，就把数据全部接收，并返回实际接收到的字节数；当读到的数据多于规定值时，在数据报文方式下，多余的数据将被丢弃。而在流方式下，剩余的数据由下recvfrom()读出。为了发送和接收数据，必须建立数据发送缓冲区和数据接收缓冲区。规定：IP层的一个数据报最大不超过64K(含数据报头)。当缓冲区设置得过多、过大时，常因内存不够而导致套接字建立失败。在减小缓冲区后，该错误消失。经过实验，文中选用了4K字节。
此外，还应注意这两个函数中最后参数的写法，给sendto()的最后参数是一个整数值，而recvfrom()的则是指向一整数值的指针。
4.套接字关闭函数：closesocket(SOCKET s)
通讯结束时，应关闭指定的套接字，以释与之相关的资源。
在关闭套接字时，应先对锁定的各种缓冲区加以释放。其程序片断为：
void CloseSocket(void)
{
GlobalUnlock(hSendData)
GlobalFree(hSenddata)
GlobalUnlock(hReceiveData)
GlobalFree(hReceiveDava)
if(WSAAysncSelect(ss,hwnd,0,0)=SOCKET_ERROR)
{
MessageBos(hwnd,“发送套接字关闭失败!”，“”，MB_OK)
return
}
if(WSAAysncSelect(sr,hwnd,0,0)==SOCKET_ERROR)
{
MessageBox(hwnd,“接收套接字关闭失败!”，“”，MB_OK)
return
}
WSACleanup()
closesockent(ss)
closesockent(sr)
return
}
三、Winsock的编程特点与异步选择机制
1 阻塞及其处理方式
在网络通讯中，由于网络拥挤或一次发送的数据量过大等原因，经常会发生交换的数据在短时间内不能传送完，收发数据的函数因此不能返回，这种现象叫做阻塞。Winsock对有可能阻塞的函数提供了两种处理方式：阻塞和非阻塞方式。在阻塞方式下，收发数据的函数在被调用后一直要到传送完毕或者出错才能返回。在阻塞期间，被阻的函数不会断调用系统函数GetMessage()来保持消息循环的正常进行。对于非阻塞方式，函数被调用后立即返回，当传送完成后由Winsock给程序发一个事先约定好的消息。
在编程时，应尽量使用非阻塞方式。因为在阻塞方式下，用户可能会长时间的等待过程中试图关闭程序，因为消息循环还在起作用，所以程序的窗口可能被关闭，这样当函数从Winsock的动态连接库中返回时，主程序已经从内存中删除，这显然是极其危险的。
2 异步选择函数WSAAsyncSelect()的使用
Winsock通过WSAAsyncSelect()自动地设置套接字处于非阻塞方式。使用WindowsSockets实现Windows网络程序设计的关键就是它提供了对网络事件基于消息的异步存取，用于注册应用程序感兴趣的网络事件。它请求Windows Sockets DLL在检测到套接字上发生的网络事件时，向窗口发送一个消息。对UDP协议，这些网络事件主要为：
FD_READ 期望在套接字收到数据(即读准备好)时接收通知；
FD_WRITE 期望在套接字可发送数(即写准备好)时接收通知；
FD_CLOSE 期望在套接字关闭时接电通知
消息变量wParam指示发生网络事件的套接字，变量1Param的低字节描述发生的网络事件，高字包含错误码。如在窗口函数的消息循环中均加一个分支：
int ok=sizeof(SOCKADDR)
case wMsg
switch(1Param)
{
case FD_READ:
//套接字上读数据
if(recvfrom(sr.lpPlayData[j],dwDataSize,0,(struct sockaddr FAR*)&there1,
(int FAR*)&ok)==SOCKET_ERROR0
{
MessageBox)hwnd,“数据接收失败!”，“”，MB_OK)
return(FALSE)
}
case FD_WRITE:
//套接字上写数据
}
break；
在程序的编制中，应根据需要灵活地将WSAAsyncSelect()函灵敏放在相应的消息循环之中，其它说明可参见文献[1]。此外，应该指出的是，以上程序片断中的消息框主要是为程序调试方便而设置的，而在正式产品中不再出现。同时，按照程序容错误设计，应建立一个专门的容错处理函数。程序中可能出现的各种错误都将由该函数进行处理，依据错误的危害程度不同，建立几种不同的处理措施。这样，才能保证双方通话的顺利和可靠。
四、结论
本文是多媒体网络传输项目的重要内容之一，目前，结合硬件全双工语音卡等设备，已经成功地实现了话音的全双工的通信。有关整个多媒体传输系统设计的内容，将有另文叙述。
客户端···
#include <stdio.h>
#include <string.h>
#include <errno.h>衡枯帆
#include <stdlib.h>咐雹
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define DEST_PORT 6020
#define DSET_IP_ADDRESS "192.168.1.92"
int main()
{
/* socket锟侥硷拷锟斤拷锟斤拷锟斤拷 */
int sock_fd
/* udp socket */
sock_fd = socket(AF_INET, SOCK_DGRAM, 0)
if(sock_fd <0)
{
perror("socket")
exit(1)
}
/* 锟斤拷锟斤拷address */
struct sockaddr_in addr_serv
int len
memset(&addr_serv, 0, sizeof(addr_serv))
addr_serv.sin_family = AF_INET
addr_serv.sin_addr.s_addr = inet_addr(DSET_IP_ADDRESS)
addr_serv.sin_port = htons(DEST_PORT)
len = sizeof(addr_serv)
int send_num
int recv_num
char send_buf[100]={0}
send_buf[0]=0x23
send_buf[1]=0x23
send_buf[2]=0x23
send_buf[3]=0x23
败罩 send_buf[4]=0x4a
send_buf[5]=0
send_buf[6]=0
send_buf[7]=0
send_buf[8]=0x4a
send_buf[9]=0
send_buf[10]=0
send_buf[11]=0
send_buf[12]=0x01
send_buf[13]=0
send_buf[14]=0
send_buf[15]=0
send_buf[16]=0xFF
send_buf[17]=0xCC
send_buf[18]=0x0B
send_buf[19]=0x01
uint8_t mycheck
int i=0
// char recv_buf[20]
while(1){
send_buf[65]=0x01
for(i=0i<71i++)
{
mycheck ^= send_buf[i]
}
send_buf[71]= mycheck
send_buf[72]=0xEE
send_buf[73]=0xDD
//printf("client send: %s\n", send_buf)
sleep(1)
send_num = sendto(sock_fd, send_buf, 74, 0, (struct sockaddr *)&addr_serv, len)
if(send_num <0)
{
perror("sendto error:")
exit(1)
}
/* recv_num = recvfrom(sock_fd, recv_buf, sizeof(recv_buf), 0, (struct sockaddr *)&addr_serv, (socklen_t *)&len)
if(recv_num <0)
{
perror("recvfrom error:")
exit(1)
}
recv_buf[recv_num] = '\0'
printf("client receive %d bytes: %s\n", recv_num, recv_buf)
}
close(sock_fd)
return 0
*/
}}
···
服务器端
...
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#define SERV_PORT 6020
int main()
{
/* sock_fd --- socket文件描述符 创建udp套接字*/
int sock_fd = socket(AF_INET, SOCK_DGRAM, 0)
if(sock_fd <0)
{
perror("socket")
exit(1)
}
/* 将套接字和IP、端口绑定 */
struct sockaddr_in addr_serv
int len
memset(&addr_serv, 0, sizeof(struct sockaddr_in)) //每个字节都用0填充
addr_serv.sin_family = AF_INET //使用IPV4地址
addr_serv.sin_port = htons(SERV_PORT) //端口
/* INADDR_ANY表示不管是哪个网卡接收到数据，只要目的端口是SERV_PORT，就会被该应用程序接收到 */
addr_serv.sin_addr.s_addr = htonl(INADDR_ANY) //自动获取IP地址
len = sizeof(addr_serv)
/* 绑定socket */
if(bind(sock_fd, (struct sockaddr *)&addr_serv, sizeof(addr_serv)) <0)
{
perror("bind error:")
exit(1)
}
int recv_num
int send_num
char send_buf[20] = "i am server!"
char recv_buf[100]
struct sockaddr_in addr_client
while(1)
{
printf("server wait:\n")
recv_num = recvfrom(sock_fd, recv_buf, sizeof(recv_buf), 0, (struct sockaddr *)&addr_client, (socklen_t *)&len)
if(recv_num <0)
{
perror("recvfrom error:")
exit(1)
}
recv_buf[recv_num] = '\0'
printf("server receive %d bytes: %s\n", recv_num, recv_buf)
send_num = sendto(sock_fd, send_buf, recv_num, 0, (struct sockaddr *)&addr_client, len)
if(send_num <0)
{
perror("sendto error:")
exit(1)
}
}
close(sock_fd)
return 0
}
...
执行客户端、服务端命令即可：
前段时间，我们在 这篇文章 中谈到了多进程和进程之间的通信方式，主要谈到了本地进程之间使用队列（Queue）进程通信，如果我们要通信的衫滑圆进程不在同一台主机上，我们就无法使用队列进行通信了，这时就需要使用 Socket（套接字）。Socket 是应用层和传输层之间的一层抽象协议，可以用来进行进程间通信，一般有 UDP 和 TCP 两种通信方式，前者速度稍快，稳定性不好，无法丢包重传。后者速度稍慢一点，但稳定性很好，可以丢包重传。
本文首先介绍使用 Socket 进行 UDP 通信。
使用 Socket 进行 UDP 通信的流程如下：
下面依次进行讲解。
要进行 Socket 通信，我们需要使用 socket 模块，首先需要创建一个 Socket 对象。下面是两种创建方式：
如果我们需要向别的主机发送数据，我们需要改主机的 IP 地址和相应的端口号。在使用 Socket 进行通信时，需要将两个信息写在一元组中，元组的第一项为目标主机 IP 地址，第或塌二项为接受数据的端口号：
其中，IP 地址使用字符串类型，端口号使用数字类型。
如果不绑定端口，每次使用 Socket 时都会由 *** 作系统动态分配一个端口，我们也可以绑定为某个固定的端口。这样做的好处是：如果我们想要接受其他主机的信息，其他主机可以直接向这个端口发送数据，如果使用动态端口的话，发送方并不知道目标端口是什么，因此无法向接收方发送数据。
绑定端口需要使用 Socket 对象的 bind 方法：
bind 方法接受一个元组作为参数，元组的第一项为绑定的 IP 地址，第二项为绑定的端口号。我们可以把第一项指定为本机上的任意一个 IP 地址，也可以设置为一个空字符串 "" ，表示本机上任意合法的 IP 地址。
使用 UDP 套接字协议时，发送数据使用 Socket 对象的 sendto 方法，接受数据使用 Socket 对象的 recvfrom 方法。这两个方法的使用方式如下：
sendto 方法接受两个参数：发送的数据和目标主机的 IP 和端口元组，在 Python3 中，发送的数据应该转为 byte 类型发送，Python2 中可以直接发送字符串。
recvfrom 接受一个参数：本次接受的最大数据尺寸。该方法是阻塞的，只有在接收到数据后才能进行后续的 *** 作。
就像使用文件那样，在使用完套接字后，需要关闭它，调用 close 方法即可。
上面我们介绍了 Socket 的使用方式，下面我们来做一个单工通信的例子（一方负责发送信息，一方负责接收信息）。
我们这里来创建两个文件：用以发送信息的 send.py 和用以接收信息的 recv.py。该实例在虚拟机中模拟（注意将虚拟机设置为桥接模式）。
创建 send.py：
创建 recv.py：
运行结果如下：
上面实现了一个单工通信的例子：一方负责发，一方负责接收。下面我们继续实现一个双工通信的例子，使双方都能够收发消息。
由于接收和发送消息时是使用 while 循环不断轮询的，因此要实现同时发送和接受，我们需要进行多任务处理。
新建一个 msg.py：
这里我们使用 3000 端口发送数据，3001 端口接收数据，运行程序时只需填写目标主机的 IP 地址，就可以进行通信。
运行效果：
我们还可以进行局域网内的广播，只需对 Socket 加上一条设置：
同时，发送广播需要一个广播地址，以及目标主机接受广播的端口：
上面的设置只能给 0 网段的主机发送广播，要想给局域网中让肆所有的主机发送广播，可以这样设置：
下面我们新建一个 send.py 用来发送广播：
新建一个 recv.py 用来接收广播：
运行效果如图：
完。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）