同一端口监听tcp和udp请求

最新推荐文章于 2024-06-08 07:22:09 发布
最新推荐文章于 2024-06-08 07:22:09 发布
阅读量6.1k 收藏 11
点赞数 2
分类专栏： 网络 C/C++ 文章标签： udp tcp server
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lanyang123456/article/details/76400938
版权
C/C++ 同时被 2 个专栏收录
59 篇文章 1 订阅
订阅专栏
网络
29 篇文章 0 订阅
订阅专栏

问题：

众所周知，同一台机器的同一个端口只可以被一个进程使用，一般用于tcp，或者udp。那一个进程使用同一个端口同时监听tcp、udp请求，是否可以呢？答案：可以。

代码：

server

为了同时监听，server使用select进行多路访问控制。
server端代码如下：

/*
TCP
INET
use select
*/

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


#define LENGTH_OF_LISTEN_QUEUE  20
#define SERVER_PORT 8888
#define MAXLINE 4096
#define MAX_FD_NUM  10


static int init_new_client(int client_fd);
static int remove_client(int client_fd);
static int get_max_fd(int fd);


static int  client_fdset[MAX_FD_NUM];

int main(int argc, char** argv)
{
    int    tcp_fd, udp_fd, connfd, client_fd;
    struct sockaddr_in  servaddr;
    struct sockaddr_in  client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    char    recv_buff[4096]; 
    char    response[] = "recv well done.";
    int     recv_len;
    fd_set readfd;
    int ret;
    int max_fd;
    int i;

    for (i = 0; i < MAX_FD_NUM; i++) {
        client_fdset[i] = -1;
    }

    if ((tcp_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1 ) {
            printf("create socket error: %s(errno: %d)\n",strerror(errno),errno);
            exit(0);
    }


    if ((udp_fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1 ) {
            printf("create socket error: %s(errno: %d)\n",strerror(errno),errno);
            exit(0);
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(SERVER_PORT);

    if (bind(tcp_fd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
            printf("tcp bind socket error: %s(errno: %d)\n",strerror(errno),errno);
            exit(0);
    }

    if (bind(udp_fd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
            printf("udp bind socket error: %s(errno: %d)\n",strerror(errno),errno);
            exit(0);
    }

    if (listen(tcp_fd, LENGTH_OF_LISTEN_QUEUE) == -1) {
            printf("listen socket error: %s(errno: %d)\n",strerror(errno),errno);
            exit(0);
        }

    printf("----------waiting for client's request---------\n");
    while (1) {

            /*每次调用select前，都要重置监听的描述符*/  
        FD_ZERO(&readfd);
        FD_SET(tcp_fd, &readfd);
        FD_SET(udp_fd, &readfd);
        for (i = 0; i < MAX_FD_NUM; i++) {
            if (client_fdset[i] != -1) {
                FD_SET(client_fdset[i], &readfd);
            }   
        }

        int fd = tcp_fd;
        if (udp_fd > tcp_fd)
        {
            fd = udp_fd;
        }

        max_fd = get_max_fd(fd);
        ret = select(max_fd + 1, &readfd, NULL, NULL, NULL);//有数据时才返回
            if (ret == -1) {  //错误情况
            if (errno == EINTR) {//signal interrupt
                continue;
            }
            else {
                perror("select error");
                exit(0);
            }
        }
            else if (ret) {    //返回值大于0 有数据到来
                    if (FD_ISSET(tcp_fd, &readfd))
                    {
                if((connfd = accept(tcp_fd, (struct sockaddr *)&client_addr, &client_addr_len)) == -1) {
                        printf("accept socket error: %s(errno: %d)\n",strerror(errno),errno);
                        continue;
                    }
                printf("accept a new  connection from client IP: %s, port: %u\n", inet_ntoa(client_addr.sin_addr),                      ntohs(client_addr.sin_port));
                ret = init_new_client(connfd);
                if (ret != 0) {
                    printf("init_new_client() failed ret = %d.\n", ret);
                    close(connfd);
                }

                    } else if (FD_ISSET(udp_fd, &readfd)) {

                int ret =recvfrom(udp_fd,recv_buff, MAXLINE - 1, 0,(struct sockaddr *)&client_addr, &client_addr_len);
                if(ret<0){
                    perror("recvfrom error_1");
                    continue;
                }

                    recv_buff[ret] = '\0';
                printf("udp recv:");
                    printf("recv msg %d byte from client: %s\n", recv_len, recv_buff);

                    } else {
                /*one fd  can be read.*/
                for (i = 0; i < MAX_FD_NUM; i++) {
                    if (client_fdset[i] != -1 && FD_ISSET(client_fdset[i], &readfd)) {
                        client_fd = client_fdset[i];
                        break;
                    }
                }

                memset(recv_buff, 0, MAXLINE);
                    recv_len = recv(client_fd, recv_buff, MAXLINE - 1, 0);          
                printf("tcp recv:");
                printf("recv len = %d\n", recv_len);
                if (recv_len <= 0) {
                    if (recv_len == 0) {
                        printf("socket disconnnect(or the other side shutdown socket fd, or network problem)\n");
                        printf("recv socket error: %s(errno: %d)\n",strerror(errno),errno);
                    }
                    else {
                        printf("recv socket error: %s(errno: %d)\n",strerror(errno),errno);
                    }
                    ret = remove_client(client_fd);
                    if (ret != 0) {
                        printf("remove_client() failed ret = %d.\n", ret);
                    }
                    close(client_fd);
                    continue;
                }
                    recv_buff[recv_len] = '\0';
                    printf("recv msg %d byte from client: %s\n", recv_len, recv_buff);

                    if (send(client_fd, response, strlen(response), 0) < 0) {
                        printf("send socket error: %s(errno: %d)\n", strerror(errno), errno);
                        ret = remove_client(client_fd);
                    if (ret != 0) {
                        printf("remove_client() failed ret = %d.\n", ret);
                    }
                    close(client_fd);
                    continue;
                    }

            }

        }
            else    //ret 为0，超时情况
            {
                    printf("time out\n");
            //close(keybd_fd);//产生异常，查看结果
            }

    }

    close(tcp_fd);
    close(udp_fd);
    printf("--------server exit------.\n");
    exit(0);
}




static int init_new_client(int client_fd)
{
    int i;

    for(i = 0; i < MAX_FD_NUM; i++) {
        if (client_fdset[i] == -1) {
            client_fdset[i] = client_fd;    
            break;  
        }
    }

    if (i == MAX_FD_NUM) {
        printf("too many client.\n");
        return -1;
    }

    return 0;
}

static int remove_client(int client_fd)
{

    int i;

    for(i = 0; i < MAX_FD_NUM; i++) {
        if (client_fdset[i] == client_fd) {
            client_fdset[i] = -1;   
            break;  
        }
    }

    if (i == MAX_FD_NUM) {
        printf("client fd is not in list.\n");
        return -1;
    }

    return 0;

}

static int get_max_fd(int fd)
{
    int i;

    for(i = 0; i < MAX_FD_NUM; i++) {
        if (client_fdset[i] > fd) {
            fd = client_fdset[i];
        }
    }

    return fd;
}

client

tcp client 代码如下：

/*
TCP
client
API
usage:
./client 192.168.1.78

notes:
client 端connect()成功之后，此时立刻关闭sockfd断开连接，
server 端recv()会立刻返回，其返回值为0；
*/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>

#define SERVER_PORT 8888
#define MAXLINE 4096

int main(int argc, char** argv)
{
    int    sockfd, n;
    char    recvline[MAXLINE], sendline[MAXLINE];
    struct sockaddr_in    servaddr;
    int recv_len;
    int ret;

    memset(recvline, 0, MAXLINE);
    memset(sendline, 0, MAXLINE);

    if (argc != 2) {
        printf("usage: ./client <ipaddress>\n");
        exit(0);
    }

    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
            printf("create socket error: %s(errno: %d)\n", strerror(errno),errno);
        exit(0);
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(SERVER_PORT);

    if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0) {
        printf("inet_pton error for %s/n",argv[1]);
        close(sockfd);
        exit(0);
    }

    if(connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
        printf("connect error: %s(errno: %d)/n",strerror(errno),errno);
        close(sockfd);
        exit(0);
    }


    /*sleep(10);close(sockfd);exit(0);*/
        printf("send msg to server: \n");

        fgets(sendline, MAXLINE - 1, stdin);
    ret = send(sockfd, sendline, strlen(sendline), 0);
    printf("the len of send data = %d.\n", ret);
    if (ret < 0)
        {
            printf("send msg error: %s(errno: %d)\n", strerror(errno), errno);
        close(sockfd);
            exit(0);
        } else if (ret == 0) {//return 0
        printf("socket disconnnect(or the other side shutdown socket fd, or network problem) and send error: %s(errno: %d)\n", 
            strerror(errno), errno);
        close(sockfd);
            exit(0);
    }

        recv_len = recv(sockfd, recvline, MAXLINE - 1, 0);
        if (recv_len < 0) {
        printf("recv socket error: %s(errno: %d)\n",strerror(errno),errno);
        close(sockfd);
        exit(0);
        } else if (recv_len == 0) {//return 0
        printf("socket disconnnect(or the other side shutdown socket fd, or network problem) and recv error: %s(errno: %d)\n", 
            strerror(errno), errno);
        close(sockfd);
            exit(0);
    }

        recvline[recv_len] = '\0';
        printf("from server: %s\n", recvline);

        close(sockfd);
    exit(0);
}

udp client 代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netdb.h>
#include<errno.h>
#include<sys/types.h>
int port=8888;

int main(int argc,char *argv[]){
  int sockfd;
  int i=0;
  int z;
  char buf[80],str1[80];
  struct hostent *host;
  struct sockaddr_in adr_srvr;
  if(argc<2){
    fprintf(stderr,"please enter the server's hostname!\n");
    exit(1);
  }

 if((host=gethostbyname(argv[1]))==NULL){
    herror("gethostbyname error!");
    exit(1);
  }

  adr_srvr.sin_family=AF_INET;
  adr_srvr.sin_port=htons(port);
  adr_srvr.sin_addr=*((struct in_addr *)host->h_addr);
  bzero(&(adr_srvr.sin_zero),8);

  sockfd=socket(AF_INET,SOCK_DGRAM,0);
  if(sockfd==-1){
    perror("socket error!");
    exit(1);
  }

  printf("msg to server:\n");
  fgets(buf, sizeof(buf) - 1, stdin);

  printf("send ....\n");
  z=sendto(sockfd,buf,sizeof(buf),0,(struct sockaddr *)&adr_srvr,sizeof(adr_srvr));
  if(z<0){
    perror("sendto error");
    exit(1);
  }


  sprintf(buf,"stop\n");
  z=sendto(sockfd,buf,sizeof(buf),0,(struct sockaddr *)&adr_srvr,sizeof(adr_srvr));
  if(z<0){
    perror("sendto error");
    exit(1);
  }

  close(sockfd);
  exit(0);
}

测试：

编译

$ gcc server_tcp_udp.c -o server_tcp_udp.c
$ gcc tcp_client.c -o tcp_client.c
$ gcc udp_client.c -o udp_client.c

启动server

$ ./server_tcp_udp
$ ./server_tcp_udp 
----------waiting for client's request---------
accept a new  connection from client IP: 127.0.0.1, port: 60858

tcp recv:recv len = 30
recv msg 30 byte from client: Hello Server, I'm tcp client.


udp recv:recv msg 0 byte from client: Hello server, I'm udp client.
udp recv:recv msg 0 byte from client: stop

启动tcp udp client

$ ./client_tcp 127.0.0.1
send msg to server: 
Hello Server, I'm tcp client.
the len of send data = 30.
from server: recv well done.
$ ./client_udp 127.0.0.1
msg to server:
Hello server, I'm udp client.
send ....

可以看到，server端接到tcp client和udp client发送的请求。

翔云123456
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
linux C++ 同时监听多个端口 同时处理TCP和UDP服务请求的回射服务器
晴天的专栏
08-16 6970
#include #include #include #include #include #include #include #include #include #include #include #include #include #define MAX_EVENT_NUMBER 1024 #define TCP_BUFFER_SIZE 512 #define UDP
UDP和TCP可以使用同一个端口吗？
资料免费分享，点击名片
07-25 3825
之前有读者在面试的时候，被问到：TCP 和 UDP 可以同时监听相同的端口吗？关于端口的知识点，还是挺多可以讲的，比如还可以牵扯到这几个问题：多个 TCP 服务进程可以同时绑定同一个端口吗？客户端的端口可以重复使用吗？客户端 TCP 连接 TIME_WAIT 状态过多，会导致端口资源耗尽而无法建立新的连接吗？所以，这次就跟大家盘一盘这些问题。TCP 和 UDP 可以同时绑定相同的端口吗？ 其实我感觉这个问题「TCP 和 UDP 可以同时监听相同的端口吗？」表述有问题，这个问题应该表述成「TCP 和 UDP
如何多个进程监听同一个端口
L13763338360的博客
06-03 1万+
1. 问题描述 一个进程监听端口，经验告诉我们，如果多次启动一个进程会报错：“Address already in use!"。这是由于bind函数导致的，由于该端口号已经被第一个进程监听了。有哪些方法可以实现多个进程监听同一个端口呢？ 2. 方案一：fork 只要在绑定端口号（bind函数）之后，监听端口号之前（listen函数），用fork（）函数生成子进程，这样子进程就可以克隆父进程，达到监听同一个端口的目的，而且还相互竞争，提高程序效率。 这里要注意的是，计算机三次握手创建连接是不需要服务进
TCP和udp能使用同一个端口通讯吗
最新发布
codemami的博客
06-08 672
这是因为TCP和UDP是两个完全不同的协议，它们工作在传输层，各自维护不同的连接和会话。每个协议都有自己的端口号空间，因此TCP和UDP可以互不干扰地使用相同的端口号。但是，需要注意的是，当TCP和UDP使用相同的端口时，它们需要处理不同的数据流。例如，如果一个TCP连接正在使用一个端口，那么一个UDP数据包也可以发送到该端口，但这两个数据流是完全独立的。此外，虽然TCP和UDP可以使用相同的端口，但在实际应用中，为了避免潜在的冲突和混淆，通常建议为不同的协议分配不同的端口号。
我眼中的TCP对应的协议和UDP对应的协议
ovowovo的博客
09-17 189
TCP对应的协议和UDP对应的协议 TCP对应的协议： （1） FTP：定义了文件传输协议，使用21端口。 （2） Telnet：一种用于远程登陆的端口，使用23端口，用户可以以自己的身份远程连接到计算机上，可提供基于DOS模式下的通信服务。 （3） SMTP：邮件传送协议，用于发送邮件。服务器开放的是25号端口。 （4） POP3：它是和SMTP对应，POP3用于接收邮件。POP3协议所用的是110端口。 （5）HTTP：是从Web服务器传输超文本到本地浏览器的传送协议。 UDP对应的协议： （1） DN
同一端口监听TCP与UDP数据包
走在成长的路上
11-02 2970
展示了关于udp与tcp在同一端口下的监听实现。
同一端口即作TCP用又作UDP使用
12-16
"测试 可以看到，server端接到tcp client和udp client发送的请求.txt"可能是运行示例后的日志文件，记录了服务器接收不同客户端请求的情况。"gcc编译.txt"可能包含编译这些C程序的命令和步骤。 请注意，在实际应用...
Android Tcp&Udp; demo
08-07
TCP服务器通常监听一个端口，等待客户端的连接请求。在这个demo中，TCP服务器直接使用了本地手机的IP地址，这意味着它将只接受来自同一设备的连接。这可能用于模拟或测试目的，但实际应用中通常需要监听所有网络接口...
使用select实现的UDP/TCP组合服务器
03-29
在示例代码中，服务器创建了一个用于监听TCP连接请求的TCP套接字（`tcp_fd`）和一个用于接收UDP数据的UDP套接字（`udp_fd`）。两者都绑定到相同的服务器地址和端口（这里是5000），这样就可以在同一端口上同时提供...
C语言实现TCP和UDP通信
12-03
主要涉及的函数有socket()用于创建套接字，bind()将套接字与特定的IP地址和端口号绑定，listen()使服务器进入监听状态，accept()等待并接受客户端的连接请求，connect()则是客户端用于连接服务器，send()和recv()...
wangluotongxin.rar_labview TCP_labview udp_tcp
09-20
服务器监听特定端口，等待客户端的连接请求；客户端则连接到服务器的IP地址和端口号。 2. 数据收发：一旦连接建立，可以使用“读取”和“写入”节点来交换数据。TCP保证数据的正确接收，即使在网络不稳定的情况下，...
tcptrace TCP端口监听工具 TCP跟踪
06-11
好用的TCP端口监听工具，　用於調試WCF, SOAP的工具
多个进程可以监听同一个端口?【转】
Uaena的博客
05-08 2084
（转自：https://blog.csdn.net/memo_weiwei/article/details/7696593） 多个socket绑定同一个端口，叫做端口复用 下列代码可以使用socket绑定多次 多个socket绑定同一个端口，叫做端口复用 下列代码可以使用socket绑定多次 //SO_REUSEADDR选项就是可以实现端口重绑定的 　　if(setsockopt(...
单个进程监听多个端口及多个进程监听同一个端口
mtAsnow
08-27 3994
单个进程监听多个端口 单个进程创建多个 socket 绑定不同的端口，TCP, UDP 都行 多个进程监听同一个端口(multiple processes listen on same port) 方式1：通过 fork 创建子进程的方式可以实现，其他情况下不行。 当连接到来时，子进程、父进程都可以 accept, 这就是著名的“惊群”问题(thundering herd problem)。 NG...
多个socket使用同一端口
热门推荐
yuanfen139re的专栏
03-02 1万+
突然想到多个socket能不能绑定同一个端口？度娘不给力，自己做实验，结论如下： 1. 如果设置SO_REUSEADDR，就是端口复用，只有一个socket能收到，毕竟只有一块肉嘛，给那个socket，另一个必然要饿肚子，除非有copy机制。 int opt = 1; setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)
Socket监听与TcpListener监听的区别和用法
ID_Dexter的博客
06-13 1万+
socket是针对应用层和传输层之间封装的接口Tcplistener是对socket tcp协议封装的接口，更便于开发1.利用Tcp协议编程1)服务器端：     a)建立TCP监听器TcpListener对象。                   TcpListener tl=new TcpListener(端口号);     b)启动监听器                    tl.Star...
一条命令查看监听本机所有的TCP通信
王星的博客
02-08 4152
# netstat  -plnt
tcp/udp聊天室
09-13
TCP和UDP是两种常用的传输协议，它们在网络编程中被广泛使用。 TCP聊天室使用TCP协议进行通信。TCP提供可靠的、面向连接的通信，确保数据按照发送的顺序到达目标，并且没有丢失或重复。在TCP聊天室中，服务器和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值