linuxcsocket编程实例

❶ linux下C语言Socket编程问题（高手进）

网络断开如拔掉网线时，系统程序一般是检测不出来的，尤其是广域网上。

建议连接时设置linger属性，如果网络不通，能迅速决断立即返回失败错误。
LINGER oLinger;
oLinger.l_onoff = 1;
oLinger.l_linger = 0;
setsockopt(m_Socket,SOL_SOCKET,SO_LINGER,(char *)&oLinger,sizeof(oLinger));

❷ 设计一个linux c语言，Http协议的服务器，用socket收发消息，简单点，求代码and注释。

OK
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/ip.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <string.h>

int main(int argc,char *argv[])
{
int sockfd,new_socket;
int sock_value;
char buf[] = "hello! China!I Love You\n";

struct sockaddr_in client_;
struct sockaddr_in server_;

int SIZE = sizeof(struct sockaddr_in);

if(argc != 2){
fprintf(stderr,"The two number!\n");
exit(1);
}

if((sock_value = atoi(argv[1])) < 0){
fprintf(stderr,"socket error!\n");
exit(1);
}

if((sockfd = socket(PF_INET,SOCK_STREAM, 0)) == -1){
perror("socket");
exit(1);
}

bzero(&server_,SIZE);

server_.sin_family = PF_INET;
server_.sin_port = htons(sock_value);
server_.sin_addr.s_addr = INADDR_ANY;

if(bind(sockfd,(struct sockaddr *)(&server_),SIZE) == -1){
perror("bind");
exit(1);
}

if(listen(sockfd, 12) == -1){
perror("listen");
exit(1);
}

printf("Waiting ... ...\n");

while(1){
if((new_socket = accept(sockfd,(struct sockaddr *)(&client_),&SIZE)) == -1){
perror("accept");
exit(1);
}

printf("The client IP is %s\n",inet_ntoa(client_.sin_addr));
printf("The socket is %d\n",ntohs(client_.sin_port));

if(write(new_socket,buf,strlen(buf)) == -1){
perror("write");
exit(1);
}

int my;
char mybuf[1024];

if((my = read(new_socket, mybuf,1024)) == -1){
perror("read");
exit(1);
}

mybuf[my] = '\0';
printf("#++++#++++#:%s\n",mybuf);

close(new_socket);

}

close(sockfd);

return 0;
}

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/ip.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>

int main(int argc,char *argv[])
{
int sockfd;
int sock_value;
char buf[1024];
char mybuf[] = "Linux\n";
int read_count;

struct sockaddr_in client_;
struct sockaddr_in server_;

int SIZE = sizeof(struct sockaddr_in);

if(argc != 3){
fprintf(stderr,"The two number!\n");
exit(1);
}

if((sock_value = atoi(argv[2])) < 0){
fprintf(stderr,"socket error!\n");
exit(1);
}

if((sockfd = socket(PF_INET,SOCK_STREAM, 0)) == -1){
perror("socket");
exit(1);
}

bzero(&client_,SIZE);
bzero(&server_,SIZE);

client_.sin_family = PF_INET;
client_.sin_port = htons(52252);
client_.sin_addr.s_addr = INADDR_ANY;

server_.sin_family = PF_INET;
server_.sin_port = htons(sock_value);
server_.sin_addr.s_addr = inet_addr(argv[1]);

if(connect(sockfd,(struct sockaddr *)(&server_),SIZE) == -1){
perror("connect");
exit(1);
}

if((read_count = read(sockfd,buf,1024)) == -1){
perror("read");
exit(1);
}

buf[read_count] = '\0';
printf("#----#----#:%s\n",buf);

if(write(sockfd, mybuf,6) == -1){
perror("write");
exit(1);
}

close(sockfd);

exit(0);

return 0;
}

❸ socket，linux用c语言实现

不难吧，我给你说下流程
客户端
1、创建socket套接子s
2、用s连接到服务端，connect这个函数，成功返回0，错误 -1；
3、可以发送和接收数据，看你是面向连接还是无连接的了，具体的你自己处理
服务端
1、创建socket，比如s
2、绑定端口和本级IP。bind
3、listen。监听端口
4、accept，接受服务端连接，如果成功的话会返回一个新套接字的，比如s1，你可以利用s1和客户端进行通信，接收和发送和客户端的一样

还有需要提醒的是，你使用面向无连接的时候客户端和服务端差不多是一样的工作流程，都和上边服务端工作模式一样

❹ 关于linux环境C语言socket编程基础的问题

你这个服务端的逻辑有问题（当然也可以说是客户端逻辑有问题，这是相对的）。
客户端使用的是长连接，也就是一次连接，多次通话。而服务端则是短连接，一次连接，一次通话，然后就断开了。
想实现你的需求很 简单，把服务端的accept放在while的外面就可以了。
但你这个代码不完整，最后没有关闭句柄的语句，应该把这些内容补充完整。良好的编码习惯，要把打开的文件、句柄，分配的内存等，都关闭、释放掉。不要想着程序结束会自动释放。

❺ 求linux socket网络编程代码

Linux是多任务的操作系统，可在运行在Intel 80386及更高档次的PC机、ARMS、MIPS和PowerPC等多种计算机平台，已成为应用广泛、可靠性高、功能强大的计算机操作系统，Linux具有内核小、效率高、源代码开放等优点，还内含了TCP/IP网络协议，很适合在服务器领域使用，而服务器主要用途之一就是进行网络通信，随着计算机办公自动化处理技术的应用与推广，网络的不断普及，传统的纸张式文件传输方式已经不再适合发展的需要，人们更期待一种便捷、高效、环保、安全的网络传输方式.

协议概述TCP/IP即传输控制协议/网络协议[1]（Transmission Control Protocol/Internet Protocol），是一个由多种协议组成的协议族，他定义了计算机通过网络互相通信及协议族各层次之间通信的规范，图1描述了Linux对IP协议族的实现机制[2]。

Linux支持BSD的套接字和全部的TCP/IP协议，是通过网络协议将其视为一组相连的软件层来实现的，BSD套接字（BSD Socket）由通用的套接字管理软件支持，该软件是INET套接字层，用来管理基于IP的TCP与UDP端口到端口的互联问题，从协议分层来看，IP是网络层协议，TCP是一个可靠的端口到端口的传输层协议，他是利用IP层进行传接报文的，同时也是面向连接的，通过建立一条虚拟电路在不同的网路间传输报文，保证所传输报文的无丢失性和无重复性。用户数据报文协议（User Datagram Protocol，UDP）也是利用IP层传输报文，但他是一个非面向连接的传输层协议，利用IP层传输报文时，当目的方网际协议层收到IP报文后，必须识别出该报文所使用的上层协议（即传输层协议），因此，在IP报头上中，设有一个"协议"域（Protocol）。通过该域的值，即可判明其上层协议类型，传输层与网络层在功能说的最大区别是前者提供进程通信能力，而后者则不能，在进程通信的意义上，网络通信的最终地址不仅仅是主机地址，还包括可以描述进程的某种标识符，为此，TCP/UDP提出了协议端口（Protocol Port）的概念，用于标识通信的进程，例如，Web服务器进程通常使用端口80，在/etc/services文件中有这些注册了的端口地址。

对于TCP传输，传输节点间先要建立连接，然后通过该连接传输已排好序的报文，以保证传输的正确性，IP层中的代码用于实现网际协议，这些代码将IP头增加到传输数据中，同时也把收到的IP报文正确的传送到TCP层或UDP层。TCP是一个面向连接协议，而UDP则是一个非面向连接协议，当一个UDP报文发送出去后，Linux并不知道也不去关心他是否成功地到达了目的的主机，IP层之下，是支持所有Linux网络应用的网络设备层，例如点到点协议（Point to Point Protocol，PPP）和以太网层。网络设备并非总代表物理设备，其中有一些（例如回送设备）则是纯粹的软件设备，网络设备与标准的Linux设备不同，他们不是通过Mknod命令创建的，必须是底层软件找到并进行了初始化之后，这些设备才被创建并可用。因此只有当启动了正确设置的以太网设备驱动程序的内核后，才会有/dev/eth0文件，ARP协议位于IP层和支持地址解析的协议层之间。

网络通信原理所有的网络通信就其实现技术可以分为两种，线路交换和包交换，计算机网络一般采用包交换，TCP使用了包交换通信技术，计算机网络中所传输的数据，全部都以包（Packet）这个单位来发送，包由"报头"和"报文"组成，结构如图2所示，在"报头"中记载有发送主机地址，接收主机地址及与报文内容相关的信息等，在"报文"中记载有需要发送的数据，网络中的每个主机和路由器中都有一个路由寻址表，根据这个路由表，包就可以通过网络传送到相应的目的主机。

网络通信中的一个非常重要的概念就是套接字（Socket）[3，4]，简单地说，套接字就是网络进程的ID，网络通信归根到底是进程的通信，在网络中，每个节点有一个网络地址（即IP地址），两个进程通信时，首先要确定各自所在网络节点的网络地址，但是，网络地址只能确定进程所在的计算机，而一台计算机上可能同时有多个网络进程，还不能确定到底是其中的哪个进程，由此套接字中还要有其他的信息，那就是端口号（Port），在一台计算机中，一个端口一次只能分配给一个进程，即端口号与进程是一一对应的关系，所以，端口号和网络地址就能唯一地确定Internet中的一个网络进程。可以认为：套接字=网络地址+端口号系统调用一个Socket（）得到一个套接字描述符，然后就可以通过他进行网络通信了。

套接字有很多种类，最常用的就有两种；流式套接字和数据报套接字。在Linux中分别称之为"SOCK_STREAM"和"SOCK_DGRAM）"他们分别使用不同的协议，流式套接字使用TCP协议，数据报套接字使用UDP协议，本文所使用的是流式套接字协议。

网络通信原理在文件传输程序设计中的应用网络上的绝大多数通信采用的都是客户机/服务器机制（Client/Server），即服务器提供服务，客户是这些服务的使用者，服务器首先创建一个Socket，然后将该Socket与本地地址/端口号绑定（Bind（）），成功之后就在相应的Socket上监听（Listen（）） 。当Accept（）函数捕捉到一个连接服务（Connect（））请求时，接受并生成一个新的Socket,并通过这个新的Socket与客户端通信，客户端同样也要创建一个Socket，将该Socket与本地地址/端口号绑定，还需要指定服务器端的地址与端口号，随后向服务器端发出Connect（），请求被服务器端接受后，可以通过Socket与服务器端通信。

TCP是一种面向连接的、可靠的、双向的通信数据流，说他可靠，是因为他使用3段握手协议传输数据，并且在传输时采用"重传肯定确认"机制保证数据的正确发送：接收端收到的数据后要发出一个肯定确认，而发送端必须要能接受到这个肯定信号，否则就要将数据重发。在此原理基础之上，设计了基于Linux操作系统下TCP/IP编程实现文件传输的实例。我们采用客户机/服务器模式通信时，通信双方发送/接收数据的工作流程如图3所示。

文件传输就是基于客户机/服务器模型而设计的，客户机和服务器之间利用TCP建立连续，因文件传输是一个交互式会话系统，客户机每次执行文件传输，都需要与服务器建立控制连接和数据连接，其中控制连接负责传输控制信息、利用控制命令、客户机可以向服务器提出无限次的请求，客户机每次提出的请求，服务器与客户机建立一个数据连接，进行实际的数据传输，数据传输完毕后，对应的数据连接被清除，控制连接依然保持，等待客户机发出新的传输请求，直到客户机撤销控制连接，结束会话。

当进行文件传输时，首先向服务器发出连接请求，服务器验证身份后，与客户端建立连接，双方进入会话状态，这时只要客户端向服务器端发出数据连接请求，建立起数据连接后，双方就进入数据传输状态，数据传输完毕后，数据连接被撤销，如此循环反复，直到会话结束，从而实现将文件从服务器端传输至客户机端。

文件传输程序设计流程[5，客户端的TCP应用程序流程（1）先用Socket（）创建本地套接口，给服务器端套接口地址结构赋值。

（2）用Connect（）函数使本地套接口向服务器端套接口发出建立连接请求，经3次握手建立TCP连接。

（3）用Read（）函数读取所要接收的文件名以及存放在内存里的文件内容。

（4）用Open（）函数打开客户端新建立的目标文件，如果没有建立，该函数会自动生成目标文件，等待存放文件内容。

（5）最后用Write（）函数将读取的文件内容存放在新的目标文件中，以实现服务器端向客户端的文件传输。

（6）通信结束，用Close（）关闭套接口，停止接收文件。

服务器端的TCP应用程序流程（1）先用Open（）函数打开等待传输的可读文件；（2）用Socket（）创建套接口，并给套接口地址结构赋值；（3）用Bind（）函数绑定套接口；（4）用Listen（）函数在该套接口上监听请求；（5）用Accept（）函数接受请求，产生新的套接口及描述字，并与客户端连接；（6）用Lseek（）函数是为了在每次接受客户机连接时，将用于读的源文件指针移到文件头；（7）用Read（）函数读取一定长度的源文件数据；（8）最后用Write（）函数将读取的源文件数据存放在内存中，以便客户端读取；（9）传输完毕时，用Close（）关闭所有进程，结束文件传输。

结语Linux操作系统在网络应用方面具有很强的开发潜力，同时Linux也是可靠性、安全性非常高的系统，因此在基于TCP/IP网络通信的研究与开发中，通常选用Linux操作系统作为开发平台

❻ Linux下Socket编程 怎样实现客户端之间互相通信

1. 网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用Socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。

2. 下面用Socket实现一个windows下的c语言socket通信例子，这里我们客户端传递一个字符串，服务器端进行接收。

【服务器端】
#include"stdafx.h"
#include<stdio.h>
#include<winsock2.h>
#include<winsock2.h>
#defineSERVER_PORT5208//侦听端口
voidmain()
{
WORDwVersionRequested;
WSADATAwsaData;
intret,nLeft,length;
SOCKETsListen,sServer;//侦听套接字，连接套接字
structsockaddr_insaServer,saClient;//地址信息
char*ptr;//用于遍历信息的指针
//WinSock初始化
wVersionRequested=MAKEWORD(2,2);//希望使用的WinSockDLL的版本
ret=WSAStartup(wVersionRequested,&wsaData);
if(ret!=0)
{
printf("WSAStartup()failed!
");
return;
}
//创建Socket,使用TCP协议
sListen=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(sListen==INVALID_SOCKET)
{
WSACleanup();
printf("socket()faild!
");
return;
}
//构建本地地址信息
saServer.sin_family=AF_INET;//地址家族
saServer.sin_port=htons(SERVER_PORT);//注意转化为网络字节序
saServer.sin_addr.S_un.S_addr=htonl(INADDR_ANY);//使用INADDR_ANY指示任意地址

//绑定
ret=bind(sListen,(structsockaddr*)&saServer,sizeof(saServer));
if(ret==SOCKET_ERROR)
{
printf("bind()faild!code:%d
",WSAGetLastError());
closesocket(sListen);//关闭套接字
WSACleanup();
return;
}

//侦听连接请求
ret=listen(sListen,5);
if(ret==SOCKET_ERROR)
{
printf("listen()faild!code:%d
",WSAGetLastError());
closesocket(sListen);//关闭套接字
return;
}

printf("Waitingforclientconnecting!
");
printf("Tips:Ctrl+ctoquit!
");
//阻塞等待接受客户端连接
while(1)//循环监听客户端，永远不停止，所以，在本项目中，我们没有心跳包。
{
length=sizeof(saClient);
sServer=accept(sListen,(structsockaddr*)&saClient,&length);
if(sServer==INVALID_SOCKET)
{
printf("accept()faild!code:%d
",WSAGetLastError());
closesocket(sListen);//关闭套接字
WSACleanup();
return;
}
charreceiveMessage[5000];
nLeft=sizeof(receiveMessage);
ptr=(char*)&receiveMessage;
while(nLeft>0)
{
//接收数据
ret=recv(sServer,ptr,5000,0);
if(ret==SOCKET_ERROR)
{
printf("recv()failed!
");
return;
}
if(ret==0)//客户端已经关闭连接
{
printf("Clienthasclosedtheconnection
");
break;
}
nLeft-=ret;
ptr+=ret;
}
printf("receivemessage:%s
",receiveMessage);//打印我们接收到的消息。

}
//closesocket(sListen);
//closesocket(sServer);
//WSACleanup();
}
【客户端】
#include"stdafx.h"
#include<stdio.h>
#include<stdlib.h>
#include<winsock2.h>
#defineSERVER_PORT5208//侦听端口
voidmain()
{
WORDwVersionRequested;
WSADATAwsaData;
intret;
SOCKETsClient;//连接套接字
structsockaddr_insaServer;//地址信息
char*ptr;
BOOLfSuccess=TRUE;
//WinSock初始化
wVersionRequested=MAKEWORD(2,2);//希望使用的WinSockDLL的版本
ret=WSAStartup(wVersionRequested,&wsaData);
if(ret!=0)
{
printf("WSAStartup()failed!
");
return;
}
//确认WinSockDLL支持版本2.2
if(LOBYTE(wsaData.wVersion)!=2||HIBYTE(wsaData.wVersion)!=2)
{
WSACleanup();
printf("InvalidWinSockversion!
");
return;
}
//创建Socket,使用TCP协议
sClient=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(sClient==INVALID_SOCKET)
{
WSACleanup();
printf("socket()failed!
");
return;
}
//构建服务器地址信息
saServer.sin_family=AF_INET;//地址家族
saServer.sin_port=htons(SERVER_PORT);//注意转化为网络节序
saServer.sin_addr.S_un.S_addr=inet_addr("192.168.1.127");
//连接服务器
ret=connect(sClient,(structsockaddr*)&saServer,sizeof(saServer));
if(ret==SOCKET_ERROR)
{
printf("connect()failed!
");
closesocket(sClient);//关闭套接字
WSACleanup();
return;
}


charsendMessage[]="hellothisisclientmessage!";
ret=send(sClient,(char*)&sendMessage,sizeof(sendMessage),0);
if(ret==SOCKET_ERROR)
{
printf("send()failed!
");
}
else
printf("clientinfohasbeensent!");
closesocket(sClient);//关闭套接字
WSACleanup();
}

❼ 在linux下如何用c语言来写一个socket编程的聊天小程序

源码如下：
//chat_one.c

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <malloc.h>
#include <sys/select.h>

int main( int argc, char **argv)
{
struct sockaddr_in chatone, chattwo;
char pmsg[1000];
char *buf;
int chatone_fd;
int ret,i;
int len, msg_len;
fd_set fdset;

if ( argc < 2 ){
printf("please input ip address\n");
return -1;
}

printf("server address is %s\n", argv[1]);

chattwo.sin_family = AF_INET;
chattwo.sin_port = htons(60002);
inet_pton(AF_INET, argv[1], &chattwo.sin_addr.s_addr);

chatone.sin_family = AF_INET;
chatone.sin_port = htons(60000);
chatone.sin_addr.s_addr = INADDR_ANY;

chatone_fd = socket(PF_INET, SOCK_DGRAM, 0);
if ( -1 == chatone_fd ){
printf("create socket failed %s\n", strerror(errno));
return -1;
}

ret = bind(chatone_fd, (struct sockaddr *)&chatone, sizeof(chatone));
if ( -1 == ret){
printf("bind failed %s \n", strerror(errno));
return -1;
}

for(i=0; i<1000;i++){
FD_ZERO( &fdset );
FD_SET ( 0, &fdset);
FD_SET( chatone_fd, &fdset);

if ( -1 == select ( chatone_fd+1, &fdset, NULL, NULL, NULL) ){
continue;
}

if ( FD_ISSET( chatone_fd, &fdset)){
recvfrom( chatone_fd, pmsg, 999, 0, NULL, 0);
printf("receive %s\n", pmsg);
}
else{
memset( pmsg, 0, 1000);
fgets(pmsg, 999, stdin);
len = sizeof(chattwo);
sendto( chatone_fd, pmsg, 1000, 0,\
(struct sockaddr*) &chattwo, len);

printf("send %s\n", pmsg);
}
}

printf("sent %d packets\n", i);

close(chatone_fd);
return 0;
}
//chat_two.c

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <malloc.h>
#include <sys/select.h>

int main( int argc, char **argv)
{
struct sockaddr_in chatone, chattwo;
char pmsg[1000];
char *buf;
int chattwo_fd;
int ret,i;
int len, msg_len;
fd_set fdset;

if ( argc < 2 ){
printf("please input ip address\n");
return -1;
}

printf("server address is %s\n", argv[1]);

chattwo.sin_family = AF_INET;
chattwo.sin_port = htons(60002);
chattwo.sin_addr.s_addr = INADDR_ANY;

chatone.sin_family = AF_INET;
chatone.sin_port = htons(60000);
inet_pton(AF_INET, argv[1], &chatone.sin_addr.s_addr);

chattwo_fd = socket(PF_INET, SOCK_DGRAM, 0);
if ( -1 == chattwo_fd ){
printf("create socket failed %s\n", strerror(errno));
return -1;
}

ret = bind(chattwo_fd, (struct sockaddr *)&chattwo, sizeof(chattwo));
if ( -1 == ret){
printf("bind failed %s \n", strerror(errno));
return -1;
}

for(i=0; i<1000;i++){
FD_ZERO( &fdset );
FD_SET ( 0, &fdset);
FD_SET( chattwo_fd, &fdset);

if ( -1 == select ( chattwo_fd+1, &fdset, NULL, NULL, NULL) ){
continue;
}

if ( FD_ISSET( chattwo_fd, &fdset)){
recvfrom( chattwo_fd, pmsg, 999, 0, NULL, 0);
printf("receive: %s\n", pmsg);
}
else{
memset( pmsg, 0, 1000);
fgets(pmsg, 999, stdin);
len = sizeof(chatone);
sendto( chattwo_fd, pmsg, 1000, 0,\
(struct sockaddr*) &chatone, len);

printf("send %s\n", pmsg);
}
}

printf("sent %d packets\n", i);

close(chattwo_fd);
return 0;
}
编译好这个两个程序就可以进行简单的通信了。

❽ linux下C语言socket编程双机互发数据

这个问题很好办啦，服务器接受一个连接请求，然后开一个线程或者进程都可以，再在线程或者进程里面采用其他技术实现同时收发(比如I/O复用，比如非阻塞I/O)。客户端也可以采用I/O复用。

推荐资料的话，《unix网络编程》这本书很好，公认的经典，当教科书用，这本书里有你想要的所有内容。

ps:你基础太差，多补补吧，别想一下吃个胖子。

另外我这里正好有个例子满足你的要求,贴给你，自己写的，不是网上找的,用的是多进程加I/O复用技术:

server端:
/****************************************************************
**
**
**
****************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <errno.h>
#include <string.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/select.h>
#include <sys/time.h>
#include <unistd.h>

#define BUFLEN 1024
#define MAX(a,b) ((a)>(b)?(a):(b))

typedef void Sigfunc (int);

void str_echo(FILE *,int);
//Sigfunc *signal(int, Sigfunc *);

int main(int argc,char **argv)
{
int connfd,listenfd;
pid_t childpid;
socklen_t clilen;
struct sockaddr_in cliaddr,servaddr;
void sig_chld(int);

listenfd = socket(AF_INET, SOCK_STREAM, 0);

memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(5358);

bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
listen(listenfd,8);

signal(SIGCHLD,sig_chld);

while(1)
{
clilen = sizeof(cliaddr);
if((connfd = accept(listenfd,(struct sockaddr*)&cliaddr,&clilen)) < 0)
{
if(errno == EINTR)
{
fputs("accept error: EINTR\n",stdout);
continue;
}
else
{
fputs("accept error..\n",stdout);
}
}

if((childpid = fork()) == 0)
{
close(listenfd);
str_echo(stdin,connfd);
exit(0);
}
close(connfd);
}
}

void str_echo(FILE *fp,int sockfd)
{
int n = 0;
char sendbuf[BUFLEN] = { 0 },recvbuf[BUFLEN] = { 0 };
int maxfdp;
fd_set rset;

FD_ZERO(&rset);

while(1)
{
FD_SET(fileno(fp),&rset);
FD_SET(sockfd, &rset);
maxfdp = MAX(fileno(fp),sockfd)+1;

select(maxfdp, &rset ,NULL, NULL, NULL);

if(FD_ISSET(sockfd, &rset))
{
if(n = read(sockfd, recvbuf, BUFLEN) == 0)
{
return;
}
if(n == -1)
{
break;
}
printf("%s\n",recvbuf);
memset(recvbuf,0,BUFLEN);
}
if(FD_ISSET(fileno(fp),&rset))
{
scanf("%s",sendbuf);
write(sockfd, sendbuf,strlen(sendbuf));
}
}
}

void sig_chld (int signo)
{
pid_t pid;
int stat;

while ((pid = waitpid(-1,&stat, WNOHANG)) > 0)
{
printf("child %d terminated\n",pid);
}
return;
}

client端:
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>

#define MAX(a,b) (a)>(b)?(a):(b)

int main()
{
int s,connectReturn, maxfd;
fd_set rset;
char sendbuf[1024] = {0};
char recvbuf[1024] = {0};
long port=5358;
s=socket(PF_INET,SOCK_STREAM,0);

struct sockaddr_in sa;
sa.sin_family=AF_INET;
sa.sin_addr.s_addr=inet_addr("127.0.0.1");
sa.sin_port=htons(port);
connectReturn=connect(s,(struct sockaddr *)&sa,sizeof(sa));
printf("%d\n",connectReturn);
FD_ZERO(&rset);
while(1)
{
FD_SET(fileno(stdin), &rset);
FD_SET(s, &rset);
maxfd=MAX(fileno(stdin), s) + 1;

select(maxfd, &rset, NULL, NULL, NULL);
if(FD_ISSET(fileno(stdin), &rset))
{
scanf("%s",sendbuf);
send(s,sendbuf,strlen(sendbuf),0);
bzero(sendbuf, 1024);
}
else if(FD_ISSET(s, &rset))
{
memset(recvbuf,0,1024);
recv(s,recvbuf,1024,0);
printf("remote: %s\n",recvbuf);
}
}
return 0;
}

❾ linux下C语言用socket网络编程怎么计算传输速度

这要你的通信程序协商一个协议，比如定义一个通信结构体，传文件的时候，一开始发送结构体的信息过去，告诉对端你的文件总大小，然后，传输过程中，统计已经收到或者发送的数据，做个除法就得到速率了。

具体这类协商，你可以自己随便想，也可以借鉴现有的比较好的一些设计，有些考虑断点续传的技术，还有压缩的，看你代码也不需要考虑吧。