296 lines
7.5 KiB
C
296 lines
7.5 KiB
C
/*
|
|
* GRUB -- GRand Unified Bootloader
|
|
* Copyright (C) 2010 Free Software Foundation, Inc.
|
|
*
|
|
* GRUB is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* GRUB is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <grub/net.h>
|
|
#include <grub/i18n.h>
|
|
#include <grub/mm.h>
|
|
#include <grub/dl.h>
|
|
#include <grub/command.h>
|
|
|
|
struct grub_net_route *grub_net_routes = NULL;
|
|
struct grub_net_network_layer_interface *grub_net_network_layer_interfaces = NULL;
|
|
struct grub_net_card *grub_net_cards = NULL;
|
|
struct grub_net_network_layer_protocol *grub_net_network_layer_protocols = NULL;
|
|
|
|
grub_err_t
|
|
grub_net_resolve_address (struct grub_net_network_layer_protocol **prot,
|
|
char *name,
|
|
grub_net_network_layer_address_t *addr)
|
|
{
|
|
FOR_NET_NETWORK_LEVEL_PROTOCOLS (*prot)
|
|
{
|
|
grub_err_t err;
|
|
err = grub_net_resolve_address_in_protocol (*prot, name, addr);
|
|
if (err == GRUB_ERR_NET_BAD_ADDRESS)
|
|
{
|
|
grub_errno = GRUB_ERR_NONE;
|
|
continue;
|
|
}
|
|
if (err)
|
|
return err;
|
|
return GRUB_ERR_NONE;
|
|
}
|
|
return grub_error (GRUB_ERR_NET_BAD_ADDRESS, N_("Unrecognised address %s"),
|
|
name);
|
|
}
|
|
|
|
grub_err_t
|
|
grub_net_route_address (grub_net_network_layer_address_t addr,
|
|
grub_net_network_layer_address_t *gateway,
|
|
struct grub_net_network_layer_interface **interf)
|
|
{
|
|
struct grub_net_route *route;
|
|
int depth = 0;
|
|
int routecnt = 0;
|
|
struct grub_net_network_layer_protocol *prot = NULL;
|
|
grub_net_network_layer_address_t curtarget = addr;
|
|
|
|
*gateway = addr;
|
|
|
|
FOR_NET_ROUTES(route)
|
|
routecnt++;
|
|
|
|
for (depth = 0; depth < routecnt + 2; depth++)
|
|
{
|
|
FOR_NET_ROUTES(route)
|
|
{
|
|
if (depth && prot != route->prot)
|
|
continue;
|
|
prot = route->prot;
|
|
if (!route->prot->match_net (route->target, curtarget))
|
|
continue;
|
|
|
|
if (route->is_gateway)
|
|
{
|
|
if (depth == 0)
|
|
*gateway = route->gw;
|
|
curtarget = route->gw;
|
|
break;
|
|
}
|
|
*interf = route->interface;
|
|
return GRUB_ERR_NONE;
|
|
}
|
|
if (route == NULL)
|
|
return grub_error (GRUB_ERR_NET_NO_ROUTE, "destination unreachable");
|
|
}
|
|
|
|
return grub_error (GRUB_ERR_NET_ROUTE_LOOP, "route loop detected");
|
|
}
|
|
|
|
static grub_err_t
|
|
grub_cmd_deladdr (struct grub_command *cmd __attribute__ ((unused)),
|
|
int argc, char **args)
|
|
{
|
|
struct grub_net_network_layer_interface *inter;
|
|
|
|
if (argc != 4)
|
|
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
|
|
|
|
FOR_NET_NETWORK_LEVEL_INTERFACES (inter)
|
|
if (grub_strcmp (inter->name, args[1]))
|
|
break;
|
|
if (inter == NULL)
|
|
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("address not found"));
|
|
|
|
// inter->protocol->fini (inter);
|
|
grub_net_network_layer_interface_unregister (inter);
|
|
grub_free (inter->name);
|
|
grub_free (inter);
|
|
|
|
return GRUB_ERR_NONE;
|
|
}
|
|
|
|
static grub_err_t
|
|
grub_cmd_addaddr (struct grub_command *cmd __attribute__ ((unused)),
|
|
int argc, char **args)
|
|
{
|
|
struct grub_net_card *card;
|
|
struct grub_net_network_layer_protocol *prot;
|
|
grub_err_t err;
|
|
grub_net_network_layer_address_t addr;
|
|
struct grub_net_network_layer_interface *inter;
|
|
|
|
if (argc != 4)
|
|
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("four arguments expected"));
|
|
|
|
FOR_NET_CARDS (card)
|
|
if (grub_strcmp (card->name, args[1]))
|
|
break;
|
|
if (card == NULL)
|
|
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("card not found"));
|
|
|
|
FOR_NET_NETWORK_LEVEL_PROTOCOLS (prot)
|
|
if (grub_strcmp (prot->name, args[2]))
|
|
break;
|
|
|
|
if (card == NULL)
|
|
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("protocol not found"));
|
|
|
|
err = grub_net_resolve_address_in_protocol (prot, args[3], &addr);
|
|
if (err)
|
|
return err;
|
|
|
|
inter = grub_zalloc (sizeof (*inter));
|
|
if (!inter)
|
|
return grub_errno;
|
|
|
|
inter->name = grub_strdup (args[0]);
|
|
inter->protocol = prot;
|
|
grub_memcpy (&(inter->address), &addr, sizeof (inter->address));
|
|
inter->card = card;
|
|
|
|
// err = prot->init (inter);
|
|
if (err)
|
|
{
|
|
grub_free (inter->name);
|
|
grub_free (inter);
|
|
return err;
|
|
}
|
|
grub_net_network_layer_interface_register (inter);
|
|
|
|
return GRUB_ERR_NONE;
|
|
}
|
|
|
|
static grub_err_t
|
|
grub_cmd_delroute (struct grub_command *cmd __attribute__ ((unused)),
|
|
int argc, char **args)
|
|
{
|
|
struct grub_net_route *route;
|
|
struct grub_net_route **prev;
|
|
|
|
if (argc != 1)
|
|
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
|
|
|
|
for (prev = &grub_net_routes, route = *prev; route; prev = &((*prev)->next),
|
|
route = *prev)
|
|
if (grub_strcmp (route->name, args[0]) == 0)
|
|
{
|
|
*prev = route->next;
|
|
grub_free (route->name);
|
|
grub_free (route);
|
|
}
|
|
|
|
return GRUB_ERR_NONE;
|
|
}
|
|
|
|
static grub_err_t
|
|
grub_cmd_addroute (struct grub_command *cmd __attribute__ ((unused)),
|
|
int argc, char **args)
|
|
{
|
|
struct grub_net_network_layer_protocol *prot;
|
|
struct grub_net_route *route;
|
|
|
|
if (argc < 3)
|
|
return grub_error (GRUB_ERR_BAD_ARGUMENT,
|
|
N_("At least 3 arguments are expected"));
|
|
|
|
route = grub_zalloc (sizeof (*route));
|
|
if (!route)
|
|
return grub_errno;
|
|
|
|
route->name = grub_strdup (args[0]);
|
|
if (!route->name)
|
|
{
|
|
grub_free (route);
|
|
return grub_errno;
|
|
}
|
|
|
|
FOR_NET_NETWORK_LEVEL_PROTOCOLS(prot)
|
|
{
|
|
grub_err_t err;
|
|
err = prot->net_ntoa (args[1], &(route->target));
|
|
if (err == GRUB_ERR_NET_BAD_ADDRESS)
|
|
{
|
|
grub_errno = GRUB_ERR_NONE;
|
|
continue;
|
|
}
|
|
if (err)
|
|
return err;
|
|
break;
|
|
}
|
|
|
|
if (!prot)
|
|
{
|
|
grub_free (route->name);
|
|
grub_free (route);
|
|
return grub_error (GRUB_ERR_NET_BAD_ADDRESS,
|
|
N_("Unrecognised address %s"), args[1]);
|
|
}
|
|
|
|
if (grub_strcmp (args[2], "gw") == 0 && argc >= 4)
|
|
{
|
|
grub_err_t err;
|
|
route->is_gateway = 1;
|
|
err = grub_net_resolve_address_in_protocol (prot,
|
|
args[3], &(route->gw));
|
|
if (err)
|
|
{
|
|
grub_free (route->name);
|
|
grub_free (route);
|
|
return err;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
struct grub_net_network_layer_interface *inter;
|
|
route->is_gateway = 0;
|
|
|
|
FOR_NET_NETWORK_LEVEL_INTERFACES (inter)
|
|
if (grub_strcmp (inter->name, args[2]))
|
|
break;
|
|
|
|
if (!inter)
|
|
{
|
|
grub_free (route->name);
|
|
grub_free (route);
|
|
return grub_error (GRUB_ERR_BAD_ARGUMENT,
|
|
N_("Unrecognised interface %s"), args[2]);
|
|
}
|
|
route->interface = inter;
|
|
}
|
|
|
|
grub_net_route_register (route);
|
|
|
|
return GRUB_ERR_NONE;
|
|
}
|
|
|
|
static grub_command_t cmd_addaddr, cmd_deladdr, cmd_addroute, cmd_delroute;
|
|
|
|
GRUB_MOD_INIT(net)
|
|
{
|
|
cmd_addaddr = grub_register_command ("net_add_addr", grub_cmd_addaddr,
|
|
"SHORTNAME CARD PROTOCOL ADDRESS",
|
|
N_("Add a network address."));
|
|
cmd_deladdr = grub_register_command ("net_del_addr", grub_cmd_deladdr,
|
|
"SHORTNAME",
|
|
N_("Delete a network address."));
|
|
cmd_addroute = grub_register_command ("net_add_route", grub_cmd_addroute,
|
|
"SHORTNAME NET [INTERFACE| gw GATEWAY]",
|
|
N_("Add a network route."));
|
|
cmd_delroute = grub_register_command ("net_del_route", grub_cmd_delroute,
|
|
"SHORTNAME",
|
|
N_("Delete a network route."));
|
|
}
|
|
|
|
GRUB_MOD_FINI(net)
|
|
{
|
|
grub_unregister_command (cmd_addaddr);
|
|
grub_unregister_command (cmd_deladdr);
|
|
grub_unregister_command (cmd_addroute);
|
|
grub_unregister_command (cmd_delroute);
|
|
}
|