网络编程学习笔记(使用select函数的TCP和UDP回射服务器程序)

最新推荐文章于 2024-08-31 10:09:26 发布

kgduu

最新推荐文章于 2024-08-31 10:09:26 发布

阅读量1.1k

点赞数

分类专栏：网络编程学习笔记基础常识

本文链接：https://blog.csdn.net/xiexingshishu/article/details/39756171

版权

基础常识同时被 2 个专栏收录

339 篇文章 4 订阅

订阅专栏

网络编程学习笔记

51 篇文章 30 订阅

订阅专栏

一开始，创建完TCP后，没有用listen监听。启动服务器后，再启动TCP客户端，前几次总是打印readline error:success。后面就恢复正常了

服务器端：

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

#define SER_PORT 9999
#define BUFLEN 128
#define max(a, b) ((a) < (b) ? (b):(a))


void str_echo(int);

void signal_chld(int signo)
{
	pid_t pid;
	int status;

	while ((pid = waitpid(-1, &status, WNOHANG)) < 0) {
		printf("child pid:%d terminated\n", pid);
	}

	return;
}

ssize_t readline(int fd, void *ptr, int maxsize)
{
    char *p = ptr;
    char c;
    int rc;
    int n;
    
    for (n = 1; n < maxsize; n++) {
    again:
        if ((rc = read(fd, &c, 1)) == 1) {
              *p++ = c;
              if (c == '\n') break; 
        } else if (rc == 0) {
                    if (n == 1) return 0;
                       else break;
                       }else {
            if (errno == EINTR) goto again;
            else return -1;
        }
    }
    
    *p = 0;
    return n;
}


ssize_t readn(int fd, void *ptr, size_t n)
{
    char *p = ptr;
    int nleft = n;
    int nread;
    
    while (nleft > 0) {
          if ((nread = read(fd, p, nleft)) < 0) {
                if (errno == EINTR) nread = 0;
                else return -1;
          } else if (nread == 0) break;
          nleft -= nread;
          p += nread;
    }
    
    return n - nleft;
}

ssize_t writen(int fd, void *ptr, size_t n)
{
    size_t nwriten;
    size_t nleft = n;
    char *p = ptr;
    
    while (nleft > 0) {
          if ((nwriten = write(fd, p, nleft)) <= 0) {
                if (errno == EINTR) nwriten = 0;
                else return -1;
          }
          
          nleft -= nwriten;
          p += nwriten;
    }
    
    return n;
}

int main(int argc, char **argv)
{
	struct sockaddr_in servaddr, clientaddr;
	int listenfd, connfd, udpfd;
	int on = 1;
	pid_t child;
	fd_set rset;
	int maxfd, nready;
	int len;
	int n;
	char recvline[BUFLEN];
	
	memset(&servaddr, 0x00, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(SER_PORT);
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

	listenfd = socket(AF_INET, SOCK_STREAM, 0);
	if (listenfd < 0) {
		printf("socket error:%s\n", strerror(errno));
		return -1;
	}
	
	if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) {
		printf("setsockopt error:%s\n", strerror(errno));
		close(listenfd);
		return -1;
	}

	if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr))) {
		printf("bind error:%s\n", strerror(errno));
		close(listenfd);
		return -1;
	}
	
	if (listen(listenfd, 100) < 0) {
		printf("listen error:%s\n", strerror(errno));
		close(listenfd);
		return -1;
	}

	
	udpfd = socket(AF_INET, SOCK_DGRAM, 0);	
	if (udpfd < 0) {
		printf("socket error:%s\n", strerror(errno));
		close(listenfd);	
		return -1;
	}
	
	memset(&servaddr, 0x00, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(SER_PORT);	
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);	
	if (bind(udpfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0) {
		printf("bind updfd error:%s\n", strerror(errno));
		close(listenfd);	
		close(udpfd);	
		return -1;
	}	
	
	
	signal(SIGCHLD, signal_chld);
	
	maxfd = max(listenfd, udpfd) + 1;

	FD_ZERO(&rset);	
	for (;;) {
		FD_SET(listenfd, &rset);	
		FD_SET(udpfd, &rset);	
		nready = select(maxfd, &rset, NULL, NULL, NULL);
		if (nready <= 0) {
			if (errno == EINTR) continue;
			else {
				printf("select error:%s\n", strerror(errno));
				break;
			}
		}		

		if (FD_ISSET(udpfd, &rset)) {
			len = sizeof(clientaddr);
			n = recvfrom(udpfd, recvline, BUFLEN, 0, (struct sockaddr*)&clientaddr, &len);
			
			recvline[n] = 0;
			printf("recvline=%s\n", recvline);
			sendto(udpfd, recvline, strlen(recvline), 0, (struct sockaddr*)&clientaddr, len);			
		}
			
		if (FD_ISSET(listenfd, &rset)) {
			connfd = accept(listenfd, (struct sockaddr*)&clientaddr, &len);
			if ((child = fork()) == 0) {
				close(listenfd);
				str_echo(connfd);
				exit(0);
			} 

			close(connfd);
		}
		
		
			
	}	


	
}

void str_echo(int fd)
{
	int n;
	char recvline[BUFLEN];
	
	for (;;) {
		 n = readline(fd, recvline, BUFLEN);
		//printf("n=%d\n", n);
		if (n ==  0) return;
		if (n > 0)writen(fd, recvline, n);
	}

TCP客户端代码：

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>

#define SIN_PORT 9999
#define BUF_LEN 256
#define max(a, b) ((a) > (b) ? (a) : (b))

size_t readline(int fd, void *ptr, int maxsize)
{
    char *p = ptr;
    char c;
    int rc;
    int n;
    
    for (n = 1; n < maxsize; n++) {
    again:
        if ((rc = read(fd, &c, 1)) == 1) {
              *p++ = c;
              if (c == '\n') break; 
        } else if (rc == 0) {
                    if (n == 1) return 0;
                       else break;
                       }else {
            if (errno == EINTR) goto again;
            else return -1;
        }
    }
    
    *p = 0;
    return n;
}


size_t readn(int fd, void *ptr, size_t n)
{
    char *p = ptr;
    int nleft = n;
    int nread;
    
    while (nleft > 0) {
          if ((nread = read(fd, p, nleft)) < 0) {
                if (errno == EINTR) nread = 0;
                else return -1;
          } else if (nread == 0) break;
          nleft -= nread;
          p += nread;
    }
    
    return n - nleft;
}

size_t writen(int fd, void *ptr, size_t n)
{
    size_t nwriten;
    size_t nleft = n;
    char *p = ptr;
    
    while (nleft > 0) {
          if ((nwriten = write(fd, p, nleft)) <= 0) {
                if (errno == EINTR) nwriten = 0;
                else return -1;
          }
          
          nleft -= nwriten;
          p += nwriten;
    }
    
    return n;
}

void str_cli(FILE *file, int fd)
{
    char recvline[BUF_LEN], sendline[BUF_LEN];
    int maxfdp1;
    fd_set fdset;
    int ret;

    int stdineof = 0;

    FD_ZERO(&fdset);

    for(;;) {
        if (stdineof == 0)
            FD_SET(fileno(file), &fdset);
        FD_SET(fd, &fdset);
        maxfdp1 = max(fileno(file), fd) + 1;
        ret = select(maxfdp1, &fdset, NULL, NULL, NULL);   
        if (ret <= 0) {
             continue;
        }
        //printf("ret=%d\n", ret);
        if (FD_ISSET(fd, &fdset)) {
            if (readline(fd, recvline, BUF_LEN) == 0) {
                if (stdineof == 1)
                    return;
                else {
                    printf("readline error:%s\n", strerror(errno));
                    return;
                }
            }
            fputs(recvline, stdout);
        } 
    
        if (FD_ISSET(fileno(file), &fdset)) {
            memset(sendline, 0x00, sizeof(sendline));
            if (fgets(sendline, BUF_LEN, file) == NULL) {
                //printf("fgets error:%s\n", strerror(errno));
                stdineof = 1;
                shutdown(fd, SHUT_WR);
                FD_CLR(fileno(file), &fdset);
                continue;
            }
            
            //printf("len=%d\n", strlen(sendline));
            writen(fd, sendline, strlen(sendline));
        }   
    }
}

int main(int argc, char** argv)
{
    struct sockaddr_in serveraddr;
    int sockfd;
    
#ifndef ONLINE_JUDGE
    //freopen("6.4Client.c", "r", stdin);
#endif

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        printf("socket error:%s\n", strerror(errno));
        return -1;
    }   
    
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(SIN_PORT);
    if (inet_pton(AF_INET, argv[1], &serveraddr.sin_addr) != 1) {
          printf("inet_pton error:%s\n", strerror(errno));
          close(sockfd);
          return -1;
    }
    
    if (connect(sockfd, (struct sockaddr*)&serveraddr, sizeof(serveraddr)) < 0) {
        printf("connect error:%s\n", strerror(errno));
        close(sockfd);
        return -1;
    }
    
    str_cli(stdin, sockfd);
    
    exit(0);
    
}

UDP客户端代码：

#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define SERV_PORT 9999
#define BUF_LEN 128

char *sock_ntop(const struct sockaddr* sockaddr, socklen_t len)
{
	static char str[BUF_LEN];
	char portstr[7];
	struct sockaddr_in *sin;
		
	switch (sockaddr->sa_family) {
	case AF_INET:
		sin = (struct sockaddr_in*)sockaddr;
		if (inet_ntop(AF_INET, &sin->sin_addr, str, sizeof(str)) == (const char *)NULL) {
			printf("inet_ntop error:%s\n", strerror(errno));
			return NULL;
		}	
		
	
		if (ntohs(sin->sin_port) != 0) {
			snprintf(portstr, sizeof(portstr), ":%d", ntohs(sin->sin_port));
			strcat(str, portstr);
		}
		return str;
	}	

	
	return NULL;	
}

void dg_cli(FILE *fp, int sockfd, const struct sockaddr_in * pservaddr, socklen_t servlen)
{
	int n;
	char sendline[BUF_LEN], recvline[BUF_LEN];
	struct sockaddr reply_addr;
	socklen_t len;

	if (connect(sockfd, (struct sockaddr*)pservaddr, servlen) < 0) {
		printf("connect error:%s\n", strerror(errno));
		return ;
	}

	while (fgets(sendline, BUF_LEN, fp) != NULL) {
		//sendto(sockfd, sendline, strlen(sendline), 0, (struct sockaddr*)pservaddr, servlen);	
		write(sockfd, sendline, strlen(sendline));
		len = servlen;
		//n = recvfrom(sockfd, recvline, BUF_LEN, 0, &reply_addr, &len);
		n = read(sockfd, recvline, BUF_LEN);
		
		/*
		if (len != servlen || memcmp(&reply_addr, pservaddr, len) != 0) {
			printf("receive (%s) ignored\n", sock_ntop(&reply_addr, len));
			continue;
		}
		*/
		
		recvline[n] = 0;
		fputs(recvline, stdout);
	}
}

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

	memset(&servaddr, 0x00, sizeof(servaddr));	
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(SERV_PORT);	
	
	if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) < 0) {
		printf("inet_pton error:%s\n", strerror(errno));
		return -1;
	}

	sock = socket(AF_INET, SOCK_DGRAM, 0);	
	if (sock < 0) {
		printf("socket error:%s\n", strerror(errno));
		return -1;
	}

	dg_cli(stdin, sock, &servaddr, sizeof(servaddr));
	return 0;
}