csocketlinux

‘贰’ 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下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;
}

‘肆’ 要学c语言的socket,先学linux还是linux c还是tcp/ip

先学C吧，socket本身不难，熟悉API后可以深入学习TCP/IP。

‘伍’ 关于linuxC socket的一道题

服务器端代码
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>

#define SERVPORT 7 /*服务器监听端口号 */
#define BACKLOG 10 /* 最大同时连接请求数 */
#define BUFF_SIZE 1024

void main()
{
int sockfd,client_fd; /*sock_fd：监听socket；client_fd：数据传输socket */
struct sockaddr_in6 my_addr; /* 本机地址信息 */
struct sockaddr_in6 remote_addr; /* 客户端地址信息 */
if ((sockfd = socket(AF_INET6, SOCK_STREAM, 0)) == -1)
{
perror("socket创建出错！"); exit(1);
}
bzero(&my_addr, sizeof(my_addr));
my_addr.sin6_family=AF_INET6;
my_addr.sin6_port=htons(SERVPORT);
my_addr.sin6_addr = in6addr_any;
if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr_in6)) == -1)
{
perror("bind出错！");
exit(1);
}
if (listen(sockfd, BACKLOG) == -1) {
perror("listen出错！");
exit(1);
}
while(1) {
int sin_size = sizeof(struct sockaddr_in);
char temp[INET6_ADDRSTRLEN];
if ((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size)) == -1) {
perror("accept出错");
continue;
}
printf("received a connection from %s\n", inet_ntop(AF_INET6, remote_addr.sin6_addr, temp, sizeof(temp)));
if (!fork()) { /* 子进程代码段 */
char buffer[BUFF_SIZE];
int len = recv(client_fd, buffer, BUFF_SIZE, 0);

while(len > 0)
{
if (send(client_fd, buffer, len, 0) == -1)
{
perror("unable to send!");
close(client_fd);
exit(1);
}
len = recv(client_fd, buffer, BUFF_SIZE, 0);
}
close(client_fd);
exit(0);
}
close(client_fd);
}
}

客户端
#include<stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>

#define BUFF_SIZE 1024

void main(int argc, char *argv[])
{
int sockfd, len, recv_len;
char buf[BUFF_SIZE];
struct sockaddr_in6 serv_addr;
if (argc != 3)
{
fprintf(stderr,"Usage: %s dstip dstport\n", argv[0]);
exit(1);
}

if ((sockfd = socket(AF_INET6, SOCK_STREAM, 0)) == -1){
perror("socket 创建出错！");
exit(1);
}

bzero(&serv_addr, sizeof(serv_addr));
serv_addr.sin6_family=AF_INET6;
serv_addr.sin6_port=htons(atoi(argv[2]));
if (inet_pton(AF_INET6, argv[1], &serv_addr.sin6_addr) < 0)
{
perror(argv[1]);
exit(1);
}

if (connect(sockfd, (struct sockaddr *)&serv_addr, \
sizeof(struct sockaddr)) == -1) {
perror("connect出错！");
exit(1);
}

printf("sendmsg> ");
gets(buf);

len = send(sockfd, buf, strlen(buf), 0);
if (len != strlen(buf))
{
perror("failed to send msg!");
exit(1);
}

recv_len = recv(sockfd, buf, len, 0);
if (recv_len != len)
{
perror("received length != send");
exit(1);
}
buf[recv_len] = '\0';
printf("recvmsg> %s\n", buf);
close(sockfd);
}

‘陆’ C语言的Sockets能在Linux和Unix下使用么

用c实现的tcp/ip sockets程序 当然可以在linux下使用,同样也可以在unix下使用.

‘柒’ linux c socket tcp 怎么打开server

socket编程一般是基于tcp或者udp协议来写,所以通过这个可以知道，你分别封装S和C就可以完成，断开连接后，C继续工作。

‘捌’ socket linux c++ send（）函数

给你一个代码,linux下编译运行即可，做了简单的注释，client.c如下：

send()函数在client.c末尾

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

#defineMAXLINE4096//发送接受信息长度
#definePORT6666//端口

intmain(intargc,char**argv)
{
intsockfd,n;
charrecvline[MAXLINE],sendline[MAXLINE];
structsockaddr_inservaddr;

if(argc!=2){
printf("usage:./client<ipaddress>
");//使用方法
exit(0);
}

if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0){//创建套接字，并未连接
printf("createsocketerror:%s(errno:%d)
",strerror(errno),errno);
exit(0);
}
	

//memset(结构体地址，清零，要清零的长度);清零结构体servaddr，将结构体数据全部设置为0
	//同bzero(结构体地址，要清理的长度);默认清零
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family=AF_INET;//sa_family是通信类型，最常用的值是"AF_INET"
servaddr.sin_port=htons(PORT);//端口号
	
	//servaddr.sin_addr.s_addr=inet_addr(argv[1]);//服务器IP,如下功能相同
	if(inet_pton(AF_INET,argv[1],&servaddr.sin_addr)<=0){
printf("inet_ptonerrorfor%s
",argv[1]);
exit(0);
}

//连接服务器
if(connect(sockfd,(structsockaddr*)&servaddr,sizeof(servaddr))<0){
printf("connecterror:%s(errno:%d)
",strerror(errno),errno);
exit(0);
}

printf("sendmsgtoserver:
");
fgets(sendline,MAXLINE,stdin);//输入向服务器发送的信息
	
if(send(sockfd,sendline,strlen(sendline),0)<0)//向服务器发送信息
{
printf("sendmsgerror:%s(errno:%d)
",strerror(errno),errno);
exit(0);
}

close(sockfd);//关闭套接字
exit(0);
}

服务器程序：server.c如下：

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

#defineMAXLINE4096
#definePORT6666

intmain(intargc,char**argv)
{
intlistenfd,connfd;
structsockaddr_inservaddr;
charbuff[MAXLINE];
intn;

if((listenfd=socket(AF_INET,SOCK_STREAM,0))==-1){//创建套接字
printf("createsocketerror:%s(errno:%d)
",strerror(errno),errno);
exit(0);
}

memset(&servaddr,0,sizeof(servaddr));//结构体清零
servaddr.sin_family=AF_INET;//sa_family是通信类型，最常用的值是"AF_INET"
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);//指定接受任何连接
servaddr.sin_port=htons(PORT);//监听端口

	//给套接口绑定地址
if(bind(listenfd,(structsockaddr*)&servaddr,sizeof(servaddr))==-1){
printf("bindsocketerror:%s(errno:%d)
",strerror(errno),errno);
exit(0);
}

if(listen(listenfd,10)==-1){//开始监听，最大请求数为10，可以自己设置
printf("listensocketerror:%s(errno:%d)
",strerror(errno),errno);
exit(0);
}

printf("======waitingforclient'srequest======
");
	
while(1){
	//建立通信，等待客户端connect()函数的连接
if((connfd=accept(listenfd,(structsockaddr*)NULL,NULL))==-1)
	{
printf("acceptsocketerror:%s(errno:%d)",strerror(errno),errno);
continue;
}
n=recv(connfd,buff,MAXLINE,0);//n可以判断错误，此处可直接用recv()函数
	//接收到的信息存放在buff中
buff[n]='';//添加结束符
printf("recvmsgfromclient:%s
",buff);
close(connfd);
}

close(listenfd);
}

‘玖’ socket，linux用c语言实现

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

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

‘拾’ c语言在linux和FreeBSD下Socket编程的区别

详细的我觉得你应该看看APUE的描述，Socket最初是在BSD开发出来的，所以也叫BSD Socket，是UNIX的网络编程方法，所有的类UNIX系统都支持的，不同在于一些函数的实现，或着多一些少一些，但前提是不影响大局。所以在编程是尽量少用其他系统不支持的函数，或做出说明，这样就解决迁移性了。
BSD下开发的，估计到Linux，到Mac只需改函数。