класс OpenSSL::Config

Родитель:: Объект
Включенные модули:: Enumerable

Конфигурация библиотеки openssl.

Установка библиотеки openssl на многих системах зависит от вашей конфигурации системы. Посмотрите значение OpenSSL::Config::DEFAULT_CONFIG_FILE для расположения файла для вашего хоста.

См. также www.openssl.org/docs/apps/config.html

Константы

DEFAULT_CONFIG_FILE: Файл конфигурации по умолчанию для OpenSSL.

Публичные методы класса

new(filename) → OpenSSL::Config Показать исходный код

static VALUE
config_initialize(int argc, VALUE *argv, VALUE self)
{
    CONF *conf = GetConfig(self);
    VALUE filename;

    /* 0-arguments call has no use-case, but is kept for compatibility */
    rb_scan_args(argc, argv, "01", &filename);
    rb_check_frozen(self);
    if (!NIL_P(filename)) {
        BIO *bio = BIO_new_file(StringValueCStr(filename), "rb");
        if (!bio)
            ossl_raise(eConfigError, "BIO_new_file");
        config_load_bio(conf, bio); /* Consumes BIO */
    }
    return self;
}

Создает экземпляр OpenSSL::Config из содержимого файла, указанного параметром filename.

Это можно использовать в контекстах, таких как OpenSSL::X509::ExtensionFactory.config=

Это может вызвать исключения IO на основе доступа или наличия файла. Исключение ConfigError может быть вызвано в зависимости от валидности конфигурируемых данных.

parse(string) → OpenSSL::Config Показать исходный код

static VALUE
config_s_parse(VALUE klass, VALUE str)
{
    VALUE obj = config_s_alloc(klass);
    CONF *conf = GetConfig(obj);
    BIO *bio;

    bio = ossl_obj2bio(&str);
    config_load_bio(conf, bio); /* Consumes BIO */
    return obj;
}

Парсит заданную строку string как блок, содержащий конфигурацию для OpenSSL.

parse_config(io) → hash Показать исходный код

static VALUE
config_s_parse_config(VALUE klass, VALUE io)
{
    VALUE obj, sections, ret;
    long i;

    obj = config_s_parse(klass, io);
    sections = config_get_sections(obj);
    ret = rb_hash_new();
    for (i = 0; i < RARRAY_LEN(sections); i++) {
        VALUE section = rb_ary_entry(sections, i);
        rb_hash_aset(ret, section, config_get_section(obj, section));
    }
    return ret;
}

Парсит данные конфигурации, считанные из io, и возвращает всё содержимое в виде Hash.

Публичные методы экземпляров

config[section] → hash Показать исходный код

static VALUE
config_get_section(VALUE self, VALUE section)
{
    CONF *conf = GetConfig(self);
    STACK_OF(CONF_VALUE) *sk;
    int i, entries;
    VALUE hash;

    hash = rb_hash_new();
    StringValueCStr(section);
    if (!(sk = NCONF_get_section(conf, RSTRING_PTR(section)))) {
        ossl_clear_error();
        return hash;
    }
    entries = sk_CONF_VALUE_num(sk);
    for (i = 0; i < entries; i++) {
        CONF_VALUE *entry = sk_CONF_VALUE_value(sk, i);
        rb_hash_aset(hash, rb_str_new_cstr(entry->name),
                     rb_str_new_cstr(entry->value));
    }
    return hash;
}

Получает все пары ключ-значение в определённом section из текущей конфигурации.

Учитывая, что загружается следующий конфигурационный файл:

config = OpenSSL::Config.load('foo.cnf')
  #=> #<OpenSSL::Config sections=["default"]>
puts config.to_s
  #=> [ default ]
  #   foo=bar

Вы можете получить хэш определённого раздела следующим образом:

config['default']
  #=> {"foo"=>"bar"}

each { |section, key, value| } Показать исходный код

static VALUE
config_each(VALUE self)
{
    CONF *conf = GetConfig(self);

    RETURN_ENUMERATOR(self, 0, 0);

    lh_doall_arg((_LHASH *)conf->data, LHASH_DOALL_ARG_FN(each_conf_value),
                 NULL);
    return self;
}

Получает раздел и его пары для текущей конфигурации.

config.each do |section, key, value|
  # ...
end

get_value(section, key) → string Показать исходный код

static VALUE
config_get_value(VALUE self, VALUE section, VALUE key)
{
    CONF *conf = GetConfig(self);
    const char *str, *sectionp;

    StringValueCStr(section);
    StringValueCStr(key);
    /* For compatibility; NULL means "default". */
    sectionp = RSTRING_LEN(section) ? RSTRING_PTR(section) : NULL;
    str = NCONF_get_string(conf, sectionp, RSTRING_PTR(key));
    if (!str) {
        ossl_clear_error();
        return Qnil;
    }
    return rb_str_new_cstr(str);
}

Получает значение key из заданного section.

Учитывая, что загружается следующий конфигурационный файл:

config = OpenSSL::Config.load('foo.cnf')
  #=> #<OpenSSL::Config sections=["default"]>
puts config.to_s
  #=> [ default ]
  #   foo=bar

Вы можете получить определённое значение из конфигурации, если известны section и key, следующим образом:

config.get_value('default','foo')
  #=> "bar"

initialize_copy(p1) Показать исходный код

static VALUE
config_initialize_copy(VALUE self, VALUE other)
{
    CONF *conf = GetConfig(self);
    VALUE str;
    BIO *bio;

    str = rb_funcall(other, rb_intern("to_s"), 0);
    rb_check_frozen(self);
    bio = ossl_obj2bio(&str);
    config_load_bio(conf, bio); /* Consumes BIO */
    return self;
}

inspect → string Показать исходный код

static VALUE
config_inspect(VALUE self)
{
    VALUE str, ary = config_get_sections(self);
    const char *cname = rb_class2name(rb_obj_class(self));

    str = rb_str_new_cstr("#<");
    rb_str_cat_cstr(str, cname);
    rb_str_cat_cstr(str, " sections=");
    rb_str_append(str, rb_inspect(ary));
    rb_str_cat_cstr(str, ">");

    return str;
}

Представление String этого объекта конфигурации, включая имя класса и его разделы.

sections → массив строк Показать исходный код

static VALUE
config_get_sections(VALUE self)
{
    CONF *conf = GetConfig(self);
    VALUE ary;

    ary = rb_ary_new();
    lh_doall_arg((_LHASH *)conf->data, LHASH_DOALL_ARG_FN(get_conf_section),
                 &ary);
    return ary;
}

Получить имена всех разделов в текущей конфигурации.

to_s → string Показать исходный код

static VALUE
config_to_s(VALUE self)
{
    CONF *conf = GetConfig(self);
    VALUE str;

    str = rb_str_new(NULL, 0);
    lh_doall_arg((_LHASH *)conf->data, LHASH_DOALL_ARG_FN(dump_conf_value),
                 &str);
    return str;
}

Получить форматируемую форму текущей конфигурации.

Учитывая, что создаётся следующая конфигурация:

config = OpenSSL::Config.new
  #=> #<OpenSSL::Config sections=[]>
config['default'] = {"foo"=>"bar","baz"=>"buz"}
  #=> {"foo"=>"bar", "baz"=>"buz"}
puts config.to_s
  #=> [ default ]
  #   foo=bar
  #   baz=buz

Вы можете получить сериализованную конфигурацию, используя to_s, а затем пропарсить её позднее:

serialized_config = config.to_s
# much later...
new_config = OpenSSL::Config.parse(serialized_config)
  #=> #<OpenSSL::Config sections=["default"]>
puts new_config
  #=> [ default ]
      foo=bar
      baz=buz

Ruby Core © 1993–2022 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.