UNP函数笔记十四: 带外数据

最新推荐文章于 2022-08-09 06:47:50 发布
原创 最新推荐文章于 2022-08-09 06:47:50 发布 · 719 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#signal #null #tcp #byte #server #socket

本文介绍如何使用TCP协议处理带外数据（OOB），包括发送和接收带外数据的方法、利用信号处理机制实现心跳监测等高级应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

第二十四章  带外数据:

#include <sys/socket.h>
int sockatmark(int sockfd);
    have oob mark return 1, have not oob mark return 0, error return -1

示例: 

#include <sys/ioctl.h>

int 
sockatmark(int fd)
{
    int        flag;

    if (ioctl(fd, SIOCATMARK, &flag) == -1) {
        return(-1);
    }
    return(flag != 0);
}

#include "err_exit.h"
#include "tcp_connect.h"

int 
main(int argc, char ** argv)
{
    int sockfd;

    if (argc != 3) {
        printf("usage: tcpsend01 <host> <port#>\n");
        exit(1);
    }

    sockfd = tcp_connect(argv[1], argv[2]);

    if (write(sockfd, "123", 3) != 3) {
        err_exit("write error");
    }
    printf("wrote 3 bytes of normal data\n");
    sleep(1);

    if (send(sockfd, "4", 1, MSG_OOB) != 1) {
        err_exit("send error");
    }
    printf("wrote 1 byte of OOB data\n");
    sleep(1);

    if (write(sockfd, "56", 2) != 2) {
        err_exit("write error");
    }
    printf("wrote 2 bytes of normal data\n");
    sleep(1);

    if (send(sockfd, "7", 1, MSG_OOB) != 1) {
        err_exit("send error");
    }
    printf("wrote 1 byte of OOB data\n");
    sleep(1);

    if (write(sockfd, "89", 2) != 2) {
        err_exit("write error");
    }
    printf("wrote 2 bytes of normal data\n");
    sleep(1);

    exit(0);
}

#include <fcntl.h>

#include "err_exit.h"
#include "my_signal.h"
#include "tcp_listen.h"

int listenfd;
int connfd;

void 
sig_urg(int signo)
{
    int   n;
    char  buff[100];

    printf("SIGURG received\n");
    if ((n = recv(connfd, buff, sizeof(buff)-1, MSG_OOB)) < 0) {
        err_exit("recv error");
    }
    buff[n] = 0;  /* null terminate */
    printf("read %d OOB byte: %s\n", n, buff);
}

int 
main(int argc, char ** argv)
{
    int   n;
    char  buff[100];

    if (argc == 2) {
        listenfd = tcp_listen(NULL, argv[1], NULL);
    }
    else if (argc == 3) {
        listenfd = tcp_listen(argv[1], argv[2], NULL);
    }
    else {
        printf("usage: tcprecv01 [ <host> ] <port#>\n");
    }

    if ((connfd = accept(listenfd, NULL, NULL)) == -1) {
        err_exit("accept error");
    }

    if (my_signal(SIGURG, sig_urg) == SIG_ERR) {
        err_exit("my_signal error");
    }
    if (fcntl(connfd, F_SETOWN, getpid()) == -1) {
        err_exit("fcntl error");
    }

    for ( ; ; ) {
        if ((n = read(connfd, buff, sizeof(buff)-1)) < 0) {
            err_exit("read error");
        }
        else if (n == 0) {
            printf("received EOF\n");
            exit(0);
        }
        buff[n] = 0;  /* null terminate */
        printf("read %d bytes: %s\n", n, buff);
    }
}

#include "err_exit.h"
#include "tcp_listen.h"

int 
main(int argc, char ** argv)
{
    int     listenfd;
    int     connfd;
    int     n;
    int     justreadoob = 0;
    char    buff[100];
    fd_set  rset;
    fd_set  xset;

    if (argc == 2) {
        listenfd = tcp_listen(NULL, argv[1], NULL);
    }
    else if (argc == 3) {
        listenfd = tcp_listen(argv[1], argv[2], NULL);
    }
    else {
        printf("usage: tcprecv02 [ <host> ] <port#>\n");
        exit(1);
    }

    if ((connfd = accept(listenfd, NULL, NULL)) == -1) {
        err_exit("accept error");
    }

    FD_ZERO(&rset);
    FD_ZERO(&xset);
    for ( ; ; ) {
        FD_SET(connfd, &rset);
        if (justreadoob == 0) {
            FD_SET(connfd, &xset);
        }

        if (select(connfd + 1, &rset, NULL, &xset, NULL) == -1) {
            err_exit("select error");
        }

        if (FD_ISSET(connfd, &xset)) {
            if ((n = recv(connfd, buff, sizeof(buff)-1, MSG_OOB)) < 0) {
                err_exit("recv error");
            }
            buff[n] = 0;  /* null terminate */
            printf("read %d OOB byte: %s\n", n, buff);
            justreadoob = 1;
            FD_CLR(connfd, &xset);
        }

        if (FD_ISSET(connfd, &rset)) {
            if ((n = read(connfd, buff, sizeof(buff)-1)) < 0) {
                err_exit("read error");
            }
            else if (n == 0) {
                printf("received EOF\n");
                exit(0);
            }
            buff[n] = 0;  /* null terminate */
            printf("read %d bytes: %s\n", n, buff);
            justreadoob = 0;
        }
    }
}


#include "err_exit.h"
#include "tcp_listen.h"

int 
main(int argc, char ** argv)
{
    int   listenfd;
    int   connfd;
    int   n;
    int   on = 1;
    char  buff[100];

    if (argc == 2) {
        listenfd = tcp_listen(NULL, argv[1], NULL);
    }
    else if (argc == 3) {
        listenfd = tcp_listen(argv[1], argv[2], NULL);
    }
    else {
        printf("usage: tcprecv02 [ <host> ] <port#>\n");
        exit(1);
    }

    if (setsockopt(listenfd, SOL_SOCKET, SO_OOBINLINE, &on, sizeof(on)) == -1) {
        err_exit("setsockopt error");
    }

    if ((connfd = accept(listenfd, NULL, NULL)) == -1) {
        err_exit("accept error");
    }
    sleep(5);

    for ( ; ; ) {
        if ((n = sockatmark(connfd)) == -1) {
            err_exit("sockatmark error");
        }
        else if (n == 1) {
            printf("at OOB mark\n");
        }

        if ((n = read(connfd, buff, sizeof(buff)-1)) < 0) {
            err_exit("read error");
        }
        else if (n == 0) {
            printf("received EOF\n");
            exit(0);
        }
        buff[n] = 0;  /* null terminate */
        printf("read %d bytes: %s\n", n, buff);
    }
}

#include "err_exit.h"
#include "tcp_connect.h"

int 
main(int argc, char ** argv)
{
    int sockfd;

    if (argc != 3) {
        printf("usage: tcpsend01 <host> <port#>\n");
        exit(1);
    }

    sockfd = tcp_connect(argv[1], argv[2]);

    if (write(sockfd, "123", 3) != 3) {
        err_exit("write error");
    }
    printf("wrote 3 bytes of normal data\n");

    if (send(sockfd, "4", 1, MSG_OOB) != 1) {
        err_exit("send error");
    }
    printf("wrote 1 byte of OOB data\n");

    if (write(sockfd, "5", 1) != 1) {
        err_exit("write error");
    }
    printf("wrote 1 bytes of normal data\n");

    exit(0);
}

#include "err_exit.h"
#include "tcp_connect.h"

int 
main(int argc, char ** argv)
{
    int sockfd;

    if (argc != 3) {
        printf("usage: tcpsend01 <host> <port#>\n");
        exit(1);
    }

    sockfd = tcp_connect(argv[1], argv[2]);

    if (write(sockfd, "123", 3) != 3) {
        err_exit("write error");
    }
    printf("wrote 3 bytes of normal data\n");
    sleep(1);

    if (send(sockfd, "4", 1, MSG_OOB) != 1) {
        err_exit("send error");
    }
    printf("wrote 1 byte of OOB data\n");
    sleep(1);

    if (write(sockfd, "5", 1) != 1) {
        err_exit("write error");
    }
    printf("wrote 1 bytes of normal data\n");
    sleep(1);

    if (send(sockfd, "6", 1, MSG_OOB) != 1) {
        err_exit("send error");
    }
    printf("wrote 1 byte of OOB data\n");
    sleep(1);

    if (write(sockfd, "7", 1) != 1) {
        err_exit("write error");
    }
    printf("wrote 1 bytes of normal data\n");
    sleep(1);

    exit(0);
}


#include <fcntl.h>

#include "err_exit.h"
#include "my_signal.h"
#include "tcp_listen.h"

int listenfd;
int connfd;

void 
sig_urg(int signo)
{
    int   n;
    char  buff[2048];

    printf("SIGURG received\n");
    if ((n = recv(connfd, buff, sizeof(buff)-1, MSG_OOB)) < 0) {
        err_exit("recv error");
    }
    buff[n] = 0;  /* null terminate */
    printf("read %d OOB byte: %s\n", n, buff);
}

int 
main(int argc, char ** argv)
{
    int size = 4096;

    if (argc == 2) {
        listenfd = tcp_listen(NULL, argv[1], NULL);
    }
    else if (argc == 3) {
        listenfd = tcp_listen(argv[1], argv[2], NULL);
    }
    else {
        printf("usage: tcprecv01 [ <host> ] <port#>\n");
    }

    if (setsockopt(listenfd, SOL_SOCKET, SO_RCVBUF, &size, 
                   sizeof(size)) == -1) {
        err_exit("setsockopt error");
    }

    if ((connfd = accept(listenfd, NULL, NULL)) == -1) {
        err_exit("accept error");
    }

    if (my_signal(SIGURG, sig_urg) == SIG_ERR) {
        err_exit("my_signal error");
    }
    if (fcntl(connfd, F_SETOWN, getpid()) == -1) {
        err_exit("fcntl error");
    }

    for ( ; ; ) {
        pause();
    }
}

#include "err_exit.h"
#include "tcp_connect.h"

int 
main(int argc, char ** argv)
{
    int   sockfd;
    int   size;
    char  buff[16384];

    if (argc != 3) {
        printf("usage: tcpsend01 <host> <port#>\n");
        exit(1);
    }

    sockfd = tcp_connect(argv[1], argv[2]);

    size = 32768;
    if (setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size)) == -1) {
        err_exit("setsockopt error");
    }

    if (write(sockfd, buff, 16384) != 16384) {
        err_exit("write error");
    }
    printf("wrote 16384 bytes of normal data\n");
    sleep(5);

    if (send(sockfd, "a", 1, MSG_OOB) != 1) {
        err_exit("send error");
    }
    printf("wrote 1 byte of OOB data\n");

    if (write(sockfd, buff, 1024) != 1024) {
        err_exit("write error");
    }
    printf("wrote 1024 bytes of normal data\n");

    exit(0);
}


#include <fcntl.h>
#include <sys/socket.h>

#include "err_exit.h"
#include "my_signal.h"

static int  servfd;
static int  nsec;         /* seconds betweeen each alarm */
static int  maxnprobes;   /* probes w/no response before quit */
static int  nprobes;      /* probes since last server response */

void 
sig_urg(int signo)
{
    int   n;
    char  c;
 
    if ((n = recv(servfd, &c, 1, MSG_OOB)) < 0) {
        if (errno != EWOULDBLOCK) {
            err_exit("recv error");
        }
    }
    nprobes = 0;  /* reset counter */
    return;  /* may interrupt client code */
}

void 
sig_alrm(int signo)
{
    if (++nprobes > maxnprobes) {
        fprintf(stderr, "server is unreachable\n");
        exit(0);
    }
    if (send(servfd, "1", 1, MSG_OOB) != 1) {
        err_exit("send error");
    }
    alarm(nsec);
    return;  /* may interrupt client code */
}

void 
heartbeat_cli(int servfd_arg, int nsec_arg, int maxnprobes_arg)
{
    servfd = servfd_arg;  /* set globals for signal handlers */
    if ((nsec = nsec_arg) < 1) {
        nsec = 1;
    }
    if ((maxnprobes = maxnprobes_arg) < nsec) {
        maxnprobes = nsec;
    }
    nprobes = 0;

    if (my_signal(SIGURG, sig_urg) == SIG_ERR) {
        err_exit("my_signal error");
    }
    if (fcntl(servfd, F_SETOWN, getpid()) == -1) {
        err_exit("fcntl error");
    }

    if (my_signal(SIGALRM, sig_alrm) == SIG_ERR) {
        err_exit("my_signal error");
    }
    alarm(nsec);
}

#include <fcntl.h>
#include <sys/socket.h>

#include "err_exit.h"
#include "my_signal.h"

static int  servfd;
static int  nsec;        /* seconds between each alarm */
static int  maxnalarms;  /* alarms w/no client probe before quit */
static int  nprobes;     /* alarms since last client probe */

void 
sig_urg(int signo)
{
    int   n;
    char  c;

    if ((n = recv(servfd, &c, 1, MSG_OOB)) < 0) {
        if (errno != EWOULDBLOCK) {
            err_exit("recv error");
        }
    }
    if (send(servfd, &c, 1, MSG_OOB) != 1) {  /* echo back out-of-band byte */
        err_exit("send error");
    }

    nprobes = 0;  /* reset counter */
    return;  /* may interrupt server code */
}

void 
sig_alrm(int signo)
{
    if (++nprobes > maxnalarms) {
        printf("no probes from client\n");
        exit(0);
    }
    alarm(nsec);
    return;  /* may interrupt server code */
}

void
heartbeat_serv(int servfd_arg, int nsec_arg, int maxnalarms_arg)
{
    servfd = servfd_arg;  /* set globals for signal handlers */
    if ((nsec = nsec_arg) < 1) {
        nsec = 1;
    }
    if ((maxnalarms = maxnalarms_arg) < nsec) {
        maxnalarms = nsec;
    }
    nprobes = 0;

    if (my_signal(SIGURG, sig_urg) == SIG_ERR) {
        err_exit("my_signal error");
    }
    if (fcntl(servfd, F_SETOWN, getpid()) == -1) {
        err_exit("fcntl error");
    }

    if (my_signal(SIGALRM, sig_alrm) == SIG_ERR) {
        err_exit("my_signal error");
    }
    alarm(nsec);
}

AR502H-CN开发笔记34：socket中的read和write函数
snmplink的博客
08-12 1332
本系列文章将向大家讲述华为网关AR502H的开发方法。 本文介绍socket中read和write函数的使用方法。 本文转载自：浅谈TCP/IP网络编程中socket的行为 我认为，想要熟练掌握Linux下的TCP/IP网络编程，至少有三个层面的知识需要熟悉： 1. TCP/IP协议（如连接的建立和终止、重传和确认、滑动窗口和拥塞控制等等） 2. Socket I/O系统调用（重点如read/write），这是TCP/IP协议在应用层表现出来的行为。 3. 编写Performant, Scal
【unix网络编程第三版】阅读笔记（五）：I/O复用：select和poll函数
ZeeCoder
07-14 5753
本博文主要针对UNP一书中的第六章内容来聊聊I/O复用技术以及其在网络编程中的实现 1. I/O复用技术I/O多路复用是指内核一旦发现进程指定的一个或者多个I/O条件准备就绪，它就通知该进程。I/O复用适用于以下场合：(1) 当客户处理多个描述符（一般是交互式输入或网络套接字），必须适用I/O复用(2) 当一个客户处理多个套接字时，这种情况很少见，但也可能出现(3) 当一个TCP服务器既要处理监听套
SIGURG信号 -- 带外数据的处理
未来之歌
04-06 3051
使用SIGURG处理带外数据程序实例：#include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <assert.h> #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <errno.h> #include <str
UNIX网络编程——sockatmark函数
weixin_34257076的博客
07-28 212
每当收到一个带外数据时，就有一个与之关联的带外标记。这是发送进程发送带外字节时该字节在发送端普通数据流中的位置。在从套接字读入期间，接收进程通过调用sockatmark函数确定是否处于带外标记。#include <sys/socket.h> int sockatmark(int sockfd); /* 返回值：如果在带外标记上为1, 不在标记上为0, 出错为-1 */...
带外数据
辉哥仔
01-26 509
概述 许多传输层有带外数据的概念，有时候也称经加速数据。其想法是一个连接的某端发生了重要的事情，而且该端希望迅速通告其对端。这里的“迅速”意味着这种通知在已经排队等待发送的任何“普通”数据之前发送，也就是优先级更高。 TCP带外数据 TCP没有真正的带外数据，不过提供了紧急模式。假设一个进程已经往一个TCP套接字写出N字节数据，而且TCP把这些数据排队在该套接字的发送缓冲区中，等...
[Linux系统编程]_网络编程（五）
weixin_50546241的博客
08-09 698
[Linux系统编程]_网络编程（五）
UNP学习笔记讲义
04-29
协议是网络通信中的核心概念，其在C语言中可以类比为一个结构体（struct），具有多个字段和可以执行的函数，这些函数可以对结构体中的数据进行解析和操作。网络协议就是一系列规则，用于指导数据如何在网络中进行...
UNP 学习笔记(一)：简介
amoscykl的博客
05-02 5340
简介概述客户与服务器之间是通过某个网络协议通信的。焦点是TCP/IP协议族，也称为网际协议族。 同一网络应用的客户和服务器无需处于同一个服务器，而这两个局域网是使用路由器连接到广域网(WAN)的。路由器是广域网的架构设备。当今最大的广域网是因特网。 一个简单的时间获取服务器程序/* 一个简单的时间获取服务器程序 */ #include "unp.h"                        ...
APUE，TLPI，UNP读书笔记——linux IO模型以及IO复用
frankwyw的博客
05-11 1019
linux IO模型与IO复用
关于TCP带外数据
yangqisheng的专栏
06-14 1136
一、 读UNP,看到24章的带外数据。书上还给出了一个小例子 ------ 一个服务端接收普通数据和带外数据，另外有个客户端发送普通数据和带外数据。接收端的普通数据和带外数据是分开接收的。普通数据就用普通的recv,而带外数据是在SIGURG信号处理函数里面用recv(... MSG_OOB)接收的。我冒出个想法，在SIGURG信号处理函数里面，如果我在recv( MSG_OOB)之前用普通的r
Unix网络编程-TCP带外数据（紧急数据）
NINE_world的博客
05-19 397
简单的发送程序 /** * @file oobtcpsend1.c * 简单的带外数据发送程序 */ #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/socket.h> #include <netinet/ip.h> #include <netinet/in.h> #include <arpa/inet.h> #inclu
带外数据的接收与发送
liuxuejiang158的专栏
10-10 4466
带外数据比普通数据具有更高的优先级，TCP没有真正的带外数据，而是提供了一个我们要讨论的紧急模式，TCP将数据放置在套机口发送缓冲区的下一个可用位置，并设置这个连接的TCP紧急指针(urgent pointer)为下一个可用位置，TCP紧急指针有一个比用MSG_OOB标志写入的数据多一个字节的序列号。由于接收端的带外缓冲只有1B所以发送端发送的多字节带外数据只有最后1B被当做带外数据，若接收端
UNP函数笔记十三: 非阻塞式I/O
二斗墨汁
04-20 818
第十六章  非阻塞式I/O: 示例: #include #include #include #include #include "err_exit.h" #define MAXLINE 4096 char * gf_time(void) { struct timeval tv; time_t t; static char
Linux高性能服务器笔记--1
mgpdian的博客
03-05 170
1.网络编程基础API 1.1 主机字节序和网络字节序 pc大多采用小端字节序, 因此小端字节序又称为主机字节序 大端字节序也称为网络字节序,它给所有接收数据的主机提供一个正确解释收到的格式化数据的保证 Linux提供了4个函数来完成主机字节序和网络字节序的转换 #include <netinet/in.h> unsigned long int htonl( unsigned long int hostlong); unsigned short int htons( unsi..
关于TCP带外数据（OOB，Out Of Bound）
淡红星空的专栏
09-13 8276
定义带 外 数据  想 像一下在银行人们排起队待等处置他们的帐单。在这个步队中每个人最后会都移到面前由出纳员行进服务。在现想像一下一个走入银行，超出个整步队，然后用枪抵 住出纳员。这个就可以看作为带 外 数据 。这个盗强超出个整步队，是因为这把枪给了他凌驾于世人的权利。出纳员也集会中注意力于这个盗强身上，因为他晓得后以 的势形是很紧迫的。 应相的，一个连接的流式套口接上的带 外
带外数据OOB与紧急模式URG
dingmin1860的专栏
09-09 945
传输层协议使用带外数据(out-of-band,OOB)来发送一些重要的数据,如果通信一方有重要的数据需要通知对方时,协议能够将这些数据快速地发送到对方.为了发送这些数据,协议一般不使用与普通数据相同的通道,而是使用另外的通道.linux系统的套接字机制支持低层协议发送和接受带外数据.但是TCP协议没有真正意义上的带外数据.为了发送重要协议,TCP提供了一种称为紧急模式(urgent mode
【Linux Server】四、Linux网络编程
江湖人称菠萝包
12-05 526
四、Linux网络编程 1.以太网的MTU是1500字节，因此过长的IP数据报可能需要被分片传输。 帧才是最终在物理网络上传送的字节序列。 2.所有知名应用层协议使用的端口号都可在/etc/services文件中找到。 3.Linux下可以使用arp命令来查看和修改ARP高速缓存。 sudo arp -a # 查看当前时刻的ARP缓存内容 sudo arp -d 192.168.1.109
tcp和udp的基本函数调用过程及如何选择
cpp加油站的专栏
06-12 2390
1. socket编程 1.1 概述 TCP是TCP/IP体系中面向连接的传输层协议，它提供全双工和可靠交付的服务。它采用许多机制来确保端到端结点之间的可靠数据传输，如采用序列号、确认重传、滑动窗口等。 首先，TCP要为所发送的每一个报文段加上序列号，保证每一个报文段能被接收方接收，并只被正确的接收一次。 其次，TCP采用具有重传功能的积极确认技术作为可靠数据流传输服务的基础。这里“确认”是指接收...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值