(user) name to IDs(UID or GID) or to obtain groups which user are member of.

  %package -n libsss_certmap

  Group: Development/Libraries

  License: LGPLv3+

  Requires(post): /sbin/ldconfig

  Library to map certificates to users based on rules

  %package -n libsss_certmap-devel

  Group: Development/Libraries

  License: LGPLv3+

  Requires: libsss_certmap = %{version}-%{release}

      rule_name = ldb_msg_find_attr_as_string(msg, CONFDB_CERTMAP_NAME, NULL);

      if (rule_name == NULL) {

                                     ldb_dn_get_linearized(msg->dn));

          return EINVAL;

      }

      TALLOC_CTX *tmp_ctx = NULL;

      struct ldb_dn *dn = NULL;

      struct ldb_result *res = NULL;

       * sysdb_ldb_msg_attr_to_certmap_info and must match

       * enum certmap_info_member. */

      static const char *attrs[] = { CONFDB_CERTMAP_NAME,

   * @oaram[in] obj The original object

   * @param[in] override_obj The object with the override data, may be NULL

   * @param[in] req_attrs List of attributes to be requested, if not set a

   *

   * @return EOK - Override data was added successfully

   * @return ENOMEM - There was insufficient memory to complete the operation

  /*

     SSSD - certificate handling utils

     libsss_certmap.

     Copyright (C) Sumit Bose <sbose@redhat.com> 2017

  /*

     SSSD - certificate handling utils - OpenSSL version

     libsss_certmap.

     Copyright (C) Sumit Bose <sbose@redhat.com> 2017

  /*

     SSSD - certificate handling utils - NSS version

     libsss_certmap.

     Copyright (C) Sumit Bose <sbose@redhat.com> 2017

                          Try to use certificate based authentication, i.e.

                          authentication with a Smartcard or similar devices. If a

                          Smartcard is available and the service is allowed for

                          PIN and the certificate based authentication will

                          continue

                      </para>

                              where the 'removable' flags is set and read the

                              certificates from the inserted token from the first

                              slot found. If multiple readers are connected

                              specific reader.

                          </para>

                          <para>

   * This pair of functions provides client-side GPO processing.

   *

   * While a GPO can target both user and computer objects, this

   *

   * A GPO overview is at https://fedorahosted.org/sssd/wiki/GpoOverview

   *

          return ret;

      }

      if (subdoms_ctx->ad_enabled_domains != NULL) {

          for (dom = subdoms_ctx->be_ctx->domain->subdomains; dom;

                                              dom = get_next_domain(dom, false)) {

      /* In contrast to online_cb_list which are only run if the backend is

       * offline the unconditional_online_cb_list should be run whenever the

       * backend receives a request to go online. The typical use case is to

      struct be_cb *unconditional_online_cb_list;

      struct be_offline_status offstat;

      gettimeofday(&tv, NULL);

      if (timeout != 0 && server->common->server_status == SERVER_NOT_WORKING) {

          if (STATUS_DIFF(server->common, tv) > timeout) {

                        SERVER_NAME(server));

              server->common->server_status = SERVER_NAME_NOT_RESOLVED;

              server->common->last_status_change.tv_sec = tv.tv_sec;

              ret = errno;

              DEBUG(SSSDBG_CRIT_FAILURE,

                    "Unable to set effective group id (%"PRIu32") of the "

                    orig_gid);

              DEBUG(SSSDBG_CRIT_FAILURE,

                    "Sending SIGUSR2 to the process: %d\n", getpid());

          goto fail;

      }

      key.type = HASH_KEY_STRING;

      value.type = HASH_VALUE_PTR;

      for (i = 0; i < count; i++) {

          }

      } else {

          if (state->mapped_attrs != NULL) {

              ret = sysdb_remove_mapped_data(state->domain, state->mapped_attrs);

              if (ret != EOK) {

                  DEBUG(SSSDBG_OP_FAILURE, "sysdb_remove_mapped_data failed, "

      if ((ccname[0] == '/') || (strncmp(ccname, "FILE:", 5) == 0)) {

          DEBUG(SSSDBG_CONF_SETTINGS, "ccache is of type FILE\n");

          sss_check_cc_template(ccname);

          if (ccname[0] == '/') {

          goto done;

      }

      attrs[0] = talloc_strdup(memctx, "objectClass");

      if (!attrs[0]) return ENOMEM;

  Returns a dictionary with a dictionary of results for each given POSIX UID.\n\

  The result dictionary contain the SID and the type of the object which can be\n\

  accessed with the key constants SID_KEY and TYPE_KEY, respectively. Since \n\

  returned."

  );

      struct sss_nc_ctx *ncache;

      int midpoint;

      struct sss_domain_info *domain;

      bool cache_first;

      bool bypass_cache;

      return 0;

  }

  int sss_packet_shrink(struct sss_packet *packet, size_t size)

  {

      size_t newlen;

          }

      }

       * user found by name. If a certificate was given an no mapped user was

       * found return an error. */

      if (state->pem_cert == NULL) {

      if (next_entry == NULL) {

          /* If there was no other entry, schedule removal of the queue. Do it

           * in another tevent tick to avoid issues with callbacks invoking

           */

          imm = tevent_create_immediate(entry->queue);

          if (imm == NULL) {

      if (idx->result > cmd_ctx->enum_ctx->netgroup_count) {

          DEBUG(SSSDBG_CRIT_FAILURE,

          ret = EINVAL;

          goto done;

      }

          SBus code generator tries to reduce amount of generated code by

          reusing keygens whenever possible. Therefore we must ensure

      """

      @staticmethod

      def BuildKey(sbus_member, sbus_signature, Args=None):

          by = sbus_annotation_find(annotations, SBUS_ANNOTATION_DEPRECATED_BY);

          if (by != NULL) {

                    iface_name, dot, member, by);

          } else {

                    iface_name, dot, member);

          }

      }

      if (!talloc_msg->in_talloc_destructor) {

          /* References to this message dropped to zero but through

           * dbus_message_unref(), not by calling talloc_free(). We need to free

          talloc_set_destructor(talloc_msg, NULL);

          talloc_free(talloc_msg);

      }

      const char *unique_name;

      /**

       * manipulation with the connection is allowed.

       */

      bool disconnecting;

   *

   * @param mem_ctx       Memory context with which the reply will be bound.

   *                      If NULL, the reply is not bound with talloc context.

   * @param msg           Message to be sent.

   * @param timeout_ms    Timeout is miliseconds.

   * @param _reply        Output reply. If NULL no reply is expected.

  /**

   * Emit signal on synchronous sbus connection.

   *

   * @param msg           Message to be sent.

   */

  void sbus_sync_emit_signal(struct sbus_sync_connection *conn,

              continue;

          }

           * send the signal to a specific name. */

          if (avoid_name != NULL) {

              has_name = sbus_server_connection_has_name(server, match_conn,

   *

   * @return #wbcErr

   *

   *                  be removed in the next major version change.

   **/

  wbcErr wbcSetUidMapping(uid_t uid, const struct wbcDomainSid *sid);

                                     struct wbcDomainControllerInfoEx **dc_info);

  /**********************************************************

   **********************************************************/

  /**

  # Regression test for bug 3179

      # Override

      subprocess.check_call(["sss_override", "user-add", "user1",

  def realloc_users(pwd_ops, num):

      # canary is added first

      for i in range(1, num):

          user = user_generator(i)

                        ip: 10.65.223.18

                        role: master

        * create a conftest.py as below::

      fail_unless(idmap_ctx != NULL, "sss_idmap_init returned NULL.");

  }

  {

      enum idmap_error_code err;

                                ck_leak_check_setup,

                                ck_leak_check_teardown);

      tcase_add_checked_fixture(tc_map_additional_secondary_slices,

                                idmap_ctx_teardown);

      tcase_add_checked_fixture(tc_map_additional_secondary_slices,

                                idmap_add_domain_with_sec_slices_setup,

      hmackey = EVP_PKEY_new_mac_key(EVP_PKEY_HMAC, NULL, key, keylen);

      if (!hmackey) return ENOMEM;

       * algorithms so we just truncate to the key size should the hmac be bigger

       * (or pad with zeros should the HMAC be smaller) */

      hmaclen = keylen;

      hmac = &mechs[AES256CBC_HMAC_SHA256].hmac;

      ivlen = enc->bsize;

       * algorithms so we just truncate to the key size should the hmac be bigger

       * (or pad with zeros should the HMAC be smaller) */

      hmaclen = keylen;

          goto done;

      }

       * fairly restrictive permissions that still allow us to use the

       * directory.

       * */

   *

   * @param mem_ctx              Memory context.

   * @param free_data_on_removal If true than the stored pointer is freed when

   *                             the list is freed.

   * @return New list or NULL on failure.

   */

   * @param[in]  mem_ctx         The talloc context that owns the response

   * @param[in]  req             The request previously obtained with tcurl_request_send

   * @param[out] _response       Response to the request

   *

   * @returns The error code of the curl request (not the HTTP code!)

   */

      while (input[i]) {

          /* Even though this character might have a special meaning, if it's

           */

          if (ignore == NULL) {

              allowed = NULL;

  /**

   * @brief Add two list of strings

   *

   *

   * @param[in] mem_ctx      Talloc memory context for the new list.

   * @param[in] copy_strings If set to 'true' the list items will be copied

   *                         otherwise only the pointers to the items are

   *                         copied.