static int do_nfs(int argc, char *argv[])
{
char *localfile;
char *remotefile;
if (argc < 2)
return COMMAND_ERROR_USAGE;
remotefile = argv[1];
if (argc == 2)
localfile = basename(remotefile);
else
localfile = argv[2];
net_store_fd = open(localfile, O_WRONLY | O_CREAT);
if (net_store_fd < 0) {
perror("open");
return 1;
}
nfs_con = net_udp_new(net_get_serverip(), 0, nfs_handler, NULL);
if (IS_ERR(nfs_con)) {
nfs_err = PTR_ERR(nfs_con);
goto err_udp;
}
net_udp_bind(nfs_con, 1000);
nfs_err = 0;
nfs_start(remotefile);
while (nfs_state != STATE_DONE) {
if (ctrlc()) {
nfs_err = -EINTR;
break;
}
net_poll();
if (is_timeout(nfs_timer_start, NFS_TIMEOUT * SECOND)) {
show_progress(-1);
nfs_send();
}
}
net_unregister(nfs_con);
err_udp:
close(net_store_fd);
if (nfs_err) {
printf("NFS failed: %s\n", strerror(-nfs_err));
unlink(localfile);
}
printf("\n");
return nfs_err == 0 ? 0 : 1;
}
IPaddr_t resolv(char *host)
{
IPaddr_t ip;
const char *ns;
if (!string_to_ip(host, &ip))
return ip;
dns_ip = 0;
dns_state = STATE_INIT;
ns = getenv("net.nameserver");
if (!ns || !*ns) {
printk("%s: no nameserver specified in $net.nameserver\n",
__func__);
return 0;
}
if (string_to_ip(ns, &ip))
return 0;
debug("resolving host %s via nameserver %s\n", host, ip_to_string(ip));
dns_con = net_udp_new(ip, DNS_PORT, dns_handler, NULL);
if (IS_ERR(dns_con))
return PTR_ERR(dns_con);
dns_timer_start = get_time_ns();
dns_send(host);
while (dns_state != STATE_DONE) {
if (ctrlc()) {
break;
}
net_poll();
if (is_timeout(dns_timer_start, SECOND)) {
dns_timer_start = get_time_ns();
printf("T ");
dns_send(host);
}
}
net_unregister(dns_con);
return dns_ip;
}
static int nc_init(void)
{
struct nc_priv *priv = g_priv;
if (priv->con)
net_unregister(priv->con);
priv->con = net_udp_new(priv->ip, priv->port, nc_handler, NULL);
if (IS_ERR(priv->con)) {
int ret = PTR_ERR(priv->con);
priv->con = NULL;
return ret;
}
net_udp_bind(priv->con, priv->port);
priv->cdev.f_caps = CONSOLE_STDIN | CONSOLE_STDOUT | CONSOLE_STDERR;
return 0;
}
static int do_dhcp(struct command *cmdtp, int argc, char *argv[])
{
int ret;
dhcp_con = net_udp_new(0xffffffff, PORT_BOOTPS, dhcp_handler, NULL);
if (IS_ERR(dhcp_con)) {
ret = PTR_ERR(dhcp_con);
goto out;
}
ret = net_udp_bind(dhcp_con, PORT_BOOTPC);
if (ret)
goto out1;
net_set_ip(0);
ret = bootp_request(); /* Basically same as BOOTP */
if (ret)
goto out1;
while (dhcp_state != BOUND) {
if (ctrlc())
break;
net_poll();
if (is_timeout(dhcp_start, 3 * SECOND)) {
dhcp_start = get_time_ns();
printf("T ");
ret = bootp_request();
if (ret)
goto out1;
}
}
out1:
net_unregister(dhcp_con);
out:
if (ret)
printf("dhcp failed: %s\n", strerror(-ret));
return ret ? 1 : 0;
}
static int nc_set_active(struct console_device *cdev, unsigned flags)
{
struct nc_priv *priv = container_of(cdev,
struct nc_priv, cdev);
if (priv->con) {
net_unregister(priv->con);
priv->con = NULL;
}
if (!flags)
return 0;
if (!priv->port) {
pr_err("port not set\n");
return -EINVAL;
}
if (!priv->ip) {
pr_err("ip not set\n");
return -EINVAL;
}
priv->con = net_udp_new(priv->ip, priv->port, nc_handler, NULL);
if (IS_ERR(priv->con)) {
int ret = PTR_ERR(priv->con);
priv->con = NULL;
return ret;
}
net_udp_bind(priv->con, priv->port);
pr_info("netconsole initialized with %s:%d\n", ip_to_string(priv->ip), priv->port);
return 0;
}
static struct file_priv *tftp_do_open(struct device_d *dev,
int accmode, const char *filename)
{
struct file_priv *priv;
struct tftp_priv *tpriv = dev->priv;
int ret;
priv = xzalloc(sizeof(*priv));
filename++;
switch (accmode & O_ACCMODE) {
case O_RDONLY:
priv->push = 0;
priv->state = STATE_RRQ;
break;
case O_WRONLY:
priv->push = 1;
priv->state = STATE_WRQ;
break;
case O_RDWR:
ret = -ENOSYS;
goto out;
}
priv->block = 1;
priv->err = -EINVAL;
priv->filename = filename;
priv->blocksize = TFTP_BLOCK_SIZE;
priv->block_requested = -1;
priv->fifo = kfifo_alloc(TFTP_FIFO_SIZE);
if (!priv->fifo) {
ret = -ENOMEM;
goto out;
}
priv->tftp_con = net_udp_new(tpriv->server, TFTP_PORT, tftp_handler,
priv);
if (IS_ERR(priv->tftp_con)) {
ret = PTR_ERR(priv->tftp_con);
goto out1;
}
ret = tftp_send(priv);
if (ret)
goto out2;
tftp_timer_reset(priv);
while (priv->state != STATE_RDATA &&
priv->state != STATE_DONE &&
priv->state != STATE_WDATA) {
ret = tftp_poll(priv);
if (ret == TFTP_ERR_RESEND)
tftp_send(priv);
if (ret < 0)
goto out2;
}
if (priv->state == STATE_DONE && priv->err) {
ret = priv->err;
goto out2;
}
priv->buf = xmalloc(priv->blocksize);
return priv;
out2:
net_unregister(priv->tftp_con);
out1:
kfifo_free(priv->fifo);
out:
free(priv);
return ERR_PTR(ret);
}
static int do_dhcp(int argc, char *argv[])
{
int ret, opt;
int retries = DHCP_DEFAULT_RETRY;
dhcp_reset_env();
getenv_uint("global.dhcp.retries", &retries);
while((opt = getopt(argc, argv, "H:v:c:u:U:r:")) > 0) {
switch(opt) {
case 'H':
dhcp_set_param_data(DHCP_HOSTNAME, optarg);
break;
case 'v':
dhcp_set_param_data(DHCP_VENDOR_ID, optarg);
break;
case 'c':
dhcp_set_param_data(DHCP_CLIENT_ID, optarg);
break;
case 'u':
dhcp_set_param_data(DHCP_CLIENT_UUID, optarg);
break;
case 'U':
dhcp_set_param_data(DHCP_USER_CLASS, optarg);
break;
case 'r':
retries = simple_strtoul(optarg, NULL, 10);
break;
}
}
if (!retries) {
printf("retries is set to zero, set it to %d\n", DHCP_DEFAULT_RETRY);
retries = DHCP_DEFAULT_RETRY;
}
dhcp_con = net_udp_new(0xffffffff, PORT_BOOTPS, dhcp_handler, NULL);
if (IS_ERR(dhcp_con)) {
ret = PTR_ERR(dhcp_con);
goto out;
}
ret = net_udp_bind(dhcp_con, PORT_BOOTPC);
if (ret)
goto out1;
net_set_ip(0);
dhcp_start = get_time_ns();
ret = bootp_request(); /* Basically same as BOOTP */
if (ret)
goto out1;
while (dhcp_state != BOUND) {
if (ctrlc()) {
ret = -EINTR;
goto out1;
}
if (!retries) {
ret = -ETIMEDOUT;
goto out1;
}
net_poll();
if (is_timeout(dhcp_start, 3 * SECOND)) {
dhcp_start = get_time_ns();
printf("T ");
ret = bootp_request();
/* no need to check if retries > 0 as we check if != 0 */
retries--;
if (ret)
goto out1;
}
}
if (dhcp_tftpname[0] != 0) {
IPaddr_t tftpserver = resolv(dhcp_tftpname);
if (tftpserver)
net_set_serverip(tftpserver);
}
out1:
net_unregister(dhcp_con);
out:
if (ret)
printf("dhcp failed: %s\n", strerror(-ret));
return ret;
}
static int do_dhcp(int argc, char *argv[])
{
int ret, opt;
dhcp_reset_env();
while((opt = getopt(argc, argv, "H:v:c:u:U:")) > 0) {
switch(opt) {
case 'H':
dhcp_set_param_data(DHCP_HOSTNAME, optarg);
break;
case 'v':
dhcp_set_param_data(DHCP_VENDOR_ID, optarg);
break;
case 'c':
dhcp_set_param_data(DHCP_CLIENT_ID, optarg);
break;
case 'u':
dhcp_set_param_data(DHCP_CLIENT_UUID, optarg);
break;
case 'U':
dhcp_set_param_data(DHCP_USER_CLASS, optarg);
break;
}
}
dhcp_con = net_udp_new(0xffffffff, PORT_BOOTPS, dhcp_handler, NULL);
if (IS_ERR(dhcp_con)) {
ret = PTR_ERR(dhcp_con);
goto out;
}
ret = net_udp_bind(dhcp_con, PORT_BOOTPC);
if (ret)
goto out1;
net_set_ip(0);
dhcp_start = get_time_ns();
ret = bootp_request(); /* Basically same as BOOTP */
if (ret)
goto out1;
while (dhcp_state != BOUND) {
if (ctrlc())
break;
net_poll();
if (is_timeout(dhcp_start, 3 * SECOND)) {
dhcp_start = get_time_ns();
printf("T ");
ret = bootp_request();
if (ret)
goto out1;
}
}
out1:
net_unregister(dhcp_con);
out:
if (ret)
printf("dhcp failed: %s\n", strerror(-ret));
return ret ? 1 : 0;
}
int dhcp(int retries, struct dhcp_req_param *param)
{
int ret = 0;
dhcp_reset_env();
dhcp_set_param_data(DHCP_HOSTNAME, param->hostname);
dhcp_set_param_data(DHCP_VENDOR_ID, param->vendor_id);
dhcp_set_param_data(DHCP_CLIENT_ID, param->client_id);
dhcp_set_param_data(DHCP_USER_CLASS, param->user_class);
dhcp_set_param_data(DHCP_CLIENT_UUID, param->client_uuid);
if (!retries)
retries = DHCP_DEFAULT_RETRY;
dhcp_con = net_udp_new(0xffffffff, PORT_BOOTPS, dhcp_handler, NULL);
if (IS_ERR(dhcp_con)) {
ret = PTR_ERR(dhcp_con);
goto out;
}
ret = net_udp_bind(dhcp_con, PORT_BOOTPC);
if (ret)
goto out1;
net_set_ip(0);
dhcp_start = get_time_ns();
ret = bootp_request(); /* Basically same as BOOTP */
if (ret)
goto out1;
while (dhcp_state != BOUND) {
if (ctrlc()) {
ret = -EINTR;
goto out1;
}
if (!retries) {
ret = -ETIMEDOUT;
goto out1;
}
net_poll();
if (is_timeout(dhcp_start, 3 * SECOND)) {
dhcp_start = get_time_ns();
printf("T ");
ret = bootp_request();
/* no need to check if retries > 0 as we check if != 0 */
retries--;
if (ret)
goto out1;
}
}
if (dhcp_tftpname[0] != 0) {
IPaddr_t tftpserver = resolv(dhcp_tftpname);
if (tftpserver)
net_set_serverip(tftpserver);
}
out1:
net_unregister(dhcp_con);
out:
if (ret)
debug("dhcp failed: %s\n", strerror(-ret));
return ret;
}
static int nfs_probe(struct device_d *dev)
{
struct fs_device_d *fsdev = dev_to_fs_device(dev);
struct nfs_priv *npriv = xzalloc(sizeof(struct nfs_priv));
char *tmp = xstrdup(fsdev->backingstore);
char *path;
int ret;
dev->priv = npriv;
debug("nfs: mount: %s\n", fsdev->backingstore);
path = strchr(tmp, ':');
if (!path) {
ret = -EINVAL;
goto err;
}
*path = 0;
npriv->path = xstrdup(path + 1);
npriv->server = resolv(tmp);
debug("nfs: server: %s path: %s\n", tmp, npriv->path);
npriv->con = net_udp_new(npriv->server, 0, nfs_handler, npriv);
if (IS_ERR(npriv->con)) {
ret = PTR_ERR(npriv->con);
goto err1;
}
/* Need a priviliged source port */
net_udp_bind(npriv->con, 1000);
ret = rpc_lookup_req(npriv, PROG_MOUNT, 1);
if (ret) {
printf("lookup mount port failed with %d\n", ret);
goto err2;
}
ret = rpc_lookup_req(npriv, PROG_NFS, 2);
if (ret) {
printf("lookup nfs port failed with %d\n", ret);
goto err2;
}
ret = nfs_mount_req(npriv);
if (ret) {
printf("mounting failed with %d\n", ret);
goto err2;
}
free(tmp);
return 0;
err2:
net_unregister(npriv->con);
err1:
free(npriv->path);
err:
free(tmp);
free(npriv);
return ret;
}
