/*********************************************************************** * ldap_parse_resultW (WLDAP32.@) * * Parse a result message. * * PARAMS * ld [I] Pointer to an LDAP context. * result [I] Result message. * retcode [O] Return code for the server operation. * matched [O] DNs matched in the operation. * error [O] Error message for the operation. * referrals [O] Referrals found in the result message. * serverctrls [O] Controls used in the operation. * free [I] Free the result message? * * RETURNS * Success: LDAP_SUCCESS * Failure: An LDAP error code. * * NOTES * Free the DNs and error message with ldap_memfree. Free * the referrals with ldap_value_free and the controls with * ldap_controls_free. Pass a nonzero value for 'free' or call * ldap_msgfree to free the result message. */ ULONG CDECL ldap_parse_resultW( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *result, ULONG *retcode, PWCHAR *matched, PWCHAR *error, PWCHAR **referrals, PLDAPControlW **serverctrls, BOOLEAN free ) { ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED; #ifdef HAVE_LDAP char *matchedU = NULL, *errorU = NULL, **referralsU = NULL; LDAPControl **serverctrlsU = NULL; TRACE( "(%p, %p, %p, %p, %p, %p, %p, 0x%02x)\n", ld, result, retcode, matched, error, referrals, serverctrls, free ); if (!ld) return WLDAP32_LDAP_PARAM_ERROR; ret = map_error( ldap_parse_result( ld, result, (int *)retcode, &matchedU, &errorU, &referralsU, &serverctrlsU, free )); if (matched) *matched = strUtoW( matchedU ); if (error) *error = strUtoW( errorU ); if (referrals) *referrals = strarrayUtoW( referralsU ); if (serverctrls) *serverctrls = controlarrayUtoW( serverctrlsU ); ldap_memfree( matchedU ); ldap_memfree( errorU ); strarrayfreeU( referralsU ); ldap_controls_free( serverctrlsU ); #endif return ret; }
/*********************************************************************** * ldap_parse_sort_controlW (WLDAP32.@) * * Parse a sort control. * * PARAMS * ld [I] Pointer to an LDAP context. * control [I] Control obtained from a result message. * result [O] Result code. * attr [O] Failing attribute. * * RETURNS * Success: LDAP_SUCCESS * Failure: An LDAP error code. * * NOTES * If the function fails, free the failing attribute with ldap_memfree. */ ULONG CDECL ldap_parse_sort_controlW( WLDAP32_LDAP *ld, PLDAPControlW *control, ULONG *result, PWCHAR *attr ) { ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED; #ifdef HAVE_LDAP char *attrU = NULL; LDAPControl **controlU = NULL; #ifdef HAVE_LDAP_PARSE_SORT_CONTROL unsigned long res; #elif defined(HAVE_LDAP_PARSE_SORTRESPONSE_CONTROL) ber_int_t res; LDAPControl *sortcontrol = NULL; unsigned int i; #endif TRACE( "(%p, %p, %p, %p)\n", ld, control, result, attr ); if (!ld) return WLDAP32_LDAP_PARAM_ERROR; if (!control) return WLDAP32_LDAP_CONTROL_NOT_FOUND; controlU = controlarrayWtoU( control ); if (!controlU) return WLDAP32_LDAP_NO_MEMORY; #ifdef HAVE_LDAP_PARSE_SORT_CONTROL if (!(ret = ldap_parse_sort_control( ld, controlU, &res, &attrU ))) { *result = res; *attr = strUtoW( attrU ); } #elif defined(HAVE_LDAP_PARSE_SORTRESPONSE_CONTROL) for (i = 0; controlU[i]; i++) { if (!strcmp( LDAP_SERVER_RESP_SORT_OID, controlU[i]->ldctl_oid )) sortcontrol = controlU[i]; } if (!sortcontrol) { controlarrayfreeU( controlU ); return WLDAP32_LDAP_CONTROL_NOT_FOUND; } if (!(ret = ldap_parse_sortresponse_control( ld, sortcontrol, &res, &attrU ))) { *result = res; *attr = strUtoW( attrU ); } #endif controlarrayfreeU( controlU ); #endif return map_error( ret ); }
/*********************************************************************** * ldap_ufn2dnW (WLDAP32.@) * * Convert a user-friendly name to a DN. * * PARAMS * ufn [I] User-friendly name to convert. * dn [O] Receives a pointer to a string containing the DN. * * RETURNS * Success: LDAP_SUCCESS * Failure: An LDAP error code. * * NOTES * Free the string with ldap_memfree. */ ULONG CDECL ldap_ufn2dnW( PWCHAR ufn, PWCHAR *dn ) { ULONG ret = WLDAP32_LDAP_SUCCESS; #ifdef HAVE_LDAP char *ufnU = NULL; TRACE( "(%s, %p)\n", debugstr_w(ufn), dn ); if (!dn) return WLDAP32_LDAP_PARAM_ERROR; *dn = NULL; if (ufn) { ufnU = strWtoU( ufn ); if (!ufnU) return WLDAP32_LDAP_NO_MEMORY; /* FIXME: do more than just a copy */ *dn = strUtoW( ufnU ); if (!*dn) ret = WLDAP32_LDAP_NO_MEMORY; } strfreeU( ufnU ); #endif return ret; }
ULONG CDECL ldap_parse_sort_controlW( WLDAP32_LDAP *ld, PLDAPControlW *control, ULONG *result, PWCHAR *attr ) { ULONG ret = LDAP_NOT_SUPPORTED; #ifdef HAVE_LDAP char *attrU = NULL; LDAPControl **controlU = NULL; TRACE( "(%p, %p, %p, %p)\n", ld, control, result, attr ); if (!ld) return ~0UL; if (control) { controlU = controlarrayWtoU( control ); if (!controlU) return WLDAP32_LDAP_NO_MEMORY; } ret = ldap_parse_sort_control( ld, controlU, result, &attrU ); *attr = strUtoW( attrU ); controlarrayfreeU( controlU ); #endif return ret; }
/*********************************************************************** * ldap_extended_operation_sW (WLDAP32.@) * * Perform an extended operation (synchronous mode). * * PARAMS * ld [I] Pointer to an LDAP context. * oid [I] OID of the extended operation. * data [I] Data needed by the operation. * serverctrls [I] Array of LDAP server controls. * clientctrls [I] Array of LDAP client controls. * retoid [O] OID of the server response message. * retdata [O] Data returned by the server. * * RETURNS * Success: LDAP_SUCCESS * Failure: An LDAP error code. * * NOTES * The data parameter should be set to NULL if the operation * requires no data. The serverctrls, clientctrls, retoid and * and retdata parameters are also optional. Set to NULL if not * used. Free retoid and retdata after use with ldap_memfree. */ ULONG CDECL ldap_extended_operation_sW( WLDAP32_LDAP *ld, PWCHAR oid, struct WLDAP32_berval *data, PLDAPControlW *serverctrls, PLDAPControlW *clientctrls, PWCHAR *retoid, struct WLDAP32_berval **retdata ) { ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED; #ifdef HAVE_LDAP char *oidU = NULL, *retoidU = NULL; LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL; ret = WLDAP32_LDAP_NO_MEMORY; TRACE( "(%p, %s, %p, %p, %p, %p, %p)\n", ld, debugstr_w(oid), data, serverctrls, clientctrls, retoid, retdata ); if (!ld) return WLDAP32_LDAP_PARAM_ERROR; if (oid) { oidU = strWtoU( oid ); if (!oidU) goto exit; } if (serverctrls) { serverctrlsU = controlarrayWtoU( serverctrls ); if (!serverctrlsU) goto exit; } if (clientctrls) { clientctrlsU = controlarrayWtoU( clientctrls ); if (!clientctrlsU) goto exit; } ret = map_error( ldap_extended_operation_s( ld, oid ? oidU : "", (struct berval *)data, serverctrlsU, clientctrlsU, &retoidU, (struct berval **)retdata )); if (retoid && retoidU) { *retoid = strUtoW( retoidU ); if (!*retoid) ret = WLDAP32_LDAP_NO_MEMORY; ldap_memfree( retoidU ); } exit: strfreeU( oidU ); controlarrayfreeU( serverctrlsU ); controlarrayfreeU( clientctrlsU ); #endif return ret; }
/*********************************************************************** * ldap_next_attributeW (WLDAP32.@) * * Get the next attribute for a given entry. * * PARAMS * ld [I] Pointer to an LDAP context. * entry [I] Entry to retrieve attribute for. * ptr [I/O] Position pointer. * * RETURNS * Success: The name of the next attribute. * Failure: NULL * * NOTES * Free the returned string after each iteration with ldap_memfree. * When done iterating and when ptr != NULL, call ber_free( ptr, 0 ). */ PWCHAR CDECL ldap_next_attributeW( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *entry, WLDAP32_BerElement *ptr ) { PWCHAR ret = NULL; #ifdef HAVE_LDAP char *retU; TRACE( "(%p, %p, %p)\n", ld, entry, ptr ); if (!ld || !entry || !ptr) return NULL; retU = ldap_next_attribute( ld, entry, ptr ); ret = strUtoW( retU ); ldap_memfree( retU ); #endif return ret; }
/*********************************************************************** * ldap_get_dnW (WLDAP32.@) * * Retrieve the DN from a given LDAP message. * * PARAMS * ld [I] Pointer to an LDAP context. * entry [I] LDAPMessage structure to retrieve the DN from. * * RETURNS * Success: Pointer to a string that contains the DN. * Failure: NULL * * NOTES * Free the string with ldap_memfree. */ PWCHAR CDECL ldap_get_dnW( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *entry ) { PWCHAR ret = NULL; #ifdef HAVE_LDAP char *retU; TRACE( "(%p, %p)\n", ld, entry ); if (!ld || !entry) return NULL; retU = ldap_get_dn( ld, entry ); ret = strUtoW( retU ); ldap_memfree( retU ); #endif return ret; }
/*********************************************************************** * ldap_dn2ufnW (WLDAP32.@) * * Convert a DN to a user-friendly name. * * PARAMS * dn [I] DN to convert. * * RETURNS * Success: Pointer to a string containing the user-friendly name. * Failure: NULL * * NOTES * Free the string with ldap_memfree. */ PWCHAR CDECL ldap_dn2ufnW( PWCHAR dn ) { PWCHAR ret = NULL; #ifdef HAVE_LDAP char *dnU, *retU; TRACE( "(%s)\n", debugstr_w(dn) ); dnU = strWtoU( dn ); if (!dnU) return NULL; retU = ldap_dn2ufn( dnU ); ret = strUtoW( retU ); strfreeU( dnU ); ldap_memfree( retU ); #endif return ret; }
ULONG CDECL ldap_parse_extended_resultW( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *result, PWCHAR *oid, struct WLDAP32_berval **data, BOOLEAN free ) { ULONG ret = LDAP_NOT_SUPPORTED; #ifdef HAVE_LDAP char *oidU = NULL; TRACE( "(%p, %p, %p, %p, 0x%02x)\n", ld, result, oid, data, free ); if (!ld) return WLDAP32_LDAP_PARAM_ERROR; if (!result) return WLDAP32_LDAP_NO_RESULTS_RETURNED; ret = ldap_parse_extended_result( ld, result, &oidU, (struct berval **)data, free ); if (oid) { *oid = strUtoW( oidU ); if (!*oid) ret = WLDAP32_LDAP_NO_MEMORY; ldap_memfree( oidU ); } #endif return ret; }
/*********************************************************************** * ldap_get_optionW (WLDAP32.@) * * Retrieve option values for a given LDAP context. * * PARAMS * ld [I] Pointer to an LDAP context. * option [I] Option to get values for. * value [O] Pointer to option values. * * RETURNS * Success: LDAP_SUCCESS * Failure: An LDAP error code. */ ULONG CDECL ldap_get_optionW( WLDAP32_LDAP *ld, int option, void *value ) { ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED; #ifdef HAVE_LDAP TRACE( "(%p, 0x%08x, %p)\n", ld, option, value ); if (!ld || !value) return WLDAP32_LDAP_PARAM_ERROR; switch (option) { case WLDAP32_LDAP_OPT_API_FEATURE_INFO: { LDAPAPIFeatureInfo featureU; LDAPAPIFeatureInfoW *featureW = value; if (!featureW->ldapaif_name) return WLDAP32_LDAP_PARAM_ERROR; featureU.ldapaif_info_version = featureW->ldapaif_info_version; featureU.ldapaif_name = strWtoU( featureW->ldapaif_name ); featureU.ldapaif_version = 0; if (!featureU.ldapaif_name) return WLDAP32_LDAP_NO_MEMORY; ret = map_error( ldap_get_option( ld, option, &featureU )); featureW->ldapaif_version = featureU.ldapaif_version; strfreeU( featureU.ldapaif_name ); return ret; } case WLDAP32_LDAP_OPT_API_INFO: { LDAPAPIInfo infoU; LDAPAPIInfoW *infoW = value; memset( &infoU, 0, sizeof(LDAPAPIInfo) ); infoU.ldapai_info_version = infoW->ldapai_info_version; ret = map_error( ldap_get_option( ld, option, &infoU )); infoW->ldapai_api_version = infoU.ldapai_api_version; infoW->ldapai_protocol_version = infoU.ldapai_protocol_version; if (infoU.ldapai_extensions) { infoW->ldapai_extensions = strarrayUtoW( infoU.ldapai_extensions ); if (!infoW->ldapai_extensions) return WLDAP32_LDAP_NO_MEMORY; } if (infoU.ldapai_vendor_name) { infoW->ldapai_vendor_name = strUtoW( infoU.ldapai_vendor_name ); if (!infoW->ldapai_vendor_name) { ldap_memvfree( (void **)infoU.ldapai_extensions ); return WLDAP32_LDAP_NO_MEMORY; } } infoW->ldapai_vendor_version = infoU.ldapai_vendor_version; ldap_memvfree( (void **)infoU.ldapai_extensions ); ldap_memfree( infoU.ldapai_vendor_name ); return ret; } case WLDAP32_LDAP_OPT_DEREF: case WLDAP32_LDAP_OPT_DESC: case WLDAP32_LDAP_OPT_ERROR_NUMBER: case WLDAP32_LDAP_OPT_PROTOCOL_VERSION: case WLDAP32_LDAP_OPT_REFERRALS: case WLDAP32_LDAP_OPT_SIZELIMIT: case WLDAP32_LDAP_OPT_TIMELIMIT: return map_error( ldap_get_option( ld, option, value )); case WLDAP32_LDAP_OPT_CACHE_ENABLE: case WLDAP32_LDAP_OPT_CACHE_FN_PTRS: case WLDAP32_LDAP_OPT_CACHE_STRATEGY: case WLDAP32_LDAP_OPT_IO_FN_PTRS: case WLDAP32_LDAP_OPT_REBIND_ARG: case WLDAP32_LDAP_OPT_REBIND_FN: case WLDAP32_LDAP_OPT_RESTART: case WLDAP32_LDAP_OPT_THREAD_FN_PTRS: return WLDAP32_LDAP_LOCAL_ERROR; case WLDAP32_LDAP_OPT_AREC_EXCLUSIVE: case WLDAP32_LDAP_OPT_AUTO_RECONNECT: case WLDAP32_LDAP_OPT_CLIENT_CERTIFICATE: case WLDAP32_LDAP_OPT_DNSDOMAIN_NAME: case WLDAP32_LDAP_OPT_ENCRYPT: case WLDAP32_LDAP_OPT_ERROR_STRING: case WLDAP32_LDAP_OPT_FAST_CONCURRENT_BIND: case WLDAP32_LDAP_OPT_GETDSNAME_FLAGS: case WLDAP32_LDAP_OPT_HOST_NAME: case WLDAP32_LDAP_OPT_HOST_REACHABLE: case WLDAP32_LDAP_OPT_PING_KEEP_ALIVE: case WLDAP32_LDAP_OPT_PING_LIMIT: case WLDAP32_LDAP_OPT_PING_WAIT_TIME: case WLDAP32_LDAP_OPT_PROMPT_CREDENTIALS: case WLDAP32_LDAP_OPT_REF_DEREF_CONN_PER_MSG: case WLDAP32_LDAP_OPT_REFERRAL_CALLBACK: case WLDAP32_LDAP_OPT_REFERRAL_HOP_LIMIT: case WLDAP32_LDAP_OPT_ROOTDSE_CACHE: case WLDAP32_LDAP_OPT_SASL_METHOD: case WLDAP32_LDAP_OPT_SECURITY_CONTEXT: case WLDAP32_LDAP_OPT_SEND_TIMEOUT: case WLDAP32_LDAP_OPT_SERVER_CERTIFICATE: case WLDAP32_LDAP_OPT_SERVER_CONTROLS: case WLDAP32_LDAP_OPT_SERVER_ERROR: case WLDAP32_LDAP_OPT_SERVER_EXT_ERROR: case WLDAP32_LDAP_OPT_SIGN: case WLDAP32_LDAP_OPT_SSL: case WLDAP32_LDAP_OPT_SSL_INFO: case WLDAP32_LDAP_OPT_SSPI_FLAGS: case WLDAP32_LDAP_OPT_TCP_KEEPALIVE: FIXME( "Unsupported option: 0x%02x\n", option ); return WLDAP32_LDAP_NOT_SUPPORTED; default: FIXME( "Unknown option: 0x%02x\n", option ); return WLDAP32_LDAP_LOCAL_ERROR; } #endif return ret; }