自学教程：C++ sss_strerror函数代码示例

static const char *convert_user(TALLOC_CTX *mem_ctx,             struct ipa_sudo_conv *conv,             const char *value){    char *rdn;    const char *group;    errno_t ret;    ret = ipa_get_rdn(mem_ctx, conv->sysdb, value, &rdn,                      MATCHRDN_USER(conv->map_user));    if (ret == EOK) {        return rdn;    } else if (ret != ENOENT) {        DEBUG(SSSDBG_OP_FAILURE, "ipa_get_rdn() failed on value %s [%d]: %s/n",              value, ret, sss_strerror(ret));        return NULL;    }    ret = ipa_get_rdn(mem_ctx, conv->sysdb, value, &rdn,                      MATCHRDN_GROUP(conv->map_group));    if (ret == ENOENT) {        DEBUG(SSSDBG_CRIT_FAILURE, "Unexpected DN %s/n", value);        return NULL;    } else if (ret != EOK) {        DEBUG(SSSDBG_OP_FAILURE, "ipa_get_rdn() failed on value %s [%d]: %s/n",              value, ret, sss_strerror(ret));        return NULL;    }    group = talloc_asprintf(mem_ctx, "%%%s", rdn);    talloc_free(rdn);    return group;}

int ad_autofs_init(struct be_ctx *be_ctx,                   struct ad_id_ctx *id_ctx,                   struct bet_ops **ops,                   void **pvt_data){    int ret;    DEBUG(SSSDBG_TRACE_INTERNAL, "Initializing autofs AD back end/n");    ret = sdap_autofs_init(be_ctx, id_ctx->sdap_id_ctx, ops, pvt_data);    if (ret != EOK) {        DEBUG(SSSDBG_OP_FAILURE, "Cannot initialize AD autofs [%d]: %s/n",                                 ret, sss_strerror(ret));        return ret;    }    ret = ad_get_autofs_options(id_ctx->ad_options, be_ctx->cdb,                                be_ctx->conf_path);    if (ret != EOK) {        DEBUG(SSSDBG_OP_FAILURE, "Cannot initialize AD autofs [%d]: %s/n",                                 ret, sss_strerror(ret));        return ret;    }    return EOK;}

struct ipa_sudo_conv *ipa_sudo_conv_init(TALLOC_CTX *mem_ctx,                   struct sysdb_ctx *sysdb,                   struct sdap_attr_map *map_rule,                   struct sdap_attr_map *map_cmdgroup,                   struct sdap_attr_map *map_cmd,                   struct sdap_attr_map *map_user,                   struct sdap_attr_map *map_group,                   struct sdap_attr_map *map_host,                   struct sdap_attr_map *map_hostgroup){    struct ipa_sudo_conv *conv;    errno_t ret;    conv = talloc_zero(mem_ctx, struct ipa_sudo_conv);    if (conv == NULL) {        return NULL;    }    conv->sysdb = sysdb;    conv->map_rule = map_rule;    conv->map_cmdgroup = map_cmdgroup;    conv->map_cmd = map_cmd;    conv->map_user = map_user;    conv->map_group = map_group;    conv->map_host = map_host;    conv->map_hostgroup = map_hostgroup;    ret = sss_hash_create(conv, 20, &conv->rules);    if (ret != EOK) {        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create hash table [%d]: %s/n",              ret, sss_strerror(ret));        goto done;    }    ret = sss_hash_create(conv, 20, &conv->cmdgroups);    if (ret != EOK) {        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create hash table [%d]: %s/n",              ret, sss_strerror(ret));        goto done;    }    ret = sss_hash_create(conv, 20, &conv->cmds);    if (ret != EOK) {        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create hash table [%d]: %s/n",              ret, sss_strerror(ret));        goto done;    }done:    if (ret != EOK) {        talloc_free(conv);        return NULL;    }    return conv;}

static errno_t proxy_id_conf(TALLOC_CTX *mem_ctx,                             struct be_ctx *be_ctx,                             char **_libname,                             char **_libpath,                             bool *_fast_alias){    TALLOC_CTX *tmp_ctx;    char *libname;    char *libpath;    bool fast_alias;    errno_t ret;    tmp_ctx = talloc_new(NULL);    if (tmp_ctx == NULL) {        DEBUG(SSSDBG_CRIT_FAILURE, "talloc_new() failed/n");        return ENOMEM;    }    ret = confdb_get_string(be_ctx->cdb, tmp_ctx, be_ctx->conf_path,                            CONFDB_PROXY_LIBNAME, NULL, &libname);    if (ret != EOK) {        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to read confdb [%d]: %s/n",              ret, sss_strerror(ret));        goto done;    } else if (libname == NULL) {        DEBUG(SSSDBG_CRIT_FAILURE, "No library name given/n");        ret = ENOENT;        goto done;    }    ret = confdb_get_bool(be_ctx->cdb, be_ctx->conf_path,                          CONFDB_PROXY_FAST_ALIAS, false, &fast_alias);    if (ret != EOK) {        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to read confdb [%d]: %s/n",              ret, sss_strerror(ret));        goto done;    }    libpath = talloc_asprintf(tmp_ctx, "libnss_%s.so.2", libname);    if (libpath == NULL) {        DEBUG(SSSDBG_CRIT_FAILURE, "talloc_asprintf() failed/n");        ret = ENOMEM;        goto done;    }    *_libname = talloc_steal(mem_ctx, libname);    *_libpath = talloc_steal(mem_ctx, libpath);    *_fast_alias = fast_alias;    ret = EOK;done:    talloc_free(tmp_ctx);    return ret;}

errno_tipa_sudo_conv_cmdgroups(struct ipa_sudo_conv *conv,                        struct sysdb_attrs **cmdgroups,                        size_t num_cmdgroups){    struct ipa_sudo_cmdgroup *cmdgroup = NULL;    const char *key;    errno_t ret;    size_t i;    if (num_cmdgroups == 0) {        /* We're done here. */        return EOK;    }    for (i = 0; i < num_cmdgroups; i++) {        ret = sysdb_attrs_get_string(cmdgroups[i], SYSDB_ORIG_DN, &key);        if (ret != EOK) {            DEBUG(SSSDBG_MINOR_FAILURE, "Failed to get command group DN, "                  "skipping [%d]: %s/n", ret, sss_strerror(ret));            continue;        }        cmdgroup = talloc_zero(conv->cmdgroups, struct ipa_sudo_cmdgroup);        if (cmdgroup == NULL) {            ret = ENOMEM;            goto done;        }        ret = process_cmdgroupmember(conv, cmdgroup, cmdgroups[i]);        if (ret != EOK) {            DEBUG(SSSDBG_OP_FAILURE, "Failed to process member "                  "[%d]: %s/n", ret, sss_strerror(ret));            return ret;        }        ret = ipa_sudo_conv_store(conv->cmdgroups, key, cmdgroup);        if (ret != EOK) {            DEBUG(SSSDBG_OP_FAILURE, "Failed to store command group into "                  "table [%d]: %s/n", ret, sss_strerror(ret));            goto done;        }        cmdgroup = NULL;    }    ret = EOK;done:    if (ret != EOK) {        talloc_free(cmdgroup);    }    return ret;}

static errno_t sssctl_fetch_object(TALLOC_CTX *mem_ctx,                                   struct sssctl_object_info *info,                                   struct sss_domain_info *domains,                                   struct sss_domain_info *domain,                                   sssctl_basedn_fn basedn_fn,                                   enum cache_object obj_type,                                   const char *attr_name,                                   const char *attr_value,                                   struct sysdb_attrs **_entry,                                   struct sss_domain_info **_dom){    TALLOC_CTX *tmp_ctx;    struct sysdb_attrs *entry;    struct sss_domain_info *dom;    const char **attrs;    char *sanitized;    errno_t ret;    tmp_ctx = talloc_new(NULL);    if (tmp_ctx == NULL) {        DEBUG(SSSDBG_CRIT_FAILURE, "talloc_new() failed/n");        return ENOMEM;    }    ret = sss_filter_sanitize(tmp_ctx, attr_value, &sanitized);    if (ret != EOK) {        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to sanitize input [%d]: %s/n",              ret, sss_strerror(ret));        goto done;    }    attrs = sssctl_build_attrs(tmp_ctx, info);    if (attrs == NULL) {        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to get attribute list!/n");        ret = ENOMEM;        goto done;    }    ret = sssctl_find_object(tmp_ctx, domains, domain, basedn_fn,                             obj_type, attr_name, sanitized, attrs,                             &entry, &dom);    if (ret != EOK) {        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to query cache [%d]: %s/n",              ret, sss_strerror(ret));        goto done;    }    *_entry = talloc_steal(mem_ctx, entry);    *_dom = dom;done:    talloc_free(tmp_ctx);    return ret;}

static errno_tifp_groups_group_get(struct sbus_request *sbus_req,                     void *data,                     gid_t *_gid,                     struct sss_domain_info **_domain,                     struct ldb_message **_group){    struct ifp_ctx *ctx;    struct sss_domain_info *domain;    struct ldb_result *res;    uid_t gid;    errno_t ret;    ctx = talloc_get_type(data, struct ifp_ctx);    if (ctx == NULL) {        DEBUG(SSSDBG_CRIT_FAILURE, "Invalid pointer!/n");        return ERR_INTERNAL;    }    ret = ifp_groups_decompose_path(ctx->rctx->domains, sbus_req->path,                                    &domain, &gid);    if (ret != EOK) {        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to decompose object path"              "[%s] [%d]: %s/n", sbus_req->path, ret, sss_strerror(ret));        return ret;    }    if (_group != NULL) {        ret = sysdb_getgrgid_with_views(sbus_req, domain, gid, &res);        if (ret == EOK && res->count == 0) {            *_group = NULL;            ret = ENOENT;        }        if (ret != EOK) {            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to lookup group %[email
C++ sst_sc_reg_access函数代码示例
C++ ssprintf函数代码示例