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 justkilling it plugins can tidily shutdown and free allocatedresources. 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_onlywhile(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_REVSVN_REV,
#elseSOURCE_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_REVLOG("MJPG Streamer Version: svn rev: %s\n", SVN_REV);
#elseLOG("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); // 初始化dynctrlsenumerateControls(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);#endifif(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;

}