©2020-2024 ioDraw All rights reserved
我们来试验一下socket发送和接受数据
一共有三个文件：mysocket.h、socketServer.c、socketClient.c
过程：
1.将这三个文件准备好，放到一个目录下
2.执行 gcc socketServer.c -o server.out
3.执行 gcc socketClient.c -o client.out
4.在一个终端窗口执行：./server.out，可以看到当前进程处于等待状态
5.再打开另一个终端窗口执行：./client.out 1
6.观察两个窗口的输出
下面是三个文件的源代码，在IDE里面报红不用管，按上面的过程去执行就好。
mysocket.h：
#include <string.h> #include <errno.h> #include <sys/types.h> #include
<sys/socket.h> #include <stdarg.h> #include <stdlib.h> #define MAXLINE 4096
ssize_t/* Read "n" bytes from a descriptor. */ readn(int fd, void *vptr, size_t
n) { size_t nleft; ssize_t nread; char *ptr; ptr = vptr; nleft = n; while (nleft
> 0) { if ( (nread = read(fd, ptr, nleft)) < 0) { if (errno == EINTR) nread = 0;
/* and call read() again */ else return(-1); } else if (nread == 0) break; /*
EOF */ nleft -= nread; ptr += nread; } return n - nleft; /* return >= 0 */ }
ssize_t/* Write "n" bytes to a descriptor. */ writen(int fd, const void *vptr,
size_t n) { size_t nleft; ssize_t nwritten; const char *ptr; ptr = vptr; nleft =
n; while (nleft > 0) { if ( (nwritten = write(fd, ptr, nleft)) <= 0) { if (
nwritten< 0 && errno == EINTR) nwritten = 0; /* and call write() again */ else
return(-1); /* error */ } nleft -= nwritten; ptr += nwritten; } return n; }
static void err_doit(int, int, const char *, va_list); /* * Nonfatal error
related to a system call. * Print a message and return. */ void err_ret(const
char *fmt, ...) { va_list ap; va_start(ap, fmt); err_doit(1, errno, fmt, ap);
va_end(ap); } /* * Fatal error related to a system call. * Print a message and
terminate. */ void err_sys(const char *fmt, ...) { va_list ap; va_start(ap, fmt)
; err_doit(1, errno, fmt, ap); va_end(ap); exit(1); } /* * Fatal error
unrelated to a system call. * Error code passed as explict parameter. * Print a
message and terminate. */ void err_exit(int error, const char *fmt, ...) {
va_list ap; va_start(ap, fmt); err_doit(1, error, fmt, ap); va_end(ap); exit(1);
} /* * Fatal error related to a system call. * Print a message, dump core, and
terminate. */ void err_dump(const char *fmt, ...) { va_list ap; va_start(ap, fmt
); err_doit(1, errno, fmt, ap); va_end(ap); abort(); /* dump core and terminate
*/ exit(1); /* shouldn't get here */ } /* * Nonfatal error unrelated to a
system call. * Print a message and return. */ void err_msg(const char *fmt, ...)
{ va_list ap; va_start(ap, fmt); err_doit(0, 0, fmt, ap); va_end(ap); } /* *
Fatal error unrelated to a system call. * Print a message and terminate. */ void
err_quit(const char *fmt, ...) { va_list ap; va_start(ap, fmt); err_doit(0, 0,
fmt, ap); va_end(ap); exit(1); } /* * Print a message and return to caller. *
Caller specifies "errnoflag". */ static void err_doit(int errnoflag, int error,
const char *fmt, va_list ap) { char buf[MAXLINE]; vsnprintf(buf, MAXLINE, fmt,
ap); if (errnoflag) snprintf(buf+strlen(buf), MAXLINE-strlen(buf), ": %s",
strerror(error)); strcat(buf, "\n"); fflush(stdout); /* in case stdout and
stderr are the same */ fputs(buf, stderr); fflush(NULL); /* flushes all stdio
output streams */ }
socketServer.h:
#include<stdio.h> #include<stdlib.h> #include<string.h> #include<netinet/in.h>
#include<sys/socket.h> #include<sys/wait.h> #include "mysocket.h" void read_data
(int sockfd){ ssize_t n; char buf[1024]; int time = 0; while(1){ fprintf(stdout,
"block in read\n"); if((n = readn(sockfd, buf,1024)) == 0){ return; } time++;
fprintf(stdout, "1K read for %d \n", time); usleep(10000); } } int main(int argc
, char **argv){ int listenfd, connfd; socklen_t clilen; struct sockaddr_in
cliaddr, servaddr; // 创建 socket 套接字，bind 到对应地址和端口，并开始调用 listen 接口监听 listenfd =
socket(AF_INET, SOCK_STREAM, 0); if(listenfd == -1){ perror("socket"); exit(1);
} bzero(&servaddr, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.
sin_addr.s_addr = htonl(INADDR_ANY); servaddr.sin_port = htons(12345); /* bind
到本地地址，端口号为12345 */ if(bind(listenfd, (const struct sockaddr *) &servaddr, sizeof
(servaddr))){ perror("bind"); exit(1); } /* listen的backlog 为 1024 */ if(listen(
listenfd, 1024)){ perror("listen"); exit(1); } // 循环等待连接，通过 accept
获取实际的连接，并开始读取数据 while(1){ clilen = sizeof(cliaddr); connfd = accept(listenfd, (
struct sockaddr *) &cliaddr, &clilen); if(connfd == -1){ perror("accept"); exit(
1); } // 实际每次读取 1K 数据，之后休眠 1 秒，用来模拟服务器端处理时延 read_data(connfd); close(connfd); }
}
socketClient.c:
#include<stdio.h> #include<string.h> #include<netinet/in.h> #include
<sys/socket.h> #include<sys/wait.h> #include <arpa/inet.h> #include "mysocket.h"
//# define MESSAGE_SIZE 10240000 # define MESSAGE_SIZE 1024000 //
改小这个参数，同时Server的睡眠时间加长，可以看到send into
buffer很快打印出来了，而Server端还在打印，因为此时，发送的数据已经到发送端的发送缓冲区了，发送端send函数结束了 void send_data(
FILE*fp, int sockfd) { char * query; query = malloc(MESSAGE_SIZE+1); for(int i=0
; i< MESSAGE_SIZE; i++){ query[i] = 'a'; } query[MESSAGE_SIZE] = '\0'; const
char *cp; cp = query; int remaining = strlen(query); //while循环这个例子中没用，一次就发完了
while (remaining) { int n_written = send(sockfd, cp, remaining, 0); fprintf(
stdout, "send into buffer %ld \n", n_written); if (n_written <= 0) { perror(
"send"); return; } remaining -= n_written; printf("remaining: %d", remaining);
cp+= n_written; } return; } int main(int argc, char **argv){ int sockfd; struct
sockaddr_in servaddr; if(argc != 2){ err_quit("usage: tcpclient <IPaddress>"); }
sockfd= socket(AF_INET, SOCK_STREAM, 0); if(sockfd == -1){ perror("socket"); }
bzero(&servaddr, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.
sin_port= htons(12345); inet_pton(AF_INET, argv[1], &servaddr.sin_addr); if(
connect(sockfd, (const struct sockaddr *) &servaddr, sizeof(servaddr)) == -1){
perror("connect"); } send_data(stdin, sockfd); exit(0); }