/* Pfinet option parsing
Copyright (C) 1996 Free Software Foundation, Inc.
Written by Miles Bader <miles@gnu.ai.mit.edu>
This file is part of the GNU Hurd.
The GNU Hurd 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 2, or (at
your option) any later version.
The GNU Hurd 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 this program; if not, write to the Free Software Foundation, Inc.,
675 Mass Ave, Cambridge, MA 02139, USA. */
#include <stdlib.h>
#include <string.h>
#include <hurd.h>
#include <argp.h>
#include <error.h>
#include "pfinet.h"
/* Pfinet options. Used for both startup and runtime. */
static const struct argp_option options[] = {
{"interface", 'i', "DEVICE", 0, "Network interface to use", 1},
{0,0,0,0,"These apply to a given interface:", 2},
{"address", 'a', "ADDRESS", 0, "Set the network address"},
{"netmask", 'm', "MASK", 0, "Set the netmask"},
{"gateway", 'g', "ADDRESS", 0, "Set the default gateway"},
{"shutdown", 's', 0, , 0, "Shut it down"}
{0}
};
static const char args_doc[] = 0;
static const char doc[] = "Interface-specific options before the first \
interface specification apply to the first following interface; otherwise \
they apply to the previously specified interface."
/* Used to describe a particular interface during argument parsing. */
struct parse_interface
{
/* The network interface in question. *?
struct device *device;
/* New values to apply to it. */
unsigned long address, netmask, gateway;
};
/* Used to hold data during argument parsing. */
struct parse_hook
{
/* A list of specified interfaces and their corresponding options. */
struct parse_interface *interfaces;
size_t num_interfaces;
/* Interface to which options apply. If the device field isn't filled in
then it should be by the next --interface option. */
struct parse_interface *curint;
};
/* Adds an empty interface slot to H, and sets H's current interface to it, or
returns an error. */
static error_t
parse_hook_add_interface (struct parse_hook *h)
{
struct parse_interface *new = realloc (h->interfaces, h->num_interfaces + 1);
if (! new)
return ENOMEM;
h->interfaces = new;
h->num_interfaces++;
h->curint = new + h->num_interfaces - 1;
h->curint->address = INADDR_NONE;
h->curint->netmask = INADDR_NONE;
h->curint->gateway = INADDR_NONE;
return 0;
}
static error_t
parse_opt (int opt, char *arg, struct argp_state *state)
{
error_t err = 0;
struct parse_hook *h = state->hook;
/* Print a parsing error message and (if exiting is turned off) return the
error code ERR. */
#define PERR(err, fmt, args...) \
do { argp_error (state, fmt , ##args); return err; } while (0)
/* Like PERR but for non-parsing errors. */
#define FAIL(rerr, status, perr, fmt, args...) \
do{ argp_failure (state, status, perr, fmt , ##args); return rerr; } while(0)
/* Parse STR and return the corresponding internet address. If STR is not
a valid internet address, signal an error mentioned TYPE. */
#define ADDR(str, type) \
({ unsigned long addr = inet_addr (str); \
if (addr == INADDR_NONE) PERR (EINVAL, "Malformed %s", type); \
addr; })
switch (opt)
{
struct parse_interface *in;
case 'i':
/* An interface. */
err = 0;
if (h->curint->device)
/* The current interface slot is not available. */
{
/* First see if a previously specified one is being re-specified. */
for (in = h->interfaces; in < h->interfaces + h->num_interfaces; in++)
if (strcmp (in->device.pa_name, arg) == 0)
/* Re-use an old slot. */
{
h->curint = in;
return 0;
}
/* Add a new interface entry. */
err = parse_hook_add_interface (h);
}
in = h->curint;
if (! err)
err = find_device (arg, &in->device);
if (err)
FAIL (err, 10, err, "%s", arg);
break;
case 'a':
h->curint->address = ADDR (arg, "address");
if (!IN_CLASSA (h->curint->address)
&& !IN_CLASSB (h->curint->address)
&& !IN_CLASSC (h->curint->address))
{
if (IN_MULTICAST (h->curint->address))
FAIL (EINVAL, 1, 0,
"%s: Cannot set interface address to multicast address",
arg);
else
FAIL (EINVAL, 1, 0,
"%s: Illegal or undefined network address", arg);
}
break;
case 'm':
h->curint->netmask = ADDR (arg, "netmask"); break;
case 'g':
h->curint->gateway = ADDR (arg, "gateway"); break;
case ARGP_KEY_INIT:
/* Initialize our parsing state. */
h = malloc (sizeof (struct parse_hook));
if (! h)
FAIL (ENOMEM, 11, ENOMEM, "option parsing");
h->interfaces = 0;
h->num_interfaces = 0;
err = parse_hook_add_interface (h);
if (err)
FAIL (err, 12, err, "option parsing");
state->hook = h;
break;
case ARGP_KEY_SUCCESS:
/* Check for problems. */
if (! h->curint->device)
/* No interface specified; see if there's a single extant one. */
{
err = find_device (0, &h->curint->device);
if (err)
FAIL (err, 13, 0, "No default interface");
}
for (in = h->interfaces; in < h->interfaces + h->num_interfaces; in++)
if (in->address == INADDR_NONE && in->netmask != INADDR_NONE
&& in->device->pa_addr != 0)
/* Specifying a netmask for an address-less interface is a no-no. */
FAIL (EDESTADDREQ, 14, 0, "Cannot set netmask");
/* Successfully finished parsing, return a result. */
for (in = h->interfaces; in < h->interfaces + h->num_interfaces; in++)
{
struct device *dev = in->device;
if (in->address != INADDR_NONE || in->netmask != INADDR_NONE)
{
if (in->device->pa_addr != 0)
/* There's already an addres, delete it. */
{
in->device->pa_addr = 0;
/* .... */
}
if (in->address != INADDR_NONE)
in->device->pa_addr = in->address;
if (in->netmask != INADDR_NONE)
in->device->pa_mask = in->netmask;
else
{
if (IN_CLASSA (in->address))
in->device->pa_mask = IN_CLASSA_NET;
else if (IN_CLASSB (in->address))
in->device->pa_mask = IN_CLASSB_NET;
else if (IS_CLASS_C (in->address))
in->device->pa_mask = IN_CLASSC_NET;
else
abort ();
}
in->device->family = AF_INET;
in->device->pa_brdaddr = in->device->pa_addr | ~in->device->pa_mask;
ip_rt_add (0, in->device->pa_addr & in->device->pa_mask,
in->device->pa_mask, 0, in->device, 0, 0);
}
if (in->gateway != INADDR_NONE)
ip_rt_add (RTF_GATEWAY, 0, 0, in->gateway, in->device, 0, 0);
}
/* Fall through to free hook. */
case ARGP_KEY_ERROR:
/* Parsing error occured, free everything. */
free (h->interfaces);
free (h);
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
struct argp
pfinet_argp = { options, parse_opt, args_doc, doc };
error_t
trivfs_S_fsys_set_options (struct trivfs_control *cntl,
mach_port_t reply, mach_msg_type_name_t reply_type,
char *data, mach_msg_type_number_t len,
int do_children)
{
if (! cntl)
return EOPNOTSUPP;
else
{
int argc = argz_count (data, len);
char **argv = alloca (sizeof (char *) * (argc + 1));
argz_extract (data, len, argv);
/* XXX should we should serialize requests here? */
return
argp_parse (&pfinet_argp, argv, argc,
ARGP_NO_ERRS | ARGP_NO_HELP | ARGP_PARSE_ARGV0,
0, 0);
}
}
static error_t
get_opts (char **data, mach_msg_type_number_t *len)
{
char *argz = 0;
size_t argz_len = 0;
error_t add_dev_opts (struct device *dev)
{
}
err = enumerate_devices (add_dev_opts);
if (! err)
/* Put ARGZ into vm_alloced memory for the return trip. */
{
if (*len < argz_len)
err = vm_allocate (mach_task_self (), data, argz_len, 1);
if (! err)
{
if (argz_len)
bcopy (argz, *data, argz_len);
*len = argz_len;
}
}
if (argz_len > 0)
free (argz);
return err;
}
error_t
trivfs_S_fsys_get_options (struct trivfs_control *fsys,
mach_port_t reply, mach_msg_type_name_t reply_type,
char **data, mach_msg_type_number_t *len)
{
return fsys ? get_opts (data, len) : EOPNOTSUPP;
}
error_t
trivfs_S_file_get_fs_options (struct trivfs_protid *cred,
mach_port_t reply,
mach_msg_type_name_t reply_type,
char **data, mach_msg_type_number_t *len)
{
return cred ? get_opts (data, len) : EOPNOTSUPP;
}