O: RXLDAP
o[W: 0.21 2001-11-26
: 쐒 (IBM: tyano@yamato.ibm.com, Internet: tyano@tk.airnet.ne.jp)
@\: OS/2 REXXpLDAP API
O: 
OS/2 Warp4ȍ~
OS/2TCP/IP@\CXg[Ă邱ƁB
ύX:
2001-11-26 0.21: p̃hLgB
                 Rxldap_search_ext_ssizelimitp[^nĂȂ̂CB
                 Rxldap_search_ext_s/Rxldap_search_ext/utf8tostrł̃[N̏CB
2001-11-22 0.20: UTF-8̃T|[gB
                 RxldapToUTF8ǉB
                 RxldapFromUTF8ǉB
2001-11-16 0.11: OpenLDAP SDK̃TuZbgRXLDAPɕsvȕB
2001-11-14 0.10: OpenLDAPSDKOS/2ɈڐÂgpB
                 LDAP.DLLsvɂB
                 Rxldap_count_attributes폜B
                 Rxldap_parse_resulterrcodevarnameAmatcheddnvarnameAerrmsgvarnameȗ\ɂB
                 Rxldap_resultallp[^Ɋւ鐧ȂȂB
                 Rxldap_search_stldap_search_stĂяo悤ɂB
                 Rxldap_url_search_stldap_url_search_stĂяo悤ɂB
                 G[R[hV{OpenLDAPɍ킹B
                 bZ[W^CvV{OpenLDAPɍ킹B
                 IvVV{OpenLDAPɍ킹B
                 XR[vV{OpenLDAPɍ킹B
                 TvVdlɍ킹ĕύXB
                 pbP[WLdap SDK for OS/2̃TuZbg܂߂B (IBM C/C++3.6, TCP/IP for OS/2 V4.0p)
2001-11-02 0.02: Rxldap_parse_resultmatcheddnvarnameȗsɂB(gbvA{͏ȗ)
                 Rxldap_parse_resulterrcodevarnameȗsɂB(gbvA{͏ȗ)
                 Rxldap_parse_resulterrmsgvarnameȗsɂB(gbvA{͏ȗ)
                 Rxldap_parse_resultŕԂerrcode𐔎V{ɂB
                 Rxldap_resultmsgidLDAP_RES_*̃V{g悤ɂB
2001-10-31 0.01: Rxldap_resulttimeoutȗ\ɂB
2001-10-30 0.00: ŏ̃[X

APĨp[^̐
ld:
LDAP *Al

msg:
LDAPMessage *AȂl

msgid:
bZ[WIDAl

port:
|[gԍAl

ldapctrl: LDAPControl **Astemϐ
ldapctrl.0 = 
ldapctrl.n.!ldctl_oid = 
ldapctrl.n.!ldctl_value = 
ldapctrl.n.!ldctl_iscritical = l

dn:
Gg[Distinguished Name

mods: LDAPMod **Astemϐ
mods.0 = 
mods.n.!mod_op = A܂͐*
mods.n.!mod_type = Agr[g
mods.n.!modv.0 = 
mods.n.!modv.m = lA
*:
"LDAP_MOD_ADD"
"LDAP_MOD_ADD|LDAP_MOD_BVALUES"
"LDAP_MOD_DELETE"
"LDAP_MOD_DELETE|LDAP_MOD_BVALUES"
"LDAP_MOD_REPLACE"
"LDAP_MOD_REPLACE|LDAP_MOD_BVALUES"
0, 1, 2, 128, 129, 130

ber: 
BerElement *AȂl

pw:
pX[h

msgtype:
bZ[W^CṽV{B
"LDAP_RES_ADD"
"LDAP_RES_ANY"
"LDAP_RES_BIND"
"LDAP_RES_COMPARE"
"LDAP_RES_DELETE"
"LDAP_RES_EXTENDED"
"LDAP_RES_EXTENDED_PARTIAL"
"LDAP_RES_MODIFY"
"LDAP_RES_RENAME"
"LDAP_RES_SEARCH_ENTRY"
"LDAP_RES_SEARCH_REFERENCE"
"LDAP_RES_SEARCH_RESULT"
"LDAP_RES_UNSOLICITED"

Ldaperr:
LDAPG[R[h̃V{B
"LDAP_ADMINLIMIT_EXCEEDED"
"LDAP_AFFECTS_MULTIPLE_DSAS"
"LDAP_ALIAS_DEREF_PROBLEM"
"LDAP_ALIAS_PROBLEM"
"LDAP_ALREADY_EXISTS"
"LDAP_AUTH_METHOD_NOT_SUPPORTED"
"LDAP_AUTH_UNKNOWN"
"LDAP_BUSY"
"LDAP_CLIENT_LOOP"
"LDAP_COMPARE_FALSE"
"LDAP_COMPARE_TRUE"
"LDAP_CONFIDENTIALITY_REQUIRED"
"LDAP_CONNECT_ERROR"
"LDAP_CONSTRAINT_VIOLATION"
"LDAP_CONTROL_NOT_FOUND"
"LDAP_DECODING_ERROR"
"LDAP_ENCODING_ERROR"
"LDAP_FILTER_ERROR"
"LDAP_INAPPROPRIATE_AUTH"
"LDAP_INAPPROPRIATE_MATCHING"
"LDAP_INSUFFICIENT_ACCESS"
"LDAP_INVALID_CREDENTIALS"
"LDAP_INVALID_DN_SYNTAX"
"LDAP_INVALID_SYNTAX"
"LDAP_IS_LEAF"
"LDAP_LOCAL_ERROR"
"LDAP_LOOP_DETECT"
"LDAP_MORE_RESULTS_TO_RETURN"
"LDAP_NAMING_VIOLATION"
"LDAP_NOT_ALLOWED_ON_NONLEAF"
"LDAP_NOT_ALLOWED_ON_RDN"
"LDAP_NOT_SUPPORTED"
"LDAP_NO_MEMORY"
"LDAP_NO_OBJECT_CLASS_MODS"
"LDAP_NO_RESULTS_RETURNED"
"LDAP_NO_SUCH_ATTRIBUTE"
"LDAP_NO_SUCH_OBJECT"
"LDAP_OBJECT_CLASS_VIOLATION"
"LDAP_OPERATIONS_ERROR"
"LDAP_OTHER"
"LDAP_PARAM_ERROR"
"LDAP_PARTIAL_RESULTS"
"LDAP_PROTOCOL_ERROR"
"LDAP_REFERRAL"
"LDAP_REFERRAL_LIMIT_EXCEEDED"
"LDAP_RESULTS_TOO_LARGE"
"LDAP_SASL_BIND_IN_PROGRESS"
"LDAP_SERVER_DOWN"
"LDAP_SIZELIMIT_EXCEEDED"
"LDAP_STRONG_AUTH_REQUIRED"
"LDAP_SUCCESS"
"LDAP_TIMELIMIT_EXCEEDED"
"LDAP_TIMEOUT"
"LDAP_TYPE_OR_VALUE_EXISTS"
"LDAP_UNAVAILABLE"
"LDAP_UNAVAILABLE_CRITICAL_EXTENSION"
"LDAP_UNDEFINED_TYPE"
"LDAP_UNWILLING_TO_PERFORM"
"LDAP_USER_CANCELLED"

option:
IvV̎ށB啶̋ʂȂB
"LDAP_OPT_API_FEATURE_INFO"
"LDAP_OPT_API_INFO"
"LDAP_OPT_CLIENT_CONTROLS"
"LDAP_OPT_DEREF"
"LDAP_OPT_ERROR_NUMBER"
"LDAP_OPT_ERROR_STRING"
"LDAP_OPT_HOST_NAME"
"LDAP_OPT_MATCHED_DN"
"LDAP_OPT_PROTOCOL_VERSION"
"LDAP_OPT_REFERRALS"
"LDAP_OPT_RESTART"
"LDAP_OPT_SERVER_CONTROLS"
"LDAP_OPT_SIZELIMIT"
"LDAP_OPT_TIMELIMIT"

scope:
͈́B啶̋ʂȂB
"LDAP_SCOPE_BASE"
"LDAP_SCOPE_DEFAULT"
"LDAP_SCOPE_ONELEVEL"
"LDAP_SCOPE_SUBTREE"

attrsonly: Agr[gԂ1AlԂ0B

timeout: ^CAEgb (: 10, 10.0)

filter: tB^[B

base: Jnm[hDNB

desc: 
URL̗vfi[stemϐB
desc.!lud_host = zXg
desc.!lud_port = |[gԍ
desc.!lud_scope = 'LDAP_SCOPE_BASE', 'LDAP_SCOPE_ONELEVEL', 'LDAP_SCOPE_SUBTREE'
desc.!lud_filter = tB^
desc.!lud_attrs.0 = Agr[g̐
desc.!lud_attrs.n = Agr[g

T|[gĂȂIBM LDAP API (ʓ͗R)
ldap_bind (API)
ldap_bind_s (API)
ldap_controls_free (REXXł͕KvȂ)      
ldap_count_attributes (APIł͂Ȃ)     
ldap_count_values (REXXł͕KvȂ)
ldap_free_urldesc (REXXł͕KvȂ)
ldap_get_etnry_controls_np (APIł͂Ȃ)     
ldap_memfree (REXXł͕KvȂ)
ldap_modrdn (API)
ldap_modrdn_s (API)  
ldap_mods_free (REXXł͕KvȂ)
ldap_open (API)
ldap_parse_reference_np (APIł͂Ȃ)
ldap_parse_sasl_bind_result (SSL͏T|[g\)
ldap_perror (API)
ldap_result2error (API)
ldap_sasl_bind (SSL͏T|[g\)
ldap_sasl_bind_s (SSL͏T|[g\)       
ldap_set_rebind_pro (APIł͂Ȃ)
ldap_ssl_client_init (SSL͏T|[g\)
ldap_ssl_init (SSL͏T|[g\)
ldap_ssl_start (API) 
ldap_value_free (REXXł͕KvȂ)
ldap_value_free_len (REXXł͕KvȂ)

UTF-8T|[g
RXLDAPDNUTF-8ɕϊĂC APIɓnĂ܂BREXXvODN
  UTF-8ɕϊĂRXLDAPɓnKv͂܂B
RXLDAP͌̃tB^UTF-8ɕϊĂC APIɓnĂ܂BREXXv
  OŃtB^UTF-8ɕϊĂRXLDAPɓnKv͂܂B
RXLDAPmods.n.!mod_opLDAP_MOD_BVALUES̎w肪Ȃ("LDAP_MOD_ADD",
  "LDAP_MOD_DELETE", "LDAP_MOD_REPLACE"Ȃ) REXXϐ̑lUTF-8ɕϊ
  ĂC APIɓnĂ܂BREXXvOőlUTF-8ɕϊĂ
  RXLDAPɓnKv͂܂B
RXLDAPmods.n.!mod_opLDAP_MOD_BVALUES̎w肪
  ("LDAP_MOD_ADD|LDAP_MOD_BVALUES", "LDAP_MOD_DELETE|LDAP_MOD_BVALUES",
  "LDAP_MOD_REPLACE|LDAP_MOD_BVALUES"Ȃ) REXXϐ̑l̂܂C API
  ɓnĂ܂B
Rxldap_get_values͑lUTF-8猻sR[hy[W̃GR[fBOɕϊ
  Ă܂BREXXvOŕϊKv͂܂B
Rxldap_get_dnDNUTF-8猻sR[hy[W̃GR[fBOɕϊĂ
  BREXXvOŕϊKv͂܂B
Rxldap_get_values_lenC APIԂl̂܂ܕԂĂ܂B
Rxldap_compareRxldap_compare_s͑lUTF-8ɕϊĂC APIɓnĂ
  ܂BREXXvOőlUTF-8ɕϊĂRXLDAPɓnKv͂
  B
Rxldap_compare_extRxldap_compare_ext_sREXXϐ̑l̂܂C API
  nĂ܂B
UTF-8ւ̕ϊAUTF-8̕ϊoȂARXLDAPREXXϐ̒l̂܂C
  APIɓn܂BȂϊ|ǂRxldapToUTF8ARxldapFromUTF8Ŋm
  ߂邱Ƃł܂B

API̐

REXX API:       RxldapLoadFuncs
@\:           RXLDAP APĨ[h
l:           RxldapLoadFuncs()
߂l:         RXLDAPo[W
:
call RxldapLoadFuncs

REXX API:       RxldapDropFuncs
@\:           RXLDAP APĨA[h
l:           RxldapDropFuncs()
߂l:         ""
:
call RxldapDropFuncs

REXX API:       RxldapVersion
@\:           RXLDAP APĨo[WԂB
l:           RxldapVersion()
߂l:         RXLDAP APĨo[W
:
call RxldapVersion

REXX API:       RxldapToUTF8
@\:           sR[hy[W̕UTF-8̕ɕϊB
l:           RxldapToUTF8(str)
߂l:         UTF-8ŃGR[hꂽBϊłȂ""ԂB
:
call RxldapToUTF8 str

REXX API:       RxldapFromUTF8
@\:           UTF-8̕sR[hy[W̕ɕϊB
l:           RxldapFromUTF8(utf8str)
߂l:         sR[hy[WŃGR[hꂽBϊłȂ""ԂB
:
call RxldapFromUTF8 utf8str

REXX API:       Rxldap_abandon
ΉC API:      ldap_abandon
l:           Rxldap_abandon(ld, msgid)
߂l:         0 (), -1 (G[)
:
call Rxldap_abandon ld, msgid

REXX API:       Rxldap_abandon_ext
ΉC API:      ldap_abandon_ext
l:           Rxldap_abandon(ld, msgid, serverctrlsstemname, clientctrlsstemname)
߂l:         ldaperr
:                   
serverctrlsstemname = T[oldapctrli[stemϐ
clientctrlsstemname = NCAgldapctrli[stemϐ
ȗ\:   serverctrlsstemname, clientctrlsstemname
:
call Rxldap_abandon ld, msgid, 'serverctrls.', 'clientctrls.'

REXX API:       Rxldap_add
C API:          ldap_add
l:           Rxldap_add(ld, dn, modsstemname)
߂l:         msgid (), -1 (G[)
:                   
modsstemname = modsi[stemϐ
:
call Rxldap_add ld, dn, 'mods.'

REXX API:       Rxldap_add_s
ΉC API:      ldap_add_s
l:           Rxldap_add_s(ld, dn, modsstemname)
߂l:         ldaperr
:                   
modsstemname = modsi[stemϐ
:
call Rxldap_add_s ld, dn, 'mods.'

REXX API:       Rxldap_add_ext
ΉC API:      ldap_add_ext
l:           Rxldap_add_ext(ld, dn, modsstemname, serverctrlsstemname, clientctrlsstemname, msgidvarname)
߂l:         ldaperr
:                   
modsstemname = modsi[stemϐ
serverctrlsstemname = T[oldapctrli[stemϐ
clientctrlsstemname = NCAgldapctrli[stemϐ
msgidvarname = msgidi[ϐ
ȗ\:   serverctrlsstemname, clientctrlsstemname
:
call Rxldap_add_ext ld, dn, 'mods.', 'serverctrls.', 'clientctrls.', 'msgid'

REXX API:       Rxldap_add_ext_s
ΉC API:      ldap_add_ext_s    
l:           Rxldap_add_ext_s(ld, dn, modsstemname, serverctrlsstemname, clientctrlsstemname)
߂l:         ldaperr
:                   
modsstemname = modsi[stemϐ
serverctrlsstemname = T[oldapctrli[stemϐ
clientctrlsstemname = NCAgldapctrli[stemϐ
ȗ\:   serverctrlsstemname, clientctrlsstemname
:
call Rxldap_add_ext_s ld, dn, 'mods.', 'serverctrls.', 'clientctrls.'

REXX API:       Rxldap_first_attribute
ΉC API:      ldap_first_attribute
l:           Rxldap_first_attribute(ld, msg, bervarmame)
߂l:         Agr[gA܂"" (ldap_first_attributeNULLԂ)
:                   
bervarname = berԂϐ
:
call Rxldap_first_attribute ld, msg, 'ber'

REXX API:       Rxldap_next_attribute
ΉC API:      ldap_next_attribute
l:           Rxldap_next_attribute(ld, msg, ber)
߂l:         Agr[gA܂"" (ldap_next_attributeNULLԂ)
:
call Rxldap_next_attribute ld, msg, ber

REXX API:       Rxldap_simple_bind
ΉC API:      ldap_simple_bind
l:           Rxldap_simple_bind(ld, dn, pw)
߂l:         msgid (), -1 (s)
ȗ\:   dn, pw
:
call Rxldap_simple_bind ld, dn, pw

REXX API:       Rxldap_simple_bind_s
ΉC API:      ldap_simple_bind_s
l:           Rxldap_simple_bind_s(ld, dn, pw)
߂l:         ldaperr
ȗ\:   dn, pw
:
call Rxldap_simple_bind_s ld, dn, pw

REXX API:       Rxldap_unbind
ΉC API:      ldap_unbind
l:           Rxldap_unbind(ld)
߂l:         msgid (), -1 (s)
:
call Rxldap_unbind ld

REXX API:       Rxldap_unbind_s
ΉC API:      ldap_unbind_s
l:           Rxldap_unbind_s(ld)
߂l:         ldaperr
:
call Rxldap_unbind_s ld

REXX API:       Rxldap_compare
ΉC API:      ldap_compare
l:           Rxldap_compare(ld, dn, attr, val)
߂l:         msgid (), -1 (s)
:
call Rxldap_compare ld, dn, attr, val

REXX API:       Rxldap_compare_s
ΉC API:      ldap_compare_s
l:           Rxldap_compare_s(ld, dn, attr, val)
߂l:         ldaperr
:
call Rxldap_compare_s ld, dn, attr, val

REXX API:       Rxldap_compare_ext
ΉC API:      ldap_compare_ext
l:           Rxldap_compare_ext(ld, dn, attr, val, serverctrlsstemname, clinetctrlsstemname, msgidvarname)
߂l:         ldaperr
:                   
serverctrlsstemname = T[oldapctrli[stemϐ
clientctrlsstemname = NCAgldapctrli[stemϐ
msgidvarname = msgidi[ϐ
ȗ\:   serverctrlsstemname, clientctrlsstemname
:
call Rxldap_compare_ext ld, dn, attr, val, 'serverctrls.', 'clinetctrls.', 'msgid'

REXX API:       Rxldap_compare_ext_s
ΉC API:      ldap_compare_ext_s
l:           Rxldap_compare_ext(ld, dn, attr, val, serverctrlsstemname, clinetctrlsstemname)
߂l:         ldaperr
:                   
serverctrlsstemname = T[oldapctrli[stemϐ
clientctrlsstemname = NCAgldapctrli[stemϐ
ȗ\:   serverctrlsstemname, clientctrlsstemname
:
call Rxldap_compare_ext_s ld, dn, attr, val, 'serverctrls.', 'clinetctrls.'

REXX API:       Rxldap_delete
ΉC API:      ldap_delete
l:           Rxldap_delete(ld, dn)
߂l:         msgid (), -1 (s)
:
call Rxldap_delete ld, dn

REXX API:       Rxldap_delete_s
ΉC API:      ldap_delete_s
l:           Rxldap_delete_s(ld, dn)
߂l:         ldaperr
:
call Rxldap_delete_s ld, dn

REXX API:       Rxldap_delete_ext
ΉC API:      ldap_delete_ext
l:           Rxldap_delete_ext(ld, dn, serverctrlsstemname, clientctrlsstemname, msgidvarname)
߂l:         ldaperr
:                   
serverctrlsstemname = T[oldapctrli[stemϐ
clientctrlsstemname = NCAgldapctrli[stemϐ
msgidvarname = msgidi[ϐ
ȗ\:   serverctrlsstemname, clientctrlsstemname
:
call Rxldap_delete_ext ld, dn, 'serverctrls.', 'clientctrls.', 'msgid'

REXX API:       Rxldap_delete_ext_s
ΉC API:      ldap_delete_ext_s
l:           Rxldap_delete_ext_s(ld, dn, serverctrlsstemname, clientctrlsstemname)
߂l:         ldaperr
:                   
serverctrlsstemname = T[oldapctrli[stemϐ
clientctrlsstemname = NCAgldapctrli[stemϐ
ȗ\:   serverctrlsstemname, clientctrlsstemname
:
call Rxldap_delete_ext_s ld, dn, 'serverctrls.', 'clientctrls.'

REXX API:       Rxldap_first_etnry
ΉC API:      ldap_first_etnry
l:           Rxldap_first_entry(ld, msg)
߂l:         msg ()A0 (G[)
:
call Rxldap_first_entry ld, msg

REXX API:       Rxldap_next_etnry
ΉC API:      ldap_next_etnry
l:           Rxldap_next_entry(ld, msg)
߂l:         msg ()A0 (G[)
:
call Rxldap_next_entry ld, msg

REXX API:       Rxldap_count_etnries
ΉC API:      ldap_count_etnries
l:           Rxldap_count_etnriesld, msg)
߂l:         Gg[̐
:
call Rxldap_count_etnries ld, msg

REXX API:       Rxldap_get_errno
ΉC API:      ldap_get_errno
l:           Rxldap_get_errno(ld)
߂l:         ldaperr
:
call Rxldap_get_errno ld

REXX API:       Rxldap_err2string
ΉC API:      ldap_err2string
l:           Rxldap_err2string(ldaperr)
߂l:         G[bZ[W
:
call Rxldap_err2string ldaperr

REXX API:       Rxldap_get_dn
ΉC API:      ldap_get_dn
l:           Rxldap_get_dn(ld, msg)
߂l:         dn ()A"" (G[)
:
call Rxldap_get_dn ld, msg

REXX API:       Rxldap_explode_dn
ΉC API:      ldap_explode_dn
l:           Rxldap_explode_dn(dn, notype, dnsstemname)
߂l:         dns.0̒l
:                   
dnsstemname = dni[stemϐ (dns.0 = Adns.n = l)
:
call Rxldap_explode_dn dn, notype, 'dns.'

REXX API:       Rxldap_get_values
ΉC API:      ldap_get_values
l:           Rxldap_get_values(ld, msg, attr, valstemname)
߂l:         vals.0̒l
:                   
valsstemname = Agr[g̒li[stemϐ (vals.0 = Avals.n = l)
:
call Rxldap_get_values ld, msg, attr, 'vals.'

REXX API:       Rxldap_get_values_len
ΉC API:      ldap_get_values_len
l:           Rxldap_get_values_len(ld, msg, attr, valstemname)
߂l:         vals.0̒l
:                   
valsstemname = Agr[g̒li[stemϐ (vals.0 = Avals.n = l)
:
call Rxldap_get_values_len ld, msg, attr, 'vals.'

REXX API:       Rxldap_init
ΉC API:      ldap_init
l:           Rxldap_init(host, port)
߂l:         ld
ȗ\:   port
:
call Rxldap_init host, port

REXX API:       Rxldap_msgfree
ΉC API:      ldap_msgfree
l:           Rxldap_msgfree(msg)
߂l:         msgtype
:
call Rxldap_msgfree msg

REXX API:       Rxldap_ber_free
ΉC API:      ldap_ber_free
l:           Rxldap_ber_free(ber)
߂l:         ""
:
call Rxldap_ber_free ber

REXX API:       Rxldap_first_message
ΉC API:      ldap_first_message
l:           Rxldap_first_message(ld, msg)
߂l:         msg ()A0 (G[)
:
call Rxldap_first_message ld, msg

REXX API:       Rxldap_next_message
ΉC API:      ldap_next_message
l:           Rxldap_next_message(ld, msg)
߂l:         msg ()A0 (G[)
:
call Rxldap_next_message ld, msg

REXX API:       Rxldap_count_messages
ΉC API:      ldap_count_messages
l:           Rxldap_count_message(ld, msg)
߂l:         bZ[W̐
:
call Rxldap_count_message ld, msg

REXX API:       Rxldap_modify
ΉC API:      ldap_modify
l:           Rxldap_modify(ld, dn, modsstemname)
߂l:         msgid ()A-1 (G[)
:                   
modsstemname = modsi[stemϐ
:
call Rxldap_modify ld, dn, 'mods.'

REXX API:       Rxldap_modify_ext
ΉC API:      ldap_modify_ext
l:           Rxldap_modify_ext(ld, dn, modsstemname, serverctrlsstemname, clientctrlsstemname, msgidvarname)
߂l:         ldaperr
:                   
modsstemname = modsi[stemϐ
serverctrlsstemname = T[oldapctrli[stemϐ
clientctrlsstemname = NCAgldapctrli[stemϐ
msgidvarname = msgidi[ϐ
ȗ\:   serverctrlsstemname, clientctrlsstemname
:
call Rxldap_modify_ext ld, dn, 'mods.', 'serverctrls.', 'clientctrls.', 'msgid'

REXX API:       Rxldap_modify_s
ΉC API:      ldap_modify_s
l:           Rxldap_modify_s(ld, dn, modsstemname)
߂l:         ldaperr
:                   
modsstemname = modsi[stemϐ
:
call Rxldap_modify_s ld, dn, 'mods.'

REXX API:       Rxldap_modify_ext_s
ΉC API:      ldap_modify_ext_s
l:           Rxldap_modify_ext_s(ld, dn, modsstemname, serverctrlsstemname, clientctrlsstemname)
߂l:         ldaperr
:                   
modsstemname = modsi[stemϐ
serverctrlsstemname = T[oldapctrli[stemϐ
clientctrlsstemname = NCAgldapctrli[stemϐ
ȗ\:   serverctrlsstemname, clientctrlsstemname
:
call Rxldap_modify_ext_s ld, dn, 'mods.', 'serverctrls.', 'clientctrls.'

REXX API:       Rxldap_set_option
ΉC API:      ldap_set_option
l:           Rxldap_set_option(ld, option, value)
߂l:         ldap_set_option̖߂l
:                   
value = IvV̒lB(ɋ̂eXgĂ܂)
:
call Rxldap_set_option ld, 'LDAP_OPT_TIMELIMIT', 10.0
call Rxldap_set_option ld, 'LDAP_OPT_SIZELIMIT', 10.0

REXX API:       Rxldap_get_option
ΉC API:      ldap_set_option
l:           Rxldap_set_option(ld, option, valvarname)
߂l:         ldap_get_option̖߂l
:                   
valvarname = IvV̒li[ϐB(ɋ̂eXgĂ܂)
:
call Rxldap_get_option ld, 'LDAP_OPT_TIMELIMIT', 'timeout'
call Rxldap_get_option ld, 'LDAP_OPT_HOST_NAME', 'host'
call Rxldap_get_option ld, 'LDAP_OPT_SIZELIMIT', 'size'
call Rxldap_get_option ld, 'LDAP_OPT_PROTOCOL_VERSION', 'ver'
call Rxldap_get_option ld, 'LDAP_OPT_API_INFO', 'ai'
say ai.!ldapai_api_version
say ai.!ldapai_protocol_version
say ai.!ldapai_vendor_name
say ai.!ldapai_vendor_version
do i = 1 to ai.!ldapai_extensions.0
   say ai.!ldapai_extensions.i
end /* do */
call Rxldap_get_option ld, 'LDAP_OPT_API_FEATURE_INFO', 'aif'
say aif.!ldapaif_version
say aif.!ldapaif_name

REXX API:       Rxldap_parse_result
ΉC API:      ldap_parse_result
l:           Rxldap_parse_result(ld, msg, errcodevarname, matcheddnvarname, errmsgvarname, referralsstemname, serverctrlsstemname, freeit)
߂l:         ldaperr
:                   
errcodevarname = errcodei[ϐ
matcheddnvarname = matcheddni[ϐ
errmsgvarname = errmsgi[ϐ
referralsstemname = referralsi[stemϐ
serverctrlsstemname = serverctrlsi[stemϐ
freeit = msgJ邩ǂB
ȗ\: errcodevarname, matcheddnvarname, errmsgvarname, referralsstemname, serverctrlsstemname
:
call Rxldap_parse_result ld, msg, 'errcode', 'matcheddn', 'errmsg', 'referrals', 'serverctrls', freeit

REXX API:       Rxldap_first_reference
ΉC API:      ldap_first_etnry
l:           Rxldap_first_reference(ld, msg)
߂l:         msg ()A0 (G[)
:
call Rxldap_first_reference ld, msg

REXX API:       Rxldap_next_etnry
ΉC API:      ldap_next_etnry
l:           Rxldap_next_reference(ld, msg)
߂l:         msg ()A0 (G[)
:
call Rxldap_next_reference ld, msg

REXX API:       Rxldap_count_references
ΉC API:      ldap_count_references
l:           Rxldap_count_etnriesld, msg)
߂l:         Gg[̐
:
call Rxldap_count_references ld, msg

REXX API:       Rxldap_rename
ΉC API:      ldap_rename
l:           Rxldap_rename(ld, dn, newrdn, newparent, deleteoldrdn, serverctrlsstemname, clientctrlsstemname, msgidvarname)
߂l:         ldaperr
:                   
newrdn = ύXRDN
newparent = ύX̐eGgRDN
deleteoldrdn = ʒuύX㋌Gg폜邩ǂ
serverctrlsstemname = serverctrlsi[stemϐ
clientctrlsstemname = serverctrlsi[stemϐ
msgidvarname = msgidi[ϐ
ȗ\: newparent, serverctrlsstemname, clientctrlsstemname
:
call Rxldap_rename ld, dn, newrdn, newparent, deleteoldrdn, 'serverctrls.', 'clientctrls.', 'msgid'

REXX API:       Rxldap_rename_s
ΉC API:      ldap_rename_s
l:           Rxldap_rename_s(ld, dn, newrdn, newparent, deleteoldrdn, serverctrlsstemname, clientctrlsstemname)
߂l:         ldaperr
:                   
newrdn = ύXRDN
newparent = ύX̐eGgRDN
deleteoldrdn = ʒuύX㋌Gg폜邩ǂ
serverctrlsstemname = serverctrlsi[stemϐ
clientctrlsstemname = serverctrlsi[stemϐ
ȗ\: newparent, serverctrlsstemname, clientctrlsstemname
:
call Rxldap_rename_s ld, dn, newrdn, newparent, deleteoldrdn, 'serverctrls.', 'clientctrls.'

REXX API:       Rxldap_result
ΉC API:      ldap_result
l:           Rxldap_result(ld, msgid, all, timeout, msgvarname)
߂l:         msgtype
:                   
msgid = 񓯊̃bZ[WID܂̓bZ[W^CṽV{(: 'LDAP_RES_ANY')
all = 'LDAP_MSG_ONE', 'LDAP_MSG_RECEIVED', 'LDAP_MSG_ALL'
msgvarname = msgi[ϐ
ȗ\: timeout
:
call Rxldap_result ld, msgid, 'LDAP_MSG_ONE', 10.0, 'msg'

REXX API:       Rxldap_msgtype
ΉC API:      ldap_msgtype
l:           Rxldap_msgtype(msg)
߂l:         msgtype
:
call Rxldap_msgtype msg

REXX API:       Rxldap_msgid
ΉC API:      ldap_msgid
l:           Rxldap_msgid(msg)
߂l:         msgid
:
call Rxldap_msgid msg

REXX API:       Rxldap_search
ΉC API:      ldap_search
l:           Rxldap_search(ld, base, scope, filter, attrsstemname, attrsonly)
߂l:         msgid ()A-1 (G[)
:
attrsstemname = Agr[g̃Xgi[stem (attrs.0 = Aattrs.n = l)
:
call Rxldap_search ld, base, scope, filter, 'attrs.', 0

REXX API:       Rxldap_search_ext
ΉC API:      ldap_search_ext
l:           Rxldap_search_ext(ld, base, scope, filter, attrsstemname, attrsonly, serverctrlsstemname, clientctrlsstemname, timeout, sizelimit, msgidvarname)
߂l:         ldaperr
:
attrsstemname = Agr[g̃Xgi[stem (attrs.0 = Aattrs.n = l)
serverctrlsstemname = T[oldapctrli[stemϐ
clientctrlsstemname = NCAgldapctrli[stemϐ
sizelimit = ő僁bZ[WB0ƖB
msgidvarname = msgidi[ϐ
ȗ\:   serverctrlsstemname, clientctrlsstemname
:
call Rxldap_search_ext ld, base, scope, filter, 'attrs.', 0, 'serverctrls.', 'clientctrls.', 10.0, 0, 'msgid'

REXX API:       Rxldap_search_s
ΉC API:      ldap_search_s
l:           Rxldap_search_s(ld, base, scope, filter, attrsstemname, attrsonly, msgvarname)
߂l:         ldaperr
:
attrsstemname = Agr[g̃Xgi[stem (attrs.0 = Aattrs.n = l)
msgvarname = msgi[ϐB
:
call Rxldap_search_s ld, base, scope, filter, 'attrs.', 0, 'msg'

REXX API:       Rxldap_search_ext_s
ΉC API:      ldap_search_ext_s
l:           Rxldap_search_ext_s(ld, base, scope, filter, attrsstemname, attrsonly, serverctrlsstemname, clientctrlsstemname, timeout, sizelimit, msgvarname)
߂l:         ldaperr
:
attrsstemname = Agr[g̃Xgi[stem (attrs.0 = Aattrs.n = l)
serverctrlsstemname = T[oldapctrli[stemϐ
clientctrlsstemname = NCAgldapctrli[stemϐ
sizelimit = ő僁bZ[WB0ƖB
msgvarname = msgi[ϐ
ȗ\:   serverctrlsstemname, clientctrlsstemname
:
call Rxldap_search_ext_s ld, base, scope, filter, 'attrs.', 0, 'serverctrls.', 'clientctrls.', 10.0, 0, 'msg'

REXX API:       Rxldap_search_st
ΉC API:      ldap_search_st
l:           Rxldap_search_st(ld, base, scope, filter, attrsstemname, attrsonly, timeout, msgvarname)
߂l:         ldaperr
:
attrsstemname = Agr[g̃Xgi[stem (attrs.0 = Aattrs.n = l)
msgvarname = msgi[ϐB
:
call Rxldap_search_st ld, base, scope, filter, 'attrs.', 0, 10.0, 'msg'

REXX API:       Rxldap_is_ldap_url
ΉC API:      ldap_is_ldap_url
l:           Rxldap_is_ldap_url(url)
߂l:         0 (LDAP URLłȂ)A0ȊO (LDAP URLł)
:
call Rxldap_is_ldap_url(url)

REXX API:       Rxldap_url_desc
ΉC API:      ldap_url_desc
l:           Rxldap_url_desc(url, descstemname)
߂l:         ldaperr
:
descstemname = desci[stemϐ
:
call Rxldap_url_desc url, 'desc.'

REXX API:       Rxldap_url_search
ΉC API:      ldap_url_search
l:           Rxldap_url_search(ld, url, attrsonly)
߂l:         msgid ()A-1 (s)
:
call Rxldap_url_search ld, url, 0

REXX API:       Rxldap_url_search_s
ΉC API:      ldap_url_search_s
l:           Rxldap_url_search_s(ld, url, attrsonly, msgvarname)
߂l:         ldaperr
:
call Rxldap_url_search_s ld, url, 0, 'msg'

REXX API:       Rxldap_url_search_st
ΉC API:      ldap_url_search_st
l:           Rxldap_url_search_st(ld, url, attrsonly, timeout, msgvarname)
߂l:         ldaperr
:
call Rxldap_url_search_st ld, url, 0, 10.0, 'msg'

REXX API:       Rxldap_version
ΉC API:      ldap_version
l:           Rxldap_version(stemname)
߂l:         ldaperr
:
call Rxldap_version 'a.'
say a.!sdk_version
say a.!protocol_version


fobOtŃRpCNoCiłB  
ldap_get_errno͔WAPIłRxldap_get_errnołget_ldap_option
  LDAP_OPT_ERROR_NUMBERtŌĂяoĂ܂B
ldap_version͔WAPIłRxldap_versionłget_ldap_option
  LDAP_OPT_API_INFOtŌĂяoĂ܂B
ldap_ber_free͔WAPIłRxldap_ver_freełber_freeĂяoĂ
  B
LDAPv2pAPI͋APIƂƂō폜܂̂RxLdapv2T[oƂƂɂ͓
  ܂B

pbP[W̍\
rxldap.dll 
rxldap.def 
rxldap-jp.txt 
rxldap-en.txt 
rxldap.c   
rxldap.sym 
rxstring.h     
testrxldap.cmd (eXgɎgۂɓ삵TvłBQlɂĉ)
makefile

rh̕@
nmake32 (DLL)

nmake32 DEBUG=1 (fobOtŃrh)

nmake32 pkg (ZIP)

nmake32 LDAPSDK=D:\LDAPSDK (D:\LDAPSDKɂOpenLDAP SDK for OS/2g)

g̗\
SSLT|[gB(@ア)
