自学教程：C++ xsocket函数代码示例

/* Setup the address and return socket fd */static int setup_socket(struct sockaddr_un *sun) {	int fd = xsocket(AF_LOCAL, SOCK_STREAM | SOCK_CLOEXEC, 0);	memset(sun, 0, sizeof(*sun));	sun->sun_family = AF_LOCAL;	memcpy(sun->sun_path, REQUESTOR_DAEMON_PATH, REQUESTOR_DAEMON_PATH_LEN);	return fd;}

void    my_server(char *ip, int port, char *ip2, int port2){  int			error;  t_serv_info		*serv;  t_dest_info		*dest;  struct protoent	*pe;  serv = malloc(sizeof(serv));  dest = malloc(sizeof(dest));  pe = getprotobyname("TCP");  serv->sock = xsocket(PF_INET, SOCK_STREAM, pe->p_proto);  serv->sin.sin_addr.s_addr = INADDR_ANY;  serv->sin.sin_family = AF_INET;  serv->sin.sin_port = htons(port);  serv->ip = ip;  serv->port = port;  error = xbind(serv->sock,		(const struct sockaddr *)&serv->sin, sizeof(serv->sin));  error = xlisten(serv->sock, 42);  serv->client_len = sizeof(serv->sin_client);  dest->ip = ip2;  dest->port = port2;  main_loop(error, serv, dest);  close(serv->sock);}

/* Exits on error */static int get_address(char *dev, int *htype){	struct ifreq ifr;	struct sockaddr_ll me;	socklen_t alen;	int s;	s = xsocket(PF_PACKET, SOCK_DGRAM, 0);	memset(&ifr, 0, sizeof(ifr));	strncpy_IFNAMSIZ(ifr.ifr_name, dev);	xioctl(s, SIOCGIFINDEX, &ifr);	memset(&me, 0, sizeof(me));	me.sll_family = AF_PACKET;	me.sll_ifindex = ifr.ifr_ifindex;	me.sll_protocol = htons(ETH_P_LOOP);	xbind(s, (struct sockaddr*)&me, sizeof(me));	alen = sizeof(me);	getsockname(s, (struct sockaddr*)&me, &alen);	//never happens:	//if (getsockname(s, (struct sockaddr*)&me, &alen) == -1)	//	bb_perror_msg_and_die("getsockname");	close(s);	*htype = me.sll_hatype;	return me.sll_halen;}

/* 2. ip was always INADDR_ANY */int listen_socket(/*uint32_t ip,*/ int port, const char *inf){	int fd;	struct ifreq interface;	struct sockaddr_in addr;	DEBUG("Opening listen socket on *:%d %s", port, inf);	fd = xsocket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);	setsockopt_reuseaddr(fd);	if (setsockopt_broadcast(fd) == -1)		bb_perror_msg_and_die("SO_BROADCAST");	strncpy(interface.ifr_name, inf, IFNAMSIZ);	if (setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, &interface, sizeof(interface)) == -1)		bb_perror_msg_and_die("SO_BINDTODEVICE");	memset(&addr, 0, sizeof(addr));	addr.sin_family = AF_INET;	addr.sin_port = htons(port);	/* addr.sin_addr.s_addr = ip; - all-zeros is INADDR_ANY */	xbind(fd, (struct sockaddr *)&addr, sizeof(addr));	return fd;}

void vconfig_main(void){  struct vlan_ioctl_args request;  char *cmd;  int fd;  fd = xsocket(AF_INET, SOCK_STREAM, 0);  memset(&request, 0, sizeof(struct vlan_ioctl_args));  cmd = toys.optargs[0];  if (!strcmp(cmd, "set_name_type")) {    char *types[] = {"VLAN_PLUS_VID", "DEV_PLUS_VID", "VLAN_PLUS_VID_NO_PAD",                     "DEV_PLUS_VID_NO_PAD"};    int i, j = sizeof(types)/sizeof(*types);    for (i=0; i<j; i++) if (!strcmp(toys.optargs[1], types[i])) break;    if (i == j) {      for (i=0; i<j; i++) puts(types[i]);      error_exit("%s: unknown '%s'", cmd, toys.optargs[1]);    }    request.u.name_type = i;    request.cmd = SET_VLAN_NAME_TYPE_CMD;    xioctl(fd, SIOCSIFVLAN, &request);    return;  }  // Store interface name  xstrncpy(request.device1, toys.optargs[1], 16);  if (!strcmp(cmd, "add")) {    request.cmd = ADD_VLAN_CMD;    if (toys.optargs[2]) request.u.VID = atolx_range(toys.optargs[2], 0, 4094);    if (request.u.VID == 1)      xprintf("WARNING: VLAN 1 does not work with many switches./n");  } else if (!strcmp(cmd, "rem")) request.cmd = DEL_VLAN_CMD;  else if (!strcmp(cmd, "set_flag")) {    request.cmd = SET_VLAN_FLAG_CMD;    if (toys.optargs[2]) request.u.flag = atolx_range(toys.optargs[2], 0, 1);    if (toys.optargs[3]) request.vlan_qos = atolx_range(toys.optargs[3], 0, 7);  } else if(strcmp(cmd, "set_egress_map") == 0) {    request.cmd = SET_VLAN_EGRESS_PRIORITY_CMD;    if (toys.optargs[2])      request.u.skb_priority = atolx_range(toys.optargs[2], 0, INT_MAX);    if (toys.optargs[3]) request.vlan_qos = atolx_range(toys.optargs[3], 0, 7);  } else if(strcmp(cmd, "set_ingress_map") == 0) {    request.cmd = SET_VLAN_INGRESS_PRIORITY_CMD;    if (toys.optargs[2])      request.u.skb_priority = atolx_range(toys.optargs[2], 0, INT_MAX);    //To set flag we must have to set vlan_qos    if (toys.optargs[3]) request.vlan_qos = atolx_range(toys.optargs[3], 0, 7);  } else {    xclose(fd);    perror_exit("Unknown command %s", cmd);  }  xioctl(fd, SIOCSIFVLAN, &request);  xprintf("Successful %s on device %s/n", cmd, toys.optargs[1]);}

int FAST_FUNC udhcp_read_interface(const char *interface, int *ifindex, uint32_t *nip, uint8_t *mac, uint16_t *mtu){	/* char buffer instead of bona-fide struct avoids aliasing warning */	char ifr_buf[sizeof(struct ifreq)];	struct ifreq *const ifr = (void *)ifr_buf;	int fd;	struct sockaddr_in *our_ip;	memset(ifr, 0, sizeof(*ifr));	fd = xsocket(AF_INET, SOCK_RAW, IPPROTO_RAW);	ifr->ifr_addr.sa_family = AF_INET;	strncpy_IFNAMSIZ(ifr->ifr_name, interface);	if (nip) {		if (ioctl_or_perror(fd, SIOCGIFADDR, ifr,			"is interface %s up and configured?", interface)		) {			close(fd);			return -1;		}		our_ip = (struct sockaddr_in *) &ifr->ifr_addr;		*nip = our_ip->sin_addr.s_addr;		log1("IP %s", inet_ntoa(our_ip->sin_addr));	}	if (ifindex) {		if (ioctl_or_warn(fd, SIOCGIFINDEX, ifr) != 0) {			close(fd);			return -1;		}		log1("Adapter index %d", ifr->ifr_ifindex);		*ifindex = ifr->ifr_ifindex;	}	if (mac) {		if (ioctl_or_warn(fd, SIOCGIFHWADDR, ifr) != 0) {			close(fd);			return -1;		}		memcpy(mac, ifr->ifr_hwaddr.sa_data, 6);		log1("MAC %02x:%02x:%02x:%02x:%02x:%02x",			mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);	}	if (mtu) {		if (ioctl_or_warn(fd, SIOCGIFMTU, ifr) != 0) {			close(fd);			return -1;		}		log1("Adapter mtu %d", ifr->ifr_mtu);		*mtu = ifr->ifr_mtu;	}	close(fd);	return 0;}

int vconfig_main(int argc, char **argv){	struct vlan_ioctl_args ifr;	const char *p;	int fd;	if (argc < 3) {		bb_show_usage();	}	/* Don't bother closing the filedes.  It will be closed on cleanup. */	/* Will die if 802.1q is not present */	xopen(conf_file_name, O_RDONLY);	memset(&ifr, 0, sizeof(struct vlan_ioctl_args));	++argv;	p = xfind_str(cmds+2, *argv);	ifr.cmd = *p;	if (argc != p[-1]) {		bb_show_usage();	}	if (ifr.cmd == SET_VLAN_NAME_TYPE_CMD) { /* set_name_type */		ifr.u.name_type = *xfind_str(name_types+1, argv[1]);	} else {		if (strlen(argv[1]) >= IF_NAMESIZE) {			bb_error_msg_and_die("if_name >= %d chars", IF_NAMESIZE);		}		strcpy(ifr.device1, argv[1]);		p = argv[2];		/* I suppose one could try to combine some of the function calls below,		 * since ifr.u.flag, ifr.u.VID, and ifr.u.skb_priority are all same-sized		 * (unsigned) int members of a unions.  But because of the range checking,		 * doing so wouldn't save that much space and would also make maintainence		 * more of a pain. */		if (ifr.cmd == SET_VLAN_FLAG_CMD) { /* set_flag */			ifr.u.flag = xatoul_range(p, 0, 1);			/* DM: in order to set reorder header, qos must be set */			ifr.vlan_qos = xatoul_range(argv[3], 0, 7);		} else if (ifr.cmd == ADD_VLAN_CMD) { /* add */			ifr.u.VID = xatoul_range(p, 0, VLAN_GROUP_ARRAY_LEN-1);		} else if (ifr.cmd != DEL_VLAN_CMD) { /* set_{egress|ingress}_map */			ifr.u.skb_priority = xatou(p);			ifr.vlan_qos = xatoul_range(argv[3], 0, 7);		}	}	fd = xsocket(AF_INET, SOCK_STREAM, 0);	if (ioctl(fd, SIOCSIFVLAN, &ifr) < 0) {		bb_perror_msg_and_die("ioctl error for %s", *argv);	}	return 0;}

static void proceed_request_stack(int srv){  struct parse_state srv_state = { .state = ST_CMD,                                   .p_idx = 0 };  struct request *r;  int i=0;  for(r = req_stack ; r != NULL ; r = r->next) {    proceed_request(srv, r);    while(parse(srv, &srv_state, proceed_response));  }}static void client(){  int sd;  struct request quit       = { .command    = CMD_QUIT };  struct sockaddr_un s_addr = { .sun_family = AF_UNIX };  struct sigaction act      = { .sa_handler = srv_timeout,                                .sa_flags   = 0 };  /* ensure this lient won't live more than REQUEST_TIMEOUT seconds */  sigfillset(&act.sa_mask);  sigaction(SIGALRM, &act, NULL);  alarm(REQUEST_TIMEOUT);  /* socket creation */  sd = xsocket(AF_UNIX, SOCK_STREAM, 0);  /* bind socket to the specified sock_path */  strncpy(s_addr.sun_path, sock_path, UNIX_PATH_MAX);  /* connect to the server */  xconnect(sd, (struct sockaddr *)&s_addr, SUN_LEN(&s_addr));  proceed_request_stack(sd);  /* quit only after the request has been proceeded */  proceed_request(sd, &quit);}int main(int argc, char * const argv[]){  /* get program name */  prog_name = (const char *)strrchr(argv[0], '/');  prog_name = prog_name ? (prog_name + 1) : argv[0];  /* parse command line and build     the request stack */  cmdline(argc, argv);  /* start client */  client();  return EXIT_SUCCESS;}

int				serveur(t_serv *e){  int				fd;  fd = xsocket();  xbind(fd, e);  xlisten(fd);  e->fd_type[fd] = FD_SERVEUR;  e->fct_read[fd] = serveur_read;}

/* Dies on error */static int do_ioctl_get_ifindex(char *dev){	struct ifreq ifr;	int fd;	strncpy_IFNAMSIZ(ifr.ifr_name, dev);	fd = xsocket(AF_INET, SOCK_DGRAM, 0);	xioctl(fd, SIOCGIFINDEX, &ifr);	close(fd);	return ifr.ifr_ifindex;}

int arp_main(int argc ATTRIBUTE_UNUSED, char **argv){	char *hw_type;	char *protocol;	/* Initialize variables... */	ap = get_aftype(DFLT_AF);	if (!ap)		bb_error_msg_and_die("%s: %s not supported", DFLT_AF, "address family");	getopt32(argv, "A:p:H:t:i:adnDsv", &protocol, &protocol,				 &hw_type, &hw_type, &device);	argv += optind;	if (option_mask32 & ARP_OPT_A || option_mask32 & ARP_OPT_p) {		ap = get_aftype(protocol);		if (ap == NULL)			bb_error_msg_and_die("%s: unknown %s", protocol, "address family");	}	if (option_mask32 & ARP_OPT_A || option_mask32 & ARP_OPT_p) {		hw = get_hwtype(hw_type);		if (hw == NULL)			bb_error_msg_and_die("%s: unknown %s", hw_type, "hardware type");		hw_set = 1;	}	//if (option_mask32 & ARP_OPT_i)... -i	if (ap->af != AF_INET) {		bb_error_msg_and_die("%s: kernel only supports 'inet'", ap->name);	}	/* If no hw type specified get default */	if (!hw) {		hw = get_hwtype(DFLT_HW);		if (!hw)			bb_error_msg_and_die("%s: %s not supported", DFLT_HW, "hardware type");	}	if (hw->alen <= 0) {		bb_error_msg_and_die("%s: %s without ARP support",							 hw->name, "hardware type");	}	sockfd = xsocket(AF_INET, SOCK_DGRAM, 0);	/* Now see what we have to do here... */	if (option_mask32 & (ARP_OPT_d|ARP_OPT_s)) {		if (argv[0] == NULL)			bb_error_msg_and_die("need host name");		if (option_mask32 & ARP_OPT_s)			return arp_set(argv);		return arp_del(argv);	}	//if (option_mask32 & ARP_OPT_a) - default	return arp_show(argv[0]);}

static char *do_ioctl_get_ifname(int idx){	struct ifreq ifr;	int fd;	int err;	ifr.ifr_ifindex = idx;	fd = xsocket(AF_INET, SOCK_DGRAM, 0);	err = ioctl_or_warn(fd, SIOCGIFNAME, &ifr);	close(fd);	return err ? NULL : xstrndup(ifr.ifr_name, sizeof(ifr.ifr_name));}

/* Exits on error */static int get_ctl_fd(void){	int fd;	fd = socket(PF_INET, SOCK_DGRAM, 0);	if (fd >= 0)		return fd;	fd = socket(PF_PACKET, SOCK_DGRAM, 0);	if (fd >= 0)		return fd;	return xsocket(PF_INET6, SOCK_DGRAM, 0);}

int			init_serveur(t_desc *serv){  int			s;  struct sockaddr_in	ser;  s = xsocket(PF_INET, SOCK_STREAM, 0);  ser.sin_family = AF_INET;  ser.sin_port = htons(serv->port);  ser.sin_addr.s_addr = INADDR_ANY;  xbind(s, ser);  return (s);}

static int do_ioctl_get_iftype(char *dev){	struct ifreq ifr;	int fd;	int err;	strncpy_IFNAMSIZ(ifr.ifr_name, dev);	fd = xsocket(AF_INET, SOCK_DGRAM, 0);	err = ioctl_or_warn(fd, SIOCGIFHWADDR, &ifr);	close(fd);	return err ? -1 : ifr.ifr_addr.sa_family;}

static int do_get_ioctl(const char *basedev, struct ip_tunnel_parm *p){	struct ifreq ifr;	int fd;	int err;	strncpy_IFNAMSIZ(ifr.ifr_name, basedev);	ifr.ifr_ifru.ifru_data = (void*)p;	fd = xsocket(AF_INET, SOCK_DGRAM, 0);	err = ioctl_or_warn(fd, SIOCGETTUNNEL, &ifr);	close(fd);	return err;}

static int_open_link_socket(struct sockaddr_nl *nl, int protocol){	int fd;	if ((fd = xsocket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, protocol)) == -1)		return -1;	nl->nl_family = AF_NETLINK;	if (bind(fd, (struct sockaddr *)nl, sizeof(*nl)) == -1) {		close(fd);		return -1;	}	return fd;}

int			connect_to_server(int protonum, char *ip, int port){  struct sockaddr_in	*srv_addr;  int			sockfd;  sockfd = xsocket(AF_INET, SOCK_STREAM, protonum);  srv_addr = xmalloc_and_set(NULL, sizeof(*srv_addr));  srv_addr->sin_family = AF_INET;  srv_addr->sin_addr.s_addr = inet_addr(ip);  srv_addr->sin_port = htons(port);  xconnect(sockfd, (struct sockaddr *)srv_addr, sizeof(*srv_addr));  free(srv_addr);  return (sockfd);}

int raw_socket(int ifindex){	int fd;	struct sockaddr_ll sock;	DEBUG("Opening raw socket on ifindex %d", ifindex);	fd = xsocket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));	sock.sll_family = AF_PACKET;	sock.sll_protocol = htons(ETH_P_IP);	sock.sll_ifindex = ifindex;	xbind(fd, (struct sockaddr *) &sock, sizeof(sock));	return fd;}

/* Dies on error, otherwise returns 0 */static int do_del_ioctl(const char *basedev, struct ip_tunnel_parm *p){	struct ifreq ifr;	int fd;	if (p->name[0]) {		strncpy_IFNAMSIZ(ifr.ifr_name, p->name);	} else {		strncpy_IFNAMSIZ(ifr.ifr_name, basedev);	}	ifr.ifr_ifru.ifru_data = (void*)p;	fd = xsocket(AF_INET, SOCK_DGRAM, 0);	xioctl(fd, SIOCDELTUNNEL, &ifr);	close(fd);	return 0;}

static NOINLINE int netlink_open(void){    int fd;    struct sockaddr_nl addr;    fd = xsocket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);    memset(&addr, 0, sizeof(addr));    addr.nl_family = AF_NETLINK;    addr.nl_groups = RTMGRP_LINK;    addr.nl_pid = getpid();    xbind(fd, (struct sockaddr*)&addr, sizeof(addr));    return fd;}

int xconnect(const char *peer) {    int fd;    int pf = sockaddr_pf(peer);    char sockaddr[TP_SOCKADDRLEN] = {};    if (pf < 0 || sockaddr_addr(peer, sockaddr, sizeof(sockaddr)) != 0) {	errno = EINVAL;	return -1;    }    if ((fd = xsocket(pf, XCONNECTOR)) < 0)	return -1;    if (xbind(fd, sockaddr) < 0) {	xclose(fd);	return -1;    }    return fd;}

int read_interface(const char *interface, int *ifindex, uint32_t *addr, uint8_t *arp){	int fd;	struct ifreq ifr;	struct sockaddr_in *our_ip;	memset(&ifr, 0, sizeof(ifr));	fd = xsocket(AF_INET, SOCK_RAW, IPPROTO_RAW);	ifr.ifr_addr.sa_family = AF_INET;	strncpy(ifr.ifr_name, interface, sizeof(ifr.ifr_name));	if (addr) {		if (ioctl_or_perror(fd, SIOCGIFADDR, &ifr,			"is interface %s up and configured?", interface)		) {			close(fd);			return -1;		}		our_ip = (struct sockaddr_in *) &ifr.ifr_addr;		*addr = our_ip->sin_addr.s_addr;		DEBUG("%s (our ip) = %s", ifr.ifr_name, inet_ntoa(our_ip->sin_addr));	}	if (ifindex) {		if (ioctl_or_warn(fd, SIOCGIFINDEX, &ifr) != 0) {			close(fd);			return -1;		}		DEBUG("adapter index %d", ifr.ifr_ifindex);		*ifindex = ifr.ifr_ifindex;	}	if (arp) {		if (ioctl_or_warn(fd, SIOCGIFHWADDR, &ifr) != 0) {			close(fd);			return -1;		}		memcpy(arp, ifr.ifr_hwaddr.sa_data, 6);		DEBUG("adapter hardware address %02x:%02x:%02x:%02x:%02x:%02x",			arp[0], arp[1], arp[2], arp[3], arp[4], arp[5]);	}	close(fd);	return 0;}

int FAST_FUNC udhcp_read_interface(const char *interface, int *ifindex, uint32_t *nip, uint8_t *mac){	int fd;	struct ifreq ifr;	struct sockaddr_in *our_ip;	memset(&ifr, 0, sizeof(ifr));	fd = xsocket(AF_INET, SOCK_RAW, IPPROTO_RAW);	ifr.ifr_addr.sa_family = AF_INET;	strncpy(ifr.ifr_name, interface, sizeof(ifr.ifr_name));	if (nip) {		if (ioctl_or_perror(fd, SIOCGIFADDR, &ifr,			"is interface %s up and configured?", interface)		) {			close(fd);			return -1;		}		our_ip = (struct sockaddr_in *) &ifr.ifr_addr;		*nip = our_ip->sin_addr.s_addr;		log1("IP %s", inet_ntoa(our_ip->sin_addr));	}	if (ifindex) {		if (ioctl_or_warn(fd, SIOCGIFINDEX, &ifr) != 0) {			close(fd);			return -1;		}		log1("Adapter index %d", ifr.ifr_ifindex);		*ifindex = ifr.ifr_ifindex;	}	if (mac) {		if (ioctl_or_warn(fd, SIOCGIFHWADDR, &ifr) != 0) {			close(fd);			return -1;		}		memcpy(mac, ifr.ifr_hwaddr.sa_data, 6);		log1("MAC %02x:%02x:%02x:%02x:%02x:%02x",			mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);	}	close(fd);	return 0;}

int     init_serveur(int port){  struct protoent	*pe;  t_servinfo		servinfo;  int			error;  pe = getprotobyname("TCP");  servinfo.sock = xsocket(AF_INET, SOCK_STREAM, pe->p_proto);  printf("/tMy IRC /nServer IP: %d:%d/nLocal  IP: %d:%d/nSocket %d open./n",         system(IP), port, system(IPL), port, servinfo.sock);  servinfo.sin.sin_addr.s_addr = INADDR_ANY;  servinfo.sin.sin_family = AF_INET;  servinfo.sin.sin_port = htons(port);  error = xbind(servinfo.sock,		(const struct sockaddr *)&servinfo.sin, sizeof(servinfo.sin));  error = xlisten(servinfo.sock, 42);  servinfo.client_len = sizeof(servinfo.sin_client);  error = 0;  main_loop(error, &servinfo);  close(servinfo.sock);  return (0); }

/* Initializes the dump socket, usually in /var/run directory * (the path depends on compile-time configuration). */static void dumpsocket_init(void){    unlink(SOCKET_FILE); /* not caring about the result */    int socketfd = xsocket(AF_UNIX, SOCK_STREAM, 0);    close_on_exec_on(socketfd);    struct sockaddr_un local;    memset(&local, 0, sizeof(local));    local.sun_family = AF_UNIX;    strcpy(local.sun_path, SOCKET_FILE);    xbind(socketfd, (struct sockaddr*)&local, sizeof(local));    xlisten(socketfd, MAX_CLIENT_COUNT);    if (chmod(SOCKET_FILE, SOCKET_PERMISSION) != 0)        perror_msg_and_die("chmod '%s'", SOCKET_FILE);    channel_socket = abrt_gio_channel_unix_new(socketfd);    g_io_channel_set_buffered(channel_socket, FALSE);    channel_id_socket = add_watch_or_die(channel_socket, G_IO_IN | G_IO_PRI | G_IO_HUP, server_socket_cb);}

int FAST_FUNC xrtnl_open(struct rtnl_handle *rth/*, unsigned subscriptions*/){	socklen_t addr_len;	memset(rth, 0, sizeof(rth));	rth->fd = xsocket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);	memset(&rth->local, 0, sizeof(rth->local));	rth->local.nl_family = AF_NETLINK;	/*rth->local.nl_groups = subscriptions;*/	xbind(rth->fd, (struct sockaddr*)&rth->local, sizeof(rth->local));	addr_len = sizeof(rth->local);	if (getsockname(rth->fd, (struct sockaddr*)&rth->local, &addr_len) < 0)		bb_perror_msg_and_die("getsockname");	if (addr_len != sizeof(rth->local))		bb_error_msg_and_die("wrong address length %d", addr_len);	if (rth->local.nl_family != AF_NETLINK)		bb_error_msg_and_die("wrong address family %d", rth->local.nl_family);	rth->seq = time(NULL);	return 0;}

boolsupport_enter_network_namespace (void){#ifdef CLONE_NEWUTS  if (unshare (CLONE_NEWUTS) == 0)    in_uts_namespace = true;  else    printf ("warning: unshare (CLONE_NEWUTS) failed: %m/n");#endif#ifdef CLONE_NEWNET  if (unshare (CLONE_NEWNET) == 0)    {      /* Bring up the loopback interface.  */      int fd = xsocket (AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC, 0);      struct ifreq req;      strcpy (req.ifr_name, "lo");      TEST_VERIFY_EXIT (ioctl (fd, SIOCGIFFLAGS, &req) == 0);      bool already_up = req.ifr_flags & IFF_UP;      if (already_up)        /* This means that we likely have not achieved isolation from           the parent namespace.  */        printf ("warning: loopback interface already exists"                " in new network namespace/n");      else        {          req.ifr_flags |= IFF_UP | IFF_RUNNING;          TEST_VERIFY_EXIT (ioctl (fd, SIOCSIFFLAGS, &req) == 0);        }      close (fd);      return !already_up;    }#endif  printf ("warning: could not enter network namespace/n");  return false;}

/* Dies on error, otherwise returns 0 */static int do_add_ioctl(int cmd, const char *basedev, struct ip_tunnel_parm *p){	struct ifreq ifr;	int fd;	if (cmd == SIOCCHGTUNNEL && p->name[0]) {		strncpy_IFNAMSIZ(ifr.ifr_name, p->name);	} else {		strncpy_IFNAMSIZ(ifr.ifr_name, basedev);	}	ifr.ifr_ifru.ifru_data = (void*)p;	fd = xsocket(AF_INET, SOCK_DGRAM, 0);#if ENABLE_IOCTL_HEX2STR_ERROR	/* #define magic will turn ioctl# into string */	if (cmd == SIOCCHGTUNNEL)		xioctl(fd, SIOCCHGTUNNEL, &ifr);	else		xioctl(fd, SIOCADDTUNNEL, &ifr);#else	xioctl(fd, cmd, &ifr);#endif	close(fd);	return 0;}

/* 2. ip was always INADDR_ANY */int FAST_FUNC udhcp_listen_socket(/*uint32_t ip,*/ int port, const char *inf){	int fd;	struct sockaddr_in addr;	log1("Opening listen socket on *:%d %s", port, inf);	fd = xsocket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);	setsockopt_reuseaddr(fd);	if (setsockopt_broadcast(fd) == -1)		bb_perror_msg_and_die("SO_BROADCAST");	/* NB: bug 1032 says this doesn't work on ethernet aliases (ethN:M) */	if (setsockopt_bindtodevice(fd, inf))		xfunc_die(); /* warning is already printed */	memset(&addr, 0, sizeof(addr));	addr.sin_family = AF_INET;	addr.sin_port = htons(port);	/* addr.sin_addr.s_addr = ip; - all-zeros is INADDR_ANY */	xbind(fd, (struct sockaddr *)&addr, sizeof(addr));	return fd;}