C++ (Cpp) BSignal_Finish示例

示例#1

文件： dhcpclient_test.c 项目： carriercomm/NCD

int main (int argc, char **argv)
{
    if (argc <= 0) {
        return 1;
    }
    
    if (argc != 2) {
        printf("Usage: %s <interface>\n", argv[0]);
        goto fail0;
    }
    
    char *ifname = argv[1];
    
    BTime_Init();
    
    BLog_InitStdout();
    
    if (!BNetwork_GlobalInit()) {
        DEBUG("BNetwork_GlobalInit failed");
        goto fail1;
    }
    
    if (!BReactor_Init(&reactor)) {
        DEBUG("BReactor_Init failed");
        goto fail1;
    }
    
    if (!BSignal_Init(&reactor, signal_handler, NULL)) {
        DEBUG("BSignal_Init failed");
        goto fail2;
    }
    
    struct BDHCPClient_opts opts = {};
    
    if (!BDHCPClient_Init(&dhcp, ifname, opts, &reactor, dhcp_handler, NULL)) {
        DEBUG("BDHCPClient_Init failed");
        goto fail3;
    }
    
    BReactor_Exec(&reactor);
    
    BDHCPClient_Free(&dhcp);
fail3:
    BSignal_Finish();
fail2:
    BReactor_Free(&reactor);
fail1:
    BLog_Free();
fail0:
    DebugObjectGlobal_Finish();
    
    return 1;
}

示例#2

文件： ncd.c 项目： AmVPN/badvpn

int main (int argc, char **argv)
{
    if (argc <= 0) {
        return 1;
    }
    
    int main_exit_code = 1;
    
    // open standard streams
    open_standard_streams();
    
    // parse command-line arguments
    if (!parse_arguments(argc, argv)) {
        fprintf(stderr, "Failed to parse arguments\n");
        print_help(argv[0]);
        goto fail0;
    }
    
    // handle --help and --version
    if (options.help) {
        print_version();
        print_help(argv[0]);
        return 0;
    }
    if (options.version) {
        print_version();
        return 0;
    }
    
    // initialize logger
    switch (options.logger) {
        case LOGGER_STDOUT:
            BLog_InitStdout();
            break;
        case LOGGER_STDERR:
            BLog_InitStderr();
            break;
#ifdef BADVPN_USE_SYSLOG
        case LOGGER_SYSLOG:
            if (!BLog_InitSyslog(options.logger_syslog_ident, options.logger_syslog_facility)) {
                fprintf(stderr, "Failed to initialize syslog logger\n");
                goto fail0;
            }
            break;
#endif
        default:
            ASSERT(0);
    }
    
    // configure logger channels
    for (int i = 0; i < BLOG_NUM_CHANNELS; i++) {
        if (options.loglevels[i] >= 0) {
            BLog_SetChannelLoglevel(i, options.loglevels[i]);
        }
        else if (options.loglevel >= 0) {
            BLog_SetChannelLoglevel(i, options.loglevel);
        } else {
            BLog_SetChannelLoglevel(i, DEFAULT_LOGLEVEL);
        }
    }
    
    BLog(BLOG_NOTICE, "initializing "GLOBAL_PRODUCT_NAME" "PROGRAM_NAME" "GLOBAL_VERSION);
    
    // initialize network
    if (!BNetwork_GlobalInit()) {
        BLog(BLOG_ERROR, "BNetwork_GlobalInit failed");
        goto fail1;
    }
    
    // init time
    BTime_Init();
    
    // init reactor
    if (!BReactor_Init(&reactor)) {
        BLog(BLOG_ERROR, "BReactor_Init failed");
        goto fail1;
    }
    
    // init process manager
    if (!BProcessManager_Init(&manager, &reactor)) {
        BLog(BLOG_ERROR, "BProcessManager_Init failed");
        goto fail2;
    }
    
    // init udev manager
    NCDUdevManager_Init(&umanager, options.no_udev, &reactor, &manager);
    
    // init random number generator
    if (!BRandom2_Init(&random2, BRANDOM2_INIT_LAZY)) {
        BLog(BLOG_ERROR, "BRandom2_Init failed");
        goto fail3;
    }
    
    // setup signal handler
    if (!BSignal_Init(&reactor, signal_handler, NULL)) {
        BLog(BLOG_ERROR, "BSignal_Init failed");
        goto fail4;
    }
    
    // build program
    NCDProgram program;
    if (!NCDBuildProgram_Build(options.config_file, &program)) {
        BLog(BLOG_ERROR, "failed to build program");
        goto fail5;
    }
    
    // setup interpreter parameters
    struct NCDInterpreter_params params;
    params.handler_finished = interpreter_handler_finished;
    params.user = NULL;
    params.retry_time = options.retry_time;
    params.extra_args = options.extra_args;
    params.num_extra_args = options.num_extra_args;
    params.reactor = &reactor;
    params.manager = &manager;
    params.umanager = &umanager;
    params.random2 = &random2;
    
    // initialize interpreter
    if (!NCDInterpreter_Init(&interpreter, program, params)) {
        goto fail5;
    }
    
    // don't enter event loop if syntax check is requested
    if (options.syntax_only) {
        main_exit_code = 0;
        goto fail6;
    }
    
    BLog(BLOG_NOTICE, "entering event loop");
    
    // enter event loop
    main_exit_code = BReactor_Exec(&reactor);
    
fail6:
    // free interpreter
    NCDInterpreter_Free(&interpreter);
fail5:
    // remove signal handler
    BSignal_Finish();
fail4:
    // free random number generator
    BRandom2_Free(&random2);
fail3:
    // free udev manager
    NCDUdevManager_Free(&umanager);
    
    // free process manager
    BProcessManager_Free(&manager);
fail2:
    // free reactor
    BReactor_Free(&reactor);
fail1:
    // free logger
    BLog(BLOG_NOTICE, "exiting");
    BLog_Free();
fail0:
    // finish objects
    DebugObjectGlobal_Finish();
    
    return main_exit_code;
}