libraries/libldap/nsprthreadtest.c

/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is Mozilla Communicator client code, released
 * March 31, 1998.
 *
 * The Initial Developer of the Original Code is
 * Netscape Communications Corporation.
 * Portions created by the Initial Developer are Copyright (C) 1998-1999
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either of the GNU General Public License Version 2 or later (the "GPL"),
 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */
#include <nspr.h>
#include <stdio.h>
#include <ldap.h>

#define NAME "cn=Directory Manager"
#define PASSWORD "secret99"
#define BASE "dc=example,dc=com"

static int simplebind(LDAP* ld, char* msg, int tries);
static void search_thread(void*);
static void modify_thread(void*);
static void add_thread(void*);
static void delete_thread(void*);
static void set_ld_error();
static int get_ld_error();
static void set_errno();
static int get_errno();
static void tsd_setup();
static void* my_mutex_alloc(void);
static void my_mutex_free(void*);
static int my_mutex_lock(void*);
static int my_mutex_unlock(void*);
static LDAPHostEnt* my_gethostbyname(const char* name, LDAPHostEnt* result,
                                     char* buffer, int buflen, int* statusp,
                                     void* extradata);
static LDAPHostEnt* my_gethostbyaddr(const char* addr, int length, int type,
                                     LDAPHostEnt* result, char* buffer,
                                     int buflen, int* statusp, void* extradata);
static LDAPHostEnt* copyPRHostEnt2LDAPHostEnt(LDAPHostEnt* ldhp,
                                              PRHostEnt* prhp);

typedef struct ldapmsgwrapper {
  LDAPMessage* lmw_messagep;
  struct ldapmsgwrapper* lmw_next;
} ldapmsgwrapper;

#define CONNECTION_ERROR(lderr) \
  ((lderr) == LDAP_SERVER_DOWN || (lderr) == LDAP_CONNECT_ERROR)

LDAP* ld;
PRUintn tsdindex;
#ifdef LDAP_MEMCACHE
LDAPMemCache* memcache = NULL;
#  define MEMCACHE_SIZE (256 * 1024) /* 256K bytes */
#  define MEMCACHE_TTL (15 * 60)     /* 15 minutes */
#endif

main(int argc, char** argv) {
  PRThread *search_tid, *search_tid2, *search_tid3;
  PRThread *search_tid4, *modify_tid, *add_tid;
  PRThread* delete_tid;
  struct ldap_thread_fns tfns;
  struct ldap_dns_fns dnsfns;
  int rc;

  if (argc != 3) {
    fprintf(stderr, "usage: %s host port\n", argv[0]);
    exit(1);
  }

  PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
  if (PR_NewThreadPrivateIndex(&tsdindex, NULL) != PR_SUCCESS) {
    perror("PR_NewThreadPrivateIndex");
    exit(1);
  }
  tsd_setup(); /* for main thread */

  if ((ld = ldap_init(argv[1], atoi(argv[2]))) == NULL) {
    perror("ldap_open");
    exit(1);
  }

  /* set thread function pointers */
  memset(&tfns, '\0', sizeof(struct ldap_thread_fns));
  tfns.ltf_mutex_alloc = my_mutex_alloc;
  tfns.ltf_mutex_free = my_mutex_free;
  tfns.ltf_mutex_lock = my_mutex_lock;
  tfns.ltf_mutex_unlock = my_mutex_unlock;
  tfns.ltf_get_errno = get_errno;
  tfns.ltf_set_errno = set_errno;
  tfns.ltf_get_lderrno = get_ld_error;
  tfns.ltf_set_lderrno = set_ld_error;
  tfns.ltf_lderrno_arg = NULL;
  if (ldap_set_option(ld, LDAP_OPT_THREAD_FN_PTRS, (void*)&tfns) != 0) {
    ldap_perror(ld, "ldap_set_option: thread functions");
    exit(1);
  }

  /* set DNS function pointers */
  memset(&dnsfns, '\0', sizeof(struct ldap_dns_fns));
  dnsfns.lddnsfn_bufsize = PR_NETDB_BUF_SIZE;
  dnsfns.lddnsfn_gethostbyname = my_gethostbyname;
  dnsfns.lddnsfn_gethostbyaddr = my_gethostbyaddr;
  if (ldap_set_option(ld, LDAP_OPT_DNS_FN_PTRS, (void*)&dnsfns) != 0) {
    ldap_perror(ld, "ldap_set_option: DNS functions");
    exit(1);
  }

#ifdef LDAP_MEMCACHE
  /* create the in-memory cache */
  if ((rc = ldap_memcache_init(MEMCACHE_TTL, MEMCACHE_SIZE, NULL, &tfns,
                               &memcache)) != LDAP_SUCCESS) {
    fprintf(stderr, "ldap_memcache_init failed - %s\n", ldap_err2string(rc));
    exit(1);
  }
  if ((rc = ldap_memcache_set(ld, memcache)) != LDAP_SUCCESS) {
    fprintf(stderr, "ldap_memcache_set failed - %s\n", ldap_err2string(rc));
    exit(1);
  }
#endif

  /*
   * set option so that the next call to ldap_simple_bind_s() after
   * the server connection is lost will attempt to reconnect.
   */
  if (ldap_set_option(ld, LDAP_OPT_RECONNECT, LDAP_OPT_ON) != 0) {
    ldap_perror(ld, "ldap_set_option: reconnect");
    exit(1);
  }

  /* initial bind */
  if (simplebind(ld, "ldap_simple_bind_s/main", 1) != LDAP_SUCCESS) {
    exit(1);
  }

  /* create the operation threads */
  if ((search_tid = PR_CreateThread(PR_USER_THREAD, search_thread, "1",
                                    PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
                                    PR_UNJOINABLE_THREAD, 0)) == NULL) {
    perror("PR_CreateThread search_thread");
    exit(1);
  }
  if ((modify_tid = PR_CreateThread(PR_USER_THREAD, modify_thread, "2",
                                    PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
                                    PR_UNJOINABLE_THREAD, 0)) == NULL) {
    perror("PR_CreateThread modify_thread");
    exit(1);
  }
  if ((search_tid2 = PR_CreateThread(PR_USER_THREAD, search_thread, "3",
                                     PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
                                     PR_UNJOINABLE_THREAD, 0)) == NULL) {
    perror("PR_CreateThread search_thread 2");
    exit(1);
  }
  if ((add_tid = PR_CreateThread(PR_USER_THREAD, add_thread, "4",
                                 PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
                                 PR_UNJOINABLE_THREAD, 0)) == NULL) {
    perror("PR_CreateThread add_thread");
    exit(1);
  }
  if ((search_tid3 = PR_CreateThread(PR_USER_THREAD, search_thread, "5",
                                     PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
                                     PR_UNJOINABLE_THREAD, 0)) == NULL) {
    perror("PR_CreateThread search_thread 3");
    exit(1);
  }
  if ((delete_tid = PR_CreateThread(PR_USER_THREAD, delete_thread, "6",
                                    PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
                                    PR_UNJOINABLE_THREAD, 0)) == NULL) {
    perror("PR_CreateThread delete_thread");
    exit(1);
  }
  if ((search_tid4 = PR_CreateThread(PR_USER_THREAD, search_thread, "7",
                                     PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
                                     PR_UNJOINABLE_THREAD, 0)) == NULL) {
    perror("PR_CreateThread search_thread 4");
    exit(1);
  }

  PR_Cleanup();
  return (0);
}

static int simplebind(LDAP* ld, char* msg, int tries) {
  int rc;

  while (tries-- > 0) {
    rc = ldap_simple_bind_s(ld, NAME, PASSWORD);
    if (rc != LDAP_SUCCESS) {
      ldap_perror(ld, msg);
    }
    if (tries == 0 || !CONNECTION_ERROR(rc)) {
      return (rc);
    }
    fprintf(stderr, "%s: sleeping for 5 secs - will try %d more time(s)...\n",
            msg, tries);
    sleep(5);
  }

  return (rc);
}

static void search_thread(void* arg1) {
  LDAPMessage* res;
  LDAPMessage* e;
  char* a;
  char** v;
  char* dn;
  BerElement* ber;
  int i, rc, msgid;
  void* tsd;
  char* id = arg1;

  printf("search_thread\n");
  tsd_setup();
  for (;;) {
    printf("%sSearching...\n", id);
    if ((msgid = ldap_search(ld, BASE, LDAP_SCOPE_SUBTREE, "(objectclass=*)",
                             NULL, 0)) == -1) {
      ldap_perror(ld, "ldap_search_s");
      rc = ldap_get_lderrno(ld, NULL, NULL);
      if (CONNECTION_ERROR(rc) &&
          simplebind(ld, "bind-search_thread", 5) != LDAP_SUCCESS) {
        return;
      }
      continue;
    }
    while ((rc = ldap_result(ld, msgid, 0, NULL, &res)) ==
           LDAP_RES_SEARCH_ENTRY) {
      for (e = ldap_first_entry(ld, res); e != NULL;
           e = ldap_next_entry(ld, e)) {
        dn = ldap_get_dn(ld, e);
        /* printf( "%sdn: %s\n", id, dn ); */
        free(dn);
        for (a = ldap_first_attribute(ld, e, &ber); a != NULL;
             a = ldap_next_attribute(ld, e, ber)) {
          v = ldap_get_values(ld, e, a);
          for (i = 0; v && v[i] != 0; i++) {
            /*
            printf( "%s%s: %s\n", id, a,
                v[i] );
            */
          }
          ldap_value_free(v);
          ldap_memfree(a);
        }
        if (ber != NULL) {
          ber_free(ber, 0);
        }
      }
      ldap_msgfree(res);
      /* printf( "%s\n", id ); */
    }

    if (rc == -1 || ldap_result2error(ld, res, 0) != LDAP_SUCCESS) {
      ldap_perror(ld, "ldap_search");
    } else {
      printf("%sDone with one round\n", id);
    }

    if (rc == -1) {
      rc = ldap_get_lderrno(ld, NULL, NULL);
      if (CONNECTION_ERROR(rc) &&
          simplebind(ld, "bind-search_thread", 5) != LDAP_SUCCESS) {
        return;
      }
    }
  }
}

static void modify_thread(void* arg1) {
  LDAPMessage* res;
  LDAPMessage* e;
  int i, modentry, entries, msgid, rc;
  LDAPMod mod;
  LDAPMod* mods[2];
  char* vals[2];
  char* dn;
  char* id = arg1;
  ldapmsgwrapper *list, *lmwp, *lastlmwp;

  printf("modify_thread\n");
  tsd_setup();
  if ((msgid = ldap_search(ld, BASE, LDAP_SCOPE_SUBTREE, "(objectclass=*)",
                           NULL, 0)) == -1) {
    ldap_perror(ld, "ldap_search_s");
    exit(1);
  }
  entries = 0;
  list = lastlmwp = NULL;
  while ((rc = ldap_result(ld, msgid, 0, NULL, &res)) ==
         LDAP_RES_SEARCH_ENTRY) {
    entries++;
    if ((lmwp = (ldapmsgwrapper*)malloc(sizeof(ldapmsgwrapper))) == NULL) {
      perror("modify_thread: malloc");
      exit(1);
    }
    lmwp->lmw_messagep = res;
    lmwp->lmw_next = NULL;
    if (lastlmwp == NULL) {
      list = lastlmwp = lmwp;
    } else {
      lastlmwp->lmw_next = lmwp;
    }
    lastlmwp = lmwp;
  }
  if (rc == -1 || ldap_result2error(ld, res, 0) != LDAP_SUCCESS) {
    ldap_perror(ld, "modify_thread: ldap_search");
    exit(1);
  } else {
    entries++;
    printf("%sModify got %d entries\n", id, entries);
  }

  mods[0] = &mod;
  mods[1] = NULL;
  vals[0] = "bar";
  vals[1] = NULL;
  for (;;) {
    modentry = rand() % entries;
    for (i = 0, lmwp = list; lmwp != NULL && i < modentry;
         i++, lmwp = lmwp->lmw_next) {
      /* NULL */
    }

    if (lmwp == NULL) {
      fprintf(stderr, "%sModify could not find entry %d of %d\n", id, modentry,
              entries);
      continue;
    }
    e = lmwp->lmw_messagep;
    printf("%sPicked entry %d of %d\n", id, i, entries);
    dn = ldap_get_dn(ld, e);
    mod.mod_op = LDAP_MOD_REPLACE;
    mod.mod_type = "description";
    mod.mod_values = vals;
    printf("%sModifying (%s)\n", id, dn);
    if ((rc = ldap_modify_s(ld, dn, mods)) != LDAP_SUCCESS) {
      ldap_perror(ld, "ldap_modify_s");
      if (CONNECTION_ERROR(rc) &&
          simplebind(ld, "bind-modify_thread", 5) != LDAP_SUCCESS) {
        return;
      }
    }
    free(dn);
  }
}

static void add_thread(void* arg1) {
  LDAPMod mod[5];
  LDAPMod* mods[6];
  char dn[BUFSIZ], name[40];
  char *cnvals[2], *snvals[2], *ocvals[2];
  int i, rc;
  char* id = arg1;

  printf("add_thread\n");
  tsd_setup();
  for (i = 0; i < 5; i++) {
    mods[i] = &mod[i];
  }
  mods[5] = NULL;
  mod[0].mod_op = 0;
  mod[0].mod_type = "cn";
  mod[0].mod_values = cnvals;
  cnvals[1] = NULL;
  mod[1].mod_op = 0;
  mod[1].mod_type = "sn";
  mod[1].mod_values = snvals;
  snvals[1] = NULL;
  mod[2].mod_op = 0;
  mod[2].mod_type = "objectclass";
  mod[2].mod_values = ocvals;
  ocvals[0] = "person";
  ocvals[1] = NULL;
  mods[3] = NULL;

  for (;;) {
    sprintf(name, "%d", rand());
    sprintf(dn, "cn=%s, " BASE, name);
    cnvals[0] = name;
    snvals[0] = name;

    printf("%sAdding entry (%s)\n", id, dn);
    if ((rc = ldap_add_s(ld, dn, mods)) != LDAP_SUCCESS) {
      ldap_perror(ld, "ldap_add_s");
      if (CONNECTION_ERROR(rc) &&
          simplebind(ld, "bind-add_thread", 5) != LDAP_SUCCESS) {
        return;
      }
    }
  }
}

static void delete_thread(void* arg1) {
  LDAPMessage* res;
  char dn[BUFSIZ], name[40];
  int entries, msgid, rc;
  char* id = arg1;

  printf("delete_thread\n");
  tsd_setup();
  if ((msgid = ldap_search(ld, BASE, LDAP_SCOPE_SUBTREE, "(objectclass=*)",
                           NULL, 0)) == -1) {
    ldap_perror(ld, "delete_thread: ldap_search_s");
    exit(1);
  }
  entries = 0;
  while ((rc = ldap_result(ld, msgid, 0, NULL, &res)) ==
         LDAP_RES_SEARCH_ENTRY) {
    entries++;
    ldap_msgfree(res);
  }
  entries++;
  if (rc == -1 || ldap_result2error(ld, res, 1) != LDAP_SUCCESS) {
    ldap_perror(ld, "delete_thread: ldap_search");
  } else {
    printf("%sDelete got %d entries\n", id, entries);
  }

  for (;;) {
    sprintf(name, "%d", rand());
    sprintf(dn, "cn=%s, " BASE, name);

    printf("%sDeleting entry (%s)\n", id, dn);
    if ((rc = ldap_delete_s(ld, dn)) != LDAP_SUCCESS) {
      ldap_perror(ld, "ldap_delete_s");
      if (CONNECTION_ERROR(rc) &&
          simplebind(ld, "bind-delete_thread", 5) != LDAP_SUCCESS) {
        return;
      }
    }
  }
}

struct ldap_error {
  int le_errno;
  char* le_matched;
  char* le_errmsg;
};

static void tsd_setup() {
  void* tsd;

  tsd = (void*)PR_GetThreadPrivate(tsdindex);
  if (tsd != NULL) {
    fprintf(stderr, "tsd non-null!\n");
    exit(1);
  }
  tsd = (void*)calloc(1, sizeof(struct ldap_error));
  if (PR_SetThreadPrivate(tsdindex, tsd) != 0) {
    perror("PR_SetThreadPrivate");
    exit(1);
  }
}

static void set_ld_error(int err, char* matched, char* errmsg, void* dummy) {
  struct ldap_error* le;

  le = (void*)PR_GetThreadPrivate(tsdindex);
  le->le_errno = err;
  if (le->le_matched != NULL) {
    ldap_memfree(le->le_matched);
  }
  le->le_matched = matched;
  if (le->le_errmsg != NULL) {
    ldap_memfree(le->le_errmsg);
  }
  le->le_errmsg = errmsg;
}

static int get_ld_error(char** matchedp, char** errmsgp, void* dummy) {
  struct ldap_error* le;

  le = PR_GetThreadPrivate(tsdindex);
  if (matchedp != NULL) {
    *matchedp = le->le_matched;
  }
  if (errmsgp != NULL) {
    *errmsgp = le->le_errmsg;
  }
  return (le->le_errno);
}

static void set_errno(int oserrno) {
  /* XXXmcs: should this be PR_SetError( oserrno, 0 )? */
  PR_SetError(PR_UNKNOWN_ERROR, oserrno);
}

static int get_errno(void) {
  /* XXXmcs: should this be PR_GetError()? */
  return (PR_GetOSError());
}

static void* my_mutex_alloc(void) { return ((void*)PR_NewLock()); }

static void my_mutex_free(void* mutex) { PR_DestroyLock((PRLock*)mutex); }

static int my_mutex_lock(void* mutex) {
  PR_Lock((PRLock*)mutex);
  return (0);
}

static int my_mutex_unlock(void* mutex) {
  if (PR_Unlock((PRLock*)mutex) == PR_FAILURE) {
    return (-1);
  }

  return (0);
}

static LDAPHostEnt* my_gethostbyname(const char* name, LDAPHostEnt* result,
                                     char* buffer, int buflen, int* statusp,
                                     void* extradata) {
  PRHostEnt prhent;

  if (PR_GetHostByName(name, buffer, buflen, &prhent) != PR_SUCCESS) {
    return (NULL);
  }

  return (copyPRHostEnt2LDAPHostEnt(result, &prhent));
}

static LDAPHostEnt* my_gethostbyaddr(const char* addr, int length, int type,
                                     LDAPHostEnt* result, char* buffer,
                                     int buflen, int* statusp,
                                     void* extradata) {
  PRHostEnt prhent;

  if (PR_GetHostByAddr((PRNetAddr*)addr, buffer, buflen, &prhent) !=
      PR_SUCCESS) {
    return (NULL);
  }

  return (copyPRHostEnt2LDAPHostEnt(result, &prhent));
}

static LDAPHostEnt* copyPRHostEnt2LDAPHostEnt(LDAPHostEnt* ldhp,
                                              PRHostEnt* prhp) {
  ldhp->ldaphe_name = prhp->h_name;
  ldhp->ldaphe_aliases = prhp->h_aliases;
  ldhp->ldaphe_addrtype = prhp->h_addrtype;
  ldhp->ldaphe_length = prhp->h_length;
  ldhp->ldaphe_addr_list = prhp->h_addr_list;
  return (ldhp);
}