linux下socket编程（在Linux系统下编写一个socket程序）

本文目录

• 在Linux系统下编写一个socket程序
• linux下的socket编程在哪进行
• linux 下的socket编程怎样保证并发的稳定性，需要什么机制或者工具
• Linux下C语言socket编程
• 求linux下的socket 编程
• 关于Linux下socket编程的问题
• linux下的 socket编程问题！
• Linux操作系统下Socket编程地址结构介绍

在Linux系统下编写一个socket程序

我给你一个更高端的
#include 《stdlib.h》
#include 《sys/types.h》
#include 《stdio.h》
#include 《sys/socket.h》
#include 《linux/in.h》
#include 《string.h》
#define M 8888

struct qun
{
int cy;
};

struct haoyou
{
int py;
};

struct rizhi
{
int geren;
};

int main()
{
struct qun group={0};
struct haoyou pyd={0};
struct rizhi ziji={0};

printf(“server onil\n“);
printf(“this port is %d\n“,M);

fd_set rest;
int servsock=socket(AF_INET,SOCK_STREAM,0);

if(-1==servsock)
{
perror(“socket perror“);
return 1;
}

struct sockaddr_in servaddr;
struct sockaddr_in clienaddr;

servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
servaddr.sin_port=htons(M);

int a=bind(servsock,(struct sockaddr *)&servaddr,sizeof(servaddr));
if(-1==a)

{
perror(“bind perror\n“);
return 1;
}

int b=listen(servsock,5);
if(-1==b)

{
perror(“listen perror“);
return 1;
}

FD_ZERO(&rest);
char sendbuff;
char recvbuff;
int n;
int qw;
int r;
int min={0};
int i=0;
int iWho={0};
int mabi={0};
char mingzi={0};
char caonima={0};
int wocao={0};
n=sizeof(clienaddr);
struct timeval time;
while(1)
{
time.tv_sec = 0;
time.tv_usec = 470;
FD_SET(servsock,&rest);
FD_SET(fileno(stdin),&rest);
select(servsock+1,&rest,NULL,NULL,&time);
if(FD_ISSET(servsock,&rest))
{
r[i]=accept(servsock,(struct sockaddr *)&clienaddr,&n);
if(r[i]==-1)
{
i--;
}
i++;
}
int p;
for(p=0;p《i;p++)
{
FD_SET(r[p],&rest);
}
int ret=select(r[i-1]+1,&rest,NULL,NULL,&time);
if(ret《0)
{
printf(“socket error\n“);
continue;
}
else
{
int u;
for(u=0;u《i;u++

linux下的socket编程在哪进行

LINUX下的SOCKET编程？应该所有语言都有相应的SOCKET编程接口。
C/C++、JAVA，python，RUBY，PERL，甚至是SCEME。
只不过，其他几种都是跨平台的，不算是单独的LINUX下SOCKET编程。一般C语言和C++才这么说。因为LINUX下的接口和WINDOWS不一样。
想知道接口有哪些的话，你得查手册或是看《UNIX环境高级编程》这类书，书上会有LINUX/UNIX的C编程接口。
编译环境的话，只要是C语言编译器，LINUX支持的主要是GCC，LINUX下的开发环境IDE也默认都用GCC了，比如CODEBLOCKS、GEANY什么的。按下编译、运行按钮就行了，和WINDOWS下开发的步骤差不多，只是接口不一样。
如果要用命令行的话，也不难，代码写好了，gcc 一下就可以编译了。不过，看你的水平，算了吧……要么安心学一下LINUX下编程，要么老实地用IDE。

问这种问题，让人很难回答的……在哪进行，当然在LINUX下，在LINUX的C语言代码文件里，什么编译环境？C语言的编译环境……什么编译工具，C语言的编译工具，比如GCC。

linux 下的socket编程怎样保证并发的稳定性，需要什么机制或者工具

如果客户端并发连接数不是很大，比如50个以下，可以用如下模型： 建立一个监听主线程，循环监听端口。 当有客户端连接时，建立客户端通讯线程，并保留客户端socket到链表中。 当客户端断开连接时，从socket链表中删除该socket。

Linux下C语言socket编程

socket编程一般是基于tcp或者udp协议来写的，你的问题很抽象，我不知道你要的是基于tcp还是udp的socket编译。我把相对难的基于tcp协议的socket编译给你吧。你想看懂我的代码需要知道tcp的三次握手机制。否则我写了注释，你看代码也有点困难。 ////服务端的代码
1 #include 《stdio.h》
2 #include 《string.h》
3 #include 《sys/socket.h》
4 #include 《unistd.h》
5 #include 《netinet/in.h》
6 #include 《sys/stat.h》
7 #include 《stdlib.h》
8 #include 《arpa/inet.h》
9
10 #define LOCAL_PORT 1234
11 #define MAX_LEN 512
12 #define MAX_NUM 5
13
14 int main(int argc, char *argv)
15 {
16 int sock_fd, sock_data;
17 int ret, len_addr;
18 char buf[MAX_LEN];
19 ssize_t len;
20 struct sockaddr_in local_addr, remote_addr;
21
22 sock_fd = socket(AF_INET, SOCK_STREAM, 0); //创建套接字，sock_fd是套接字描述符，类似我们的身份证号码
23 if (sock_fd 《 0)
24 {
25 perror(“socket()“);
26 return sock_fd;
27 }
28
29 local_addr.sin_family = AF_INET;// 协议族，ipv4
30 local_addr.sin_port = htons(LOCAL_PORT);// 把服务器端口转换成网络字节序
31 local_addr.sin_addr.s_addr = inet_addr(“127.0.0.1“);//把字符串形式的ip转换成网络字节序
32
33 ret = bind(sock_fd, (struct sockaddr *)&local_addr, (size_t)sizeof(local_addr));// 把sock_fd和本机ip，端口邦定
34 if (ret 《 0)
35 {
36 perror(“bind()“);
37 close(sock_fd);
38 return ret;
39 }
40
41 ret = listen(sock_fd, MAX_NUM);//监听socket
42 if (ret)
43 {
44 perror(“listen()“);
45 close(sock_fd);
46 return ret;
47 }
48
49 memset(buf, 0, MAX_LEN);
50
51 len_addr = sizeof(remote_addr);
52
53 sock_data = accept(sock_fd, (struct sockaddr *)&remote_addr, (socklen_t *)&len_addr);//接受客户端的连接
54 if (ret 《 0)
55 {
56 perror(“accept()“);
57 close(sock_fd);
58 return ret;
59 }
60
61 while (1)
62 {
63 int slen;
64 len = recv(sock_data, buf, MAX_LEN, 0);//接受客户端的数据
65 if (len 《 0)
66 {
67 perror(“recv()“);
68 close(sock_data);
69 close(sock_fd);
70 return len;
71 }
72 printf(“%s\n“, buf);
73
74 slen = send(sock_data, “congratulation!“, 15, 0);//向客户端发送数据
75 if (slen 《= 0)
76 {
77 printf(“slen = %d\n“, slen);
78 perror(“send()“);
79 close(sock_data);
80 close(sock_fd);
81 return slen;
82 }
83 sleep(1);
84 }
85
86 close(sock_data);
87 close(sock_fd);
88
89 return 0;
90 }
////////////客户端的代码 1 #include 《stdio.h》
2 #include 《string.h》
3 #include 《sys/socket.h》
4 #include 《unistd.h》
5 #include 《netinet/in.h》
6 #include 《sys/stat.h》
7 #include 《stdlib.h》
8 #include 《arpa/inet.h》
9
10 #define REMOTE_PORT 1234
11 #define MAX_LEN 512
12
13 int main(int argc, char *argv)
14 {
15 int sock_fd, ret;
16 int len;
17 char buf[MAX_LEN];
18 struct sockaddr_in local_addr, remote_addr;
19
20 sock_fd = socket(AF_INET, SOCK_STREAM, 0);
21 if (sock_fd 《 0)
22 {
23 perror(“socket()“);
24 return sock_fd;
25 }
26
28 local_addr.sin_family = AF_INET;
29 local_addr.sin_addr.s_addr = htonl(INADDR_ANY); //自动获取本机的ip地址
30 local_addr.sin_port = htons(0); //随机选取可用的端口，并不是指定端口为0
31
33 remote_addr.sin_family= AF_INET;
34 remote_addr.sin_port = htons(REMOTE_PORT);
35 ret = inet_aton(“127.0.0.1“, &remote_addr.sin_addr);
36
38 ret = bind(sock_fd, (struct sockaddr *)&local_addr, sizeof(local_addr)); //把本机的ip,port和socket绑定
39 if (ret 《 0)
40 {
41 perror(“bind() !“);
42 close(sock_fd);
43 return ret;
44 }
45
47 ret = connect(sock_fd, (struct sockaddr *)&remote_addr, (socklen_t)sizeof(remote_addr)); //把本机的socket和对方的port，ip建立连接
48 if (ret 《 0)
49 {
50 perror(“connect()“);
51 close(sock_fd);
52 return ret;
53 }
54
55 memset(buf, 0, MAX_LEN);
56
57 while (1)
58 {
59 int i;
60 // len = send(sock_fd, buf, (size_t)MAX_LEN, 0);
61 len = send(sock_fd, “hello“, 6, 0);
62 if (len 《= 0)
63 {
64 perror(“send()“);
65 close(sock_fd);
66 return ret;
67 }
68
69 // printf(“%d--》bytes send!\n“, len);
70 sleep(1);
71
72 len = recv(sock_fd, buf, MAX_LEN, 0);
73 if (len 《= 0)
74 {
75 perror(“recv()“);
76 close(sock_fd);
77 return ret;
78 }
79
80 for (i = 0; i 《 len; i++)
81 {
82 printf(“%c“, buf[i]);
83 }
84 printf(“\n“);
85 }
86
87 close(sock_fd);
88
89 return 0;
90 }
你把服务端和客户端这两个程序分别保存为server.c和client.c。然后编译gcc server.c -o server，gcc client .c -o client。运行时先运行服务端，用命令./server，再运行客户端，用命令./client。 注意运行命令是“点 斜杠”，“点”表示当前目录。

求linux下的socket 编程

看这个代码你最好了解一下tcp协议，了解一下三次握手机制，要不然你可能看不懂，当初我们学到这的时候学了一天的tcp....还有，就是把下面代码分开放到2个.c文件中，必须先运行服务器端，再运行客户端
//服务器端的代码
1 #include 《stdio.h》
2 #include 《string.h》
3 #include 《sys/socket.h》
4 #include 《unistd.h》
5 #include 《netinet/in.h》
6 #include 《sys/stat.h》
7 #include 《stdlib.h》
8 #include 《arpa/inet.h》
9
10 #define LOCAL_PORT 1234
11 #define MAX_LEN 512
12 #define MAX_NUM 5
13
14 int main(int argc, char *argv)
15 {
16 int sock_fd, sock_data;
17 int ret, len_addr;
18 char buf[MAX_LEN];
19 ssize_t len;
20 struct sockaddr_in local_addr, remote_addr;
21
22 sock_fd = socket(AF_INET, SOCK_STREAM, 0); //创建套接字，sock_fd是套接字描述符，类似我们的身份证号码
23 if (sock_fd 《 0)
24 {
25 perror(“socket()“);
26 return sock_fd;
27 }
28
29 local_addr.sin_family = AF_INET;// 协议族，ipv4
30 local_addr.sin_port = htons(LOCAL_PORT);// 把服务器端口转换成网络字节序
31 local_addr.sin_addr.s_addr = inet_addr(“127.0.0.1“);//把字符串形式的ip转换成网络字节序
32
33 ret = bind(sock_fd, (struct sockaddr *)&local_addr, (size_t)sizeof(local_addr));// 把sock_fd和本机ip，端口邦定
34 if (ret 《 0)
35 {
36 perror(“bind()“);
37 close(sock_fd);
38 return ret;
39 }
40
41 ret = listen(sock_fd, MAX_NUM);//监听socket
42 if (ret)
43 {
44 perror(“listen()“);
45 close(sock_fd);
46 return ret;
47 }
48
49 memset(buf, 0, MAX_LEN);
50
51 len_addr = sizeof(remote_addr);
52
53 sock_data = accept(sock_fd, (struct sockaddr *)&remote_addr, (socklen_t *)&len_addr);//接受客户端的连接
54 if (ret 《 0)
55 {
56 perror(“accept()“);
57 close(sock_fd);
58 return ret;
59 }
60
61 while (1)
62 {
63 int slen;
64 len = recv(sock_data, buf, MAX_LEN, 0);//接受客户端的数据
65 if (len 《 0)
66 {
67 perror(“recv()“);
68 close(sock_data);
69 close(sock_fd);
70 return len;
71 }
72 printf(“%s\n“, buf);
73
74 slen = send(sock_data, “congratulation!“, 15, 0);//向客户端发送数据
75 if (slen 《= 0)
76 {
77 printf(“slen = %d\n“, slen);
78 perror(“send()“);
79 close(sock_data);
80 close(sock_fd);
81 return slen;
82 }
83 sleep(1);
84 }
85
86 close(sock_data);
87 close(sock_fd);
88
89 return 0; }

//客户端代码
1 #include 《stdio.h》
2 #include 《string.h》
3 #include 《sys/socket.h》
4 #include 《unistd.h》
5 #include 《netinet/in.h》
6 #include 《sys/stat.h》
7 #include 《stdlib.h》
8 #include 《arpa/inet.h》
9
10 #define REMOTE_PORT 1234
11 #define MAX_LEN 512
12
13 int main(int argc, char *argv)
14 {
15 int sock_fd, ret;
16 int len;
17 char buf[MAX_LEN];
18 struct sockaddr_in local_addr, remote_addr;
19
20 sock_fd = socket(AF_INET, SOCK_STREAM, 0);
21 if (sock_fd 《 0)
22 {
23 perror(“socket()“);
24 return sock_fd;
25 }
26
28 local_addr.sin_family = AF_INET;
29 local_addr.sin_addr.s_addr = htonl(INADDR_ANY); //自动获取本机的ip地址
30 local_addr.sin_port = htons(0); //随机选取可用的端口，并不是指定端口为0
31
33 remote_addr.sin_family= AF_INET;
34 remote_addr.sin_port = htons(REMOTE_PORT);
35 ret = inet_aton(“127.0.0.1“, &remote_addr.sin_addr);
36
38 ret = bind(sock_fd, (struct sockaddr *)&local_addr, sizeof(local_addr)); //把本机的ip,port和socket绑定
39 if (ret 《 0)
40 {
41 perror(“bind() !“);
42 close(sock_fd);
43 return ret;
44 }
45
47 ret = connect(sock_fd, (struct sockaddr *)&remote_addr, (socklen_t)sizeof(remote_addr)); //把本机的socket和对方的port，ip建立连接
48 if (ret 《 0)
49 {
50 perror(“connect()“);
51 close(sock_fd);
52 return ret;
53 }
54
55 memset(buf, 0, MAX_LEN);
56
57 while (1)
58 {
59 int i;
60 // len = send(sock_fd, buf, (size_t)MAX_LEN, 0);
61 len = send(sock_fd, “hello“, 6, 0);
62 if (len 《= 0)
63 {
64 perror(“send()“);
65 close(sock_fd);
66 return ret;
67 }
68
69 // printf(“%d--》bytes send!\n“, len);
70 sleep(1);
71
72 len = recv(sock_fd, buf, MAX_LEN, 0);
73 if (len 《= 0)
74 {
75 perror(“recv()“);
76 close(sock_fd);
77 return ret;
78 }
79
80 for (i = 0; i 《 len; i++)
81 {
82 printf(“%c“, buf[i]);
83 }
84 printf(“\n“);
85 }
86
87 close(sock_fd);
88
89 return 0;
90 }

关于Linux下socket编程的问题

recv 函数,不能保证接受到所有你需要的数据包
因此要反复调用recv函数. 并查看函数的返回值
比如,你需要接受5000字节
datalen=0
while datalen《5000
ret=recv(...)
datalen+=ret
....

因为recv这样的特性，所以你并不能保证每次recv收到的数据包是一个完整的， 它可能包含了服务器一次发送数据包的一部分，也可能包括了服务器先后几次发送的几个数据包。因此，你必须自己设计传输协议，能够明确的分辨服务器发送过来的每个数据包（比如每个数据包都有一个明显的结尾，或者数据包头加上数据包的长度）

linux下的 socket编程问题！

第一个问题:

对，是那样的，用open打开文件，用read读取文件，在发送给对方，接收方接收到后，写入文件就可以了。不过在这个过程中最好别用字符串函数，除非你很熟悉。

第二个问题

首先你得去搞清楚什么是线程，什么是进程，fork出来的叫进程，pthread_create出来的才叫线程。服务器有很多种模型(多进程，多线程，select,epoll模型,这个我的blog上有,famdestiny.cublog.cn)，不一定要用多进程。

给你写了个代码，自己先看看:

注意，在自己的目录下创建一个叫pserverb的文件，程序会把这个文件复制成test文件。你可以自己根据需要改改

server:

#include 《stdio.h》
#include 《sys/socket.h》
#include 《netinet/in.h》
#include 《errno.h》
#include 《signal.h》
#include 《sys/wait.h》
#include 《sys/types.h》
#include 《string.h》
#include 《stdlib.h》
#include 《sys/stat.h》
#include 《fcntl.h》
#include 《unistd.h》

#define SERV_PORT 5358
#define MAX_CONN 10
#define BUF_LEN 1024

void str_echo(FILE *fp, int sockfd){
ssize_t nread;
int file_fd;
char buf[BUF_LEN] = {0};

file_fd = open(“test“, O_WRONLY | O_TRUNC | O_CREAT, 0755);
while(1) {
bzero(buf, BUF_LEN);
if((nread = read(sockfd, buf, BUF_LEN)) == -1) {
if(errno == EINTR) {
continue;
}
else {
printf(“readn error: %s\n“, strerror(errno));
continue;
}
}
else if (nread == 0) {
break;
}
else {
printf(“%s\n“, buf);
write(file_fd, buf, nread);
}
}
close(file_fd);
}

void sig_chld(int sig){
pid_t pid;
int state;
while((pid = waitpid(-1, &state, WNOHANG)) 》 0){
printf(“child process %d exited.“, pid);
}
return;
}

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

if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
printf(“socket error: %s\n“, strerror(errno));
return 0;
}

bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
if(bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1){
printf(“bind error: %s\n“, strerror(errno));
return 0;
}

if(listen(listenfd, MAX_CONN) == -1){
printf(“listen error: %s\n“, strerror(errno));
return 0;
}

signal(SIGCHLD, sig_chld);

while(1){
cliaddrlen = sizeof(cliaddr);
if((connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddrlen)) == -1){
if(errno == EINTR){
continue;
}
else{
printf(“accept error: %s\n“, strerror(errno));
continue;
}
}

if((childpid = fork()) == 0){
close(listenfd);
str_echo(stdin, connfd);
exit(0);
}
else if(childpid 》 0){
close(connfd);
}
else{
printf(“fork error!\n“);
continue;
}
}
}

client:

#include 《stdio.h》
#include 《unistd.h》
#include 《errno.h》
#include 《sys/socket.h》
#include 《netinet/in.h》
#include 《arpa/inet.h》
#include 《string.h》
#include 《sys/stat.h》
#include 《fcntl.h》
#include 《stdlib.h》

#define SERV_ADDR “127.0.0.1“
#define SERV_PORT 5358
#define BUF_LEN 1024

void str_cli(char *path, int sockfd)
{
char sendbuf[BUF_LEN] = {0};
int fd, n;

if((fd = open(“./pserverb“, O_RDONLY)) == -1){
printf(“%s\n“, strerror(errno));
exit(0);
}
while((n = read(fd, sendbuf, BUF_LEN)) != 0) {
if(n 《 0){
printf(“%s\n“, strerror(errno));
exit(0);
}
write(sockfd, sendbuf, n);
bzero(sendbuf, BUF_LEN);
}
close(fd);
return;
}

int main(int argc, char **argv)
{
int fd;
struct sockaddr_in servaddr;

fd = socket(AF_INET, SOCK_STREAM, 0);

bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = inet_addr(SERV_ADDR);
servaddr.sin_port = htons(SERV_PORT);

if (connect(fd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
printf(“connect error: %s\n“, strerror(errno));
return 0;
}

str_cli(argv, fd);
return 0;
}

Linux操作系统下Socket编程地址结构介绍

linux下的网络通信程序，一定要和一个结构打交道，这个结构就是socket
address。比如bind、connect等等函数都要使用socket
address结构。理解socket
address时我们要明白，其实在linux下针对于不同的socket
domain定义了一个通用的地址结构struct
sockaddr,它的具体定义为：
{unsigned
short
int
sa_family;char
sa_data;}
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;//未使用}struct
in_addr{uint32_t
s_addr;}
当socket的domain不同于AF_INET时，具体的地址定义又是不同的，但是整个地址结构的大小、容量都是和通用地址结构一致的。