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 void nfs_remove(struct device_d *dev) { struct nfs_priv *npriv = dev->priv; nfs_umount_req(npriv); net_unregister(npriv->con); free(npriv->path); free(npriv); }
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 tftp_do_close(struct file_priv *priv) { int ret; if (priv->push && priv->state != STATE_DONE) { int len; len = kfifo_get(priv->fifo, priv->buf, priv->blocksize); tftp_send_write(priv, priv->buf, len); priv->state = STATE_LAST; tftp_timer_reset(priv); while (priv->state != STATE_DONE) { ret = tftp_poll(priv); if (ret == TFTP_ERR_RESEND) tftp_send_write(priv, priv->buf, len); if (ret < 0) break; } } if (!priv->push && priv->state != STATE_DONE) { uint16_t *pkt = net_udp_get_payload(priv->tftp_con); *pkt++ = htons(TFTP_ERROR); *pkt++ = 0; *pkt++ = 0; net_udp_send(priv->tftp_con, 6); } net_unregister(priv->tftp_con); kfifo_free(priv->fifo); free(priv->buf); free(priv); return 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; }
static int do_ping(int argc, char *argv[]) { int ret; uint64_t ping_start; unsigned retries = 0; if (argc < 2) return COMMAND_ERROR_USAGE; net_ping_ip = resolv(argv[1]); if (!net_ping_ip) { printf("unknown host %s\n", argv[1]); return 1; } ping_con = net_icmp_new(net_ping_ip, ping_handler, NULL); if (IS_ERR(ping_con)) { ret = PTR_ERR(ping_con); goto out; } ping_start = get_time_ns(); ret = ping_send(); if (ret) goto out_unreg; ping_state = PING_STATE_INIT; ping_sequence_number = 0; while (ping_state == PING_STATE_INIT) { if (ctrlc()) { ret = -EINTR; break; } net_poll(); if (is_timeout(ping_start, SECOND)) { /* No answer, send another packet */ ping_start = get_time_ns(); ret = ping_send(); if (ret) goto out_unreg; retries++; } if (retries > PKT_NUM_RETRIES) { ret = -ETIMEDOUT; goto out_unreg; } } if (!ret) printf("host %s is alive\n", argv[1]); out_unreg: net_unregister(ping_con); out: if (ret) printf("ping failed: %s\n", strerror(-ret)); return ping_state == PING_STATE_SUCCESS ? 0 : 1; }
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; }