mjpg-streamer框架分析

mjpg-streamer框架分析

---

---

框架

main

这个函数是一个C程序的主函数，接受命令行参数并执行相应的操作。下面是这个函数的要点：
定义了一些变量，包括输入插件数组input、输出插件数组output、是否后台运行的标志daemon等。
初始化输出插件数组的第一个元素为固定的字符串。
使用getopt_long_only函数解析命令行参数。
根据解析的选项进行相应的操作，例如显示帮助信息、将输入插件添加到输入插件数组、将输出插件添加到输出插件数组、显示版本信息、设置后台运行标志等。
打开系统日志，并记录日志信息。
如果设置了后台运行标志，调用daemon_mode函数将程序转为后台运行。
忽略SIGPIPE信号。
注册信号处理程序，用于处理+C信号。
显示MJPG Streamer的版本信息。
检查是否至少选择了一个输出插件，如果没有，则使用默认插件。
初始化并打开输入插件。其中，根据输入插件名称打开相应的动态链接库，获取插件的初始化、停止和运行函数指针，并调用初始化函数进行初始化。
打开输出插件。类似于打开输入插件，获取插件的初始化、停止和运行函数指针，并调用初始化函数进行初始化。
开始读取输入，并将图像数据推送到全局缓冲区。
启动输出插件，将图像数据从全局缓冲区发送到输出。
程序进入暂停状态，等待信号的到来。
返回0，表示程序正常结束。
总体来说，这个函数是一个简单的命令行程序，用于控制输入和输出插件的启动和运行，并提供一些选项来配置程序的行为。

/*******************************************************************************
#                                                                              #
#      MJPG-streamer allows to stream JPG frames from an input-plugin          #
#      to several output plugins                                               #
#                                                                              #
#      Copyright (C) 2007 Tom Stöveken                                         #
#                                                                              #
# This program is free software; you can redistribute it and/or modify         #
# it under the terms of the GNU General Public License as published by         #
# the Free Software Foundation; version 2 of the License.                      #
#                                                                              #
# This program is distributed in the hope that it will be useful,              #
# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                #
# GNU General Public License for more details.                                 #
#                                                                              #
# You should have received a copy of the GNU General Public License            #
# along with this program; if not, write to the Free Software                  #
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA    #
#                                                                              #
*******************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <linux/videodev2.h>
#include <sys/ioctl.h>
#include <errno.h>
#include <signal.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <getopt.h>
#include <pthread.h>
#include <dlfcn.h>
#include <fcntl.h>
#include <syslog.h>

#include "utils.h"
#include "mjpg_streamer.h"

/* globals */
static globals global;

/******************************************************************************
Description.: Display a help message
Input Value.: argv[0] is the program name and the parameter progname
Return Value: -
******************************************************************************/
void help(char *progname)
{
    fprintf(stderr, "-----------------------------------------------------------------------\n");
    fprintf(stderr, "Usage: %s\n" \
            "  -i | --input \"<input-plugin.so> [parameters]\"\n" \
            "  -o | --output \"<output-plugin.so> [parameters]\"\n" \
            " [-h | --help ]........: display this help\n" \
            " [-v | --version ].....: display version information\n" \
            " [-b | --background]...: fork to the background, daemon mode\n", progname);
    fprintf(stderr, "-----------------------------------------------------------------------\n");
    fprintf(stderr, "Example #1:\n" \
            " To open an UVC webcam \"/dev/video1\" and stream it via HTTP:\n" \
            "  %s -i \"input_uvc.so -d /dev/video1\" -o \"output_http.so\"\n", progname);
    fprintf(stderr, "-----------------------------------------------------------------------\n");
    fprintf(stderr, "Example #2:\n" \
            " To open an UVC webcam and stream via HTTP port 8090:\n" \
            "  %s -i \"input_uvc.so\" -o \"output_http.so -p 8090\"\n", progname);
    fprintf(stderr, "-----------------------------------------------------------------------\n");
    fprintf(stderr, "Example #3:\n" \
            " To get help for a certain input plugin:\n" \
            "  %s -i \"input_uvc.so --help\"\n", progname);
    fprintf(stderr, "-----------------------------------------------------------------------\n");
    fprintf(stderr, "In case the modules (=plugins) can not be found:\n" \
            " * Set the default search path for the modules with:\n" \
            "   export LD_LIBRARY_PATH=/path/to/plugins,\n" \
            " * or put the plugins into the \"/lib/\" or \"/usr/lib\" folder,\n" \
            " * or instead of just providing the plugin file name, use a complete\n" \
            "   path and filename:\n" \
            "   %s -i \"/path/to/modules/input_uvc.so\"\n", progname);
    fprintf(stderr, "-----------------------------------------------------------------------\n");
}

/******************************************************************************
Description.: pressing CTRL+C sends signals to this process instead of just
              killing it plugins can tidily shutdown and free allocated
              resources. The function prototype is defined by the system,
              because it is a callback function.
Input Value.: sig tells us which signal was received
Return Value: -
******************************************************************************/
void signal_handler(int sig)
{
    int i;

    /* signal "stop" to threads */
    LOG("setting signal to stop\n");
    global.stop = 1;
    usleep(1000 * 1000);

    /* clean up threads */
    LOG("force cancellation of threads and cleanup resources\n");
    for(i = 0; i < global.incnt; i++) {
        global.in[i].stop(i);
    }

    for(i = 0; i < global.outcnt; i++) {
        global.out[i].stop(global.out[i].param.id);
        pthread_cond_destroy(&global.in[i].db_update);
        pthread_mutex_destroy(&global.in[i].db);
    }
    usleep(1000 * 1000);

    /* close handles of input plugins */
    for(i = 0; i < global.incnt; i++) {
        dlclose(global.in[i].handle);
    }

    for(i = 0; i < global.outcnt; i++) {
        /* skip = 0;
        DBG("about to decrement usage counter for handle of %s, id #%02d, handle: %p\n", \
            global.out[i].plugin, global.out[i].param.id, global.out[i].handle);
        for(j=i+1; j<global.outcnt; j++) {
          if ( global.out[i].handle == global.out[j].handle ) {
            DBG("handles are pointing to the same destination (%p == %p)\n", global.out[i].handle, global.out[j].handle);
            skip = 1;
          }
        }
        if ( skip ) {
          continue;
        }

        DBG("closing handle %p\n", global.out[i].handle);
        */
        dlclose(global.out[i].handle);
    }
    DBG("all plugin handles closed\n");

    LOG("done\n");

    closelog();
    exit(0);
    return;
}

int split_parameters(char *parameter_string, int *argc, char **argv)
{
    int count = 1;
    argv[0] = NULL; // the plugin may set it to 'INPUT_PLUGIN_NAME'
    if(parameter_string != NULL && strlen(parameter_string) != 0) {
        char *arg = NULL, *saveptr = NULL, *token = NULL;

        arg = strdup(parameter_string);

        if(strchr(arg, ' ') != NULL) {
            token = strtok_r(arg, " ", &saveptr);
            if(token != NULL) {
                argv[count] = strdup(token);
                count++;
                while((token = strtok_r(NULL, " ", &saveptr)) != NULL) {
                    argv[count] = strdup(token);
                    count++;
                    if(count >= MAX_PLUGIN_ARGUMENTS) {
                        IPRINT("ERROR: too many arguments to input plugin\n");
                        return 0;
                    }
                }
            }
        }
    }
    *argc = count;
    return 1;
}

/******************************************************************************
Description.:
Input Value.:
Return Value:
******************************************************************************/
int main(int argc, char *argv[])
{
    //char *input  = "input_uvc.so --resolution 640x480 --fps 5 --device /dev/video0";
    char *input[MAX_INPUT_PLUGINS]; // 输入插件数组
    char *output[MAX_OUTPUT_PLUGINS]; // 输出插件数组
    int daemon = 0, i; // 是否后台运行
    size_t tmp = 0;

    output[0] = "output_http.so --port 8080"; // 输出插件
    global.outcnt = 0; // 输出插件数量


    /* parameter parsing */
    //解析参数getopt_long_only
    while(1) {
        int option_index = 0, c = 0;
        static struct option long_options[] = {
            {"h", no_argument, 0, 0
            },
            {"help", no_argument, 0, 0},
            {"i", required_argument, 0, 0},
            {"input", required_argument, 0, 0},
            {"o", required_argument, 0, 0},
            {"output", required_argument, 0, 0},
            {"v", no_argument, 0, 0},
            {"version", no_argument, 0, 0},
            {"b", no_argument, 0, 0},
            {"background", no_argument, 0, 0},
            {0, 0, 0, 0}
        };

        c = getopt_long_only(argc, argv, "", long_options, &option_index); //获取参数
        /* no more options to parse */
        if(c == -1) break;

        /* unrecognized option */
        if(c == '?') {
            help(argv[0]);
            return 0;
        }

        switch(option_index) {
            /* h, help */
        case 0:
        case 1:
            help(argv[0]); //显示帮助信息
            return 0;
            break;

            /* i, input */
        case 2:
        case 3:
            input[global.incnt++] = strdup(optarg); //将输入插件添加到输入插件数组中
            break;

            /* o, output */
        case 4:
        case 5:
            output[global.outcnt++] = strdup(optarg); //将输出插件添加到输出插件数组中
            break;

            /* v, version */
        case 6:
        case 7:
            printf("MJPG Streamer Version: %s\n" \
            "Compilation Date.....: %s\n" \
            "Compilation Time.....: %s\n",
#ifdef SVN_REV
            SVN_REV,
#else
            SOURCE_VERSION,
#endif
            __DATE__, __TIME__); //显示版本信息
            return 0;
            break;

            /* b, background */
        case 8:
        case 9:
            daemon = 1; //设置后台运行标志
            break;

        default:
            help(argv[0]); //显示帮助信息
            return 0;
        }
    }


    openlog("MJPG-streamer ", LOG_PID | LOG_CONS, LOG_USER); // 打开系统日志
    //openlog("MJPG-streamer ", LOG_PID|LOG_CONS|LOG_PERROR, LOG_USER);
    syslog(LOG_INFO, "starting application"); // 记录日志

    /* fork to the background */
    if(daemon) { // 后台运行
        LOG("enabling daemon mode"); // 记录日志
        daemon_mode(); // 后台运行
    }

    /* ignore SIGPIPE (send by OS if transmitting to closed TCP sockets) */
    signal(SIGPIPE, SIG_IGN); // 忽略SIGPIPE信号

    /* register signal handler for <CTRL>+C in order to clean up */
    if(signal(SIGINT, signal_handler) == SIG_ERR) { // 注册信号处理程序
        LOG("could not register signal handler\n"); // 记录日志
        closelog(); // 关闭日志
        exit(EXIT_FAILURE); // 退出程序
    }


    /*
     * messages like the following will only be visible on your terminal
     * if not running in daemon mode
     */
#ifdef SVN_REV
    LOG("MJPG Streamer Version: svn rev: %s\n", SVN_REV);
#else
    LOG("MJPG Streamer Version.: %s\n", SOURCE_VERSION); // 如果没有SVN_REV，则使用SOURCE_VERSION
#endif

    /* 检查是否至少选择了一个输出插件 */
    if(global.outcnt == 0) {
        /* 没有？那么使用默认插件 */
        global.outcnt = 1;
    }

    /* 打开输入插件 */
    for(i = 0; i < global.incnt; i++) {
        if(pthread_mutex_init(&global.in[i].db, NULL) != 0) { // 初始化互斥锁
            LOG("could not initialize mutex variable\n"); // 记录日志
            closelog(); // 关闭日志
            exit(EXIT_FAILURE); // 退出程序
        }
        if(pthread_cond_init(&global.in[i].db_update, NULL) != 0) { // 初始化条件变量
            LOG("could not initialize condition variable\n"); // 记录日志
            closelog(); // 关闭日志
            exit(EXIT_FAILURE); // 退出程序
        }


        // 获取输入插件名称
        tmp = (size_t)(strchr(input[i], ' ') - input[i]);
        // 初始化输入插件结构体
        global.in[i].stop      = 0;
        global.in[i].buf       = NULL;
        global.in[i].size      = 0;
        global.in[i].plugin = (tmp > 0) ? strndup(input[i], tmp) : strdup(input[i]);
        // 打开输入插件
        global.in[i].handle = dlopen(global.in[i].plugin, RTLD_LAZY);打开动态链接库

        if(!global.in[i].handle) {
            LOG("ERROR: could not find input plugin\n");
            LOG("       Perhaps you want to adjust the search path with:\n");
            LOG("       # export LD_LIBRARY_PATH=/path/to/plugin/folder\n");
            LOG("       dlopen: %s\n", dlerror());
            closelog();
            exit(EXIT_FAILURE);
        }
        global.in[i].init = dlsym(global.in[i].handle, "input_init");//让init函数指针等于打开的动态链接库中的init函数
        if(global.in[i].init == NULL) {
            LOG("%s\n", dlerror());
            exit(EXIT_FAILURE);
        }
        global.in[i].stop = dlsym(global.in[i].handle, "input_stop");
        if(global.in[i].stop == NULL) {
            LOG("%s\n", dlerror());
            exit(EXIT_FAILURE);
        }
        global.in[i].run = dlsym(global.in[i].handle, "input_run");
        if(global.in[i].run == NULL) {
            LOG("%s\n", dlerror());
            exit(EXIT_FAILURE);
        }
        /* 尝试找到可选命令 */
        global.in[i].cmd = dlsym(global.in[i].handle, "input_cmd");

        global.in[i].param.parameters = strchr(input[i], ' ');
        split_parameters(global.in[i].param.parameters, &global.in[i].param.argc, global.in[i].param.argv);
        global.in[i].param.global = &global;
        global.in[i].param.id = i;

        if(global.in[i].init(&global.in[i].param, i)) {
            LOG("input_init() return value signals to exit\n");
            closelog();
            exit(0);
        }
    }


    /* open output plugin */
    for(i = 0; i < global.outcnt; i++) {
        tmp = (size_t)(strchr(output[i], ' ') - output[i]);
        global.out[i].plugin = (tmp > 0) ? strndup(output[i], tmp) : strdup(output[i]);
        global.out[i].handle = dlopen(global.out[i].plugin, RTLD_LAZY);
        if(!global.out[i].handle) {
            LOG("ERROR: could not find output plugin %s\n", global.out[i].plugin);
            LOG("       Perhaps you want to adjust the search path with:\n");
            LOG("       # export LD_LIBRARY_PATH=/path/to/plugin/folder\n");
            LOG("       dlopen: %s\n", dlerror());
            closelog();
            exit(EXIT_FAILURE);
        }
        global.out[i].init = dlsym(global.out[i].handle, "output_init");
        if(global.out[i].init == NULL) {
            LOG("%s\n", dlerror());
            exit(EXIT_FAILURE);
        }
        global.out[i].stop = dlsym(global.out[i].handle, "output_stop");
        if(global.out[i].stop == NULL) {
            LOG("%s\n", dlerror());
            exit(EXIT_FAILURE);
        }
        global.out[i].run = dlsym(global.out[i].handle, "output_run");
        if(global.out[i].run == NULL) {
            LOG("%s\n", dlerror());
            exit(EXIT_FAILURE);
        }

        /* try to find optional command */
        global.out[i].cmd = dlsym(global.out[i].handle, "output_cmd");

        global.out[i].param.parameters = strchr(output[i], ' ');
        split_parameters(global.out[i].param.parameters, &global.out[i].param.argc, global.out[i].param.argv);

        global.out[i].param.global = &global;
        global.out[i].param.id = i;
        if(global.out[i].init(&global.out[i].param, i)) {
            LOG("output_init() return value signals to exit\n");
            closelog();
            exit(0);
        }
    }

    /* start to read the input, push pictures into global buffer */
    DBG("starting %d input plugin\n", global.incnt);
    for(i = 0; i < global.incnt; i++) {
        syslog(LOG_INFO, "starting input plugin %s", global.in[i].plugin);
        if(global.in[i].run(i)) {
            LOG("can not run input plugin %d: %s\n", i, global.in[i].plugin);
            closelog();
            return 1;
        }
    }

    DBG("starting %d output plugin(s)\n", global.outcnt);
    for(i = 0; i < global.outcnt; i++) {
        syslog(LOG_INFO, "starting output plugin: %s (ID: %02d)", global.out[i].plugin, global.out[i].param.id);
        global.out[i].run(global.out[i].param.id);
    }

    /* wait for signals */
    pause();//等待信号

    return 0;
}

input_init

这个input_init函数是用于初始化视频设备输入参数的函数。函数接受一个input_parameter类型的指针参数param和一个整数参数id。以下是函数的主要步骤和功能：
初始化互斥变量cams[id].controls_mutex，使用pthread_mutex_init函数。
设置默认的设备路径、宽度、高度、帧率和格式等参数。
解析命令行参数，使用getopt_long_only函数进行参数解析，并将解析的值赋给相应的参数变量。
将解析的参数值赋给param结构体。
分配并初始化cams[id].videoIn结构体。
打开视频设备并准备数据结构，调用init_videoIn函数。
如果设置了dynctrls标志，使用initDynCtrls函数初始化动态控制。
枚举V4L2控制项，调用enumerateControls函数。
在成功时返回0，否则可能显示错误消息并退出程序。

int input_init(input_parameter *param, int id)
{
    char *dev = "/dev/video0", *s;
    int width = 640, height = 480, fps = 5, format = V4L2_PIX_FMT_MJPEG, i;
    /* initialize the mutes variable */
    if(pthread_mutex_init(&cams[id].controls_mutex, NULL) != 0) {
        IPRINT("could not initialize mutex variable\n");
        exit(EXIT_FAILURE);
    }

    param->argv[0] = INPUT_PLUGIN_NAME;

    /* show all parameters for DBG purposes */
    for(i = 0; i < param->argc; i++) {
        DBG("argv[%d]=%s\n", i, param->argv[i]);
    }

    /* parse the parameters */
    reset_getopt();
    while(1) {
        int option_index = 0, c = 0;
        static struct option long_options[] = {
            {"h", no_argument, 0, 0
            },
            {"help", no_argument, 0, 0},
            {"d", required_argument, 0, 0},
            {"device", required_argument, 0, 0},
            {"r", required_argument, 0, 0},
            {"resolution", required_argument, 0, 0},
            {"f", required_argument, 0, 0},
            {"fps", required_argument, 0, 0},
            {"y", no_argument, 0, 0},
            {"yuv", no_argument, 0, 0},
            {"q", required_argument, 0, 0},
            {"quality", required_argument, 0, 0},
            {"m", required_argument, 0, 0},
            {"minimum_size", required_argument, 0, 0},
            {"n", no_argument, 0, 0},
            {"no_dynctrl", no_argument, 0, 0},
            {"l", required_argument, 0, 0},
            {"led", required_argument, 0, 0},
            {0, 0, 0, 0}
        };

        /* parsing all parameters according to the list above is sufficent */
        c = getopt_long_only(param->argc, param->argv, "", long_options, &option_index);

        /* no more options to parse */
        if(c == -1) break;

        /* unrecognized option */
        if(c == '?') {
            help();
            return 1;
        }

        /* dispatch the given options */
        switch(option_index) {
            /* h, help */
        case 0:
        case 1:
            DBG("case 0,1\n");
            help();
            return 1;
            break;

            /* d, device */
        case 2:
        case 3:
            DBG("case 2,3\n");
            dev = strdup(optarg);
            break;

            /* r, resolution */
        case 4:
        case 5:
            DBG("case 4,5\n");
            width = -1;
            height = -1;

            /* try to find the resolution in lookup table "resolutions" */
            for(i = 0; i < LENGTH_OF(resolutions); i++) {
                if(strcmp(resolutions[i].string, optarg) == 0) {
                    width  = resolutions[i].width;
                    height = resolutions[i].height;
                }
            }
            /* done if width and height were set */
            if(width != -1 && height != -1)
                break;
            /* parse value as decimal value */
            width  = strtol(optarg, &s, 10);
            height = strtol(s + 1, NULL, 10);
            break;

            /* f, fps */
        case 6:
        case 7:
            DBG("case 6,7\n");
            fps = atoi(optarg);
            break;

            /* y, yuv */
        case 8:
        case 9:
            DBG("case 8,9\n");
            format = V4L2_PIX_FMT_YUYV;
            break;

            /* q, quality */
        case 10:
        case 11:
            DBG("case 10,11\n");
            format = V4L2_PIX_FMT_YUYV;
            gquality = MIN(MAX(atoi(optarg), 0), 100);
            break;

            /* m, minimum_size */
        case 12:
        case 13:
            DBG("case 12,13\n");
            minimum_size = MAX(atoi(optarg), 0);
            break;

            /* n, no_dynctrl */
        case 14:
        case 15:
            DBG("case 14,15\n");
            dynctrls = 0;
            break;

            /* l, led */
        case 16:
        case 17:/*
        DBG("case 16,17\n");
        if ( strcmp("on", optarg) == 0 ) {
          led = IN_CMD_LED_ON;
        } else if ( strcmp("off", optarg) == 0 ) {
          led = IN_CMD_LED_OFF;
        } else if ( strcmp("auto", optarg) == 0 ) {
          led = IN_CMD_LED_AUTO;
        } else if ( strcmp("blink", optarg) == 0 ) {
          led = IN_CMD_LED_BLINK;
        }*/
            break;

        default:
            DBG("default case\n");
            help();
            return 1;
        }
    }
    DBG("input id: %d\n", id);
    cams[id].id = id;
    cams[id].pglobal = param->global;

    /* allocate webcam datastructure */
    cams[id].videoIn = malloc(sizeof(struct vdIn));
    if(cams[id].videoIn == NULL) {
        IPRINT("not enough memory for videoIn\n");
        exit(EXIT_FAILURE);
    }
    memset(cams[id].videoIn, 0, sizeof(struct vdIn));

    /* display the parsed values */
    IPRINT("Using V4L2 device.: %s\n", dev);
    IPRINT("Desired Resolution: %i x %i\n", width, height);
    IPRINT("Frames Per Second.: %i\n", fps);
    IPRINT("Format............: %s\n", (format == V4L2_PIX_FMT_YUYV) ? "YUV" : "MJPEG");
    if(format == V4L2_PIX_FMT_YUYV)
        IPRINT("JPEG Quality......: %d\n", gquality);

    DBG("vdIn pn: %d\n", id);
    /* open video device and prepare data structure */
      if(init_videoIn(cams[id].videoIn, dev, width, height, fps, format, 1, cams[id].pglobal, id) < 0) { // 如果初始化视频输入失败
        IPRINT("init_VideoIn failed\n"); // 输出错误信息
        closelog(); // 关闭日志
        exit(EXIT_FAILURE); // 退出程序
    }
    /*
     * recent linux-uvc driver (revision > ~#125) requires to use dynctrls
     * dynctrls must get initialized
     */ // 最近的Linux-UVC驱动程序（版本>〜#125）需要使用dynctrls，dynctrls必须得到初始化
    if(dynctrls) // 如果dynctrls为真
        initDynCtrls(cams[id].videoIn->fd); // 初始化dynctrls

    enumerateControls(cams[id].videoIn, cams[id].pglobal, id); // 枚举V4L2控件在UVC扩展映射之后
    return 0;
}

input_run

input_run函数用于启动摄像头线程。它接收一个整数id作为参数，并执行以下步骤：
使用malloc函数为cams[id].pglobal->in[id].buf分配内存，大小为cams[id].videoIn->framesizeIn。如果内存分配失败，则打印错误消息并退出程序。
打印调试信息，指示正在启动摄像头线程。
使用pthread_create函数创建线程，并将上下文&(cams[id])传递给线程函数cam_thread。线程的ID存储在cams[id].threadID中。
使用pthread_detach函数将线程设置为可分离状态，以便线程结束时可以自动清理资源。
在函数执行成功时返回0。

// 启动输入线程
int input_run(int id)
{
    // 为输入缓冲区分配内存
    cams[id].pglobal->in[id].buf = malloc(cams[id].videoIn->framesizeIn);
    if(cams[id].pglobal->in[id].buf == NULL) { // 如果分配内存失败
        fprintf(stderr, "could not allocate memory\n"); // 输出错误信息
        exit(EXIT_FAILURE); // 退出程序
    }

    DBG("launching camera thread #%02d\n", id);
    /* create thread and pass context to thread function */
    pthread_create(&(cams[id].threadID), NULL, cam_thread, &(cams[id])); // 创建线程并将上下文传递给线程函数
    pthread_detach(cams[id].threadID); // 分离线程
    return 0;
}

output_init

这段代码是output_init函数的实现。该函数用于初始化输出插件的参数和配置。
函数接收两个参数：一个指向output_parameter结构体的指针param和一个整数id。
函数的主要步骤如下：
打印调试信息，指示正在初始化输出插件，并打印输出插件的ID。
初始化变量
port为8080，
credentials和
www_folder为NULL，
nocommands为0。
设置
param->argv[0]为输出插件的名称。
打印调试信息，显示所有参数的值（用于调试目的）。
重置
getopt状态，准备进行命令行参数解析。
进入循环，解析命令行参数，直到没有更多的选项可解析。
如果遇到未识别的选项，则调用
help函数打印帮助信息，并返回1表示初始化失败。
根据选项的索引执行相应的操作：
对于"h"和"help"选项，打印帮助信息，并返回1表示初始化失败。
对于"p"和"port"选项，将端口号转换为网络字节序，并赋值给
port变量。
对于"c"和"credentials"选项，将参数的字符串拷贝到
credentials变量中。
对于"w"和"www"选项，分配内存并将参数的字符串拷贝到
www_folder变量中，并确保字符串末尾有"/"。
对于"n"和"nocommands"选项，将
nocommands变量设置为1。
将输出插件的ID、全局上下文指针、配置参数赋值给相应的输出服务器结构体。
打印输出插件的配置信息，包括www文件夹路径、HTTP TCP端口号、用户名和密码（如果已设置）、命令是否启用。
在函数执行成功时返回0。
需要注意的是，代码片段中缺少一些函数和变量的定义，以及头文件的包含。此外，需要查看output_parameter结构体的定义，才能完全理解这段代码的功能和上下文关系。

int output_init(output_parameter *param, int id)
{
    int i;
    int  port;
    char *credentials, *www_folder;
    char nocommands;

    DBG("output #%02d\n", param->id);

    port = htons(8080);
    credentials = NULL;
    www_folder = NULL;
    nocommands = 0;

    param->argv[0] = OUTPUT_PLUGIN_NAME;

    /* show all parameters for DBG purposes */
    for(i = 0; i < param->argc; i++) {
        DBG("argv[%d]=%s\n", i, param->argv[i]);
    }

    reset_getopt();
    while(1) {
        int option_index = 0, c = 0;
        static struct option long_options[] = {
            {"h", no_argument, 0, 0
            },
            {"help", no_argument, 0, 0},
            {"p", required_argument, 0, 0},
            {"port", required_argument, 0, 0},
            {"c", required_argument, 0, 0},
            {"credentials", required_argument, 0, 0},
            {"w", required_argument, 0, 0},
            {"www", required_argument, 0, 0},
            {"n", no_argument, 0, 0},
            {"nocommands", no_argument, 0, 0},
            {0, 0, 0, 0}
        };

        c = getopt_long_only(param->argc, param->argv, "", long_options, &option_index);

        /* no more options to parse */
        if(c == -1) break;

        /* unrecognized option */
        if(c == '?') {
            help();
            return 1;
        }

        switch(option_index) {
            /* h, help */
        case 0:
        case 1:
            DBG("case 0,1\n");
            help();
            return 1;
            break;

            /* p, port */
        case 2:
        case 3:
            DBG("case 2,3\n");
            port = htons(atoi(optarg));
            break;

            /* c, credentials */
        case 4:
        case 5:
            DBG("case 4,5\n");
            credentials = strdup(optarg);
            break;

            /* w, www */
        case 6:
        case 7:
            DBG("case 6,7\n");
            www_folder = malloc(strlen(optarg) + 2);
            strcpy(www_folder, optarg);
            if(optarg[strlen(optarg)-1] != '/')
                strcat(www_folder, "/");
            break;

            /* n, nocommands */
        case 8:
        case 9:
            DBG("case 8,9\n");
            nocommands = 1;
            break;
        }
    }

    servers[param->id].id = param->id;
    servers[param->id].pglobal = param->global;
    servers[param->id].conf.port = port;
    servers[param->id].conf.credentials = credentials;
    servers[param->id].conf.www_folder = www_folder;
    servers[param->id].conf.nocommands = nocommands;

    OPRINT("www-folder-path...: %s\n", (www_folder == NULL) ? "disabled" : www_folder);
    OPRINT("HTTP TCP port.....: %d\n", ntohs(port));
    OPRINT("username:password.: %s\n", (credentials == NULL) ? "disabled" : credentials);
    OPRINT("commands..........: %s\n", (nocommands) ? "disabled" : "enabled");
    return 0;
}

output_run
给定的代码是一个名为output_run的函数，用于在新线程中运行输出服务器。它接受一个整数id作为输入，表示服务器的ID。
以下是代码的详细解析：
函数使用
DBG宏打印输出的服务器线程的序号(id)。
函数使用
pthread_create函数创建一个新线程，并将服务器结构体&(servers[id])作为参数传递给线程函数server_thread。
函数使用
pthread_detach函数将线程标记为可分离的，这意味着线程的资源将在退出时自动释放，无需等待主线程的显式回收。
函数返回0以表示成功启动服务器线程。

总体而言，该函数负责在新线程中启动输出服务器。它创建一个线程并将服务器结构体作为参数传递给线程函数，然后将线程标记为可分离的。这样可以使服务器在独立的线程中运行，而主线程可以继续执行其他任务。
int output_run(int id)
{
DBG(“launching server thread #%02d\n”, id);

/* create thread and pass context to thread function */
pthread_create(&(servers[id].threadID), NULL, server_thread, &(servers[id]));
pthread_detach(servers[id].threadID);

return 0;

}
server_thread
给定的代码是一个名为server_thread的线程函数，用于处理客户端连接的请求。它接受一个void*类型的参数arg，在函数内部将其转换为指向context结构体的指针。
以下是代码的详细解析：
函数从传递给线程函数的参数中获取服务器的全局上下文指针
pglobal。
函数使用
pthread_cleanup_push宏设置清理处理程序server_cleanup，以确保在线程退出时释放资源。
函数使用
getaddrinfo函数根据服务器的端口号获取地址信息。
函数初始化一些变量和数据结构，如套接字描述符数组
sd和用于存储客户端信息的数据结构（如果定义了MANAGMENT）。
函数循环遍历地址信息列表，为每个地址创建套接字，并进行绑定和监听操作。

如果成功创建了一个监听套接字，将其加入到
select函数的文件描述符集合中。
函数使用
select函数阻塞等待可读事件的发生，以接受新的客户端连接。
一旦有客户端连接请求到达监听套接字，函数将接受该连接，并为每个连接创建一个新线程来处理客户端请求。

函数将客户端连接的套接字描述符和服务器的上下文信息封装到
cfd结构体中，并将其作为参数传递给client_thread线程函数。
函数打印正在为哪个客户端提供服务，并根据需要记录客户端的信息（如果定义了
MANAGMENT）。
函数使用
pthread_create函数创建一个新线程来处理客户端连接，并将cfd结构体作为参数传递给线程函数。
函数将新线程标记为可分离的，并继续等待下一个客户端连接。

当全局变量
pglobal->stop为真时，表示需要停止服务器运行，循环结束。
函数在退出之前调用清理处理程序来释放资源，并使用
pthread_cleanup_pop宏进行清理处理程序的弹出。
函数返回
NULL，线程结束。
总体而言，该函数在一个独立的线程中运行，用于接受客户端的连接请求，并为每个连接创建一个新线程来处理客户端请求。它使用select函数进行阻塞等待，以便及时响应新的客户端连接。
void *server_thread(void *arg)
{
int on;
pthread_t client;
struct addrinfo *aip, *aip2;
struct addrinfo hints;
struct sockaddr_storage client_addr;
socklen_t addr_len = sizeof(struct sockaddr_storage);
fd_set selectfds;
int max_fds = 0;
char name[NI_MAXHOST];
int err;
int i;

context *pcontext = arg;
pglobal = pcontext->pglobal;

/* set cleanup handler to cleanup ressources */
pthread_cleanup_push(server_cleanup, pcontext);

bzero(&hints, sizeof(hints));
hints.ai_family = PF_UNSPEC;
hints.ai_flags = AI_PASSIVE;
hints.ai_socktype = SOCK_STREAM;

snprintf(name, sizeof(name), "%d", ntohs(pcontext->conf.port));
if((err = getaddrinfo(NULL, name, &hints, &aip)) != 0) {
    perror(gai_strerror(err));
    exit(EXIT_FAILURE);
}

for(i = 0; i < MAX_SD_LEN; i++)
    pcontext->sd[i] = -1;

#ifdef MANAGMENT
if (pthread_mutex_init(&client_infos.mutex, NULL)) {
    perror("Mutex initialization failed");
    exit(EXIT_FAILURE);
}

client_infos.client_count = 0;
client_infos.infos = NULL;
#endif

/* open sockets for server (1 socket / address family) */
i = 0;
for(aip2 = aip; aip2 != NULL; aip2 = aip2->ai_next) {
    if((pcontext->sd[i] = socket(aip2->ai_family, aip2->ai_socktype, 0)) < 0) {
        continue;
    }

    /* ignore "socket already in use" errors */
    on = 1;
    if(setsockopt(pcontext->sd[i], SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) {
        perror("setsockopt(SO_REUSEADDR) failed\n");
    }

    /* IPv6 socket should listen to IPv6 only, otherwise we will get "socket already in use" */
    on = 1;
    if(aip2->ai_family == AF_INET6 && setsockopt(pcontext->sd[i], IPPROTO_IPV6, IPV6_V6ONLY,
            (const void *)&on , sizeof(on)) < 0) {
        perror("setsockopt(IPV6_V6ONLY) failed\n");
    }

    /* perhaps we will use this keep-alive feature oneday */
    /* setsockopt(sd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on)); */

    if(bind(pcontext->sd[i], aip2->ai_addr, aip2->ai_addrlen) < 0) {
        perror("bind");
        pcontext->sd[i] = -1;
        continue;
    }

    if(listen(pcontext->sd[i], 10) < 0) {
        perror("listen");
        pcontext->sd[i] = -1;
    } else {
        i++;
        if(i >= MAX_SD_LEN) {
            OPRINT("%s(): maximum number of server sockets exceeded", __FUNCTION__);
            i--;
            break;
        }
    }
}

pcontext->sd_len = i;

if(pcontext->sd_len < 1) {
    OPRINT("%s(): bind(%d) failed\n", __FUNCTION__, htons(pcontext->conf.port));
    closelog();
    exit(EXIT_FAILURE);
}

/* create a child for every client that connects */
while(!pglobal->stop) {
    //int *pfd = (int *)malloc(sizeof(int));
    cfd *pcfd = malloc(sizeof(cfd));

    if(pcfd == NULL) {
        fprintf(stderr, "failed to allocate (a very small amount of) memory\n");
        exit(EXIT_FAILURE);
    }

    DBG("waiting for clients to connect\n");

    do {
        FD_ZERO(&selectfds);

        for(i = 0; i < MAX_SD_LEN; i++) {
            if(pcontext->sd[i] != -1) {
                FD_SET(pcontext->sd[i], &selectfds);

                if(pcontext->sd[i] > max_fds)
                    max_fds = pcontext->sd[i];
            }
        }

        err = select(max_fds + 1, &selectfds, NULL, NULL, NULL);

        if(err < 0 && errno != EINTR) {
            perror("select");
            exit(EXIT_FAILURE);
        }
    } while(err <= 0);

    for(i = 0; i < max_fds + 1; i++) {
        if(pcontext->sd[i] != -1 && FD_ISSET(pcontext->sd[i], &selectfds)) {
            pcfd->fd = accept(pcontext->sd[i], (struct sockaddr *)&client_addr, &addr_len);
            pcfd->pc = pcontext;

            /* start new thread that will handle this TCP connected client */
            DBG("create thread to handle client that just established a connection\n");

            if(getnameinfo((struct sockaddr *)&client_addr, addr_len, name, sizeof(name), NULL, 0, NI_NUMERICHOST) == 0) {
                syslog(LOG_INFO, "serving client: %s\n", name);
                DBG("serving client: %s\n", name);
            }

            #if defined(MANAGMENT)
            pcfd->client = add_client(name);
            #endif

            if(pthread_create(&client, NULL, &client_thread, pcfd) != 0) {
                DBG("could not launch another client thread\n");
                close(pcfd->fd);
                free(pcfd);
                continue;
            }
            pthread_detach(client);
        }
    }
}

DBG("leaving server thread, calling cleanup function now\n");
pthread_cleanup_pop(1);

return NULL;

}

如果文章对您有帮助，点赞👍支持，感谢🤝