/*
* Takes an array of mappings, similar to modify above, with the
* exception that the 'op' field is ignored and not used at all.
*/
static void
f_ldap_add(INT32 args)
{
struct pike_string *dn;
struct array *arr;
struct mapping *m;
struct svalue *val;
LDAPMod **mods;
int i, ret;
if (!THIS->bound)
Pike_error("OpenLDAP.Client: attempting operation on an unbound connection\n");
get_all_args("OpenLDAP.Client->add()", args, "%S%a", &dn, &arr);
mods = (LDAPMod**)calloc((arr->size + 1), sizeof(LDAPMod*));
if (!mods)
Pike_error("OpenLDAP.Client: OUT OF MEMORY!\n");
for (i = 0; i < arr->size; i++) {
mods[i] = (LDAPMod*)calloc(1, sizeof(LDAPMod));
if (!mods[i])
Pike_error("OpenLDAP.Client: OUT OF MEMORY!\n");
mods[i]->mod_op = LDAP_MOD_BVALUES;
if (arr->item[i].type != T_MAPPING)
Pike_error("OpenLDAP.Client->add(): array member is not a mapping.\n");
m = arr->item[i].u.mapping;
val = low_mapping_string_lookup(m, modify_type);
if (!val)
Pike_error("OpenLDAP.Client->add(): invalid modification mapping. "
"Missing the '%s' field\n", "type");
if (val->type != T_STRING || val->u.string->size_shift > 0)
Pike_error("OpenLDAP.Client->add(): invalid modification mapping. "
"The '%s' field is not an 8-bit string\n", "type");
mods[i]->mod_type = val->u.string->str;
val = low_mapping_string_lookup(m, modify_values);
if (!val)
Pike_error("OpenLDAP.Client->add(): invalid modification mapping. "
"Missing the '%s' field\n", "values");
if (val->type != T_ARRAY)
Pike_error("OpenLDAP.Client->add(): invalid modification mapping. "
"The '%s' field is not an array\n", "values");
mods[i]->mod_bvalues = make_berval_array(val);
}
ret = ldap_add_s(THIS->conn, dn->str, mods);
if (ret != LDAP_SUCCESS)
Pike_error("OpenLDAP.Client->add(): %s\n",
ldap_err2string(ret));
free_mods(mods);
pop_n_elems(args);
}
/* php_caudium_set_header() sets a header in the header mapping. Called in a
* thread safe manner from php_caudium_sapi_header_handler.
*/
INLINE static void
php_caudium_set_header(char *header_name, char *value, char *p)
{
struct svalue hsval;
struct pike_string *hval, *ind, *hind;
struct mapping *headermap;
struct svalue *s_headermap, *soldval;
int vallen;
GET_THIS();
/* hval = make_shared_string(value); */
ind = make_shared_string(" _headers");
hind = make_shared_binary_string(header_name,
(int)(p - header_name));
s_headermap = low_mapping_string_lookup(REQUEST_DATA, ind);
if(!s_headermap || s_headermap->type != PIKE_T_MAPPING)
{
struct svalue mappie;
mappie.type = PIKE_T_MAPPING;
headermap = allocate_mapping(1);
mappie.u.mapping = headermap;
mapping_string_insert(REQUEST_DATA, ind, &mappie);
free_mapping(headermap);
hval = make_shared_string(value);
} else {
headermap = s_headermap->u.mapping;
soldval = low_mapping_string_lookup(headermap, hind);
vallen = strlen(value);
if(soldval != NULL &&
soldval->type == PIKE_T_STRING &&
soldval->u.string->size_shift == 0) {
/* Existing, valid header. Prepend.*/
hval = begin_shared_string(soldval->u.string->len + 1 + vallen);
MEMCPY(hval->str, soldval->u.string->str, soldval->u.string->len);
STR0(hval)[soldval->u.string->len] = '\0';
MEMCPY(hval->str+soldval->u.string->len+1, value, vallen);
hval = end_shared_string(hval);
} else {
hval = make_shared_string(value);
}
}
hsval.type = PIKE_T_STRING;
hsval.u.string = hval;
mapping_string_insert(headermap, hind, &hsval);
free_string(hval);
free_string(ind);
free_string(hind);
}
INLINE static struct svalue *lookup_header(char *headername)
{
struct svalue *headers, *value;
struct pike_string *sind;
GET_THIS();
sind = make_shared_string("env");
headers = low_mapping_string_lookup(REQUEST_DATA, sind);
free_string(sind);
if(!headers || headers->type != PIKE_T_MAPPING) return NULL;
sind = make_shared_string(headername);
value = low_mapping_string_lookup(headers->u.mapping, sind);
free_string(sind);
if(!value) return NULL;
return value;
}
/* php_roxen_set_header() sets a header in the header mapping. Called in a
* thread safe manner from php_roxen_sapi_header_handler.
*/
static void php_roxen_set_header(char *header_name, char *value, char *p)
{
struct svalue hsval;
struct pike_string *hval, *ind, *hind;
struct mapping *headermap;
struct svalue *s_headermap;
#ifdef ROXEN_USE_ZTS
GET_THIS();
#endif
hval = make_shared_string(value);
ind = make_shared_string(" _headers");
hind = make_shared_binary_string(header_name,
(int)(p - header_name));
s_headermap = low_mapping_string_lookup(REQUEST_DATA, ind);
if(!s_headermap)
{
struct svalue mappie;
mappie.type = PIKE_T_MAPPING;
headermap = allocate_mapping(1);
mappie.u.mapping = headermap;
mapping_string_insert(REQUEST_DATA, ind, &mappie);
free_mapping(headermap);
} else
headermap = s_headermap->u.mapping;
hsval.type = PIKE_T_STRING;
hsval.u.string = hval;
mapping_string_insert(headermap, hind, &hsval);
free_string(hval);
free_string(ind);
free_string(hind);
}
/*
**| method: object search ( mapping params );
**| This is the preferred way of calling this method.
**
**| alt: object search ( string filter );
**| alt: object search ( string filter, array attrs );
**| alt: object search ( string filter, array attrs, int attrsonly );
**| alt: object search ( string filter, array attrs, int attrsonly, int timeout );
**
**| general: search the LDAP directory for the specified entry
**| (entries). The first form is the preferred one as it
**| encompasses all the current and future parameters as expected
**| by the underlying API. The following fields are read from the
**| mapping:@nl
**|
**| @list
**| * base - the base DN to use in this search. Overrides the
**| default base DN (as set with set_base_dn)
**| * scope - the search scope for this search. Overrides the
**| default scope (as set with set_scope)
**| * filter - the search filter. The BNF for the filter is as
**| follows:
**| @pre
**| <filter> ::= `(' <filtercomp> `)'
**| <filtercomp> ::= <and> | <or> | <not> | <simple>
**| <and> ::= `&' <filterlist>
**| <or> ::= `|' <filterlist>
**| <not> ::= `!' <filter>
**| <filterlist> ::= <filter> | <filter> <filterlist>
**| <simple> ::= <attributetype> <filtertype> <attributevalue>
**| <filtertype> ::= `=' | `~=' | `<=' | `>='
**| @pre_end
**| * attrs - search attributes. An array of attribute types to
**| return in the result. If absent, all types will be returned.
**| * attrsonly - if != then the result will contain attribute
**| types only - no values shall be returned.
**| * timeout - the timeout, in seconds, after which the call
**| should return if the search isn't finished.
**| @list_end
*/
static void
f_ldap_search(INT32 args)
{
char *filter;
int scope;
struct pike_string *base;
char **attrs;
int attrsonly;
struct timeval *timeout;
LDAPMessage *res;
int ret;
struct object *obj;
if (!THIS->bound)
Pike_error("OpenLDAP.Client: attempting operation on an unbound connection\n");
if (!args)
Pike_error("OpenLDAP.Client->search() requires at least one argument\n");
if (args == 1) {
switch(ARG(1).type) {
case T_MAPPING:
{
/* the new style case */
struct svalue *val;
struct mapping *m = ARG(1).u.mapping;
/*
* m->base
*/
val = low_mapping_string_lookup(m,
base_str);
if (!val || val->type != T_STRING)
base = THIS->basedn;
else
base = val->u.string;
/*
* m->scope
*/
val = low_mapping_string_lookup(m,
scope_str);
if (!val || val->type != T_INT)
scope = THIS->scope;
else
scope = val->u.integer;
/*
* m->filter
*/
val = low_mapping_string_lookup(m,
filter_str);
if (!val || val->type != T_STRING)
filter = OL_DEF_FILTER;
else
filter = val->u.string->str;
/*
* m->attrs
*/
val = low_mapping_string_lookup(m,
attrs_str);
if (!val || val->type != T_ARRAY)
attrs = NULL;
else
attrs = make_c_array(val);
/*
* m->attrsonly
*/
val = low_mapping_string_lookup(m,
attrsonly_str);
if (!val || val->type != T_INT)
attrsonly = 0;
else
attrsonly = val->u.integer != 0;
/*
* m->timeout
*/
val = low_mapping_string_lookup(m,
timeout_str);
if (!val || val->type != T_INT)
timeout = NULL;
else
timeout = make_timeout(val->u.integer); /*TEMPORARY*/
break;
}
case T_STRING:
/* the old style case */
base = THIS->basedn;
scope = THIS->scope;
filter = ARG(1).u.string->str;
attrs = NULL;
attrsonly = 0;
timeout = NULL;
break;
default:
Pike_error("OpenLDAP.Client->search() with single argument requires either a mapping or a string\n");
break;
}
} else switch(args) {
case 4: /* timeout */
if (ARG(4).type != T_INT)
Pike_error("OpenLDAP.Client->search(): argument 4 must be an integer\n");
else
timeout = make_timeout(ARG(4).u.integer);
/* fall through */
case 3: /* attrsonly */
if (ARG(3).type != T_INT)
Pike_error("OpenLDAP.Client->search(): argument 3 must be an integer\n");
else
attrsonly = ARG(3).u.integer != 0;
/* fall through */
case 2: /* attrs */
if (ARG(2).type != T_ARRAY)
Pike_error("OpenLDAP.Client->search(): argument 2 must be an array\n");
else
attrs = make_c_array(&ARG(2));
base = THIS->basedn;
scope = THIS->scope;
filter = ARG(1).u.string->str;
attrsonly = 0;
timeout = NULL;
break;
default:
Pike_error("OpenLDAP.Client->search(): incorrect number of arguments\n");
break;
}
ret = timeout ?
ldap_search_st(THIS->conn,
base->str,
scope,
filter,
attrs,
attrsonly,
timeout,
&res) :
ldap_search_s(THIS->conn,
base->str,
scope,
filter,
attrs,
attrsonly,
&res);
if (ret)
Pike_error("OpenLDAP.Client->search(): %s\n",
ldap_err2string(ret));
pop_n_elems(args);
THIS->data = res;
obj = clone_object(result_program, 0);
push_object(obj);
if (attrs)
free(attrs);
}