lib/libadmin/template.c \

  	lib/libadmin/util.c \

  	lib/base/crit.cpp \

  	lib/base/dnsdmain.cpp \

  	lib/base/ereport.cpp \

  	lib/base/file.cpp \

  	lib/base/fsmutex.cpp \

  	lib/base/nscperror.c \

  	lib/base/plist.cpp \

  	lib/base/pool.cpp \

  AC_FUNC_STRERROR_R

  AC_FUNC_STRFTIME

  AC_FUNC_VPRINTF

  # These functions are *required* without option.

  AC_CHECK_FUNCS([clock_gettime], [], AC_MSG_ERROR([unable to locate required symbol clock_gettime]))

  from lib389.utils import *

  from lib389.topologies import topology_m2 as topo_m2, TopologyMain, topology_m3 as topo_m3, create_topology, _remove_ssca_db

  from lib389._constants import *

  from lib389.idm.organizationalunit import OrganizationalUnits

  from lib389.agreement import Agreements

  from lib389.idm.user import UserAccount

  from lib389.idm.group import Groups, Group

  from lib389.replica import Replicas, ReplicationManager

  from lib389.changelog import Changelog5

      logging.getLogger(__name__).setLevel(logging.INFO)

  log = logging.getLogger(__name__)

  def find_start_location(file, no):

      log_pattern = re.compile("slapd_daemon - slapd started.")

      count = 0

  def pattern_errorlog(file, log_pattern, start_location=0):

      count = 0

      file.seek(start_location)

      # Use a while true iteration because 'for line in file: hit a

      log.debug("_pattern_errorlog: complete (count=%d)" % count)

      return count

  def _move_ruv(ldif_file):

      """ Move RUV entry in an ldif file to the top"""

          subprocess.Popen(cmd, stdout=subprocess.PIPE)

      def fin():

          if DEBUGGING:

              [_kill_ns_slapd(inst) for inst in topology]

          else:

              [_kill_ns_slapd(inst) for inst in topology]

              assert _remove_ssca_db(topology)

              [inst.delete() for inst in topology if inst.exists()]

      request.addfinalizer(fin)

      return topology

      repl.test_replication(m1, m2)

      repl.test_replication(m2, m1)

  @pytest.mark.bz1506831

  def test_repl_modrdn(topo_m2):

      """Test that replicated MODRDN does not break replication

      topo_m2.pause_all_replicas()

      log.info("Apply modrdn to M1 - move test user from OU A -> C")

      log.info("Apply modrdn on M2 - move test user from OU B -> C")

      log.info("Start Replication")

      topo_m2.resume_all_replicas()

      repl.test_replication(master2, master1)

  def test_password_repl_error(topo_m2, create_entry):

      """Check that error about userpassword replication is properly logged

              'cn': 'whatever',

              'nsDS5ReplicaRoot': DEFAULT_SUFFIX,

              'nsDS5ReplicaBindDN': 'cn=replication manager,cn=config',

              'nsDS5ReplicaTransportInfo': 'LDAP',

              'nsds5replicaTimeout': '5',

              'description': "test agreement",

      repl.test_replication(m1, m2)

      repl.test_replication(m2, m1)

  def test_fetch_bindDnGroup(topo_m2):

      """Check the bindDNGroup is fetched on first replication session

      M2 = topo_m2.ms['master2']

      # Enable replication log level. Not really necessary

      # Create a group and a user

      PEOPLE = "ou=People,%s" % SUFFIX

      PASSWD = 'password'

      uid = REPL_MGR_BOUND_DN.encode()

      users = UserAccounts(M1, PEOPLE, rdn=None)

      groups_M1 = Groups(M1, DEFAULT_SUFFIX)

      group_properties = {

      group_M1 = groups_M1.create(properties=group_properties)

      group_M2 = Group(M2, group_M1.dn)

      assert(not group_M1.is_member(create_user.dn))

      # Check that M1 and M2 are in sync

      repl = ReplicationManager(DEFAULT_SUFFIX)

      repl.wait_for_replication(M1, M2, timeout=20)

      replica.apply_mods([(ldap.MOD_REPLACE, 'nsDS5ReplicaBindDnGroupCheckInterval', '60'),

                          (ldap.MOD_REPLACE, 'nsDS5ReplicaBindDnGroup', group_M1.dn)])

      replicas = Replicas(M2)

      replica = replicas.list()[0]

      replica.apply_mods([(ldap.MOD_REPLACE, 'nsDS5ReplicaBindDnGroupCheckInterval', '60'),

                          (ldap.MOD_REPLACE, 'nsDS5ReplicaBindDnGroup', group_M1.dn)])

      # Then pause the replication agreement to prevent them trying to acquire

      # while the user is not member of the group

      topo_m2.pause_all_replicas()

          agmt.replace('nsDS5ReplicaBindDN', create_user.dn.encode())

          agmt.replace('nsds5ReplicaCredentials', PASSWD.encode())

      # Key step

      # The restart will fetch the group/members define in the replica

      #

      topo_m2.resume_all_replicas()

      # trigger updates to be sure to have a replication session, giving some time

      time.sleep(10)

      # Check replication is working

      count = pattern_errorlog(errorlog_M1, regex, start_location=restart_location_M1)

      assert(count <= 1)

      count = pattern_errorlog(errorlog_M2, regex, start_location=restart_location_M2)

      if DEBUGGING:

          # Add debugging steps(if any)...

          pass

  def test_cleanallruv_repl(topo_m3):

      """Test that cleanallruv could not break replication if anchor csn in ruv originated in deleted replica

      :id: 46faba9a-897e-45b8-98dc-aec7fa8cec9a

      user_props = TEST_USER_PROPERTIES.copy()

      user_props.update({'uid': "testuser10"})

      user_props.update({'uid': "testuser20"})

      user20 = users_m2.create(properties=user_props)

      # ClearRuv is launched but with Force

      M3.stop()

      M1.tasks.cleanAllRUV(suffix=SUFFIX, replicaid='3',

      # here M1 should clear 31

      M2.start()

      M1.agreement.resume(m1_m2[0].dn)

      time.sleep(10)

      expected_m1_users = [user31.dn, user11.dn, user21.dn, user32.dn, user33.dn, user12.dn]

      expected_m2_users = [user31.dn, user11.dn, user21.dn, user12.dn]

      current_m1_users = [user.dn for user in users_m1.list()]

      current_m2_users = [user.dn for user in users_m2.list()]

      assert set(expected_m1_users).issubset(current_m1_users)

      assert set(expected_m2_users).issubset(current_m2_users)

  NSPR_BEGIN_EXTERN_C

  NSAPI_PUBLIC int INTutil_itoa(int i, char *a);

  NSAPI_PUBLIC

  NSPR_END_EXTERN_C

  #define util_itoa INTutil_itoa

  #define util_vsprintf INTutil_vsprintf

  #define util_sprintf INTutil_sprintf

  #endif /* SNI || LINUX1_2 */

  #if defined(_WINDOWS) || defined(macintosh)

  #define CTIME(c, b, l) ctime(c)

  #define STRTOK(s1, s2, l) strtok(s1, s2)

  #else /* UNIX */

  /*

   * XXXmcs: GETHOSTBYADDR() is only defined for IRIX/SGI and Solaris for now.

   */

  #include <arpa/inet.h> /* for inet_addr() */

  #endif                 /* SOLARIS */

  /*

   * SAFEMEMCPY is an overlap-safe copy from s to d of n bytes

   */

      conn->c_ns_close_jobs = 0;

  }

  /*

   * Callers of connection_reset() must hold the conn->c_mutex lock.

   */

  {

      char *pTmp = is_SSL ? "SSL " : "";

      char *str_ip = NULL, *str_destip;

      char *str_unknown = "unknown";

      int in_referral_mode = config_check_referral_mode();

                  (from->ipv6.ip.pr_s6_addr32[1] != 0) ||

                  (from->ipv6.ip.pr_s6_addr32[2] != 0) ||

                  (from->ipv6.ip.pr_s6_addr32[3] != 0)) ||

          conn->cin_addr = (PRNetAddr *)slapi_ch_malloc(sizeof(PRNetAddr));

          memcpy(conn->cin_addr, from, sizeof(PRNetAddr));

          if (PR_IsNetAddrType(conn->cin_addr, PR_IpAddrV4Mapped)) {

              PRNetAddr v4addr = {{0}};

              v4addr.inet.family = PR_AF_INET;

      } else {

          /* try syscall since "from" was not given and PR_GetPeerName failed */

          /* a corner case */

  #if (defined(hpux))

          int addrlen;

  #else

          addrlen = sizeof(addr);

          if ((conn->c_prfd == NULL) &&

              conn->cin_addr = (PRNetAddr *)slapi_ch_malloc(sizeof(PRNetAddr));

              memset(conn->cin_addr, 0, sizeof(PRNetAddr));

              PR_NetAddrFamily(conn->cin_addr) = AF_INET6;

              /* note: IPv4-mapped IPv6 addr does not work on Windows */

          } else {

              str_ip = str_unknown;

          }

      } else {

          /* try syscall since c_prfd == NULL */

          /* a corner case */

  #if (defined(hpux))

          int destaddrlen;

  #else

          socklen_t destaddrlen;

  #endif

          destaddrlen = sizeof(destaddr);

              conn->cin_destaddr = (PRNetAddr *)slapi_ch_malloc(sizeof(PRNetAddr));

              memset(conn->cin_destaddr, 0, sizeof(PRNetAddr));

              PR_NetAddrFamily(conn->cin_destaddr) = AF_INET6;

              /* note: IPv4-mapped IPv6 addr does not work on Windows */

          } else {

              str_destip = str_unknown;

          }

      }

      if (!in_referral_mode) {

          /* create a sasl connection */

          ids_sasl_server_new(conn);

  #include <string.h>

  #include <sys/param.h>

  #include <sys/socket.h>

  #include <netinet/in.h>

  #include <arpa/inet.h>

  #include <netdb.h>

  static char *

  find_localhost_DNS(void)

  {

      char hostname[MAXHOSTNAMELEN + 1];

      FILE *f;

      char *cp;

      char *domain;

      char line[MAXHOSTNAMELEN + 8];

      if (gethostname(hostname, MAXHOSTNAMELEN)) {

          int oserr = errno;

                        oserr, slapd_system_strerror(oserr));

          return NULL;

      }

          slapi_log_err(SLAPI_LOG_ERR, "find_localhost_DNS",

          return NULL;

      }

          }

      }

      /* The following is copied from dns_guess_domain(),

         in ldapserver/lib/base/dnsdmain.c */

      domain = NULL;

      }

  #endif

      if (domain == NULL) {

          return NULL;

      }

      if (domain[0] == '.')

          ++domain;

      if (domain[0]) {

          PL_strcatn(hostname, sizeof(hostname), domain);

      }

      slapi_log_err(SLAPI_LOG_CONFIG, "find_localhost_DNS", "hostname == %s\n", hostname);

      return slapi_ch_strdup(hostname);

  }

  #include "remote.h"

  #include "lber.h"

  #include "ldap.h"

  enum

  {

  main(int argc, char **argv)

  {

      static char logline[512];

      char **tmp;

      char *p;

      while ((i = getopt(argc, argv, "p:")) != EOF) {

          switch (i) {

              break;

          }

      }

      srvsaddr.sin_family = AF_INET;

      srvsaddr.sin_port = htons(port);

      maxop = npend = 0;

      pendops = (Optype *)malloc(sizeof(Optype) * 20);

      sigset(SIGPIPE, SIG_IGN);

      while (fgets(logline, sizeof(logline), stdin)) {

              *p = 0;

          }

          if (!connected) {

  #include "remote.h"

  #include "lber.h"

  #include "ldap.h"

  /*

   * Enumeration for internal list

      int sockfd, log = 0;

      static char logline[512];

      char **tmp, *hn, *hp, *hf;

      while ((i = getopt(argc, argv, "tdP:s:")) != EOF) {

          switch (i) {

              /*

               * Get master address, just the first.

               */

                  printf("Unknown host %s\n", hn);

                  break;

              }

              srvlist = (Towho *)realloc(srvlist, (nsrv + 1) * sizeof(Towho));

              srvlist[nsrv].addr.sin_family = AF_INET;

              srvlist[nsrv].addr.sin_port = htonl((hp == hf ? port : atoi(hp)));

              if ((srvlist[nsrv].filter = regcmp(hf, NULL)) == NULL)

              srvlist[nsrv].fd = open_cnx((struct sockaddr *)&srvlist[nsrv].addr);

              srvlist[nsrv].hname = strdup(hn);

              nsrv++;

              break;

          }

      }

              printf("\t-t\tprints input on stdout.\n\t-d\tdebug mode.\n");

              exit(1);

          }

              exit(1);

          }

          srvlist[nsrv].addr.sin_family = AF_INET;

          srvlist[nsrv].addr.sin_port = htons(port);

          srvlist[nsrv].filter = NULL;

          srvlist[nsrv].fd = open_cnx((struct sockaddr *)&srvlist[nsrv].addr);

          srvlist[nsrv].hname = strdup(argv[optind]);

          nsrv++;

      }

      maxop = npend = 0;

      pendops = (Optype *)malloc(sizeof(Optype) * 20);