int
cmd_help (Shell *shell, void *args)
{
if (array_is_empty (args))
{
printf ("Available commands:\n");
const Array *a = shell_get_commands (shell);
for (size_t i = 0, n = array_get_size (a); i < n; ++i)
{
const command_t *command = array_get (a, i);
printf (" %s\n", command->name);
}
return 0;
}
int return_value = 0;
for (size_t i = 0, n = array_get_size (args); i < n; ++i)
{
const char *name = array_get (args, i);
const command_t *p = shell_get_command (shell, name);
if (!p) // Command not found.
{
fprintf (stderr, "No command \"%s\" found.\n", name);
--return_value;
}
else
{
printf ("- %s: %s", name, name);
if (p->args_list)
{
printf (" %s", p->args_list);
}
printf ("\n ");
if (p->help)
{
printf ("%s", p->help);
}
else
{
printf ("%s", "No help available for this command.");
}
printf ("\n");
}
}
return return_value;
}
/*
* Print info about variable: php var_dump()
*/
void php_var_dump(PHP_VALUE_NODE *node, int ident, int ref)
{
for(int i = 0; i < ident;i++) {
printf("\t");
}
if ( ref ) printf("&");
switch(node->type) {
case PHP_VAL_BOOL: printf("bool(%s)\n", node->int_val ? "true" : "false"); break;
case PHP_VAL_INT: printf("int(%"PRIu64")\n", node->int_val); break;
case PHP_VAL_FLOAT: printf("float(%f)\n", node->float_val); break;
case PHP_VAL_STRING: printf("string(%d) \"%s\"\n", (int)strlen(node->str_val), node->str_val); break;
case PHP_VAL_OBJECT: printf("Object(%s)\n", node->obj_val.class_name); break;
case PHP_VAL_ARRAY: {
int arr_size = array_get_size(node);
printf("array(%d) {\n", arr_size);
for(int i = 0; i < arr_size;i++) {
const std::string &curr_key = array_get_ith_key(node, i);
PHP_VAR_NODE *curr_val = array_get_by_str_key(node, curr_key);
printf("\t[%s]=>\n", curr_key.c_str());
php_var_dump(&curr_val->value, ident+1, curr_val->ref_count > 1);
}
for(int i = 0; i < ident;i++) {
printf("\t");
}
printf("}\n");
break;
}
case PHP_VAL_NONE: printf("NULL\n"); break;
case PHP_VAL_VAR_NODE:
case PHP_VAL_INT_DATA: assert(0); break;
}
}
size_t array_append_element(Array * arr, Element * elem)
{
assert(arr != NULL);
assert(elem);
if (arr == NULL || elem == NULL)
return 0;
return array_add_element(arr, array_get_size(arr), elem);
}
int stack_is_empty(object store, string name)
{
int size=array_get_size(store,name);
if (size==1 || size==0)
return TRUE;
else
return FALSE;
}
route_t* route_find_device( char* dev_name ) {
int i;
int size;
route_t* route;
net_device_t* device;
mutex_lock( route_mutex, LOCK_IGNORE_SIGNAL );
size = array_get_size(&device_routes);
for ( i = 0; i < size; i++ ) {
route_t* tmp;
tmp = (route_t*)array_get_item( &device_routes, i );
if ( tmp->device == NULL ) {
kprintf( ERROR, "route_find_device(): found device route without a valid network device!\n" );
continue;
}
if ( strcmp( tmp->device->name, dev_name ) == 0 ) {
tmp->ref_count++;
route = tmp;
goto out;
}
}
device = net_device_get(dev_name);
if ( device == NULL ) {
route = NULL;
goto out;
}
route = route_create( device->ip_addr, device->netmask, NULL, RTF_UP );
if ( route == NULL ) {
net_device_put(device);
goto out;
}
/* NOTE: we don't have to put the net_device_t later as we assign
the device to the newly created route entry. */
route->device = device;
route_insert( &device_routes, route );
out:
mutex_unlock( route_mutex );
return route;
}
void save_session_vars(std::map<std::string, std::string> &varmap)
{
PHP_EXP_NODE *sess_vars_exp_node = get_var_node("_SESSION");
PHP_VAR_NODE *sess_vars = sess_vars_exp_node->var_si_node->var;
delete sess_vars_exp_node;
if ( sess_vars->value.type != PHP_VAL_ARRAY ) {
return;
}
for(int i = 0; i < array_get_size(&sess_vars->value); i++) {
std::string s = array_get_ith_key(&sess_vars->value, i);
PHP_VAR_NODE *var = array_get_by_str_key(&sess_vars->value, s);
cast_value_str(&var->value);
varmap[s] = var->value.str_val;
}
}
void php_native_count(PHP_VALUE_NODE *result)
{
PHP_SCOPE_ITEM *si = get_scope_item(g_current_scope, "__param_0");
if ( si ) {
PHP_VALUE_NODE *param = &si->var->value;
if ( result ) {
cast_value_dnum(result);
if ( (si->var->value.type == PHP_VAL_NONE) || (si->var->value.type != PHP_VAL_ARRAY) ) {
result->int_val = 0;
} else {
result->int_val = array_get_size(param);
}
}
} else {
php_report_error(PHP_ERROR, "Invalid or missing argument");
}
}
int
cmd_setenv (Shell *shell, void *args)
{
if (array_is_empty (args))
{
char **p = environ;
while (*p)
{
printf ("%s\n", *p);
++p;
}
}
else
{
for (size_t i = 0, n = array_get_size (args); i < n; ++i)
{
putenv (strdup (array_get (args, i)));
}
}
return 0;
}
uint deps_add_evr(struct deps *deps, const char *name, int flags, uint epoch,
const char *version, const char *release) {
uint i, iter = 0, hash, size = array_get_size(&deps->names), ver, rel, nam;
nam = strings_add(deps->strings, name);
ver = strings_add(deps->strings, version != NULL ? version : "");
rel = strings_add(deps->strings, release != NULL ? release : "");
if (hashtable_resize(&deps->hashtable)) {
for (i = 0; i < size; i++) {
hash = dephash(array_get(&deps->names, i));
hashtable_add(&deps->hashtable, i, hash);
}
}
hash = dephash(nam);
while ((i = hashtable_find(&deps->hashtable, hash, &iter)) != -1)
if (array_get(&deps->names, i) == nam &&
array_get(&deps->epochs, i) == epoch &&
array_get(&deps->vers, i) == ver &&
array_get(&deps->rels, i) == rel &&
array_get(&deps->flags, i) == flags)
break;
if (i != -1)
/* already stored */
return i;
i = size;
array_set(&deps->names, i, nam);
array_set(&deps->epochs, i, epoch);
array_set(&deps->vers, i, ver);
array_set(&deps->rels, i, rel);
array_set(&deps->flags, i, flags);
hashtable_add_dir(&deps->hashtable, i, hash, iter);
return i;
}
static int route_insert( array_t* route_table, route_t* route ) {
int i;
int size;
/* TODO: check if the same route already exists. */
size = array_get_size(route_table);
for ( i = 0; i < size; i++ ) {
route_t* tmp;
tmp = (route_t*)array_get_item( route_table, i );
if ( route->mask_bits >= tmp->mask_bits ) {
break;
}
}
route->ref_count++;
array_insert_item( route_table, i, route );
return 0;
}
int main(int argc, char *argv[])
{
Array *myArray = array_init();
Element *p;
assert(myArray);
size_t size = array_get_size(myArray);
assert(size == 0);
int i;
for (i = 0; i < 1000; ++i) {
Element *p = new_element(i);
array_append_element(myArray, p);
free(p);
}
p = new_element(10);
array_add_element(myArray, 0, p);
assert(myArray->size == 1001);
free(p);
assert(strcmp(myArray->elem[0].test, "ms0:/music/test10.mp3") == 0);
assert(strcmp(myArray->elem[1].test, "ms0:/music/test0.mp3") == 0);
assert(strcmp(myArray->elem[10].test, "ms0:/music/test9.mp3") == 0);
assert(strcmp(myArray->elem[1000].test, "ms0:/music/test999.mp3") == 0);
assert(myArray->size <= myArray->capable);
array_del_element(myArray, 0);
assert(strcmp(myArray->elem[0].test, "ms0:/music/test0.mp3") == 0);
array_del_element(myArray, 1);
assert(strcmp(myArray->elem[1].test, "ms0:/music/test2.mp3") == 0);
array_del_element(myArray, 998);
assert(strcmp
(myArray->elem[array_get_size(myArray) - 1].test,
"ms0:/music/test998.mp3") == 0);
while (array_get_size(myArray)) {
array_del_element(myArray, 0);
}
assert(myArray->size == 0);
int findpos = array_find_element_by_func(myArray, find_path_name,
"ms0:/music/test445.mp3");
assert(findpos < 0);
for (i = 0; i < 1000; ++i) {
Element *p = new_element(i);
array_append_element(myArray, p);
free(p);
}
findpos =
array_find_element_by_func(myArray, find_path_name,
"ms0:/music/test445.mp3");
assert(findpos == 445);
array_swap_element(myArray, 0, 1);
assert(strcmp(myArray->elem[0].test, "ms0:/music/test1.mp3") == 0);
assert(strcmp(myArray->elem[1].test, "ms0:/music/test0.mp3") == 0);
assert(array_swap_element(myArray, 0, 1000) == 0);
array_free(myArray);
return 0;
}
int route_get_table( struct rttable* table ) {
int i;
int size;
int count;
int remaining;
struct rtabentry* entry;
entry = (struct rtabentry*)( table + 1 );
remaining = table->rtt_count;
table->rtt_count = 0;
/* Static routes */
mutex_lock( route_mutex, LOCK_IGNORE_SIGNAL );
size = array_get_size(&static_routes);
for ( i = 0; ( i < size ) && ( remaining > 0 ); i++, entry++, remaining--, table->rtt_count++ ) {
route_t* tmp;
struct sockaddr_in* addr;
tmp = (route_t*)array_get_item( &static_routes, i );
addr = (struct sockaddr_in*)&entry->rt_dst;
IP_COPY_ADDR( &addr->sin_addr, tmp->network_addr );
addr = (struct sockaddr_in*)&entry->rt_genmask;
IP_COPY_ADDR( &addr->sin_addr, tmp->network_mask );
addr = (struct sockaddr_in*)&entry->rt_gateway;
IP_COPY_ADDR( &addr->sin_addr, tmp->gateway_addr );
entry->rt_flags = tmp->flags;
if ( tmp->device != NULL ) {
strncpy( entry->rt_dev, tmp->device->name, 64 );
entry->rt_dev[63] = 0;
} else {
entry->rt_dev[0] = 0;
}
}
mutex_unlock( route_mutex );
/* Network interface routes */
count = net_device_get_count();
for ( i = 0;
( i < count ) && ( remaining > 0 );
i++ ) {
net_device_t* device;
struct sockaddr_in* addr;
device = net_device_get_nth(i);
if ( ( net_device_flags(device) & NETDEV_UP ) == 0 ) {
net_device_put(device);
continue;
}
entry->rt_flags = RTF_UP;
addr = (struct sockaddr_in*)&entry->rt_dst;
IP_COPY_ADDR_MASKED( &addr->sin_addr, device->ip_addr, device->netmask );
addr = (struct sockaddr_in*)&entry->rt_genmask;
IP_COPY_ADDR( &addr->sin_addr, device->netmask );
strncpy( entry->rt_dev, device->name, 64 );
entry->rt_dev[63] = 0;
entry++;
remaining--;
table->rtt_count++;
net_device_put(device);
}
return 0;
}
route_t* route_find( uint8_t* ipv4_addr ) {
int i;
int size;
route_t* route;
route_t* found;
net_device_t* device;
mutex_lock( route_mutex, LOCK_IGNORE_SIGNAL );
/* Find a device that has a suitable address and netmask to send the packet. */
device = net_device_get_by_address(ipv4_addr);
if ( device != NULL ) {
route = route_create( device->ip_addr, device->netmask, NULL, RTF_UP );
if ( route != NULL ) {
route->device = device;
}
goto out;
}
/* Try to find a suitable static route. */
size = array_get_size(&static_routes);
found = NULL;
for ( i = 0; i < size; i++ ) {
route_t* tmp;
tmp = (route_t*)array_get_item( &static_routes, i );
if ( IP_EQUALS_MASKED( tmp->network_addr, ipv4_addr, tmp->network_mask ) ) {
found = tmp;
break;
}
}
/* If nothing is found, or the found
route is not a gateway then we failed. */
if ( ( found == NULL ) ||
( ( found->flags & RTF_GATEWAY ) == 0 ) ) {
route = NULL;
goto out;
}
/* Find a network interface for the gateway address. */
device = net_device_get_by_address(found->gateway_addr);
if ( device == NULL ) {
route = NULL;
goto out;
}
/* Clone the original route and assign the network device to it. */
route = route_clone(found);
if ( route == NULL ) {
goto out;
}
route->device = device;
out:
mutex_unlock( route_mutex );
return route;
}
