Пример #1
0
void
aim_log_vcommon(aim_log_t* l, aim_log_flag_t flag,
                aim_ratelimiter_t* rl, uint64_t time,
                const char* fname, const char* file, int line,
                const char* fmt, va_list vargs)
{
    const char* color = NULL;

    if(flag == AIM_LOG_FLAG_MSG || flag == AIM_LOG_FLAG_FATAL ||
       aim_log_enabled(l, flag)) {
        if(rl == NULL || aim_ratelimiter_limit(rl, time) == 0) {

            if(aim_pvs_isatty(l->pvs) == 1) {
                if((color = aim_log_flag_color__(flag))) {
                    aim_printf(l->pvs, color);
                }
            }

            aim_log_output__(l, fname, file, line, fmt, vargs);

            if(color) {
                aim_printf(l->pvs, color_reset__);
            }
        }
    }
}
int
x86_64_mlnx_msn2410_config_show(struct aim_pvs_s* pvs)
{
    int i;
    for(i = 0; x86_64_mlnx_msn2410_config_settings[i].name; i++) {
        aim_printf(pvs, "%s = %s\n", x86_64_mlnx_msn2410_config_settings[i].name, x86_64_mlnx_msn2410_config_settings[i].value);
    }
    return i;
}
Пример #3
0
int
timer_wheel_config_show(struct aim_pvs_s* pvs)
{
    int i;
    for(i = 0; timer_wheel_config_settings[i].name; i++) {
        aim_printf(pvs, "%s = %s\n", timer_wheel_config_settings[i].name, timer_wheel_config_settings[i].value);
    }
    return i;
}
int
onlp_platform_defaults_config_show(struct aim_pvs_s* pvs)
{
    int i;
    for(i = 0; onlp_platform_defaults_config_settings[i].name; i++) {
        aim_printf(pvs, "%s = %s\n", onlp_platform_defaults_config_settings[i].name, onlp_platform_defaults_config_settings[i].value);
    }
    return i;
}
int
powerpc_quanta_lb9_r0_config_show(struct aim_pvs_s* pvs)
{
    int i;
    for(i = 0; powerpc_quanta_lb9_r0_config_settings[i].name; i++) {
        aim_printf(pvs, "%s = %s\n", powerpc_quanta_lb9_r0_config_settings[i].name, powerpc_quanta_lb9_r0_config_settings[i].value);
    }
    return i;
}
int
x86_64_accton_as7816_64x_config_show(struct aim_pvs_s* pvs)
{
    int i;
    for(i = 0; x86_64_accton_as7816_64x_config_settings[i].name; i++) {
        aim_printf(pvs, "%s = %s\n", x86_64_accton_as7816_64x_config_settings[i].name, x86_64_accton_as7816_64x_config_settings[i].value);
    }
    return i;
}
int
x86_64_quanta_ly6_rangeley_r0_config_show(struct aim_pvs_s* pvs)
{
    int i;
    for(i = 0; x86_64_quanta_ly6_rangeley_r0_config_settings[i].name; i++) {
        aim_printf(pvs, "%s = %s\n", x86_64_quanta_ly6_rangeley_r0_config_settings[i].name, x86_64_quanta_ly6_rangeley_r0_config_settings[i].value);
    }
    return i;
}
Пример #8
0
int
debug_counter_config_show(struct aim_pvs_s* pvs)
{
    int i;
    for(i = 0; debug_counter_config_settings[i].name; i++) {
        aim_printf(pvs, "%s = %s\n", debug_counter_config_settings[i].name, debug_counter_config_settings[i].value);
    }
    return i;
}
int
x86_64_ingrasys_s9180_32x_config_show(struct aim_pvs_s* pvs)
{
    int i;
    for(i = 0; x86_64_ingrasys_s9180_32x_config_settings[i].name; i++) {
        aim_printf(pvs, "%s = %s\n", x86_64_ingrasys_s9180_32x_config_settings[i].name, x86_64_ingrasys_s9180_32x_config_settings[i].value);
    }
    return i;
}
int
x86_64_cel_redstone_xp_config_show(struct aim_pvs_s* pvs)
{
    int i;
    for(i = 0; x86_64_cel_redstone_xp_config_settings[i].name; i++) {
        aim_printf(pvs, "%s = %s\n", x86_64_cel_redstone_xp_config_settings[i].name, x86_64_cel_redstone_xp_config_settings[i].value);
    }
    return i;
}
int
x86_64_delta_ag9032v2_config_show(struct aim_pvs_s* pvs)
{
    int i;
    for(i = 0; x86_64_delta_ag9032v2_config_settings[i].name; i++) {
        aim_printf(pvs, "%s = %s\n", x86_64_delta_ag9032v2_config_settings[i].name, x86_64_delta_ag9032v2_config_settings[i].value);
    }
    return i;
}
Пример #12
0
int
ofstatemanager_config_show(struct aim_pvs_s* pvs)
{
    int i;
    for(i = 0; ofstatemanager_config_settings[i].name; i++) {
        aim_printf(pvs, "%s = %s\n", ofstatemanager_config_settings[i].name, ofstatemanager_config_settings[i].value);
    }
    return i;
}
int
x86_64_alphanetworks_snx60a0_486f_config_show(struct aim_pvs_s* pvs)
{
    int i;
    for(i = 0; x86_64_alphanetworks_snx60a0_486f_config_settings[i].name; i++) {
        aim_printf(pvs, "%s = %s\n", x86_64_alphanetworks_snx60a0_486f_config_settings[i].name, x86_64_alphanetworks_snx60a0_486f_config_settings[i].value);
    }
    return i;
}
Пример #14
0
void
aim_pvs_logf(void* cookie, aim_log_flag_t flag, const char* str)
{
    const char* color = NULL;
    aim_pvs_t* pvs = (aim_pvs_t*)cookie;

    if(pvs && aim_pvs_isatty(pvs) == 1) {
        if((color = aim_log_flag_color__(flag))) {
            aim_printf(pvs, color);
        }
    }

    aim_printf(pvs, "%s", str);

    if(color) {
        aim_printf(pvs, color_reset__);
    }
}
Пример #15
0
int
slot_allocator_config_show(struct aim_pvs_s* pvs)
{
    int i;
    for(i = 0; slot_allocator_config_settings[i].name; i++) {
        aim_printf(pvs, "%s = %s\n", slot_allocator_config_settings[i].name, slot_allocator_config_settings[i].value);
    }
    return i;
}
Пример #16
0
int
vpi_config_show(struct aim_pvs_s* pvs)
{
    int i;
    for(i = 0; vpi_config_settings[i].name; i++) {
        aim_printf(pvs, "%s = %s\n", vpi_config_settings[i].name, vpi_config_settings[i].value);
    }
    return i;
}
Пример #17
0
void
bighash_table_utilization_show(bighash_table_t *table, aim_pvs_t *pvs)
{
    int i;
    int count = 0;

    aim_printf(pvs, "table: %d buckets\n", table->bucket_count);

    for(i = 0; i < table->bucket_count; i++) {
        int c = 0;
        bighash_entry_t *cur = table->buckets[i];
        while (cur != NULL) {
            c++;
            cur = cur->next;
        }
        aim_printf(pvs, "    %.4d: %d \n", i, c);
        count += c;
    }
}
Пример #18
0
int
aim_avsparse_type(const char* arg, aim_pvs_t* epvs,
                  char c, char* type, aim_va_list_t* vargs)
{
    int rv;
    aim_datatype_t* dt;
    aim_datatype_context_t dtc;

    if(arg == NULL) {
        return AIM_ERROR_PARAM;
    }

    if(type && type[0] == '%') {
        /* Immediate string specified. The argument must be that string. */
        if(type[1] == 0) {
            /* No string */
            return AIM_ERROR_PARAM;
        }
        if(!AIM_STRCMP(type+1, arg)) {
            return AIM_ERROR_NONE;
        }
        aim_printf(epvs, "expected '%s', not '%s'\n", type+1, arg);
        return AIM_ERROR_PARAM;
    }

    dt = aim_datatype_find(c, type);
    if(dt == NULL) {
        /* Unrecognized type */
        aim_printf(epvs, "<bug: no handler for type '%c:%s'>\n", (c) ? c : '.', (type) ? type : "[NULL]");
        return AIM_ERROR_NOT_FOUND;
    }

    dtc.dt = dt;
    dtc.epvs = epvs;
    rv = dt->from_str(&dtc, arg, vargs);

    if( (rv < 0) && dt->desc) {
        aim_printf(epvs, "'%s' is not a valid %s\n", arg, dt->desc);
    }
    return rv;
}
Пример #19
0
/**
 * Basic output function for all log messages.
 */
static void
aim_log_output__(aim_log_t* l, const char* fname, const char* file,
                 int line, const char* fmt, va_list vargs)
{
    aim_pvs_t* msg;
    char* pmsg;

    msg = aim_pvs_buffer_create();
    if(AIM_BIT_GET(l->options, AIM_LOG_OPTION_TIMESTAMP)) {
        aim_log_time__(msg);
    }
    aim_vprintf(msg, fmt, vargs);
    if(l->options & (1 << AIM_LOG_OPTION_FUNC)) {
        aim_printf(msg, " [%s]", fname);
    }
    if(l->options & (1 << AIM_LOG_OPTION_FILE_LINE)) {
        aim_printf(msg, " [%s:%d]", file, line);
    }
    aim_printf(msg, "\n");
    pmsg = aim_pvs_buffer_get(msg);
    aim_printf(l->pvs, "%s", pmsg);
    aim_free(pmsg);
    aim_pvs_destroy(msg);
}
Пример #20
0
static void
aim_log_time__(aim_pvs_t* pvs)
{
#if AIM_CONFIG_LOG_INCLUDE_LINUX_TIMESTAMP == 1
    struct timeval timeval;
    struct tm *loctime;
    char lt[128];

    gettimeofday(&timeval, NULL);
    loctime = localtime(&timeval.tv_sec);
    strftime(lt, sizeof(lt), "%b %d %T", loctime);
    aim_printf(pvs, "%s.%.03d ", lt, (int)timeval.tv_usec/1000);
#else
    AIM_REFERENCE(pvs);
    AIM_REFERENCE(size);
#endif
}
Пример #21
0
int
sff_tool(int argc, char* argv[])
{
    int rv = 0;
    int i;
    int c;

    int s = 0;
    int e = 0;
    int help = 0;
    int n = 0;
    int v = 0;

    biglist_t* fnames=NULL;


    while( (c = getopt(argc, argv, "sehnv")) != -1) {
        switch(c)
            {
            case 's': s = 1; break;
            case 'e': e = 1; break;
            case 'h': help=1; rv=0; break;
            case 'n': n=1; break;
            case 'v': v=1; break;
            default: help=1; rv = 1; break;
            }
    }

    if(help) {
        printf("Usage: %s [OPTIONS] [FILES]\n", argv[0]);
        printf("  -s    Read filenames from stdin. \n");
        printf("  -n    Print the filename if successful.\n");
        printf("  -v    Print the filename always.\n");
        printf("  -e    Show the raw eeprom data.\n");
        printf("  -h    Help.\n");
        return rv;
    }

    if(s) {
        /* Read filenames from stdin */
        char b[PATH_MAX];
        char* l;
        while((l = fgets(b, PATH_MAX, stdin))) {
            int len=SFF_STRLEN(l);
            if(len) {
                if(l[len-1] == '\n') {
                    l[len-1] = 0;
                }
                fnames = biglist_append(fnames, aim_strdup(l));
            }
        }
    }

    /* Read from command line. This can be used together with -s */
    for(i = optind; i < argc; i++) {
        fnames = biglist_append(fnames, aim_strdup(argv[i]));
    }

    biglist_t* ble;
    char* f;
    BIGLIST_FOREACH_DATA(ble, fnames, char*, f) {
        sff_info_t info;
        memset(&info, 0, sizeof(info));
        if( (rv = sff_info_init_file(&info, f)) >= 0) {
            if(n || v) {
                aim_printf(&aim_pvs_stdout, "%s\n", f);
            }
            if(e) {
                aim_printf(&aim_pvs_stdout, "eeprom:\n%{data}\n", info.eeprom, sizeof(info.eeprom));
            }
            sff_info_show(&info, &aim_pvs_stdout);
        }
        else if(v) {
            aim_printf(&aim_pvs_stdout, "%s: failed.\n", f);
        }
    }
Пример #22
0
int
aim_main(int argc, char* argv[])
{
    /*
     * Fixme -- this is just a hacked placeholder for
     * a more fully-functional tool.
     */
    uint32_t pa;
    int size;
    uint8_t* va = NULL;

#define USAGE()                                                         \
    do {                                                                \
        fprintf(stderr, "usage: mtool dump PHYSADDR BYTES\n");          \
        fprintf(stderr, "usage: mtool odump PHYSADDR [json]\n");        \
        return 1;                                                       \
    } while(0)

    if(argc < 3) {
        USAGE();
    }

    if(sscanf(argv[2], "0x%x", &pa) != 1) {
        USAGE();
    }

    if(!strcmp(argv[1], "dump")) {
        if(argv[3] == NULL || sscanf(argv[3], "%d", &size) != 1) {
            USAGE();
        }
        va = onlp_mmap(pa, size, "mtool");
        if(va) {
            aim_printf(&aim_pvs_stdout, "%{data}\n", va, size);
        }
    }
    else if(!strcmp(argv[1], "odump")) {
        size = 1024*512; /* arbitrary */
        va = onlp_mmap(pa, size, "mtool");
        if(va) {
            onlp_onie_info_t info;
            if(onlp_onie_decode(&info, va, size) == 0) {
                if(argv[3] && !strcmp(argv[3], "json")) {
                    onlp_onie_show_json(&info, &aim_pvs_stdout);
                }
                else {
                    onlp_onie_show(&info, &aim_pvs_stdout);
                }
                onlp_onie_info_free(&info);
            }
            else {
                int dsize = 128;
                aim_printf(&aim_pvs_stdout, "Here are the first %d bytes:\n%{data}\n", dsize, va, dsize);
            }
        }
    }
    else {
        USAGE();
    }
    if(va) {
        munmap(va, size);
    }
    return 0;
}
Пример #23
0
int aim_main(int argc, char* argv[])
{
    int i;

    {
        const char* tstStrings[] = { "This", "is", "a", "complete", "sentence." };
        char* join = aim_strjoin(" ", tstStrings, AIM_ARRAYSIZE(tstStrings));
        if(strcmp(join, "This is a complete sentence.")) {
            printf("fail: join='%s'\n", join);
        }
        AIM_FREE(join);
    }

    for(i = 0; i < argc; i++) {
        aim_printf(&aim_pvs_stdout, "arg%d: '%s'\n", i, argv[i]);
    }

    {
        /* Test data */
        char data[2500];
        memset(data, 0xFF, sizeof(data));
        aim_printf(&aim_pvs_stdout, "data is %{data}", data, sizeof(data));
    }

    {
        char* sdata = "DEADBEEFCAFE";
        char* data;
        int size;
        aim_sparse(&sdata, &aim_pvs_stdout, "{data}", &data, &size);
        aim_printf(&aim_pvs_stdout, "data is %{data}\n", data, size);
        aim_free(data);
    }

    utest_list();

    AIM_LOG_MSG("Should print 1-27");
    AIM_LOG_MSG("%d %d %d %d %d %d %d %d %d "
                "%d %d %d %d %d %d %d %d %d "
                "%d %d %d %d %d %d %d %d %d",
                1, 2, 3, 4, 5, 6, 7, 8, 9,
                10, 11, 12, 13, 14, 15, 16, 17, 18,
                19, 20, 21, 22, 23, 24, 25, 26, 27);


    aim_printf(&aim_pvs_stdout, "aim_pvs_stdout from %s:%d\n",
               __FILE__, __LINE__);


    {
        char c;
        aim_pvs_t* pvs = aim_pvs_buffer_create();
        aim_printf(pvs, "\nConsider ");
        aim_printf(pvs, "%s ", "the");
        aim_printf(pvs, "alphabet: ");
        for(c = 'A'; c <= 'Z'; c++) {
            aim_printf(pvs, "%c", c);
        }
        aim_printf(pvs, "\n");
        {
            char* s = aim_pvs_buffer_get(pvs);
            aim_printf(&aim_pvs_stdout, "first: %s", s);
            free(s);
            aim_printf(pvs, "(second)");
            s = aim_pvs_buffer_get(pvs);
            aim_printf(&aim_pvs_stdout, "second: %s", s);
            free(s);
            aim_pvs_destroy(pvs);
        }
        {
            aim_ratelimiter_t rl;
            aim_ratelimiter_init(&rl, 10, 5, NULL);

            /* 5 (6?) tokens available at t=0 */
            assert(aim_ratelimiter_limit(&rl, 0) == 0);
            assert(aim_ratelimiter_limit(&rl, 0) == 0);
            assert(aim_ratelimiter_limit(&rl, 0) == 0);
            assert(aim_ratelimiter_limit(&rl, 0) == 0);
            assert(aim_ratelimiter_limit(&rl, 0) == 0);
            assert(aim_ratelimiter_limit(&rl, 0) == 0);
            assert(aim_ratelimiter_limit(&rl, 0) < 0);

            /* Another token at t=10 */
            assert(aim_ratelimiter_limit(&rl, 10) == 0);
            assert(aim_ratelimiter_limit(&rl, 10) < 0);

            /* Nothing at t=15 */
            assert(aim_ratelimiter_limit(&rl, 15) < 0);

            /* 4 more tokens granted by t=50 */
            assert(aim_ratelimiter_limit(&rl, 50) == 0);
            assert(aim_ratelimiter_limit(&rl, 50) == 0);
            assert(aim_ratelimiter_limit(&rl, 50) == 0);
            assert(aim_ratelimiter_limit(&rl, 50) == 0);
            assert(aim_ratelimiter_limit(&rl, 50) < 0);
        }
        {
            aim_printf(&aim_pvs_stdout, "valgrind_status=%d\n",
                       aim_valgrind_status());
        }

        AIM_LOG_MSG("%{aim_error}", AIM_ERROR_PARAM);
    }

    return 0;
}
Пример #24
0
int
onlpdump_main(int argc, char* argv[])
{
    int show = 0;
    uint32_t showflags = 0;
    int help = 0;
    int c;
    int rv = -1;
    int j = 0;
    int o = 0;
    int m = 0;
    int i = 0;
    int p = 0;
    int x = 0;
    const char* O = NULL;
    const char* t = NULL;

    while( (c = getopt(argc, argv, "srehdojmipxt:O:")) != -1) {
        switch(c)
            {
            case 's': show=1; break;
            case 'r': show=1; showflags |= ONLP_OID_SHOW_F_RECURSE; break;
            case 'e': show=1; showflags |= ONLP_OID_SHOW_F_EXTENDED; break;
            case 'd': show=0; break;
            case 'h': help=1; rv = 0; break;
            case 'j': j=1; break;
            case 'o': o=1; break;
            case 'x': x=1; break;
            case 'm': m=1; break;
            case 'i': i=1; break;
            case 'p': p=1; show=-1; break;
            case 't': t = optarg; break;
            case 'O': O = optarg; break;
            default: help=1; rv = 1; break;
            }
    }

    if(help) {
        printf("Usage: %s [OPTIONS]\n", argv[0]);
        printf("  -d   Use dump(). This is the default.\n");
        printf("  -s   Use show() instead of dump().\n");
        printf("  -r   Recursive show(). Implies -s\n");
        printf("  -e   Extended show(). Implies -s\n");
        printf("  -o   Dump ONIE data only.\n");
        printf("  -x   Dump Platform Info only.\n");
        printf("  -j   Dump ONIE data in JSON format.\n");
        printf("  -m   Run platform manager.\n");
        printf("  -i   Iterate OIDs.\n");
        printf("  -p   Show SFP presence.\n");
        printf("  -t <file>  Decode TlvInfo data.\n");
        printf("  -O <oid> Dump OID.\n");
        return rv;
    }


    if(t){
        int rv;
        onlp_onie_info_t onie;
        rv = onlp_onie_decode_file(&onie, t);
        if(rv >= 0) {
            onlp_onie_show(&onie, &aim_pvs_stdout);
            onlp_onie_info_free(&onie);
            return 0;
        }
        else {
            aim_printf(&aim_pvs_stdout, "Decode failed.");
            return 1;
        }
    }

    onlp_init();

    if(O) {
        int oid;
        if(sscanf(O, "0x%x", &oid) == 1) {
            onlp_oid_dump(oid, &aim_pvs_stdout,
                          ONLP_OID_DUMP_F_RECURSE |
                          ONLP_OID_DUMP_F_EVEN_IF_ABSENT);
        }
        return 0;
    }

    if(i) {
        iterate_oids__();
        return 0;
    }

    if(o || x) {
        onlp_sys_info_t si;
        if(onlp_sys_info_get(&si) < 0) {
            fprintf(stderr, "onlp_sys_info_get() failed.");
            return 1;
        }

        if(o) {
            if(j) {
                onlp_onie_show_json(&si.onie_info, &aim_pvs_stdout);
            }
            else {
                onlp_onie_show(&si.onie_info, &aim_pvs_stdout);
            }
        }

        if(x) {
            if(j) {
                onlp_platform_info_show_json(&si.platform_info, &aim_pvs_stdout);
            }
            else {
                onlp_platform_info_show(&si.platform_info, &aim_pvs_stdout);
            }
        }

        onlp_sys_info_free(&si);
        return 0;
    }

    if(show >= 0) {
        if(show == 0) {
            /* Default to full dump */
            onlp_platform_dump(&aim_pvs_stdout,
                               ONLP_OID_DUMP_F_RECURSE | ONLP_OID_DUMP_F_EVEN_IF_ABSENT);
        }
        else {
            onlp_platform_show(&aim_pvs_stdout,
                               showflags);
        }
    }


    if(m) {
        printf("Running the platform manager for 600 seconds...\n");
        onlp_sys_platform_manage_start();
        sleep(600);
        printf("Stopping the platform manager.\n");
        onlp_sys_platform_manage_stop();
    }

    if(p) {
        onlp_sfp_bitmap_t presence;
        onlp_sfp_bitmap_t_init(&presence);
        int rv = onlp_sfp_presence_bitmap_get(&presence);
        aim_printf(&aim_pvs_stdout, "Presence: ");
        if(rv < 0) {
            aim_printf(&aim_pvs_stdout, "Error %{onlp_status}\n", rv);
        }
        else {
            aim_printf(&aim_pvs_stdout, "%{aim_bitmap}\n", &presence);
        }
    }
    return 0;
}
Пример #25
0
        -help\n\
\n";


int
faultd_main(int argc, char* argv[])
{
    char** arg;

    char* pidfile = NULL;
    int daemonize = 0;
    int restart = 0;
    int test = 0;
    char* pipename = FAULTD_CONFIG_MAIN_PIPENAME;

    aim_pvs_t* aim_pvs_syslog = NULL;
    faultd_server_t* faultd_server = NULL;
    int sid = -1;


    for(arg = argv+1; *arg; arg++) {
        if(!strcmp(*arg, "-dr")) {
            daemonize=1;
            restart=1;
        }
        else if(!strcmp(*arg, "-d")) {
            daemonize=1;
            restart=0;
        }
        else if(!strcmp(*arg, "-pid")) {
            arg++;
            pidfile = *arg;
            if(!pidfile) {
                fprintf(stderr, "-pid requires an argument.\n");
                exit(1);
            }
        }
        else if(!strcmp(*arg, "-p")) {
            arg++;
            pipename = *arg;
            if(!pipename) {
                fprintf(stderr, "-p requires an argument.\n");
                exit(1);
            }
        }
        else if(!strcmp(*arg, "-t")) {
            test = 1;
        }
        else if(!strcmp(*arg, "-h") || !strcmp(*arg, "--help")) {
            printf(help__, FAULTD_CONFIG_MAIN_PIPENAME);
            exit(0);
        }
    }

    if(test) {
        return test__(argv[0], pipename);
    }

    /**
     * Start Server
     */
    aim_pvs_syslog = aim_pvs_syslog_open("faultd", LOG_PID, LOG_DAEMON);
    aim_printf(aim_pvs_syslog, "faultd starting");
    faultd_server_create(&faultd_server);
    sid = faultd_server_add(faultd_server, pipename);

    if(sid < 0) {
        perror("server_add:");
        abort();
    }

    if(daemonize) {
        aim_daemon_restart_config_t rconfig;
        aim_daemon_config_t config;

        memset(&config, 0, sizeof(config));
        aim_daemon_restart_config_init(&rconfig, 1, 1);
        AIM_BITMAP_CLR(&rconfig.signal_restarts, SIGTERM);
        AIM_BITMAP_CLR(&rconfig.signal_restarts, SIGKILL);
        rconfig.maximum_restarts=0;
        rconfig.pvs = aim_pvs_syslog_get();

        config.wd = "/";
        if(restart) {
            aim_daemonize(&config, &rconfig);
        }
        else {
            aim_daemonize(&config, NULL);
        }
    }

    /*
     * Write our PID file if requested.
     */
    if(pidfile) {
        FILE* fp = fopen(pidfile, "w");
        if(fp == NULL) {
            int e = errno;
            aim_printf(aim_pvs_syslog, "fatal: open(%s): %s\n",
                       pidfile, strerror(e));
            aim_printf(&aim_pvs_stderr, "fatal: open(%s): %s\n",
                       pidfile, strerror(e));

            /* Don't attempt restart */
            raise(SIGTERM);
        }
        fprintf(fp, "%d\n", getpid());
        fclose(fp);
    }

    /**
     * Process Fault Messages
     */
    for(;;) {
        faultd_info_t faultd_info;
        memset(&faultd_info, 0, sizeof(faultd_info));
        if(faultd_server_read(faultd_server, &faultd_info, sid) >= 0) {
            faultd_info_show(&faultd_info, aim_pvs_syslog, 0);
            if(aim_pvs_isatty(&aim_pvs_stderr)) {
                faultd_info_show(&faultd_info, &aim_pvs_stderr, 0);
            }
        }
    }
}
Пример #26
0
/**
 * Show log settings.
 */
void
aim_log_show(aim_log_t* lobj, aim_pvs_t* pvs)
{
    int i;
    int count;
    aim_map_si_t* map;

    aim_printf(pvs, "name: %s\n", lobj->name);
    aim_printf(pvs, "dest: %s\n", aim_pvs_desc_get(lobj->pvs));

    count = 0;
    aim_printf(pvs, "enabled options: ");
    /* @fixme */
    for(i = 0; i <= AIM_LOG_OPTION_TIMESTAMP; i++) {
        if(AIM_BIT_GET(lobj->options, i)) {
            aim_printf(pvs, "%s ", aim_log_option_name(i));
            count++;
        }
    }
    if(count == 0) {
        aim_printf(pvs, "none.");
    }
    aim_printf(pvs, "\n");


    count = 0;
    aim_printf(pvs, "disabled options: ");
    for(i = 0; i <= AIM_LOG_OPTION_TIMESTAMP; i++) {
        if(AIM_BIT_GET(lobj->options, i) == 0) {
            aim_printf(pvs, "%s ", aim_log_option_name(i));
            count++;
        }
    }
    if(count == 0) {
        aim_printf(pvs, "none. ");
    }
    aim_printf(pvs, "\n");

    aim_printf(pvs, "enabled: ");
    count = 0;
    /* @fixme */
    for(i = 0; i <= AIM_LOG_FLAG_FTRACE; i++) {
        if(AIM_BIT_GET(lobj->common_flags, i)) {
            aim_printf(pvs, "%s ", aim_log_flag_name(i));
            count++;
        }
    }
    for(map = lobj->custom_map; map && map->s; map++) {
        if(AIM_BIT_GET(lobj->custom_flags, map->i)) {
            aim_printf(pvs, "%s ", map->s);
            count++;
        }
    }
    if(count == 0) {
        aim_printf(pvs, "none.");
    }
    aim_printf(pvs, "\n");

    aim_printf(pvs, "disabled: ");
    count = 0;
    for(i = 0; i < AIM_LOG_FLAG_FTRACE; i++) {
        if(AIM_BIT_GET(lobj->common_flags, i) == 0) {
            aim_printf(pvs, "%s ", aim_log_flag_name(i));
            count++;
        }
    }
    for(map = lobj->custom_map; map && map->s; map++)  {
        if(AIM_BIT_GET(lobj->custom_flags, map->i) == 0) {
            aim_printf(pvs, "%s ", map->s);
            count++;
        }
    }
    if(count == 0) {
        aim_printf(pvs, "none");
    }
    aim_printf(pvs, "\n");
}
Пример #27
0
int
wnc_sys_eeprom_show(aim_pvs_t* pvs, wnc_sys_eeprom_t* e)
{
    aim_printf(pvs, "Product Name: %s\n", e->product_name);
    aim_printf(pvs, "Model Name: %s\n", e->model_name);
    aim_printf(pvs, "Part Number:  %s\n", e->part_number);
    aim_printf(pvs, "Serial Number: %s\n", e->serial_number);
    aim_printf(pvs, "Manufacture Date: %s\n", e->manufacture_date);
    aim_printf(pvs, "Label Version: %s\n", e->label_version);
    aim_printf(pvs, "MAC: %{mac}\n", e->mac_address);
    aim_printf(pvs, "Hardware Version: 0x%x (%d)\n", e->hardware_version, e->hardware_version);
    aim_printf(pvs, "Software Version: 0x%x (%d)\n", e->software_version, e->software_version);
    aim_printf(pvs, "Card Type: 0x%x (%d)\n", e->card_type, e->card_type);
    aim_printf(pvs, "CRC: 0x%.2x\n", e->crc);
    return 0;
}