← Back to branch summary

~ubuntu-branches/ubuntu/maverick/openipmi/maverick

« back to all changes in this revision

Viewing changes to lib/domain.c

  • Committer: Bazaar Package Importer
  • Author(s): Chuck Short
  • Date: 2010-05-26 14:58:52 UTC
  • mfrom: (1.1.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20100526145852-q08oehnlfle6j5da
Tags: 2.0.18-0ubuntu1
New upstream version. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/domain.c
345
345
    unsigned int option_activate_if_possible : 1;
346
346
    unsigned int option_local_only : 1;
347
347
    unsigned int option_local_only_set : 1;
 
348
    unsigned int option_use_cache : 1;
348
349
};
349
350
 
350
351
/* A list of all domains in the system. */
862
863
}
863
864
 
864
865
static int
865
 
setup_domain(const char    *name,
866
 
             ipmi_con_t    *ipmi[],
867
 
             int           num_con,
868
 
             ipmi_domain_t **new_domain)
 
866
process_options(ipmi_domain_t      *domain, 
 
867
                ipmi_open_option_t *options,
 
868
                unsigned int       num_options)
 
869
{
 
870
    unsigned int i;
 
871
 
 
872
    /* Option processing. */
 
873
    for (i=0; i<num_options; i++) {
 
874
        switch (options[i].option) {
 
875
        case IPMI_OPEN_OPTION_ALL:
 
876
            domain->option_all = options[i].ival != 0;
 
877
            break;
 
878
        case IPMI_OPEN_OPTION_SDRS:
 
879
            domain->option_SDRs = options[i].ival != 0;
 
880
            break;
 
881
        case IPMI_OPEN_OPTION_FRUS:
 
882
            domain->option_FRUs = options[i].ival != 0;
 
883
            break;
 
884
        case IPMI_OPEN_OPTION_SEL:
 
885
            domain->option_SEL = options[i].ival != 0;
 
886
            break;
 
887
        case IPMI_OPEN_OPTION_IPMB_SCAN:
 
888
            domain->option_IPMB_scan = options[i].ival != 0;
 
889
            break;
 
890
        case IPMI_OPEN_OPTION_OEM_INIT:
 
891
            domain->option_OEM_init = options[i].ival != 0;
 
892
            break;
 
893
        case IPMI_OPEN_OPTION_SET_EVENT_RCVR:
 
894
            domain->option_set_event_rcvr = options[i].ival != 0;
 
895
            break;
 
896
        case IPMI_OPEN_OPTION_SET_SEL_TIME:
 
897
            domain->option_set_sel_time = options[i].ival != 0;
 
898
            break;
 
899
        case IPMI_OPEN_OPTION_USE_CACHE:
 
900
            domain->option_use_cache = options[i].ival != 0;
 
901
            break;
 
902
        case IPMI_OPEN_OPTION_ACTIVATE_IF_POSSIBLE:
 
903
            domain->option_activate_if_possible = options[i].ival != 0;
 
904
            break;
 
905
        case IPMI_OPEN_OPTION_LOCAL_ONLY:
 
906
            domain->option_local_only = options[i].ival != 0;
 
907
            domain->option_local_only_set = 1;
 
908
            break;
 
909
        default:
 
910
            return EINVAL;
 
911
        }
 
912
    }
 
913
 
 
914
    return 0;
 
915
}
 
916
 
 
917
static int
 
918
setup_domain(const char         *name,
 
919
             ipmi_con_t         *ipmi[],
 
920
             int                num_con,
 
921
             ipmi_open_option_t *options,
 
922
             unsigned int       num_options,
 
923
             ipmi_domain_t      **new_domain)
869
924
{
870
925
    struct timeval               timeout;
871
926
    ipmi_domain_t                *domain;
872
927
    int                          rv;
873
928
    ipmi_system_interface_addr_t si;
874
929
    int                          i, j;
 
930
    unsigned int                 priv;
875
931
 
876
932
    /* Don't allow '(' in the domain name, as that messes up the
877
933
       naming.  That is the only restriction. */
890
946
    domain->option_activate_if_possible = 1;
891
947
    domain->option_local_only = 0;
892
948
    domain->option_local_only_set = 0;
 
949
    domain->option_use_cache = 1;
 
950
 
 
951
    priv = IPMI_PRIVILEGE_ADMIN;
 
952
    for (i=0; i<num_con; i++) {
 
953
        /* Find the least-common demominator privilege for the
 
954
           connections. */
 
955
        if ((ipmi[i]->priv_level != 0) && (ipmi[i]->priv_level < priv))
 
956
            priv = ipmi[i]->priv_level;
 
957
    }
 
958
 
 
959
    /* Enable setting the event receiver (by default) if the privilege
 
960
       is admin or greater. */
 
961
    domain->option_set_event_rcvr = (priv >= IPMI_PRIVILEGE_ADMIN);
 
962
    domain->option_set_sel_time = (priv >= IPMI_PRIVILEGE_ADMIN);
 
963
 
 
964
    if (options)
 
965
        process_options(domain, options, num_options);
893
966
 
894
967
    strncpy(domain->name, name, sizeof(domain->name)-2);
895
968
    i = strlen(domain->name);
5423
5496
}
5424
5497
 
5425
5498
int
 
5499
ipmi_option_use_cache(ipmi_domain_t *domain)
 
5500
{
 
5501
    return domain->option_use_cache;
 
5502
}
 
5503
 
 
5504
int
5426
5505
ipmi_option_activate_if_possible(ipmi_domain_t *domain)
5427
5506
{
5428
5507
    return domain->option_activate_if_possible;
5443
5522
}
5444
5523
 
5445
5524
 
5446
 
static int
5447
 
process_options(ipmi_domain_t      *domain, 
5448
 
                ipmi_open_option_t *options,
5449
 
                unsigned int       num_options)
5450
 
{
5451
 
    unsigned int i;
5452
 
 
5453
 
    /* Option processing. */
5454
 
    for (i=0; i<num_options; i++) {
5455
 
        switch (options[i].option) {
5456
 
        case IPMI_OPEN_OPTION_ALL:
5457
 
            domain->option_all = options[i].ival != 0;
5458
 
            break;
5459
 
        case IPMI_OPEN_OPTION_SDRS:
5460
 
            domain->option_SDRs = options[i].ival != 0;
5461
 
            break;
5462
 
        case IPMI_OPEN_OPTION_FRUS:
5463
 
            domain->option_FRUs = options[i].ival != 0;
5464
 
            break;
5465
 
        case IPMI_OPEN_OPTION_SEL:
5466
 
            domain->option_SEL = options[i].ival != 0;
5467
 
            break;
5468
 
        case IPMI_OPEN_OPTION_IPMB_SCAN:
5469
 
            domain->option_IPMB_scan = options[i].ival != 0;
5470
 
            break;
5471
 
        case IPMI_OPEN_OPTION_OEM_INIT:
5472
 
            domain->option_OEM_init = options[i].ival != 0;
5473
 
            break;
5474
 
        case IPMI_OPEN_OPTION_SET_EVENT_RCVR:
5475
 
            domain->option_set_event_rcvr = options[i].ival != 0;
5476
 
            break;
5477
 
        case IPMI_OPEN_OPTION_SET_SEL_TIME:
5478
 
            domain->option_set_sel_time = options[i].ival != 0;
5479
 
            break;
5480
 
        case IPMI_OPEN_OPTION_ACTIVATE_IF_POSSIBLE:
5481
 
            domain->option_activate_if_possible = options[i].ival != 0;
5482
 
            break;
5483
 
        case IPMI_OPEN_OPTION_LOCAL_ONLY:
5484
 
            domain->option_local_only = options[i].ival != 0;
5485
 
            domain->option_local_only_set = 1;
5486
 
            break;
5487
 
        default:
5488
 
            return EINVAL;
5489
 
        }
5490
 
    }
5491
 
 
5492
 
    return 0;
5493
 
}
5494
 
 
5495
5525
int
5496
5526
ipmi_open_domain(const char         *name,
5497
5527
                 ipmi_con_t         *con[],
5507
5537
    int           rv;
5508
5538
    ipmi_domain_t *domain = NULL;
5509
5539
    unsigned int  i;
5510
 
    unsigned int  priv;
5511
5540
 
5512
5541
    if ((num_con < 1) || (num_con > MAX_CONS))
5513
5542
        return EINVAL;
5514
5543
 
5515
 
    rv = setup_domain(name, con, num_con, &domain);
 
5544
    rv = setup_domain(name, con, num_con, options, num_options, &domain);
5516
5545
    if (rv)
5517
5546
        return rv;
5518
5547
 
5520
5549
    domain->domain_fully_up_cb_data = domain_fully_up_cb_data;
5521
5550
    domain->fully_up_count = 1;
5522
5551
 
5523
 
    priv = IPMI_PRIVILEGE_ADMIN;
5524
5552
    for (i=0; i<num_con; i++) {
5525
 
        /* Find the least-common demominator privilege for the
5526
 
           connections. */
5527
 
        if ((con[i]->priv_level != 0) && (con[i]->priv_level < priv))
5528
 
            priv = con[i]->priv_level;
5529
5553
        rv = con[i]->add_con_change_handler(con[i], ll_con_changed, domain);
5530
5554
        if (rv)
5531
5555
            goto out_err;
5534
5558
            goto out_err;
5535
5559
    }
5536
5560
 
5537
 
    /* Enable setting the event receiver (by default) if the privilege
5538
 
       is admin or greater. */
5539
 
    domain->option_set_event_rcvr = (priv >= IPMI_PRIVILEGE_ADMIN);
5540
 
    domain->option_set_sel_time = (priv >= IPMI_PRIVILEGE_ADMIN);
5541
 
 
5542
 
    process_options(domain, options, num_options);
5543
 
 
5544
5561
    add_known_domain(domain);
5545
5562
 
5546
5563
    if (con_change_handler) {
6571
6588
    if ((num_con < 1) || (num_con > MAX_CONS))
6572
6589
        return EINVAL;
6573
6590
 
6574
 
    rv = setup_domain("", con, num_con, &domain);
 
6591
    rv = setup_domain("", con, num_con, NULL, 0, &domain);
6575
6592
    if (rv)
6576
6593
        return rv;
6577
6594