解释代码 printf_BUFFER(client_ctx->t,client_ctx->t_len)

这段代码调用了一个自定义的函数 `printf_BUFFER()`，并传递了两个参数 `client_ctx->t` 和 `client_ctx->t_len`。

`printf_BUFFER()` 函数的作用不清楚，它可能是开发者自己定义的一个函数。根据函数名的含义和通常的推测，它可能用于打印输出一个缓冲区的内容。

`client_ctx->t` 和 `client_ctx->t_len` 是两个参数，它们可能是结构体 `client_ctx` 中的成员变量。根据命名和上下文来看，`client_ctx->t` 可能是一个缓冲区的指针或数组，而 `client_ctx->t_len` 则表示该缓冲区的长度或大小。

因此，这段代码的含义可能是调用 `printf_BUFFER()` 函数，并将 `client_ctx->t` 缓冲区的内容以及长度 `client_ctx->t_len` 作为参数进行打印输出。具体的输出结果和实现细节需要查看 `printf_BUFFER()` 函数的定义。

相关问题

c++用ffmpeg创建rtsp服务器

要使用 C++ 和 FFmpeg 创建 RTSP 服务器，你需要了解以下几个步骤：

1. 安装 FFmpeg 库：你需要从 FFmpeg 官网下载源代码，并按照说明进行编译和安装。

2. 创建 RTSP 服务器：你需要编写一个 C++ 程序来创建 RTSP 服务器。可以使用 Live555 或者 FFmpeg 提供的库来完成这个任务。如果你选择使用 FFmpeg，你需要使用下面的代码来创建 RTSP 服务器：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <pthread.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <fcntl.h>
#include <stdbool.h>
#include <libavutil/avutil.h>
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libavutil/opt.h>
#include <libavutil/error.h>
#include <libavutil/time.h>
#include <libavutil/mathematics.h>
#include <libswscale/swscale.h>
#include <libswresample/swresample.h>
#include <libavutil/imgutils.h>

#define RTSP_PORT   554
#define MAX_CLIENTS 10

typedef struct RTSPClient {
    int state;
    int socket;
    struct sockaddr_in address;
    AVFormatContext *pFormatCtx;
    AVCodecContext *pCodecCtx;
    AVCodec *pCodec;
    AVFrame *pFrame;
    AVPacket packet;
    struct SwsContext *img_convert_ctx;
    int video_stream_index;
    pthread_t thread_id;
    bool is_running;
} RTSPClient;

RTSPClient clients[MAX_CLIENTS];

void* client_thread(void *arg) {
    RTSPClient *client = (RTSPClient*)arg;
    int ret;
    AVPacket packet;
    AVFrame *frame;
    uint8_t *buffer;
    int buffer_size;
    struct timeval tv;
    int64_t start_time, end_time, pts;
    int64_t duration, sleep_time;
    int64_t last_frame_pts = -1;

    client->is_running = true;

    while (client->is_running) {
        ret = av_read_frame(client->pFormatCtx, &packet);
        if (ret < 0) {
            if (ret == AVERROR_EOF) {
                printf("End of stream\n");
                break;
            } else if (ret == AVERROR(EAGAIN)) {
                usleep(1000);
                continue;
            } else {
                char errbuf[AV_ERROR_MAX_STRING_SIZE];
                av_make_error_string(errbuf, AV_ERROR_MAX_STRING_SIZE, ret);
                printf("Error while reading frame: %s\n", errbuf);
                break;
            }
        }

        if (packet.stream_index == client->video_stream_index) {
            frame = av_frame_alloc();
            if (!frame) {
                printf("Error allocating frame\n");
                av_packet_unref(&packet);
                break;
            }

            ret = avcodec_send_packet(client->pCodecCtx, &packet);
            if (ret < 0) {
                av_frame_free(&frame);
                av_packet_unref(&packet);
                char errbuf[AV_ERROR_MAX_STRING_SIZE];
                av_make_error_string(errbuf, AV_ERROR_MAX_STRING_SIZE, ret);
                printf("Error sending packet to decoder: %s\n", errbuf);
                break;
            }

            while (ret >= 0) {
                ret = avcodec_receive_frame(client->pCodecCtx, frame);
                if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                    av_frame_free(&frame);
                    break;
                } else if (ret < 0) {
                    av_frame_free(&frame);
                    char errbuf[AV_ERROR_MAX_STRING_SIZE];
                    av_make_error_string(errbuf, AV_ERROR_MAX_STRING_SIZE, ret);
                    printf("Error receiving frame from decoder: %s\n", errbuf);
                    break;
                }

                if (frame->pts != AV_NOPTS_VALUE) {
                    pts = av_rescale_q(frame->pts, client->pFormatCtx->streams[client->video_stream_index]->time_base, AV_TIME_BASE_Q);
                } else {
                    duration = av_frame_get_pkt_duration(frame);
                    pts = last_frame_pts + duration;
                }

                last_frame_pts = pts;

                buffer_size = av_image_get_buffer_size(client->pCodecCtx->pix_fmt, client->pCodecCtx->width, client->pCodecCtx->height, 1);
                buffer = (uint8_t*)av_malloc(buffer_size);
                av_image_fill_arrays(frame->data, frame->linesize, buffer, client->pCodecCtx->pix_fmt, client->pCodecCtx->width, client->pCodecCtx->height, 1);

                av_init_packet(&packet);
                packet.data = buffer;
                packet.size = buffer_size;
                packet.pts = pts;
                packet.dts = pts;
                packet.duration = duration;
                packet.stream_index = 0;

                gettimeofday(&tv, NULL);
                start_time = tv.tv_sec * 1000000 + tv.tv_usec;

                av_packet_rescale_ts(&packet, client->pFormatCtx->streams[client->video_stream_index]->time_base, client->pFormatCtx->streams[0]->time_base);

                ret = av_interleaved_write_frame(client->pFormatCtx, &packet);
                if (ret < 0) {
                    char errbuf[AV_ERROR_MAX_STRING_SIZE];
                    av_make_error_string(errbuf, AV_ERROR_MAX_STRING_SIZE, ret);
                    printf("Error writing frame: %s\n", errbuf);
                }

                gettimeofday(&tv, NULL);
                end_time = tv.tv_sec * 1000000 + tv.tv_usec;

                sleep_time = (duration * 1000000 - (end_time - start_time)) / 1000;
                if (sleep_time > 0) {
                    usleep(sleep_time);
                }

                av_packet_unref(&packet);
                av_free(buffer);
                av_frame_free(&frame);
            }
        } else {
            av_packet_unref(&packet);
        }
    }

    avformat_close_input(&client->pFormatCtx);
    avcodec_free_context(&client->pCodecCtx);
    av_frame_free(&client->pFrame);
    sws_freeContext(client->img_convert_ctx);
    close(client->socket);
    client->state = 0;

    return NULL;
}

int main(int argc, char *argv[]) {
    int ret;
    int server_socket;
    int client_socket;
    struct sockaddr_in server_address;
    struct sockaddr_in client_address;
    socklen_t client_address_len;
    char buf[1024];
    int n;
    int i;
    int optval;
    RTSPClient *client;

    av_register_all();
    avformat_network_init();

    server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket < 0) {
        printf("Error creating socket: %s\n", strerror(errno));
        return 1;
    }

    optval = 1;
    setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));

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

    ret = bind(server_socket, (struct sockaddr*)&server_address, sizeof(server_address));
    if (ret < 0) {
        printf("Error binding socket: %s\n", strerror(errno));
        close(server_socket);
        return 1;
    }

    ret = listen(server_socket, 5);
    if (ret < 0) {
        printf("Error listening on socket: %s\n", strerror(errno));
        close(server_socket);
        return 1;
    }

    for (i = 0; i < MAX_CLIENTS; i++) {
        clients[i].state = 0;
    }

    while (1) {
        client_address_len = sizeof(client_address);
        client_socket = accept(server_socket, (struct sockaddr*)&client_address, &client_address_len);
        if (client_socket < 0) {
            printf("Error accepting connection: %s\n", strerror(errno));
            continue;
        }

        for (i = 0; i < MAX_CLIENTS; i++) {
            if (clients[i].state == 0) {
                client = &clients[i];
                break;
            }
        }

        if (i == MAX_CLIENTS) {
            printf("Too many clients\n");
            close(client_socket);
            continue;
        }

        client->state = 1;
        client->socket = client_socket;
        client->address = client_address;

        client->pFormatCtx = avformat_alloc_context();
        client->pCodecCtx = NULL;
        client->pCodec = NULL;
        client->pFrame = NULL;
        client->img_convert_ctx = NULL;
        client->video_stream_index = -1;

        ret = avformat_open_input(&client->pFormatCtx, "video.mp4", NULL, NULL);
        if (ret < 0) {
            char errbuf[AV_ERROR_MAX_STRING_SIZE];
            av_make_error_string(errbuf, AV_ERROR_MAX_STRING_SIZE, ret);
            printf("Error opening input file: %s\n", errbuf);
            close(client_socket);
            client->state = 0;
            continue;
        }

        ret = avformat_find_stream_info(client->pFormatCtx, NULL);
        if (ret < 0) {
            char errbuf[AV_ERROR_MAX_STRING_SIZE];
            av_make_error_string(errbuf, AV_ERROR_MAX_STRING_SIZE, ret);
            printf("Error finding stream info: %s\n", errbuf);
            avformat_close_input(&client->pFormatCtx);
            close(client_socket);
            client->state = 0;
            continue;
        }

        for (i = 0; i < client->pFormatCtx->nb_streams; i++) {
            if (client->pFormatCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
                client->video_stream_index = i;
                break;
            }
        }

        if (client->video_stream_index == -1) {
            printf("No video stream found\n");
            avformat_close_input(&client->pFormatCtx);
            close(client_socket);
            client->state = 0;
            continue;
        }

        client->pCodec = avcodec_find_decoder(client->pFormatCtx->streams[client->video_stream_index]->codecpar->codec_id);
        if (!client->pCodec) {
            printf("Codec not found\n");
            avformat_close_input(&client->pFormatCtx);
            close(client_socket);
            client->state = 0;
            continue;
        }

        client->pCodecCtx = avcodec_alloc_context3(client->pCodec);
        if (!client->pCodecCtx) {
            printf("Error allocating codec context\n");
            avformat_close_input(&client->pFormatCtx);
            close(client_socket);
            client->state = 0;
            continue;
        }

        ret = avcodec_parameters_to_context(client->pCodecCtx, client->pFormatCtx->streams[client->video_stream_index]->codecpar);
        if (ret < 0) {
            char errbuf[AV_ERROR_MAX_STRING_SIZE];
            av_make_error_string(errbuf, AV_ERROR_MAX_STRING_SIZE, ret);
            printf("Error setting codec parameters: %s\n", errbuf);
            avcodec_free_context(&client->pCodecCtx);
            avformat_close_input(&client->pFormatCtx);
            close(client_socket);
            client->state = 0;
            continue;
        }

        ret = avcodec_open2(client->pCodecCtx, client->pCodec, NULL);
        if (ret < 0) {
            char errbuf[AV_ERROR_MAX_STRING_SIZE];
            av_make_error_string(errbuf, AV_ERROR_MAX_STRING_SIZE, ret);
            printf("Error opening codec: %s\n", errbuf);
            avcodec_free_context(&client->pCodecCtx);
            avformat_close_input(&client->pFormatCtx);
            close(client_socket);
            client->state = 0;
            continue;
        }

        client->pFrame = av_frame_alloc();
        if (!client->pFrame) {
            printf("Error allocating frame\n");
            avcodec_free_context(&client->pCodecCtx);
            avformat_close_input(&client->pFormatCtx);
            close(client_socket);
            client->state = 0;
            continue;
        }

        client->img_convert_ctx = sws_getContext(client->pCodecCtx->width, client->pCodecCtx->height, client->pCodecCtx->pix_fmt, client->pCodecCtx->width, client->pCodecCtx->height, AV_PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);
        if (!client->img_convert_ctx) {
            printf("Error creating img_convert_ctx\n");
            av_frame_free(&client->pFrame);
            avcodec_free_context(&client->pCodecCtx);
            avformat_close_input(&client->pFormatCtx);
            close(client_socket);
            client->state = 0;
            continue;
        }

        ret = pthread_create(&client->thread_id, NULL, client_thread, client);
        if (ret != 0) {
            printf("Error creating thread\n");
            av_frame_free(&client->pFrame);
            sws_freeContext(client->img_convert_ctx);
            avcodec_free_context(&client->pCodecCtx);
            avformat_close_input(&client->pFormatCtx);
            close(client_socket);
            client->state = 0;
            continue;
        }
    }

    for (i = 0; i < MAX_CLIENTS; i++) {
        if (clients[i].state == 1) {
            clients[i].is_running = false;
            pthread_join(clients[i].thread_id, NULL);
            av_frame_free(&clients[i].pFrame);
            sws_freeContext(clients[i].img_convert_ctx);
            avcodec_free_context(&clients[i].pCodecCtx);
            avformat_close_input(&clients[i].pFormatCtx);
            close(clients[i].socket);
        }
    }

    avformat_network_deinit();
    av_free_all();

    return 0;
}

3. 启动 RTSP 服务器：你需要在终端上运行上面编写好的 C++ 程序，然后根据需要设置你的客户端连接地址和端口号，并开始发送数据。

以上就是使用 C++ 和 FFmpeg 创建 RTSP 服务器的基本步骤。如果你不想从头开始编写代码，也可以使用现成的 RTSP 服务器实现，如 Live555 或者 FFmpeg 提供的 RTSP 服务器。

开源工具iperf代码C/C++

以下是iperf3的C代码，可以在GitHub上找到完整的代码：

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

#include "iperf.h"
#include "iperf_api.h"
#include "iperf_locale.h"
#include "units.h"
#include "net.h"
#include "timer.h"
#include "tcp_window_size.h"
#include "cjson.h"

#ifdef HAVE_SSL
#include <openssl/ssl.h>
#include <openssl/err.h>
#endif

/* Forwards. */
static int iperf_run(struct iperf_test *test);

/**************************************************************************/

int
main(int argc, char **argv)
{
    int i;
    struct iperf_test *test;
    int result;
    struct sigaction sa;
    char client_version[10] = IPERF_VERSION;

    setlocale(LC_ALL, "");
    bindtextdomain("iperf3", LOCALEDIR);
    textdomain("iperf3");

    /* Initialize settings. */
    test = iperf_new_test();

    /* Register a few signal handlers to make clean exit more likely. */
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = &iperf_got_sigint;
    sigaction(SIGINT, &sa, NULL);
    sa.sa_handler = &iperf_got_sigpipe;
    sigaction(SIGPIPE, &sa, NULL);

    /* Parse command line options, handling some options immediately. */
    i = iperf_parse_arguments(test, argc, argv);
    if (i < 0) {
        fprintf(stderr, "%s", iperf_strerror(i));
        exit(1);
    }
    if (test->version) {
        printf("%s\n", client_version);
        exit(0);
    } else if (test->help) {
        iperf_printf(test, "\n%s\n\n%s\n\n%s\n\n%s\n\n%s\n\n%s\n\n%s\n",
                "Usage: iperf3 [-options] [-s|-c host] [options]\n",
                "Client/Server:",
                "  -V, --version           show version information and quit.",
                "  -h, --help              show this message and quit.",
                "  -i, --interval n        seconds between periodic bandwidth reports.",
                "  -f, --format [kmKM]     format to report: Kbits, Mbits, KBytes, MBytes",
                "  -P, --parallel n        number of parallel client streams to run.");
        iperf_printf(test, "\n%s\n\n%s\n\n%s\n\n%s\n\n%s\n\n%s\n\n%s\n\n%s\n\n%s\n\n%s\n\n%s\n\n%s\n\n%s\n\n%s\n\n",
                "Client specific:",
                "  -c, --client    <host>  run in client mode, connecting to <host>.",
                "  -u, --udp               use UDP rather than TCP.",
                "  -b, --bitrate #[KMG][/#] target bitrate in bits/sec (0 for unlimited)",
                "                           (default 1 Mbit/sec for UDP, unlimited for TCP)",
                "  -t, --time    n         time in seconds to transmit for (default 10 secs)",
                "  -n, --bytes   n         number of bytes to transmit (instead of -t)",
                "  -k, --blockcount #[KMG] number of blocks (packets) to transmit (instead of -t or -n)",
                "  -l, --length  #[KMG]    length of buffer to read or write",
                "                           (default 128 KB for TCP, dynamic or 8 KB for UDP)",
                "  -R, --reverse           reverse the direction of a test (client sends, server receives).");
        iperf_printf(test, "\n%s\n\n%s\n\n%s\n\n%s\n\n%s\n\n",
                "Server specific:",
                "  -s, --server            run in server mode.",
                "  -D, --daemon            run the server as a daemon",
                "  -I, --pidfile file      write PID file (default /var/run/iperf3.pid)",
                "  -1, --one-off           handle one client connection then exit.",
                "  -B, --bind      <host>  bind to a specific interface, e.g. eth0");
        iperf_printf(test, "\n%s\n\n%s\n\n%s\n\n%s\n\n%s\n\n%s\n\n%s\n\n%s\n\n",
                "JSON options:",
                "  -J, --json              output in JSON format",
                "  --logfile f             send output to a log file",
                "",
                "For more information and tuning options, see iperf3's man page.",
                "",
                "Please report bugs to https://github.com/esnet/iperf",
                "");
        exit(0);
    }

    /* Check for version number consistency. */
    if (test->protocol->id == Ptcp && test->version == 3 && test->tcp.omit_version) {
        i = 2;
    } else {
        i = 3;
    }
    if (strncmp(client_version, test->version_string, i) != 0) {
        iperf_printf(test, "warning: version number mismatch (client %s, server %s)\n",
                client_version, test->version_string);
    }

    /* Initialize IP protocol */
    if (test->cookiefile) {
        test->cookie = iperf_load_cookie(test->cookiefile);
        if (test->cookie == NULL) {
            iperf_errexit(test, "unable to load cookie from file '%s'", test->cookiefile);
        }
    }

    if (test->reverse)
        test->settings->reverse = 1;

    if (test->protocol->id == Pudp) {
        if (test->settings->mss || test->settings->socket_bufsize) {
            iperf_printf(test, "warning: MSS and socket buffer size settings are not used in UDP mode.\n");
        }
        if (test->settings->no_delay) {
            iperf_printf(test, "warning: the TCP_NODELAY option is not used in UDP mode.\n");
        }
        if (test->settings->pmtu != -1) {
            iperf_printf(test, "warning: the PMTU option is not used in UDP mode.\n");
        }
    }

#ifdef HAVE_SSL
    /* Initialize SSL library */
    if (test->protocol->id == Ptcp && test->settings->ssl) {
        SSL_load_error_strings();
        SSL_library_init();
        test->sslctx = SSL_CTX_new(TLS_client_method());
        if (test->sslctx == NULL) {
            iperf_errexit(test, "failed to create SSL context\n");
        }
        if (test->settings->ssl_cafile) {
            if (SSL_CTX_load_verify_locations(test->sslctx, test->settings->ssl_cafile, NULL) != 1) {
                SSL_CTX_free(test->sslctx);
                iperf_errexit(test, "failed to load CA certificates from %s\n", test->settings->ssl_cafile);
            }
        }
        if (test->settings->ssl_cert) {
            if (SSL_CTX_use_certificate_chain_file(test->sslctx, test->settings->ssl_cert) != 1) {
                SSL_CTX_free(test->sslctx);
                iperf_errexit(test, "failed to load SSL certificate from %s\n", test->settings->ssl_cert);
            }
        }
        if (test->settings->ssl_key) {
            if (SSL_CTX_use_PrivateKey_file(test->sslctx, test->settings->ssl_key, SSL_FILETYPE_PEM) != 1) {
                SSL_CTX_free(test->sslctx);
                iperf_errexit(test, "failed to load SSL key from %s\n", test->settings->ssl_key);
            }
        }
        SSL_CTX_set_verify(test->sslctx, SSL_VERIFY_PEER, NULL);
    }
#endif

    /* Daemon mode. */
    if (test->daemon) {
        if (daemon(0, 0) != 0) {
            iperf_errexit(test, "error - failed to become a daemon: %s\n", strerror(errno));
        }
        if (test->pidfile) {
            FILE *f;
            f = fopen(test->pidfile, "w");
            if (f == NULL) {
                iperf_errexit(test, "error - unable to write PID file '%s': %s\n", test->pidfile, strerror(errno));
            }
            fprintf(f, "%d\n", getpid());
            fclose(f);
        }
    }

    /* Ignore SIGPIPE to simplify error handling */
    sa.sa_handler = SIG_IGN;
    sigaction(SIGPIPE, &sa, NULL);

    /* If we are doing a single client (-1) and it is a daemon, don't do -D again */
    if (test->daemon && test->num_ostreams == 1)
        test->daemon = 0;

    /* Defer daemon mode until after the above check for single client + daemon */
    if (test->daemon) {
        if (daemon(0, 0) != 0) {
            iperf_errexit(test, "error - failed to become a daemon: %s\n", strerror(errno));
        }
        if (test->pidfile) {
            FILE *f;
            f = fopen(test->pidfile, "w");
            if (f == NULL) {
                iperf_errexit(test, "error - unable to write PID file '%s': %s\n", test->pidfile, strerror(errno));
            }
            fprintf(f, "%d\n", getpid());
            fclose(f);
        }
    }

    /* Ignore SIGPIPE to simplify error handling */
    sa.sa_handler = SIG_IGN;
    sigaction(SIGPIPE, &sa, NULL);

    /* Set up the output stream */
    if (test->json_output) {
        test->outfile = json_get_output_stream(test->json_output_file);
    } else if (test->logfile) {
        test->outfile = fopen(test->logfile, "w");
        if (test->outfile == NULL) {
            iperf_errexit(test, "error - unable to write log to file '%s': %s\n", test->logfile, strerror(errno));
        }
    } else {
        test->outfile = stdout;
    }

    /* Start the client or server */
    if (test->server) {
        if (test->daemon) {
            iperf_printf(test, "Server listening on port %d\n", test->server_port);
        }
        else {
            iperf_printf(test, "-----------------------------------------------------------\n");
            iperf_printf(test, "Server listening on %s port %d\n", test->settings->domain == AF_INET6 ? "[::]" : "0.0.0.0", test->server_port);
            iperf_printf(test, "-----------------------------------------------------------\n");
        }
        result = iperf_run_server(test);
    } else {
        if (test->daemon) {
            iperf_printf(test, "Client connecting to %s, TCP port %d\n", test->server_hostname, test->server_port);
        }
        else {
            if (test->reverse)
                iperf_printf(test, "-----------------------------------------------------------\n");
            iperf_printf(test, "Client connecting to %s, %s port %d\n", test->server_hostname, test->protocol->name, test->server_port);
            if (test->reverse)
                iperf_printf(test, "-----------------------------------------------------------\n");
        }
        result = iperf_run_client(test);
    }

    if (test->cookie)
        iperf_delete_cookie(test->cookie);

#ifdef HAVE_SSL
    if (test->protocol->id == Ptcp && test->settings->ssl) {
        SSL_CTX_free(test->sslctx);
    }
    ERR_free_strings();
#endif

    iperf_free_test(test);

    return result;
}

static int
iperf_run(struct iperf_test *test)
{
    test->start_time = milliseconds();
    test->next_time = test->start_time;
    test->bytes_sent = 0;
    test->blocks_sent = 0;
    test->retransmits = 0;

    if (test->server_hostname) {
        test->server_hostname_len = strlen(test->server_hostname);
    }

    if (test->bind_address) {
        test->bind_address_len = strlen(test->bind_address);
    }

    if (test->json_output) {
        cJSON *json_output = cJSON_CreateObject();
        if (json_output == NULL) {
            iperf_errexit(test, "error - cJSON_CreateObject failed: %s\n", strerror(errno));
        }
        cJSON_AddItemToObject(json_output, "start", cJSON_CreateNumber((double) test->start_time / 1000));
        if (test->verbose) {
            cJSON_AddItemToObject(json_output, "verbose", cJSON_CreateNumber(1));
        }
        cJSON_AddItemToObject(json_output, "system_info", cJSON_CreateObject());
        iperf_json_printf(json_output, "version", "%s", test->version);
        iperf_json_printf(json_output, "system_info", "%s", get_system_info());
        if (test->title) {
            iperf_json_printf(json_output, "title", "%s", test->title);
        }
        if (test->extra_data) {
            cJSON_AddItemToObject(json_output, "extra_data", cJSON_Parse(test->extra_data));
        }
        test->json_start_time = milliseconds();
        test->json_output_string = cJSON_Print(json_output);
        cJSON_Delete(json_output);
        if (test->json_output_string == NULL) {
            iperf_errexit(test, "error - cJSON_Print failed: %s\n", strerror(errno));
        }
    }

    if (test->protocol->id == Ptcp) {
        if (test->settings->socket_bufsize) {
            if (iperf_set_tcp_windowsize(test) != 0) {
                iperf_errexit(test, "error - %s\n", strerror(errno));
            }
        }
    }

    if (test->reverse) {
        if (test->protocol->id == Ptcp) {
            if (iperf_create_streams(test, test->reverse) < 0) {
                iperf_errexit(test, "error - %s\n", strerror(errno));
            }
        }
        if (iperf_connect(test, test->reverse) < 0) {
            iperf_errexit(test, "error - %s\n", strerror(errno));
        }
    } else {
        if (iperf_create_streams(test, test->reverse) < 0) {
            iperf_errexit(test, "error - %s\n", strerror(errno));
        }
        if (iperf_connect(test, test->reverse) < 0) {
            iperf_errexit(test, "error - %s\n", strerror(errno));
        }
    }

    if (test->json_output) {
        cJSON *json_output = cJSON_CreateObject();
        if (json_output == NULL) {
            iperf_errexit(test, "error - cJSON_CreateObject failed: %s\n", strerror(errno));
        }
        cJSON_AddItemToObject(json_output, "start", cJSON_CreateNumber((double) test->start_time / 1000));
        if (test->verbose) {
            cJSON_AddItemToObject(json_output, "verbose", cJSON_CreateNumber(1));
        }
        iperf_json_printf(json_output, "interval", "%d", test->settings->stats_interval);
        if (test->title) {
            iperf_json_printf(json_output, "title", "%s", test->title);
        }
        if (test->extra_data) {
            cJSON_AddItemToObject(json_output, "extra_data", cJSON_Parse(test->extra_data));
        }
        iperf_json_printf(json_output, "start_connected", "%d", test->connected);
        cJSON_AddItemToObject(json_output, "intervals", cJSON_CreateArray());
        test->json_output_string = cJSON_Print(json_output);
        cJSON_Delete(json_output);
        if (test->json_output_string == NULL) {
            iperf_errexit(test, "error - cJSON_Print failed: %s\n", strerror(errno));
        }
    }

    if (test->protocol->id == Pudp) {
        if (iperf_udp_connect(test) < 0) {
            iperf_errexit(test, "error - %s\n", strerror(errno));
        }
    }

    if (test->reverse) {
        if (test->protocol->id == Ptcp) {
            if (iperf_listen(test) < 0) {
                iperf_errexit(test, "error - %s\n", strerror(errno));
            }
        }
        if (test->protocol->id == Pudp || test->protocol->id == Psctp) {
            if (iperf_run_server_udp(test) < 0) {
                iperf_errexit(test, "error - %s\n", strerror(errno));
            }
        } else {
            if (iperf_run_server_tcp(test) < 0) {
                iperf_errexit(test, "error - %s\n", strerror(errno));
            }
        }
    } else {
        if (test->protocol->id == Ptcp) {
            if (iperf_run_client_tcp(test) < 0) {
                iperf_errexit(test, "error - %s\n", strerror(errno));
            }
        } else {
            if (iperf_run_client_udp(test) < 0) {
                iperf_errexit(test, "error - %s\n", strerror(errno));
            }
        }
    }

    if (test->json_output) {
        cJSON *json_output = cJSON_CreateObject();
        if (json_output == NULL) {
            iperf_errexit(test, "error - cJSON_CreateObject failed: %s\n", strerror(errno));
        }
        cJSON_AddItemToObject(json_output, "start", cJSON_CreateNumber((double) test->start_time / 1000));
        if (test->verbose) {
            cJSON_AddItemToObject(json_output, "verbose", cJSON_CreateNumber(1));
        }
        iperf_json_printf(json_output, "interval", "%d", test->settings->stats_interval);
        if (test->title) {
            iperf_json_printf(json_output, "title", "%s", test->title);
        }
        if (test