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;
}
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 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;
}
