static int
sdlookup_next(const packet_info *response, lcb_SDENTRY *ent, size_t *iter)
{
const char *buf;
lcb_U16 rc;
lcb_U32 vlen;
if (*iter == PACKET_NVALUE(response)) {
return 0;
}
buf = PACKET_VALUE(response);
buf += *iter;
memcpy(&rc, buf, 2);
memcpy(&vlen, buf + 2, 4);
rc = ntohs(rc);
vlen = ntohl(vlen);
ent->status = map_error(NULL, rc);
ent->nvalue = vlen;
if (ent->status == LCB_SUCCESS) {
ent->value = buf + 6;
} else {
ent->value = NULL;
ent->nvalue = 0;
}
*iter += (6 + vlen);
return 1;
}
static bool
start(void *ud) {
struct ctx *ctx = (struct ctx *)ud;
int ret;
ctx->zstr.avail_in = 0;
ctx->zstr.next_in = NULL;
ctx->zstr.avail_out = 0;
ctx->zstr.next_out = NULL;
if (ctx->compress) {
ret = BZ2_bzCompressInit(&ctx->zstr, ctx->compression_flags, 0, 30);
}
else {
ret = BZ2_bzDecompressInit(&ctx->zstr, 0, 0);
}
if (ret != BZ_OK) {
zip_error_set(ctx->error, map_error(ret), 0);
return false;
}
return true;
}
int main(int ac, char **av)
{
int i;
int j;
char *tab;
t_sq sq;
char **map;
(void)ac;
j = 1;
while (av[j])
{
i = 0;
tab = read_file(av[j]);
write(1, "lo1", 3);
map = map_error(tab);
write(1, "lo2", 3);
sq = bsq(map);
write(1, "lo3", 3);
print_map(map, &sq);
write(1, "lo4", 3);
++j;
}
return(0);
}
static void stat_response_handler(lcb_server_t *server, packet_info *info)
{
lcb_t root = server->instance;
lcb_uint16_t status = PACKET_STATUS(info);
lcb_error_t rc = map_error(root, status);
lcb_server_stat_resp_t resp;
struct lcb_command_data_st *command_data = &info->ct;
if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
if (!PACKET_NKEY(info)) {
if (lcb_lookup_server_with_command(root, PROTOCOL_BINARY_CMD_STAT,
PACKET_OPAQUE(info), server) < 0) {
/* notify client that data is ready */
setup_lcb_server_stat_resp_t(&resp, NULL, NULL, 0, NULL, 0);
root->callbacks.stat(root, command_data->cookie, rc, &resp);
}
return;
}
setup_lcb_server_stat_resp_t(&resp, server->authority,
PACKET_KEY(info), PACKET_NKEY(info),
PACKET_VALUE(info), PACKET_NVALUE(info));
root->callbacks.stat(root, command_data->cookie, rc, &resp);
} else {
setup_lcb_server_stat_resp_t(&resp, server->authority,
NULL, 0, NULL, 0);
root->callbacks.stat(root, command_data->cookie, rc, &resp);
/* run callback with null-null-null to signal the end of transfer */
if (lcb_lookup_server_with_command(root, PROTOCOL_BINARY_CMD_STAT,
PACKET_OPAQUE(info), server) < 0) {
setup_lcb_server_stat_resp_t(&resp, NULL, NULL, 0, NULL, 0);
root->callbacks.stat(root, command_data->cookie, LCB_SUCCESS, &resp);
}
}
}
/***********************************************************************
* ldap_create_sort_controlW (WLDAP32.@)
*
* Create a control for server sorted search results.
*
* PARAMS
* ld [I] Pointer to an LDAP context.
* sortkey [I] Array of LDAPSortKey structures, each specifying an
* attribute to use as a sort key, a matching rule and
* the sort order (ascending or descending).
* critical [I] Tells the server this control is critical to the
* search operation.
* control [O] LDAPControl created.
*
* RETURNS
* Success: LDAP_SUCCESS
* Failure: An LDAP error code.
*
* NOTES
* Pass the created control as a server control in subsequent calls
* to ldap_search_ext(_s) to obtain sorted search results.
*/
ULONG CDECL ldap_create_sort_controlW( WLDAP32_LDAP *ld, PLDAPSortKeyW *sortkey,
UCHAR critical, PLDAPControlW *control )
{
ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
LDAPSortKey **sortkeyU = NULL;
LDAPControl *controlU = NULL;
TRACE( "(%p, %p, 0x%02x, %p)\n", ld, sortkey, critical, control );
if (!ld || !sortkey || !control)
return WLDAP32_LDAP_PARAM_ERROR;
sortkeyU = sortkeyarrayWtoU( sortkey );
if (!sortkeyU) return WLDAP32_LDAP_NO_MEMORY;
ret = map_error( ldap_create_sort_control( ld, sortkeyU, critical, &controlU ));
*control = controlUtoW( controlU );
if (!*control) ret = WLDAP32_LDAP_NO_MEMORY;
ldap_control_free( controlU );
sortkeyarrayfreeU( sortkeyU );
#endif
return ret;
}
static OM_uint32
mech_authorize_localname(OM_uint32 *minor,
const gss_union_name_t unionName,
const gss_union_name_t unionUser)
{
OM_uint32 major = GSS_S_UNAVAILABLE;
gss_mechanism mech;
if (unionName->mech_type == GSS_C_NO_OID)
return (GSS_S_NAME_NOT_MN);
mech = gssint_get_mechanism(unionName->mech_type);
if (mech == NULL)
return (GSS_S_UNAVAILABLE);
if (mech->gssspi_authorize_localname != NULL) {
major = mech->gssspi_authorize_localname(minor,
unionName->mech_name,
unionUser->external_name,
unionUser->name_type);
if (major != GSS_S_COMPLETE)
map_error(minor, mech);
}
return (major);
}
/***********************************************************************
* ldap_bind_sW (WLDAP32.@)
*
* Authenticate with an LDAP server (synchronous operation).
*
* PARAMS
* ld [I] Pointer to an LDAP context.
* dn [I] DN of entry to bind as.
* cred [I] Credentials (e.g. password string).
* method [I] Authentication method.
*
* RETURNS
* Success: LDAP_SUCCESS
* Failure: An LDAP error code.
*/
ULONG CDECL ldap_bind_sW( WLDAP32_LDAP *ld, PWCHAR dn, PWCHAR cred, ULONG method )
{
ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
char *dnU = NULL, *credU = NULL;
struct berval pwd = { 0, NULL };
ret = WLDAP32_LDAP_NO_MEMORY;
TRACE( "(%p, %s, %p, 0x%08x)\n", ld, debugstr_w(dn), cred, method );
if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
if (method != LDAP_AUTH_SIMPLE) return WLDAP32_LDAP_PARAM_ERROR;
if (dn) {
dnU = strWtoU( dn );
if (!dnU) goto exit;
}
if (cred) {
credU = strWtoU( cred );
if (!credU) goto exit;
pwd.bv_len = strlen( credU );
pwd.bv_val = credU;
}
ret = map_error( ldap_sasl_bind_s( ld, dnU, LDAP_SASL_SIMPLE, &pwd, NULL, NULL, NULL ));
exit:
strfreeU( dnU );
strfreeU( credU );
#endif
return ret;
}
static void arithmetic_response_handler(lcb_server_t *server,
struct lcb_command_data_st *command_data,
protocol_binary_response_header *res)
{
lcb_t root = server->instance;
lcb_uint16_t status = ntohs(res->response.status);
lcb_error_t rc = map_error(root, status);
char *packet;
lcb_uint16_t nkey;
const char *key = get_key(server, &nkey, &packet);
lcb_arithmetic_resp_t resp;
lcb_uint64_t value = 0;
if (key == NULL) {
lcb_error_handler(server->instance, LCB_EINTERNAL,
NULL);
return ;
}
if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
memcpy(&value, res + 1, sizeof(value));
value = ntohll(value);
}
setup_lcb_arithmetic_resp_t(&resp, key, nkey, value, res->response.cas);
TRACE_ARITHMETIC_END(res->response.opaque, command_data->vbucket,
res->response.opcode, rc, &resp);
root->callbacks.arithmetic(root, command_data->cookie, rc, &resp);
release_key(server, packet);
}
static void arithmetic_response_handler(lcb_server_t *server,
packet_info *info)
{
lcb_t root = server->instance;
lcb_uint16_t status = PACKET_STATUS(info);
lcb_error_t rc = map_error(root, status);
char *packet;
lcb_uint16_t nkey;
const char *key = get_key(server, &nkey, &packet);
lcb_arithmetic_resp_t resp;
lcb_uint64_t value = 0;
struct lcb_command_data_st *command_data = &info->ct;
if (key == NULL) {
lcb_error_handler(server->instance, LCB_EINTERNAL,
NULL);
return ;
}
if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
memcpy(&value, info->payload, sizeof(value));
value = ntohll(value);
}
setup_lcb_arithmetic_resp_t(&resp, key, nkey, value, PACKET_CAS(info));
PACKET_TRACE(TRACE_ARITHMETIC_END, info, rc, &resp);
root->callbacks.arithmetic(root, command_data->cookie, rc, &resp);
release_key(server, packet);
}
/***********************************************************************
* ldap_simple_bind_sW (WLDAP32.@)
*
* Authenticate with an LDAP server (synchronous operation).
*
* PARAMS
* ld [I] Pointer to an LDAP context.
* dn [I] DN of entry to bind as.
* passwd [I] Password string.
*
* RETURNS
* Success: LDAP_SUCCESS
* Failure: An LDAP error code.
*
* NOTES
* Set dn and passwd to NULL to bind as an anonymous user.
*/
ULONG CDECL ldap_simple_bind_sW( WLDAP32_LDAP *ld, PWCHAR dn, PWCHAR passwd )
{
ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
char *dnU = NULL, *passwdU = NULL;
struct berval pwd = { 0, NULL };
ret = WLDAP32_LDAP_NO_MEMORY;
TRACE( "(%p, %s, %p)\n", ld, debugstr_w(dn), passwd );
if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
if (dn) {
dnU = strWtoU( dn );
if (!dnU) goto exit;
}
if (passwd) {
passwdU = strWtoU( passwd );
if (!passwdU) goto exit;
pwd.bv_len = strlen( passwdU );
pwd.bv_val = passwdU;
}
ret = map_error( ldap_sasl_bind_s( ld, dnU, LDAP_SASL_SIMPLE, &pwd, NULL, NULL, NULL ));
exit:
strfreeU( dnU );
strfreeU( passwdU );
#endif
return ret;
}
/***********************************************************************
* 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;
}
static void version_response_handler(lcb_server_t *server,
packet_info *info)
{
lcb_t root = server->instance;
lcb_uint16_t status = PACKET_STATUS(info);
lcb_error_t rc = map_error(root, status);
lcb_uint32_t nvstring = PACKET_NBODY(info);
const char *vstring;
lcb_server_version_resp_t resp;
struct lcb_command_data_st *command_data = &info->ct;
if (nvstring) {
vstring = info->payload;
} else {
vstring = NULL;
}
setup_lcb_server_version_resp_t(&resp, server->authority, vstring, nvstring);
PACKET_TRACE(TRACE_VERSIONS_PROGRESS, info, rc, &resp);
root->callbacks.version(root, command_data->cookie, rc, &resp);
if (lcb_lookup_server_with_command(root, PROTOCOL_BINARY_CMD_VERSION,
PACKET_OPAQUE(info), server) < 0) {
memset(&resp, 0, sizeof(resp));
PACKET_TRACE_NORES(TRACE_VERSIONS_END, info, LCB_SUCCESS);
root->callbacks.version(root, command_data->cookie, LCB_SUCCESS, &resp);
}
}
static void version_response_handler(lcb_server_t *server,
struct lcb_command_data_st *command_data,
protocol_binary_response_header *res)
{
lcb_t root = server->instance;
lcb_uint16_t status = ntohs(res->response.status);
lcb_error_t rc = map_error(root, status);
lcb_uint32_t nvstring = ntohl(res->response.bodylen);
const char *vstring;
lcb_server_version_resp_t resp;
if (nvstring) {
vstring = (const char *)res + sizeof(res->bytes);
} else {
vstring = NULL;
}
setup_lcb_server_version_resp_t(&resp, server->authority, vstring, nvstring);
TRACE_VERSIONS_PROGRESS(res->response.opaque, command_data->vbucket,
res->response.opcode, rc, &resp);
root->callbacks.version(root, command_data->cookie, rc, &resp);
if (lcb_lookup_server_with_command(root, PROTOCOL_BINARY_CMD_VERSION,
res->response.opaque, server) < 0) {
memset(&resp, 0, sizeof(resp));
TRACE_VERSIONS_END(res->response.opaque, command_data->vbucket,
res->response.opcode, LCB_SUCCESS);
root->callbacks.version(root, command_data->cookie, LCB_SUCCESS, &resp);
}
}
/***********************************************************************
* ldap_add_sW (WLDAP32.@)
*
* Add an entry to a directory tree (synchronous operation).
*
* PARAMS
* ld [I] Pointer to an LDAP context.
* dn [I] DN of the entry to add.
* attrs [I] Pointer to an array of LDAPModW structures, each
* specifying an attribute and its values to add.
*
* RETURNS
* Success: LDAP_SUCCESS
* Failure: An LDAP error code.
*/
ULONG CDECL ldap_add_sW( WLDAP32_LDAP *ld, PWCHAR dn, LDAPModW *attrs[] )
{
ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
char *dnU = NULL;
LDAPMod **attrsU = NULL;
ret = WLDAP32_LDAP_NO_MEMORY;
TRACE( "(%p, %s, %p)\n", ld, debugstr_w(dn), attrs );
if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
if (dn) {
dnU = strWtoU( dn );
if (!dnU) goto exit;
}
if (attrs) {
attrsU = modarrayWtoU( attrs );
if (!attrsU) goto exit;
}
ret = map_error( ldap_add_ext_s( ld, dn ? dnU : "", attrs ? attrsU : nullattrs, NULL, NULL ));
exit:
strfreeU( dnU );
modarrayfreeU( attrsU );
#endif
return ret;
}
static void getq_response_handler(lcb_server_t *server, packet_info *info)
{
lcb_t root = server->instance;
char *packet;
lcb_uint16_t nkey;
const char *key = get_key(server, &nkey, &packet);
lcb_error_t rc;
lcb_get_resp_t resp;
fprintf(stderr, "\n The datatype is ...%d", PACKET_DATATYPE(info));
if (key == NULL) {
lcb_error_handler(server->instance, LCB_EINTERNAL, NULL);
return;
} else if (PACKET_STATUS(info) == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
const protocol_binary_response_getq *getq = PACKET_EPHEMERAL_START(info);
rc = LCB_SUCCESS;
setup_lcb_get_resp_t(&resp, key, nkey,
PACKET_VALUE(info), PACKET_NVALUE(info),
ntohl(getq->message.body.flags),
PACKET_CAS(info),
PACKET_DATATYPE(info));
} else {
rc = map_error(root, PACKET_STATUS(info));
setup_lcb_get_resp_t(&resp, key, nkey, NULL, 0, 0, 0, 0);
}
root->callbacks.get(root, info->ct.cookie, rc, &resp);
release_key(server, packet);
}
/***********************************************************************
* ldap_search_extW (WLDAP32.@)
*
* Search a directory tree (asynchronous operation).
*
* PARAMS
* ld [I] Pointer to an LDAP context.
* base [I] Starting point for the search.
* scope [I] Search scope. One of LDAP_SCOPE_BASE,
* LDAP_SCOPE_ONELEVEL and LDAP_SCOPE_SUBTREE.
* filter [I] Search filter.
* attrs [I] Attributes to return.
* attrsonly [I] Return no values, only attributes.
* serverctrls [I] Array of LDAP server controls.
* clientctrls [I] Array of LDAP client controls.
* timelimit [I] Timeout in seconds.
* sizelimit [I] Maximum number of entries to return. Zero means unlimited.
* message [O] Message ID of the search operation.
*
* RETURNS
* Success: LDAP_SUCCESS
* Failure: An LDAP error code.
*
* NOTES
* Call ldap_result with the message ID to get the result of
* the operation. Cancel the operation by calling ldap_abandon
* with the message ID.
*/
ULONG CDECL ldap_search_extW( WLDAP32_LDAP *ld, PWCHAR base, ULONG scope,
PWCHAR filter, PWCHAR attrs[], ULONG attrsonly, PLDAPControlW *serverctrls,
PLDAPControlW *clientctrls, ULONG timelimit, ULONG sizelimit, ULONG *message )
{
ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
char *baseU = NULL, *filterU = NULL, **attrsU = NULL;
LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
struct timeval tv, *tvp = NULL;
ret = WLDAP32_LDAP_NO_MEMORY;
TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x, %p, %p, 0x%08x, 0x%08x, %p)\n",
ld, debugstr_w(base), scope, debugstr_w(filter), attrs, attrsonly,
serverctrls, clientctrls, timelimit, sizelimit, message );
if (!ld) return ~0u;
if (base) {
baseU = strWtoU( base );
if (!baseU) goto exit;
}
if (filter) {
filterU = strWtoU( filter );
if (!filterU) goto exit;
}
if (attrs) {
attrsU = strarrayWtoU( attrs );
if (!attrsU) goto exit;
}
if (serverctrls) {
serverctrlsU = controlarrayWtoU( serverctrls );
if (!serverctrlsU) goto exit;
}
if (clientctrls) {
clientctrlsU = controlarrayWtoU( clientctrls );
if (!clientctrlsU) goto exit;
}
if (timelimit)
{
tv.tv_sec = timelimit;
tv.tv_usec = 0;
tvp = &tv;
}
ret = map_error( ldap_search_ext( ld, baseU, scope, filterU, attrsU, attrsonly,
serverctrlsU, clientctrlsU, tvp, sizelimit, (int *)message ));
exit:
strfreeU( baseU );
strfreeU( filterU );
strarrayfreeU( attrsU );
controlarrayfreeU( serverctrlsU );
controlarrayfreeU( clientctrlsU );
#endif
return ret;
}
void map_test(int fd)
{
char *std_in;
std_in = take_stdin(fd);
if (!ft_strcmp(std_in, "error"))
map_error();
else
{
if (check_map(std_in))
map_error();
else
dyna_sol(std_in);
if (std_in)
free(std_in);
}
}
static void config_handler(lcb_server_t *server, packet_info *info)
{
lcb_error_t rc = map_error(server->instance, PACKET_STATUS(info));
lcb_cccp_update2(info->ct.cookie, rc,
PACKET_VALUE(info),
PACKET_NVALUE(info),
&server->curhost);
}
static void store_response_handler(lcb_server_t *server, packet_info *info)
{
lcb_t root = server->instance;
lcb_storage_t op;
char *packet;
lcb_uint16_t nkey;
lcb_error_t rc;
lcb_uint16_t status = PACKET_STATUS(info);
const char *key = get_key(server, &nkey, &packet);
if (PACKET_STATUS(info) == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
rc = LCB_SUCCESS;
} else {
rc = map_error(root, status);
}
switch (PACKET_OPCODE(info)) {
case PROTOCOL_BINARY_CMD_ADD:
op = LCB_ADD;
break;
case PROTOCOL_BINARY_CMD_REPLACE:
op = LCB_REPLACE;
break;
case PROTOCOL_BINARY_CMD_SET:
op = LCB_SET;
break;
case PROTOCOL_BINARY_CMD_APPEND:
op = LCB_APPEND;
break;
case PROTOCOL_BINARY_CMD_PREPEND:
op = LCB_PREPEND;
break;
default:
/*
** It is impossible to get here (since we're called from our
** lookup table... If we _DO_ get here, it must be a development
** version where the developer isn't done yet (and should be
** forced to think about what to do...)
*/
lcb_error_handler(root, LCB_EINTERNAL,
"Internal error. Received an illegal command opcode");
abort();
}
if (key == NULL) {
lcb_error_handler(server->instance, LCB_EINTERNAL,
NULL);
} else {
lcb_store_resp_t resp;
setup_lcb_store_resp_t(&resp, key, nkey, PACKET_CAS(info));
PACKET_TRACE(TRACE_STORE_END, info, rc, &resp);
root->callbacks.store(root, info->ct.cookie, op, rc, &resp);
release_key(server, packet);
}
}
OM_uint32 KRB5_CALLCONV
gss_get_name_attribute(OM_uint32 *minor_status,
gss_name_t name,
gss_buffer_t attr,
int *authenticated,
int *complete,
gss_buffer_t value,
gss_buffer_t display_value,
int *more)
{
OM_uint32 status;
gss_union_name_t union_name;
gss_mechanism mech;
if (minor_status == NULL)
return GSS_S_CALL_INACCESSIBLE_WRITE;
if (name == GSS_C_NO_NAME)
return GSS_S_CALL_INACCESSIBLE_READ | GSS_S_BAD_NAME;
if (attr == GSS_C_NO_BUFFER)
return GSS_S_CALL_INACCESSIBLE_READ;
if (more == NULL)
return GSS_S_CALL_INACCESSIBLE_WRITE;
if (authenticated != NULL)
*authenticated = 0;
if (complete != NULL)
*complete = 0;
*minor_status = 0;
union_name = (gss_union_name_t)name;
if (union_name->mech_type == GSS_C_NO_OID)
return GSS_S_UNAVAILABLE;
mech = gssint_get_mechanism(name->mech_type);
if (mech == NULL)
return GSS_S_BAD_NAME;
if (mech->gss_get_name_attribute == NULL)
return GSS_S_UNAVAILABLE;
status = (*mech->gss_get_name_attribute)(minor_status,
union_name->mech_name,
attr,
authenticated,
complete,
value,
display_value,
more);
if (status != GSS_S_COMPLETE)
map_error(minor_status, mech);
return status;
}
static void store_response_handler(lcb_server_t *server,
struct lcb_command_data_st *command_data,
protocol_binary_response_header *res)
{
lcb_t root = server->instance;
lcb_storage_t op;
char *packet;
lcb_uint16_t nkey;
const char *key = get_key(server, &nkey, &packet);
lcb_uint16_t status = ntohs(res->response.status);
lcb_error_t rc = map_error(root, status);
switch (res->response.opcode) {
case PROTOCOL_BINARY_CMD_ADD:
op = LCB_ADD;
break;
case PROTOCOL_BINARY_CMD_REPLACE:
op = LCB_REPLACE;
break;
case PROTOCOL_BINARY_CMD_SET:
op = LCB_SET;
break;
case PROTOCOL_BINARY_CMD_APPEND:
op = LCB_APPEND;
break;
case PROTOCOL_BINARY_CMD_PREPEND:
op = LCB_PREPEND;
break;
default:
/*
** It is impossible to get here (since we're called from our
** lookup table... If we _DO_ get here, it must be a development
** version where the developer isn't done yet (and should be
** forced to think about what to do...)
*/
lcb_error_handler(root, LCB_EINTERNAL,
"Internal error. Received an illegal command opcode");
abort();
}
if (key == NULL) {
lcb_error_handler(server->instance, LCB_EINTERNAL,
NULL);
} else {
lcb_store_resp_t resp;
setup_lcb_store_resp_t(&resp, key, nkey, res->response.cas);
TRACE_STORE_END(res->response.opaque, command_data->vbucket,
res->response.opcode, rc, &resp);
root->callbacks.store(root, command_data->cookie, op, rc, &resp);
release_key(server, packet);
}
}
/***********************************************************************
* ldap_parse_vlv_controlW (WLDAP32.@)
*
* Parse a virtual list view control.
*
* PARAMS
* ld [I] Pointer to an LDAP context.
* control [I] Controls obtained from a result message.
* targetpos [O] Position of the target in the result list.
* listcount [O] Estimate of the number of results in the list.
* context [O] Server side context.
* errcode [O] Error code from the listview operation.
*
* RETURNS
* Success: LDAP_SUCCESS
* Failure: An LDAP error code.
*
* NOTES
* Free the server context with ber_bvfree.
*/
INT CDECL ldap_parse_vlv_controlW( WLDAP32_LDAP *ld, PLDAPControlW *control,
PULONG targetpos, PULONG listcount,
struct WLDAP32_berval **context, PINT errcode )
{
int ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
LDAPControl **controlU = NULL;
#ifdef HAVE_LDAP_PARSE_VLV_CONTROL
unsigned long pos, count;
#elif defined(HAVE_LDAP_PARSE_VLVRESPONSE_CONTROL)
ber_int_t pos, count;
LDAPControl *vlvcontrol = NULL;
unsigned int i;
#endif
TRACE( "(%p, %p, %p, %p, %p, %p)\n", ld, control, targetpos,
listcount, context, errcode );
if (!ld || !control) return ~0u;
controlU = controlarrayWtoU( control );
if (!controlU) return WLDAP32_LDAP_NO_MEMORY;
#ifdef HAVE_LDAP_PARSE_VLV_CONTROL
if (!(ret = ldap_parse_vlv_control( ld, controlU, &pos, &count,
(struct berval **)context, errcode )))
{
*targetpos = pos;
*listcount = count;
}
#elif defined(HAVE_LDAP_PARSE_VLVRESPONSE_CONTROL)
for (i = 0; controlU[i]; i++)
{
if (!strcmp( LDAP_CONTROL_VLVRESPONSE, controlU[i]->ldctl_oid ))
vlvcontrol = controlU[i];
}
if (!vlvcontrol)
{
controlarrayfreeU( controlU );
return WLDAP32_LDAP_CONTROL_NOT_FOUND;
}
if (!(ret = ldap_parse_vlvresponse_control( ld, vlvcontrol, &pos, &count,
(struct berval **)context, errcode )))
{
*targetpos = pos;
*listcount = count;
}
#endif
controlarrayfreeU( controlU );
#endif
return map_error( ret );
}
OM_uint32 KRB5_CALLCONV
gss_pseudo_random (OM_uint32 *minor_status,
gss_ctx_id_t context_handle,
int prf_key,
const gss_buffer_t prf_in,
ssize_t desired_output_len,
gss_buffer_t prf_out)
{
OM_uint32 status;
gss_union_ctx_id_t ctx;
gss_mechanism mech;
if (minor_status == NULL)
return GSS_S_CALL_INACCESSIBLE_WRITE;
if (context_handle == GSS_C_NO_CONTEXT)
return GSS_S_CALL_INACCESSIBLE_READ | GSS_S_NO_CONTEXT;
if (prf_in == GSS_C_NO_BUFFER)
return GSS_S_CALL_INACCESSIBLE_READ | GSS_S_NO_CONTEXT;
if (prf_out == GSS_C_NO_BUFFER)
return GSS_S_CALL_INACCESSIBLE_WRITE | GSS_S_NO_CONTEXT;
prf_out->length = 0;
prf_out->value = NULL;
/*
* select the approprate underlying mechanism routine and
* call it.
*/
ctx = (gss_union_ctx_id_t) context_handle;
mech = gssint_get_mechanism (ctx->mech_type);
if (mech != NULL) {
if (mech->gss_pseudo_random != NULL) {
status = mech->gss_pseudo_random(minor_status,
ctx->internal_ctx_id,
prf_key,
prf_in,
desired_output_len,
prf_out);
if (status != GSS_S_COMPLETE)
map_error(minor_status, mech);
} else
status = GSS_S_UNAVAILABLE;
return status;
}
return GSS_S_BAD_MECH;
}
/***********************************************************************
* ldap_search_ext_sW (WLDAP32.@)
*
* Search a directory tree (synchronous operation).
*
* PARAMS
* ld [I] Pointer to an LDAP context.
* base [I] Starting point for the search.
* scope [I] Search scope. One of LDAP_SCOPE_BASE,
* LDAP_SCOPE_ONELEVEL and LDAP_SCOPE_SUBTREE.
* filter [I] Search filter.
* attrs [I] Attributes to return.
* attrsonly [I] Return no values, only attributes.
* serverctrls [I] Array of LDAP server controls.
* clientctrls [I] Array of LDAP client controls.
* timeout [I] Timeout in seconds.
* sizelimit [I] Maximum number of entries to return. Zero means unlimited.
* res [O] Results of the search operation.
*
* RETURNS
* Success: LDAP_SUCCESS
* Failure: An LDAP error code.
*
* NOTES
* Call ldap_msgfree to free the results.
*/
ULONG CDECL ldap_search_ext_sW( WLDAP32_LDAP *ld, PWCHAR base, ULONG scope,
PWCHAR filter, PWCHAR attrs[], ULONG attrsonly, PLDAPControlW *serverctrls,
PLDAPControlW *clientctrls, struct l_timeval* timeout, ULONG sizelimit, WLDAP32_LDAPMessage **res )
{
ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
char *baseU = NULL, *filterU = NULL, **attrsU = NULL;
LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
ret = WLDAP32_LDAP_NO_MEMORY;
TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x, %p, %p, %p, 0x%08x, %p)\n",
ld, debugstr_w(base), scope, debugstr_w(filter), attrs, attrsonly,
serverctrls, clientctrls, timeout, sizelimit, res );
if (!ld || !res) return WLDAP32_LDAP_PARAM_ERROR;
if (base) {
baseU = strWtoU( base );
if (!baseU) goto exit;
}
if (filter) {
filterU = strWtoU( filter );
if (!filterU) goto exit;
}
if (attrs) {
attrsU = strarrayWtoU( attrs );
if (!attrsU) goto exit;
}
if (serverctrls) {
serverctrlsU = controlarrayWtoU( serverctrls );
if (!serverctrlsU) goto exit;
}
if (clientctrls) {
clientctrlsU = controlarrayWtoU( clientctrls );
if (!clientctrlsU) goto exit;
}
ret = map_error( ldap_search_ext_s( ld, baseU, scope, filterU, attrsU, attrsonly,
serverctrlsU, clientctrlsU, (struct timeval *)timeout,
sizelimit, res ));
exit:
strfreeU( baseU );
strfreeU( filterU );
strarrayfreeU( attrsU );
controlarrayfreeU( serverctrlsU );
controlarrayfreeU( clientctrlsU );
#endif
return ret;
}
/***********************************************************************
* ldap_abandon (WLDAP32.@)
*
* Cancel an asynchronous operation.
*
* PARAMS
* ld [I] Pointer to an LDAP context.
* msgid [I] ID of the operation to cancel.
*
* RETURNS
* Success: LDAP_SUCCESS
* Failure: An LDAP error code.
*/
ULONG CDECL WLDAP32_ldap_abandon( WLDAP32_LDAP *ld, ULONG msgid )
{
ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
TRACE( "(%p, 0x%08x)\n", ld, msgid );
if (!ld) return ~0u;
ret = map_error( ldap_abandon_ext( ld, msgid, NULL, NULL ));
#endif
return ret;
}
static void stat_response_handler(lcb_server_t *server,
struct lcb_command_data_st *command_data,
protocol_binary_response_header *res)
{
lcb_t root = server->instance;
lcb_uint16_t status = ntohs(res->response.status);
lcb_error_t rc = map_error(root, status);
lcb_uint16_t nkey;
lcb_uint32_t nvalue;
const char *key, *value;
lcb_server_stat_resp_t resp;
if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
nkey = ntohs(res->response.keylen);
if (nkey == 0) {
if (lcb_lookup_server_with_command(root, PROTOCOL_BINARY_CMD_STAT,
res->response.opaque, server) < 0) {
/* notify client that data is ready */
setup_lcb_server_stat_resp_t(&resp, NULL, NULL, 0, NULL, 0);
TRACE_STATS_END(res->response.opaque, command_data->vbucket,
res->response.opcode, rc);
root->callbacks.stat(root, command_data->cookie, rc, &resp);
}
return;
}
key = (const char *)res + sizeof(res->bytes);
nvalue = ntohl(res->response.bodylen) - nkey;
value = key + nkey;
setup_lcb_server_stat_resp_t(&resp, server->authority, key,
nkey, value, nvalue);
TRACE_STATS_PROGRESS(res->response.opaque, command_data->vbucket,
res->response.opcode, rc, &resp);
root->callbacks.stat(root, command_data->cookie, rc, &resp);
} else {
setup_lcb_server_stat_resp_t(&resp, server->authority,
NULL, 0, NULL, 0);
TRACE_STATS_END(res->response.opaque, command_data->vbucket,
res->response.opcode, rc);
root->callbacks.stat(root, command_data->cookie, rc, &resp);
/* run callback with null-null-null to signal the end of transfer */
if (lcb_lookup_server_with_command(root, PROTOCOL_BINARY_CMD_STAT,
res->response.opaque, server) < 0) {
setup_lcb_server_stat_resp_t(&resp, NULL, NULL, 0, NULL, 0);
TRACE_STATS_END(res->response.opaque, command_data->vbucket,
res->response.opcode, LCB_SUCCESS);
root->callbacks.stat(root, command_data->cookie, LCB_SUCCESS, &resp);
}
}
}
/***********************************************************************
* 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 );
}
static HRESULT start_service( const WCHAR *name, VARIANT *retval )
{
SC_HANDLE manager, service = NULL;
UINT error = 0;
if (!(manager = OpenSCManagerW( NULL, NULL, SC_MANAGER_ENUMERATE_SERVICE )))
{
error = map_error( GetLastError() );
goto done;
}
if (!(service = OpenServiceW( manager, name, SERVICE_START )))
{
error = map_error( GetLastError() );
goto done;
}
if (!StartServiceW( service, 0, NULL )) error = map_error( GetLastError() );
done:
set_variant( VT_UI4, error, NULL, retval );
CloseServiceHandle( service );
CloseServiceHandle( manager );
return S_OK;
}
/***********************************************************************
* ldap_unbind_s (WLDAP32.@)
*
* Close LDAP connection and free resources (synchronous operation).
*
* PARAMS
* ld [I] Pointer to an LDAP context.
*
* RETURNS
* Success: LDAP_SUCCESS
* Failure: An LDAP error code.
*/
ULONG CDECL WLDAP32_ldap_unbind_s( WLDAP32_LDAP *ld )
{
ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
TRACE( "(%p)\n", ld );
if (ld)
ret = map_error( ldap_unbind_ext_s( ld, NULL, NULL ));
else
ret = WLDAP32_LDAP_PARAM_ERROR;
#endif
return ret;
}
static HRESULT control_service( const WCHAR *name, DWORD control, VARIANT *retval )
{
SC_HANDLE manager, service = NULL;
SERVICE_STATUS status;
UINT error = 0;
if (!(manager = OpenSCManagerW( NULL, NULL, SC_MANAGER_ENUMERATE_SERVICE )))
{
error = map_error( GetLastError() );
goto done;
}
if (!(service = OpenServiceW( manager, name, SERVICE_STOP|SERVICE_START|SERVICE_PAUSE_CONTINUE )))
{
error = map_error( GetLastError() );
goto done;
}
if (!ControlService( service, control, &status )) error = map_error( GetLastError() );
done:
set_variant( VT_UI4, error, NULL, retval );
CloseServiceHandle( service );
CloseServiceHandle( manager );
return S_OK;
}