/*-------------------------------------------------------------------------*/
svalue_t *
v_tls_init_connection (svalue_t *sp, int num_arg)
/* EFUN tls_init_connection()
*
* int tls_init_connection(object ob)
* int tls_init_connection(object ob, string fun, string|object fob, mixed extra...)
* int tls_init_connection(object ob, closure fun, mixed extra...)
*
* tls_init_connection() tries to start a TLS secured connection to the
* interactive object <ob> (or this_object() if <ob> is not given).
* Result:
* errorcode < 0: unsuccessful, use tls_error() to get an useful
* description of the error
* number > 0: the secure connection is still being set up in the
* background
* number == 0: the secure connection is active.
*
* If the callback <fun>/<fun>:<fob> is specified, it will be called once
* the fate of the secure connection has been determined. The first argument
* will be the return code from the handshake (errorcode < 0 on failure,
* or 0 on success), followed by the interactive object <ob> and any <extra>
* arguments.
*/
{
svalue_t * argp = sp - num_arg + 1;
long ret;
object_t * obj;
interactive_t *ip;
if (!tls_available())
errorf("tls_init_connection(): TLS layer hasn't been initialized.\n");
if (num_arg > 0)
{
obj = argp->u.ob;
put_number(argp, 0); /* remove obj reference from the stack */
}
else
{
obj = ref_object(current_object, "tls_init_connection");
}
if (!O_SET_INTERACTIVE(ip, obj))
{
free_object(obj, "tls_init_connection");
errorf("Bad arg 1 to tls_init_connection(): "
"object not interactive.\n");
}
free_object(obj, "tls_init_connection");
/* ip has another reference to obj, so this is safe to do */
if (ip->tls_status != TLS_INACTIVE)
errorf("tls_init_connection(): Interactive already has a secure "
"connection.\n");
/* Extract the callback information from the stack */
if (num_arg > 1)
{
/* Extract the callback information from the stack */
int error_index;
callback_t * cb;
inter_sp = sp;
memsafe(cb = xalloc(sizeof *cb) , sizeof *cb , "callback structure");
assign_eval_cost();
error_index = setup_efun_callback(cb, argp+1, num_arg-1);
if (error_index >= 0)
{
/* The callback values have already been removed. */
xfree(cb);
inter_sp = sp = argp;
vefun_bad_arg(error_index+2, argp);
/* NOTREACHED */
return argp;
}
/* Callback creation successful */
ip->tls_cb = cb;
}
inter_sp = sp = argp - 1;
/* Flush the connection */
{
object_t * save_c_g = command_giver;
command_giver = obj;
add_message(message_flush);
command_giver = save_c_g;
}
ret = tls_init_connection(ip);
if (ret >= 0)
{
ip->tls_status = TLS_HANDSHAKING;
ret = tls_continue_handshake(ip);
/* Adjust the return value of tls_continue_handshake() */
if (ret >= 0)
ret = !ret;
}
push_number(sp, ret);
return sp;
} /* f_tls_init_connection() */
/*-------------------------------------------------------------------------*/
svalue_t *
x_filter_string (svalue_t *sp, int num_arg)
/* EFUN: filter() for strings.
*
* string filter(string arr, string fun, string|object obj, mixed extra, ...)
* string filter(string arr, closure cl, mixed extra, ...)
* string filter(string arr, mapping map)
*
* Filter the elements of <arr> through a filter defined by the other
* arguments, and return an array of those elements, for which the
* filter yields non-zero.
*
* The filter can be a function call:
*
* <obj>-><fun>(elem, <extra>...)
*
* or a mapping query:
*
* <map>[elem]
*
* <obj> can both be an object reference or a filename. If omitted,
* this_object() is used (this also works if the third argument is
* neither a string nor an object).
*/
{
string_t *rc; /* Result string */
string_t *str; /* Argument string */
svalue_t *arg; /* First argument the vm stack */
mp_int slen; /* Argument string length */
char *src, *dest; /* String text work pointers */
char *flags; /* Flag array, one flag for each element of <str>
* (in reverse order). */
mp_int res; /* Number of surviving elements */
res = 0;
/* Locate the args on the stack, extract the string to filter
* and allocate the flags vector.
*/
arg = sp - num_arg + 1;
str = arg->u.str;
slen = (mp_int)mstrsize(str);
/* Every element in flags is associated by index number with an
* element in the vector to filter. The filter function is evaluated
* for every string character, and the associated flag is set to 0
* or 1 according to the result.
* At the end, all 1-flagged elements are gathered and copied
* into the result string.
*/
if (arg[1].type == T_MAPPING)
{
mp_int cnt;
/* --- Filter by mapping query --- */
mapping_t *m;
if (num_arg > 2) {
errorf("Too many arguments to filter(array)\n");
}
/* Allocate memory for the flag array. Simultaneously an error
* handler is pushed onto the stack (after the arguments) for freeing
* the buffer in case of runtime errors. */
flags = xalloc_with_error_handler((size_t)slen + 1);
if (!flags)
{
errorf("Out of memory (%zu bytes) for temporary buffer in filter().\n",
(size_t)slen + 1);
}
sp = inter_sp;
m = arg[1].u.map;
for (src = get_txt(str), cnt = slen; --cnt >= 0; src++)
{
svalue_t key;
put_number(&key, *src);
if (get_map_value(m, &key) == &const0)
{
flags[cnt] = 0;
continue;
}
flags[cnt] = 1;
res++;
}
} else {
/* --- Filter by function call --- */
int error_index;
callback_t cb;
mp_int cnt;
assign_eval_cost();
/* setup_efun_callback() will adopt and therefore remove the
* arguments from arg+1 on to arg+num_arg from the stack and update
* inter_sp. New top-of-stack will be arg. */
error_index = setup_efun_callback(&cb, arg+1, num_arg-1);
if (error_index >= 0)
{
vefun_bad_arg(error_index+2, arg);
/* NOTREACHED */
return arg;
}
/* push the callback structure onto the stack. */
sp = arg + 1;
put_callback(sp, &cb);
/* Allocate memory for the flag array. Simultaneously an error
* handler is pushed onto the stack (after the arguments) for freeing
* the buffer in case of runtime errors. */
inter_sp = sp;
flags = xalloc_with_error_handler((size_t)slen + 1);
if (!flags)
{
errorf("Out of memory (%"PRIdMPINT" bytes) for temporary buffer "
"in filter().\n", slen + 1);
}
sp = inter_sp;
/* Loop over all elements in p and call the filter.
* w is the current element filtered.
*/
for (src = get_txt(str), cnt = slen; --cnt >= 0; src++)
{
svalue_t *v;
flags[cnt] = 0;
if (current_object->flags & O_DESTRUCTED)
continue;
/* Don't call the filter anymore, but fill the
* flags array with 0es.
*/
if (!callback_object(&cb))
{
inter_sp = sp;
errorf("object used by filter(array) destructed");
}
push_number(inter_sp, *src);
v = apply_callback(&cb, 1);
if (!v || (v->type == T_NUMBER && !v->u.number) )
continue;
flags[cnt] = 1;
res++;
}
}
/* flags[] holds the filter results, res is the number of
* elements to keep. Now create the result vector.
*/
rc = alloc_mstring(res);
if (!rc)
{
errorf("Out of memory (%"PRIdMPINT" bytes) for result in filter().\n",
slen+1);
}
for (src = get_txt(str), dest = get_txt(rc), flags = &flags[slen]
; res > 0 ; src++)
{
if (*--flags)
{
*dest++ = *src;
res--;
}
}
/* Cleanup. Arguments for the closure have already been removed. On the
* stack are now the string, the mapping or callback structure and the
* error handler. (Not using pop_n_elems() for 2 elements for saving loop
* and function call overhead.) */
free_svalue(sp--); /* errorhandler, buffer and flags are freed by this. */
free_svalue(sp--); /* mapping or callback structure. */
free_mstring(str); /* string, at arg == sp */
sp->u.str = rc; /* put result here */
return sp;
} /* x_filter_string() */
