/* -*- C -*- 
 *
 * Copyright 2000 Compaq Computer Corporation
 * 
 * COMPAQ Registered in U.S. Patent and Trademark Office.
 * 
 * Consistent with FAR 12.211 and 12.212, Commercial Computer Software,
 * Computer Software Documentation, and Technical Data for Commercial Items
 * are licensed to the U.S. Government under vendor's standard commercial
 * license.
 * 
 * This software is subject to change without notice and is provided "AS IS"
 * WITHOUT WARRANTY OF ANY KIND. THE ENTIRE RISK ARISING OUT OF THE USE OF
 * THIS SOFTWARE REMAINS WITH RECIPIENT. IN NO EVENT SHALL COMPAQ BE LIABLE
 * FOR ANY DIRECT, CONSEQUENTIAL, INCIDENTAL, SPECIAL, PUNITIVE OR OTHER
 * DAMAGES WHATSOEVER (INCLUDING WITHOUT LIMITATION, DAMAGES FOR LOSS OF
 * BUSINESS PROFITS, BUSINESS INTERRUPTION OR LOSS OF BUSINESS INFORMATION),
 * EVEN IF COMPAQ HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  THE
 * FOREGOING SHALL APPLY REGARDLESS OF THE NEGLIGENCE OR OTHER FAULT OF
 * EITHER PARTY AND REGARDLESS OF WHETHER SUCH LIABILITY SOUNDS IN CONTRACT,
 * NEGLIGENCE, TORT, OR ANY OTHER THEORY OF LEGAL LIABILITY, AND
 * NOTWITHSTANDING ANY FAILURE OF ESSENTIAL PURPOSE OF ANY LIMITED REMEDY.
 * 
 * The limited warranties for Compaq products are exclusively set forth in
 * the documentation accompanying such products. Nothing herein should be
 * construed as constituting a further or additional warranty.
 * 
 * 
 */

/*
 * Compaq revision history
 *
 * Rev    Author         Date         Comments
 * ---    ------         ----         --------
 * 001    Nick Hudson    08-Sep-2000  Initial version
 */

/* 
 * This program demonstrates the use of the OpenVMS LDAP API from a client
 * application.
 *
 * The program may be compiled using either C or C++.
 *
 * The program may be compiled with either 32 or 64 bit pointers (providing
 * that the compiler supports it).
 *
 * To build this program use:
 * $ cc ldap_example
 * $ link ldap_example
 *
 * The program expects to run as a foreign command.  To define the foreign
 * command use the following syntax:
 *
 * $ ldap_example := $disk1:[mydir]ldap_example.exe ! define foreign command
 *
 * The program expects the following arguments:
 *
 *   server         The node which is providing LDAP access to a directory
 *
 *   base           The base object in the directory for the search operation
 *
 *   filter         The search filter to be used
 *
 *   attributes     An optional list of one or more attributes to be returned
 *                  for each matching record.  If no attributes are specified,
 *                  then all user attributes will be returned.
 *
 * An example of a search command would be: 
 *
 * $ ldap_example server "o=acme, c=us" "(sn=s*)" cn sn
 *
 * Given the parameters above, the program will attempt to make contact
 * with an LDAP server on node "server", and request a search for all
 * records below the object "o=acme, c=us" that match the filter "sn=s*".
 * For each matching record, the attributes "cn" and "sn" will be displayed.
 */

#include <ldap.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
/*
 * Generic routine to display an error message and return any 
 * supplementary information from the LDAP handle
 */
void report_error(const char *operation, int result, LDAP *ld)
{
  int    stat;
  char   *errmsgp = NULL;
  
  printf("%s returned error %d (\"%s\")\n",operation,
         result, ldap_err2string(result));
  

  stat = ldap_get_option(ld,LDAP_OPT_ERROR_STRING,&errmsgp);

  if ((stat == -1) || (strlen(errmsgp) == 0)) {
    printf("No supplementary error text available\n");
  }
  else {
    printf("Error text : \"%s\"\n",errmsgp);
  }
  
  if (errmsgp != NULL) {
    ldap_memfree(errmsgp);
    errmsgp = NULL;
  }
  

}

void main(int argc, char *argv[])
{
  int         stat;
  int         i;
  int         num_entries;
  char        **attrs_array = NULL;
  int         attribute_count;

  /*
   * For servers which don't support version 3 of the protocol, edit
   * the line below to use LDAP_VERSION2.  Both of these constants
   * are defined inside LDAP.H
   */
  int         protocol = LDAP_VERSION3;
  
  /*
   * The following pointers may be allocated by the LDAP API, and 
   * should be free'd using an appropriate mechanism
   */
  LDAP        *ld = NULL;
  LDAPMessage *result = NULL;
  LDAPMessage *one_entry = NULL;
  char        *dn = NULL;
  char        *attr_name = NULL;
  char        **values = NULL;
  BerElement  *ber = NULL;
  
  if (argc < 4) {
    printf("Usage : %s [server] [base] [filter] <attributes>\n",argv[0]);
    goto finished;
  }
  
  /*
   * If the user requested any particular attributes, then build up
   * an array to pass to the search routine.  If no attributes are
   * specified, then "attrs_array" will be NULL, and the server should 
   * return all user attributes for each matching entry
   */
  attribute_count = (argc - 4);
  if (attribute_count != 0) {
    i = 0;

    /*
     * Allocate enough room for a pointer to each attribute, plus
     * a NULL terminating pointer. 
     */
    attrs_array = (char **)calloc((attribute_count + 1),sizeof(char *));
    while (i < attribute_count) {
      attrs_array[i] = strdup(argv[i+4]);
      i++;
    }
  }
  
    
  /*
   * Establish a context with the library specifying an LDAP server name
   * and using the default LDAP port number.
   * No connection is made with the server at this stage, so a failure here
   * would indicate a problem with the library, rather than a network or
   * server related issue.
   */
  ld = ldap_init(argv[1], LDAP_PORT);
  if (ld == NULL) {
    printf("ldap_init failed\n");
    goto finished;
  }
  

  /*
   * Having been provided with a LDAP context, it is possible now to
   * specify options for this session
   */
  stat = ldap_set_option(ld, LDAP_OPT_PROTOCOL_VERSION, &protocol);
  if (stat != LDAP_SUCCESS) {
    report_error("ldap_set_option",stat,ld);
    goto finished;
  }
  

  /*
   * Execute a simple bind, without specifying any authorization
   * information, i.e. an anonymous bind
   */
  stat = ldap_simple_bind_s(ld,NULL,NULL);
  if (stat != LDAP_SUCCESS) {
    report_error("simple_bind",stat,ld);
    goto finished;
  }
  

  /*
   * Issue a synchronous search request; this call will not return 
   * until the server has responded.
   */
  stat = ldap_search_s(ld,                  /* ld */
                       argv[2],             /* base */
                       LDAP_SCOPE_SUBTREE,  /* scope */
                       argv[3],             /* filter */
                       attrs_array,         /* attrs */
                       0,                   /* attrsonly */
                       &result);            /* res */
  

  if (stat != LDAP_SUCCESS) {
    report_error("ldap_search_s",stat,ld);
    goto finished;
  }

  num_entries = ldap_count_entries(ld,result);

  if (num_entries == 0) {
    printf("No matching entries found\n");
    goto finished;
  }

  printf("Number of entries returned : %d\n",num_entries);
  
  /*
   * Now look at the results that came back
   */
  one_entry = ldap_first_entry(ld,result);

  while (one_entry != NULL) {

    /*
     * The distinguished name of this entry
     */
    dn = ldap_get_dn(ld,one_entry);

    if (dn != NULL) {
      printf("\ndn = %s\n",ldap_get_dn(ld,one_entry));
      ldap_memfree(dn);
      dn = NULL;

      /*
       * Step through each attribute
       */
      attr_name = ldap_first_attribute(ld,one_entry,&ber);
      if (attr_name == NULL) {
        printf("<No attributes returned>\n");
      }

      /*
       * Extract the values for each attribute returned.  This program
       * assumes that such values will be "printable" value strings.  For
       * non-printable (binary) data, ldap_get_values_len() should
       * be used.
       */
      while (attr_name != NULL) {
        values = ldap_get_values(ld,one_entry,attr_name);
        if (values == NULL) {
          printf("<no values returned>\n");
        }
        else {    
          i = 0;
          while (values[i] != NULL) {
            printf("%s : %s\n",attr_name,values[i]);
            i++;
          }
        }
        
        ldap_memfree(attr_name);
        attr_name = NULL;
        
        ldap_value_free(values);
        values = NULL;
        
          
        attr_name = ldap_next_attribute(ld,one_entry,ber);
      }

      /*
       * The BerElement pointer is no longer needed and so can be
       * released.  Since this pointer was just being used as an
       * iterator and doesn't point to any memory that the program
       * has allocated itself, use zero as the second parameter to 
       * ber_free().
       */
      if (ber != NULL) {
        ber_free(ber, 0);
        ber = NULL;
      }
        
    }
    else {
      report_error("ldap_get_dn",0,ld);
    }
    
    one_entry = ldap_next_entry(ld,one_entry);
  }

  /*
   * All exit paths should come through here, where free up any data
   * structures that the library has allocated using the appropriate
   * functions.
   * It is a good habit to set pointers to NULL after releasing them,
   * although in the cases below it isn't strictly necessary.
   */
finished:

  /*
   * "dn" may have been allocated by ldap_get_dn()
   */
  if (dn != NULL) {
    ldap_memfree(dn);
    dn = NULL;
  }

  /*
   * "attr_name" may have been allocated by ldap_first_attribute() or
   * ldap_next_attribute()
   */
  if (attr_name != NULL) {
    ldap_memfree(attr_name);
    attr_name = NULL;
  }
  
  /*
   * "values" may have been allocated by ldap_get_values()
   */
  if (values != NULL) {
    ldap_value_free(values);
    values = NULL;
  }
  
  /*
   * "ber" may have been allocated by ldap_first_attribute() or
   * ldap_next_attribute()
   * Since this pointer was just being used as an iterator and
   * doesn't point to any memory that the program has allocated
   * itself, use zero as the second parameter to ber_free()
   */
  if (ber != NULL) {
    ber_free(ber, 0);
    ber = NULL;
  }
      
  /*
   * "one_entry" may have been allocated by ldap_first_entry() or
   * ldap_next_entry()
   */
  if (one_entry != NULL) {
    ldap_msgfree(one_entry);
    one_entry = NULL;
  }  

  /*
   * "result" may have been allocated by ldap_search_s()
   */
  if (result != NULL) {
    ldap_msgfree(result);
    result = NULL;
  }  

  /*
   * "ld" was returned from ldap_init()
   */
  if (ld != NULL) {
    ldap_unbind(ld);
    ld = NULL;
  }
  
  /*
   * "attrs_array" was allocated by this program
   */
  if (attrs_array != NULL) {
    i = 0;
    while (attrs_array[i] != NULL) {
      free(attrs_array[i]);
      attrs_array[i] = NULL;
      i++;
    }
    free(attrs_array);
    attrs_array = NULL;
  }

  printf("\nProgram terminating\n");

}