㈠ linux socket 编程
这类问题，你不用考虑太复杂的，可以直接使用socket提供的tcp服务接口，通过send和recv等函数处理就行了。数据建议自行写封装和解封函数，
接口类似这样：int pack(char *, struct data *); int unpack(char *, struct data *);
可以按照你自己的喜好，将你的struct按照你的方式填入一个char*里面（你直接将struct data*类型转换后赋值给char*类型都行），然后就可以使用接口了；
你完全不用管tcp的实现机制的，tcp有拥塞控制，超时重传，自动分包等机制，可以保证你的数据按准确的方式送达；
像什么包的数据头什么的，如果你需要定义的是应用层的协议，或者你希望自定义网络层和传输层（使用raw方式的socket），你才需要考虑；
㈡ 最近刚学linux编程 有个问题想请教大家； 我按照网上socket教程写了个最简单的socket程序，但是怎么运行
服务端的代码写在一个.c文件中 gcc -g -o server.exe 服务端代码文件名
客户端的代码卸载一个.c文件中 gcc -g -o client.exe 客户端代码文件名
开一个终端先把服务端的server.exe启动起来
再开一个终端把客户端的client.exe启动起来
你就能看到结果了
㈢ linux下socket编程，菜鸟求解。。。
你这个东西问题太多啦，老实说，我那过去编都编不过。我改好了，给你指出几个重大错误！
server:
#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<arpa/inet.h>
#include <unistd.h>
#include<fcntl.h>
#include<string.h>
#define IPADDR "127.0.0.1"
#define PORT 21234
const char *logpath = "./log";
int main()
{
struct sockaddr_in servaddr,cliaddr;
int sockfd,clifd,logfd;
socklen_t clilen;
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(PORT);
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
//bzero(&servaddr,sizeof(servaddr));
sockfd=socket(AF_INET,SOCK_STREAM,0);
bind(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr));
listen(sockfd,8);
printf("aaaaaaaaaaaaaaaa\n");
char buf[500] = {0};
for(;;)
{
clilen = sizeof(cliaddr);
clifd=accept(sockfd,(struct sockaddr *)&cliaddr,&clilen);
printf("%d\n",clifd);
if(clifd < 0)
{
printf("cccccccccccccccccccccc\n");
continue;
}
else
{
printf("dddddddddddddddddddddddd\n");
strcpy(buf,"welcome to 127.0.0.1:21234");
send(clifd,buf,strlen(buf),0);
}
close(clifd);
}
close(sockfd);
return 0;
}
client:
#include <stdio.h>
#include <sys/socket.h>
#include <unistd.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#define PORT 43212
#define SERVPORT 21234
#define SERVADDR "127.0.0.1"
int main()
{
int servfd,clifd,connre;
struct sockaddr_in servaddr,cliaddr;
clifd=socket(AF_INET,SOCK_STREAM,0);
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(21234);
servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
//bzero(&servaddr,sizeof(servaddr));
if((connre=connect(clifd,(struct sockaddr *)&servaddr,sizeof(servaddr)))<0)
{
printf("sorry,connect wrong\n");
exit(1);
}
printf("%d\n",connre);
printf("connect ok,waiting for the server's message back\n");
int length;
char buf[500];
while(1)
{
if((length = recv(clifd,buf,500,0))<0)
{
continue;
}
else
{
printf("get it ,get it\n");
break;
}
}
printf("hi,it's the client,I have recieve message :'hello,welcome' from server");
close(clifd);
return 0;
}
/////////////////////////////////
错误1：bzero(&servaddr,sizeof(servaddr)); //刚赋值又清0，why?
错误2：servaddr.sin_port = htons(PORT);//你要连的是serverport
其他的错误懒得说了，自己看吧.累死我了
㈣ Linux下Socket编程 怎样实现客户端之间互相通信
网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用Socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。
下面用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 socket编程代码解析
很简单的一个socket server端和client端通信程序啊！
server端监听端口，client主动连接server端，连接上后client端先将student这样一个结构体数据发送给server端，server端线接受这个结构体数据，然后再向client端发送这个student结构体数据，client端接收。
ok，通信过程完成。
㈥ 学习Linux的步骤是怎样的
对于Linux的学习，可以分为四个阶段，Linux初级入门阶段→Linux中级进阶→Linux高级进阶→Linux资深方向细化阶段
第一阶段：初级阶段
初级阶段需要把linux学习路线搞清楚，任何学习都是循序渐进的，所以学linux也是需要有一定的路线。
1. Linux基础知识、基本命令；
2. Linux用户及权限基础；
3. Linux系统进程管理进阶；
4. linux高效文本、文件处理命令；
5. shell脚本入门
第二阶段:中级进阶
中级进阶需要在充分了解linux原理和基础知识之后，对上层的应用和服务进行深入学习，其中说到服务肯定涉及到网络的相关知识，是需要花时间学习的。
1. TCP/IP网络基础；
2. Linux企业常用服务；
3. Linux企业级安全原理和防范技巧；
4. 加密/解密原理及数据安全、系统服务访问控制及服务安全基础；
5. iptables安全策略构建；
6. shell脚本进阶；
7. MySQL应用原理及管理入门
第三阶段：Linux高级进阶
1. http服务代理缓存加速；
2. 企业级负载集群；
3. 企业级高可用集群；
4. 运维监控zabbix详解；
5. 运维自动化学习；
第四阶段：Linux资深方向细化
1. 大数据方向；
2. 云计算方向；
3. 运维开发；
4. 自动化运维；
5. 运维架构师
以上是Linux的一个学习方向和路线，对于Linux学习是一个需要坚持的过程，也许通过自学或者培训，3至6个月都可以把基本知识学会，但是重在实践，深入的思考和不断的摸索，你会发现Linux更多的美！
㈦ linux socket网络编程怎样收发包
1.send函数
ssize_t send( SOCKET s, const char *buf, size_t len, int flags );
（1）send先比较待发送数据的长度和套接字s的发送缓冲的长度， 如果len大于s的发送缓冲区的长度，该函数返回SOCKET_ERROR；
（2）如果len小于或者等于s的发送缓冲区的长度，那么send先检查协议是否正在发送s的发送缓冲中的数据，如果是就等待协议把数据发送完，如果协议还没有开始发送s的发送缓冲中的数据或者s的发送缓冲中没有数据，那么send就比较s的发送缓冲区的剩余空间和len；
（3）如果len大于剩余空间大小，send就一直等待协议把s的发送缓冲中的数据发送完；
（4）如果len小于剩余空间大小，send就仅仅把buf中的数据到剩余空间里（注意并不是send把s的发送缓冲中的数据传到连接的另一端的，而是协议传送的，send仅仅是把buf中的数据到s的发送缓冲区的剩余空间里）。
注意：
（1）如果send函数数据成功，就返回实际的字节数，如果send在数据时出现错误，那么send就返回SOCKET_ERROR；如果send在等待协议传送数据时网络断开的话，那么send函数也返回SOCKET_ERROR。
（2）要注意send函数把buf中的数据成功到s的发送缓冲的剩余空间里后它就返回了，但是此时这些数据并不一定马上被传到连接的另一端。如果协议在后续的传送过程中出现网络错误的话，那么下一个Socket函数就会返回SOCKET_ERROR。（每一个除send外的Socket函数在执行的最开始总要先等待套接字的发送缓冲中的数据被协议传送完毕才能继续，如果在等待时出现网络错误，那么该Socket函数就返回 SOCKET_ERROR）
（3）在Unix系统下，如果send在等待协议传送数据时网络断开的话，调用send的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。
2.recv函数
ssize_t recv(int s, char *buf, size_t len, int flags);
（1）recv先等待s的发送缓冲中的数据被协议传送完毕，如果协议在传送s的发送缓冲
中的数据时出现网络错误，那么recv函数返回SOCKET_ERROR。
（2）如果s的发送缓冲中没有数据或者数据被协议成功发送完毕后，recv先检查套接字s的接收缓冲区，如果s接收缓冲区中没有数据或者协议正在接收数 据，那么recv就一直等待，直到协议把数据接收完毕。当协议把数据接收完毕，recv函数就把s的接收缓冲中的数据到buf中。（注意：协议接收到的数据可能大于buf的长度，所以 在这种情况下要调用几次recv函数才能把s的接收缓冲中的数据完。recv函数仅仅是数据，真正的接收数据是协议来完成的）
（3）recv函数返回其实际的字节数。如果recv在时出错，那么它返回SOCKET_ERROR；如果recv函数在等待协议接收数据时网络中断了，那么它返回0。
注意：在Unix系统下，如果recv函数在等待协议接收数据时网络断开了，那么调用recv的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。
Q&A：
（1）两次send一次recv会发生什么？
一次性读取两次send的内容。
（2）recv之后，接收缓冲区会被清空吗？
是的。
㈧ linux socket 编程
去查一下select系统调用。
select的read set那个参数，可以包含一个socket和一个pipe（Linux下叫做fifo，你信号用的是fifo传递吗？），反正两个在LInux下都是“文件描述符”，同时select函数可以在最后一个参数设置超时。
这样可以么？
㈨ Linux操作系统下Socket编程地址结构介绍
linux下的网络通信程序，一定要和一个结构打交道，这个结构就是socket
address。比如bind、connect等等函数都要使用socket
address结构。理解socket
address时我们要明白，其实在linux下针对于不同的socket
domain定义了一个通用的地址结构struct
sockaddr,它的具体定义为：
{unsigned
short
int
sa_family;char
sa_data[14];}
struct
sockaddr
其中，sa_family为调用socket()函数时的参数domain参数，sa_data为14个字符长度存储。针对于不同domain下的socket，通用地址结构又对应了不同的定义，例如一般的AF_INET
domain下，socket
address的定义如下：
struct
sockaddr_in{unsigned
short
int
sin_family;uint16_t
sin_port;struct
in_addr
sin_addr;unsigned
char
sin_zero[8];//未使用}struct
in_addr{uint32_t
s_addr;}
当socket的domain不同于AF_INET时，具体的地址定义又是不同的，但是整个地址结构的大小、容量都是和通用地址结构一致的。
㈩ linux socket是什么意思
socket接口是TCP/IP网络的API，socket接口定义了许多函数或例程，程序员可以用它们来开发TCP/IP网络上的应用程序。要学Internet上的TCP/IP网络编程，必须理解socket接口。
socket接口设计者最先是将接口放在Unix操作系统里面的。如果了解Unix系统的输入和输出的话，就很容易了解socket了。网络的 socket数据传输是一种特殊的I/O，socket也是一种文件描述符。socket也具有一个类似于打开文件的函数调用socket()，该函数返回一个整型的socket描述符，随后的连接建立、数据传输等操作都是通过该socket实现的。常用的socket类型有两种：流式socket （SOCK_STREAM）和数据报式socket（SOCK_DGRAM）。流式是一种面向连接的socket，针对于面向连接的TCP服务应用；数据报式socket是一种无连接的socket，对应于无连接的UDP服务应用。
socket建立
为了建立socket，程序可以调用socket函数，该函数返回一个类似于文件描述符的句柄。socket函数原型为：
int socket(int domain, int type, int protocol); domain指明所使用的协议族，通常为PF_INET，表示互联网协议族（TCP/IP协议族）；type参数指定socket的类型： SOCK_STREAM 或SOCK_DGRAM，socket接口还定义了原始socket（SOCK_RAW），允许程序使用低层协议；protocol通常赋值 "0"。 socket()调用返回一个整型socket描述符，你可以在后面的调用使用它。
socket描述符是一个指向内部数据结构的指针，它指向描述符表入口。调用socket函数时，socket执行体将建立一个socket，实际上 "建立一个socket"意味着为一个socket数据结构分配存储空间。socket执行体为你管理描述符表。 两个网络程序之间的一个网络连接包括五种信息：通信协议、本地协议地址、本地主机端口、远端主机地址和远端协议端口。socket数据结构中包含这五种信息。
socket配置
通过socket调用返回一个socket描述符后，在使用socket进行网络传输以前，必须配置该socket。面向连接的socket客户端通过调用connect函数在socket数据结构中保存本地和远端信息。无连接socket的客户端和服务端以及面向连接socket的服务端通过调用 bind函数来配置本地信息。
bind函数将socket与本机上的一个端口相关联，随后你就可以在该端口监听服务请求。bind函数原型为：
int bind(int sockfd,struct sockaddr*my_addr, int addrlen); Sockfd是调用socket函数返回的socket描述符,my_addr是一个指向包含有本机IP地址及端口号等信息的sockaddr类型的指针；addrlen常被设置为sizeof(struct sockaddr)。
struct sockaddr结构类型是用来保存socket信息的：
struct sockaddr {
unsigned short sa_family; /*地址族，AF_xxx*/ char sa_data[14]; /*14字节的协议地址*/ };
sa_family一般为AF_INET，代表Internet（TCP/IP）地址族；sa_data则包含该socket的IP地址和端口号。 另外还有一种结构类型： struct sockaddr_in {
short int sin_family; /*地址族*/
unsigned short int sin_port; /*端口号*/ struct in_addr sin_addr; /*IP地址*/
unsigned char sin_zero[8];/*填0保持与sockaddr同样大小*/ };
这个结构更方便使用。sin_zero用来将sockaddr_in结构填充到与struct sockaddr同样的长度，可以用bzero()或memset()函数将其置为零。指向
sockaddr_in 的指针和指向sockaddr的指针可以相互转换，这意味着如果一个函数所需参数类型是sockaddr时，你可以在函数调用的时候将一个指向 sockaddr_in的指针转换为指向sockaddr的指针；或者相反。 使用bind函数时，可以用下面的赋值实现自动获得本机IP地址和随机获取一个没有被占用的端口号：
my_addr.sin_port=0; /* 系统随机选择一个未被使用的端口号*/ my_addr.sin_addr.s_addr=INADDR_ANY; /* 填入本机IP地址*/
通过将my_addr.sin_port置为0，函数会自动为你选择一个未占用的端口来使用。同样，通过将my_addr.sin_addr.s_addr置为INADDR_ANY，系统会自动填入本机IP地址。
注意在使用bind函数是需要将sin_port和sin_addr转换成为网络字节优先顺序；而sin_addr则不需要转换。
计算机数据存储有两种字节优先顺序：高位字节优先和低位字节优先。Internet上数据以高位字节优先顺序在网络上传输，所以对于在内部是以低位字节优先方式存储数据的机器，在Internet上传输数据时就需要进行转换，否则就会出现数据不一致。
htonl()：把32位值从主机字节序转换成网络字节序 htons()：把16位值从主机字节序转换成网络字节序 ntohl()：把32位值从网络字节序转换成主机字节序 ntohs()：把16位值从网络字节序转换成主机字节序
bind()函数在成功被调用时返回0；出现错误时返回 "-1"并将errno置为相应的错误号。需要注意的是，在调用bind函数时一般不要将端口号置为小于1024的值，因为1到1024是保留端口号，你可以选择大于1024中的任何一个没有被占用的端口号。
连接建立
面向连接的客户程序使用connect函数来配置socket并与远端服务器建立一个TCP连接，其函数原型为：
int connect(int sockfd, struct sockaddr*serv_addr,int addrlen); Sockfd 是socket函数返回的socket描述符；serv_addr是包含远端主机IP地址和端口号的指针；addrlen是远端地质结构的长度。 connect函数在出现错误时返回-1，并且设置errno为相应的错误码。
进行客户端程序设计无须调用bind()，因为这种情况下只需知道目的机器的IP地址，而客户通过哪个端口与服务器建立连接并不需要关心，socket执行体为你的程序自动选择一个未被占用的端口，并通知你的程序数据什么时候到达端口。
connect函数启动和远端主机的直接连接。只有面向连接的客户程序使用socket时才需要将此socket与远端主机相连。无连接协议从不建立直接连接。面向连接的服务器也从不启动一个连接，它只是被动的在协议端口监听客户的请求。
listen函数使socket处于被动的监听模式，并为该socket建立一个输入数据队列，将到达的服务请求保存在此队列中，直到程序处理它们。 int listen(int sockfd， int backlog);
Sockfd 是socket系统调用返回的socket 描述符；backlog指定在请求队列中允许的最大请求数，进入的连接请求将在队列中等待accept()它们（参考下文）。Backlog对队列中等待服务的请求的数目进行了限制，大多数系统缺省值为20。如果一个服务请求到来时，输入队列已满，该socket将拒绝连接请求，客户将收到一个出错信息。
当出现错误时listen函数返回-1，并置相应的errno错误码。
accept()函数让服务器接收客户的连接请求。在建立好输入队列后，服务器就调用accept函数，然后睡眠并等待客户的连接请求。 int accept(int sockfd, void*addr, int*addrlen);
sockfd是被监听的socket描述符，addr通常是一个指向sockaddr_in变量的指针，该变量用来存放提出连接请求服务的主机的信息（某台主机从某个端口发出该请求）；addrten通常为一个指向值为sizeof(struct sockaddr_in)的整型指针变量。出现错误时accept函数返回-1并置相应的errno值。 首先，当accept函数监视的 socket收到连接请求时，socket执行体将建立一个新的socket，执行体将这个新socket和请求连接进程的地址联系起来，收到服务请求的初始socket仍可以继续在以前的 socket上监听，同时可以在新的socket描述符上进行数据传输操作。 数据传输
send()和recv()这两个函数用于面向连接的socket上进行数据传输。 int send(int sockfd, const void*msg, int len, int flags);
Sockfd是你想用来传输数据的socket描述符；msg是一个指向要发送数据的指针；Len是以字节为单位的数据的长度；flags一般情况下置为0（关于该参数的用法可参照man手册）。
send()函数返回实际上发送出的字节数，可能会少于你希望发送的数据。在程序中应该将send()的返回值与欲发送的字节数进行比较。当send()返回值与len不匹配时，应该对这种情况进行处理。
int recv(int sockfd,void*buf,int len,unsigned int flags);