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

intinit_sockets(void){	int error;	if ((error = socreate(PF_INET, &socket_afnet, SOCK_DGRAM, 0,	    curlwp, NULL)) != 0)		return error;	if ((error = socreate(PF_ROUTE, &routeso, SOCK_RAW, 0,	    curlwp, NULL)) != 0)		return error;	return 0;}

static int slirp_state_load(QEMUFile *f, void *opaque, int version_id){    struct ex_list *ex_ptr;    int r;    while ((r = qemu_get_byte(f))) {        int ret;        struct socket *so = socreate();        if (!so)            return -ENOMEM;        ret = slirp_socket_load(f, so);        if (ret < 0)            return ret;        if ((so->so_faddr_ip & 0xffffff00) != special_addr_ip)            return -EINVAL;        for (ex_ptr = exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next)            if (ex_ptr->ex_pty == 3 &&                    (so->so_faddr_ip & 0xff) == ex_ptr->ex_addr &&                    so->so_faddr_port == ex_ptr->ex_fport)                break;        if (!ex_ptr)            return -EINVAL;        so->extra = (void *)ex_ptr->ex_exec;    }    return 0;}

/** Nasty hacky function used to debug default gateways. Prints out the * default gateway when called (ish). Definitely only for debugging. */void def_gw_get(){    struct socket *so = NULL;    struct {        struct rt_msghdr msg;        unsigned char space[512];    } rtm_msg;    char buf[1024];    size_t buflen = 1024;    struct rt_msghdr *r;    struct sockaddr *sa;    int i, datalen;#define rtm rtm_msg.msg        assert(                       // IPPROTO_IP	socreate(PF_ROUTE, &so, SOCK_RAW, AF_INET, proc0.p_ucred, curthread)	== 0);    memset(&rtm_msg, 0, sizeof(rtm_msg));        rtm.rtm_msglen = 168; // hmm...    rtm.rtm_version = RTM_VERSION;     rtm.rtm_type = RTM_GET;    rtm.rtm_flags = 2051; // hmm... what are these???    rtm.rtm_addrs = 21; // == 21    rtm.rtm_seq = 2;    rtm.rtm_inits = 0;    //rtm.rtm_pid = 0;    //msg.rtm_index = 0;          // This is seriously hax    rtm_msg.space[0] = 10;     rtm_msg.space[1] = 2;     rtm_msg.space[16] = 2;     rtm_msg.space[17] = 2;         // IP addr    rtm_msg.space[20] = 36;     rtm_msg.space[21] = 12;         datalen = 168;    assert(            nsc_sosend(so, NULL, &rtm_msg, &datalen) == 0          );    assert(            nsc_soreceive_blocking(so, buf, &buflen, NULL) == 0          );    r = (struct rt_msghdr *)buf;    sa = (struct sockaddr *)(r + 1);    printf("%s: read says:/n", __FUNCTION__);    for(i = 0; i < (r->rtm_msglen - sizeof(struct rt_msghdr)); i++) {        printf("%02hhx ", ((unsigned char *)sa)[i]);    }    soclose(so);    sofree(so);}

struct socket * soCloneUDPSocketWithForegnAddr(PNATState pData, bool fBindSocket, struct socket *pSo, uint32_t u32ForeignAddr){    struct socket *pNewSocket = NULL;    LogFlowFunc(("Enter: fBindSocket:%RTbool, so:%R[natsock], u32ForeignAddr:%RTnaipv4/n", fBindSocket, pSo, u32ForeignAddr));    pNewSocket = socreate();    if (!pNewSocket)    {        LogFunc(("Can't create socket/n"));        LogFlowFunc(("Leave: NULL/n"));        return NULL;    }    if (fBindSocket)    {        if (udp_attach(pData, pNewSocket, 0) <= 0)        {            sofree(pData, pNewSocket);            LogFunc(("Can't attach fresh created socket/n"));            return NULL;        }    }    else    {        pNewSocket->so_cloneOf = (struct socket *)pSo;        pNewSocket->s = pSo->s;        insque(pData, pNewSocket, &udb);    }    pNewSocket->so_laddr = pSo->so_laddr;    pNewSocket->so_lport = pSo->so_lport;    pNewSocket->so_faddr.s_addr = u32ForeignAddr;    pNewSocket->so_fport = pSo->so_fport;    pSo->so_cCloneCounter++;    LogFlowFunc(("Leave: %R[natsock]/n", pNewSocket));    return pNewSocket;}

static intff_veth_setaddr(struct ff_veth_softc *sc){    struct in_aliasreq req;    bzero(&req, sizeof req);    strcpy(req.ifra_name, sc->ifp->if_dname);    struct sockaddr_in sa;    bzero(&sa, sizeof(sa));    sa.sin_len = sizeof(sa);    sa.sin_family = AF_INET;    sa.sin_addr.s_addr = sc->ip;    bcopy(&sa, &req.ifra_addr, sizeof(sa));    sa.sin_addr.s_addr = sc->netmask;    bcopy(&sa, &req.ifra_mask, sizeof(sa));    sa.sin_addr.s_addr = sc->broadcast;    bcopy(&sa, &req.ifra_broadaddr, sizeof(sa));    struct socket *so = NULL;    socreate(AF_INET, &so, SOCK_DGRAM, 0, curthread->td_ucred, curthread);    int ret = ifioctl(so, SIOCAIFADDR, (caddr_t)&req, curthread);    sofree(so);    return ret;}

/** Creates a default route to the address specified. Creates and uses a * routing socket to do such. */int def_gw_init(unsigned int gw_addr){    struct socket *so = NULL;    struct {        struct rt_msghdr msg;        unsigned char space[512];    } rtm_msg;    struct sockaddr_in *dst, *gtw, *mask;    int i, datalen;#define rtm rtm_msg.msg        assert(                       // IPPROTO_IP	socreate(PF_ROUTE, &so, SOCK_RAW, AF_INET, proc0.p_ucred, curthread)	== 0);    memset(&rtm_msg, 0, sizeof(rtm_msg));        rtm.rtm_msglen = 128; // hmm...    rtm.rtm_version = RTM_VERSION;     rtm.rtm_type = RTM_ADD;    rtm.rtm_flags = 2051; // hmm... what are these???    rtm.rtm_addrs = RTA_DST | RTA_GATEWAY | RTA_NETMASK; // == 7    rtm.rtm_seq = 1;    rtm.rtm_inits = 0;    //rtm.rtm_pid = 0;    //msg.rtm_index = 0;          dst = (struct sockaddr_in *)rtm_msg.space;    dst->sin_len = sizeof(struct sockaddr_in);    dst->sin_family = AF_INET;    gtw = (struct sockaddr_in *)&rtm_msg.space[ ROUNDUP(dst->sin_len) ];    gtw->sin_len = sizeof(struct sockaddr_in);    gtw->sin_family = AF_INET;    gtw->sin_addr.s_addr = gw_addr;            mask = (struct sockaddr_in *)&rtm_msg.space[ ROUNDUP(dst->sin_len) +        ROUNDUP(gtw->sin_len) ];    mask->sin_len = sizeof(struct sockaddr_in);    mask->sin_family = AF_INET;    rtm.rtm_msglen = sizeof(struct rt_msghdr) + ROUNDUP(dst->sin_len)*3;    /*for(i = 0; i < rtm.rtm_msglen - sizeof(struct rt_msghdr); i++)        printf("%0hhx ", rtm_msg.space[i]);    printf("/n");*/    datalen = rtm.rtm_msglen;    assert(            nsc_sosend(so, NULL, &rtm_msg, &datalen)            == 0          );    soclose(so); // calls sofree for us    //def_gw_get();}

/* * XXX This should really be tcp_listen */struct socket *solisten(u_int port, u_int32_t laddr, u_int lport, int flags){	SockAddress  addr;	uint32_t     addr_ip;	struct socket *so;	int s;	DEBUG_CALL("solisten");	DEBUG_ARG("port = %d", port);	DEBUG_ARG("laddr = %x", laddr);	DEBUG_ARG("lport = %d", lport);	DEBUG_ARG("flags = %x", flags);	if ((so = socreate()) == NULL) {	  /* free(so);      Not sofree() ??? free(NULL) == NOP */	  return NULL;	}	/* Don't tcp_attach... we don't need so_snd nor so_rcv */	if ((so->so_tcpcb = tcp_newtcpcb(so)) == NULL) {		free(so);		return NULL;	}	insque(so,&tcb);	/*	 * SS_FACCEPTONCE sockets must time out.	 */	if (flags & SS_FACCEPTONCE)	   so->so_tcpcb->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT*2;	so->so_state      = (SS_FACCEPTCONN|flags);	so->so_laddr_port = lport; /* Kept in host format */    so->so_laddr_ip   = laddr; /* Ditto */    so->so_haddr_port = port;    s = socket_loopback_server( port, SOCKET_STREAM );    if (s < 0)        return NULL;    socket_get_address(s, &addr);	so->so_faddr_port = sock_address_get_port(&addr);    addr_ip = (uint32_t) sock_address_get_ip(&addr);    if (addr_ip == 0 || addr_ip == loopback_addr_ip)        so->so_faddr_ip = alias_addr_ip;    else        so->so_faddr_ip = addr_ip;	so->s = s;	return so;}

static inticl_conn_connect_tcp(struct icl_conn *ic, int domain, int socktype,    int protocol, struct sockaddr *from_sa, struct sockaddr *to_sa){	struct socket *so;	int error;	int interrupted = 0;	error = socreate(domain, &so, socktype, protocol,	    curthread->td_ucred, curthread);	if (error != 0)		return (error);	if (from_sa != NULL) {		error = sobind(so, from_sa, curthread);		if (error != 0) {			soclose(so);			return (error);		}	}	error = soconnect(so, to_sa, curthread);	if (error != 0) {		soclose(so);		return (error);	}	SOCK_LOCK(so);	while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {		error = msleep(&so->so_timeo, SOCK_MTX(so), PSOCK | PCATCH,		    "icl_connect", 0);		if (error) {			if (error == EINTR || error == ERESTART)				interrupted = 1;			break;		}	}	if (error == 0) {		error = so->so_error;		so->so_error = 0;	}	SOCK_UNLOCK(so);	if (error != 0) {		soclose(so);		return (error);	}	error = icl_conn_handoff_sock(ic, so);	if (error != 0)		soclose(so);	return (error);}

struct socket* listenon(unsigned short port){  struct socket* so = NULL;  socreate(AF_INET, &so, SOCK_STREAM, 0);  struct sockaddr_in addr;  bzero(&addr, sizeof addr);  addr.sin_len = sizeof addr;  addr.sin_family = AF_INET;  addr.sin_port = htons(port);  struct mbuf* nam = m_devget((caddr_t)&addr, sizeof addr, 0, NULL, NULL);  sobind(so, nam);  solisten(so, 5);  return so;}

/* * XXX Need to implement reconnecting as necessary.  If that were to be *     needed, most likely all current vnodes would have to be renegotiated *     or otherwise invalidated (a la NFS "stale file handle"). */static intp9fs_connect(struct mount *mp){	struct p9fsmount *p9mp = VFSTOP9(mp);	struct p9fs_session *p9s = &p9mp->p9_session;	struct socket *so;	int error;	error = socreate(p9s->p9s_sockaddr.sa_family, &p9s->p9s_sock,	    p9s->p9s_socktype, p9s->p9s_proto, curthread->td_ucred, curthread);	if (error != 0) {		vfs_mount_error(mp, "socreate");		goto out;	}	so = p9s->p9s_sock;	error = soconnect(so, &p9s->p9s_sockaddr, curthread);	SOCK_LOCK(so);	while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {		error = msleep(&so->so_timeo, SOCK_MTX(so), PSOCK | PCATCH,		    "connec", 0);		if (error)			break;	}	if (error == 0) {		error = so->so_error;		so->so_error = 0;	}	SOCK_UNLOCK(so);	if (error) {		vfs_mount_error(mp, "soconnect");		if (error == EINTR)			so->so_state &= ~SS_ISCONNECTING;		goto out;	}	if (so->so_proto->pr_flags & PR_CONNREQUIRED)		p9fs_setsockopt(so, SO_KEEPALIVE);	if (so->so_proto->pr_protocol == IPPROTO_TCP)		p9fs_setsockopt(so, TCP_NODELAY);	SOCKBUF_LOCK(&so->so_rcv);	soupcall_set(so, SO_RCV, p9fs_client_upcall, p9mp);	SOCKBUF_UNLOCK(&so->so_rcv);	error = 0;out:	return (error);}

errno_t	xi_sock_socket(int domain, int type, int protocol, sock_upcall callback, void *cookie, xi_socket_t *new_so){#ifdef __KPI_SOCKET__	return sock_socket(domain, type, protocol, callback, cookie, new_so);#else	thread_funnel_set(network_flock, TRUE);	errno_t	error;		error = socreate(domain, new_so, type, protocol); 		(void)thread_funnel_set(network_flock, FALSE);		return error;#endif	}

void handshake(){  int port = 1234;  listenon(port);  struct socket* so = NULL;  socreate(AF_INET, &so, SOCK_STREAM, 0);  struct sockaddr_in addr;  bzero(&addr, sizeof addr);  addr.sin_len = sizeof addr;  addr.sin_family = AF_INET;  addr.sin_port = htons(port);  addr.sin_addr.s_addr = htonl(0x7f000001);  struct mbuf* nam = m_devget((caddr_t)&addr, sizeof addr, 0, NULL, NULL);  soconnect(so, nam);  ipintr();}

/** * Returns: 0 on success, a positive value on error * *		EACCES (from socreate) *		EPERM (from socreate) *		EADDRNOTAVAIL (from connect) *		ETIMEDOUT (from connect) *		... * *  Rare errors: *		EPROTONOSUPPORT (from socreate) *		EPROTOTYPE (from socreate) *		ENOBUFS (from socreate) *		EALREADY (from connect) * */int sendMessageToSite(struct sockaddr *site, char *message,		struct sockaddr *sender, struct thread *td) {	int error, wrote;	struct socket *so = NULL;	if (site->sa_family == AF_INET) {		struct sockaddr_in* site_in = (struct sockaddr_in*) site;		log_debug("Sending message %s to %s:%d", message,				inet_ntoa(site_in->sin_addr), ntohs(site_in->sin_port));	} else {		struct sockaddr_un* site_un = (struct sockaddr_un*) site;		log_debug("Sending message %s to %s", message, site_un->sun_path);	}	error = socreate(site->sa_family, &so, SOCK_STREAM, 0, td->td_ucred, td);	if (error) {		log_warn("error in socreate in sendMessageToSite");		goto bad;	}	error = my_kern_connect(so, (struct sockaddr *) site, td);	if (error) {		log_warn("error in my_kern_connect in sendMessageToSite");		goto bad;	}	error = my_kern_send(so, message, strlen(message), &wrote, td);	if (error || wrote != strlen(message)) {		error = error || EPIPE;		log_warn("error in my_kern_send in sendMessageToSite(1)");		goto bad;	}	error = my_kern_send(so, sender, sizeof(struct sockaddr), &wrote, td);	if (error || wrote != sizeof(struct sockaddr)) {		error = error || EPIPE;		log_warn("error in my_kern_send in sendMessageToSite(2)");		goto bad;	}	bad: //on error	if (error)		log_error("Error in sendMessageToSite [%d]", error);	if (so != NULL)		soclose(so);	return error;}

intsys_socket(struct thread *td, struct socket_args *uap){	struct socket *so;	struct file *fp;	int fd, error, type, oflag, fflag;	AUDIT_ARG_SOCKET(uap->domain, uap->type, uap->protocol);	type = uap->type;	oflag = 0;	fflag = 0;	if ((type & SOCK_CLOEXEC) != 0) {		type &= ~SOCK_CLOEXEC;		oflag |= O_CLOEXEC;	}	if ((type & SOCK_NONBLOCK) != 0) {		type &= ~SOCK_NONBLOCK;		fflag |= FNONBLOCK;	}#ifdef MAC	error = mac_socket_check_create(td->td_ucred, uap->domain, type,	    uap->protocol);	if (error != 0)		return (error);#endif	error = falloc(td, &fp, &fd, oflag);	if (error != 0)		return (error);	/* An extra reference on `fp' has been held for us by falloc(). */	error = socreate(uap->domain, &so, type, uap->protocol,	    td->td_ucred, td);	if (error != 0) {		fdclose(td, fp, fd);	} else {		finit(fp, FREAD | FWRITE | fflag, DTYPE_SOCKET, so, &socketops);		if ((fflag & FNONBLOCK) != 0)			(void) fo_ioctl(fp, FIONBIO, &fflag, td->td_ucred, td);		td->td_retval[0] = fd;	}	fdrop(fp, td);	return (error);}

struct socket *udp_listen(Slirp *slirp, uint32_t haddr, u_int hport, uint32_t laddr,           u_int lport, int flags){	struct sockaddr_in addr;	struct socket *so;	socklen_t addrlen = sizeof(struct sockaddr_in);	so = socreate(slirp);	if (!so) {	    return NULL;	}	so->s = qemu_socket(AF_INET,SOCK_DGRAM,0);	so->so_expire = curtime + SO_EXPIRE;	insque(so, &slirp->udb);	addr.sin_family = AF_INET;	addr.sin_addr.s_addr = haddr;	addr.sin_port = hport;	if (bind(so->s,(struct sockaddr *)&addr, addrlen) < 0) {		udp_detach(so);		return NULL;	}	socket_set_fast_reuse(so->s);	getsockname(so->s,(struct sockaddr *)&addr,&addrlen);	so->so_fport = addr.sin_port;	if (addr.sin_addr.s_addr == 0 ||	    addr.sin_addr.s_addr == loopback_addr.s_addr) {	   so->so_faddr = slirp->vhost_addr;	} else {	   so->so_faddr = addr.sin_addr;	}	so->so_lport = lport;	so->so_laddr.s_addr = laddr;	if (flags != SS_FACCEPTONCE)	   so->so_expire = 0;	so->so_state &= SS_PERSISTENT_MASK;	so->so_state |= SS_ISFCONNECTED | flags;	return so;}

longt_socket(int family,    int   type,    int   proto){   struct socket *   so;   INET_TRACE (INETM_SOCKET, ("SOCK:sock:family %d, typ %d, proto %d/n",    family, type, proto));   LOCK_NET_RESOURCE(NET_RESID);   if ((so = socreate (family, type, proto)) == NULL)    {  /* can't really return error info since no socket.... */      UNLOCK_NET_RESOURCE(NET_RESID);      return SOCKET_ERROR;   }   SOC_RANGE(so);   so->so_error = 0;   UNLOCK_NET_RESOURCE(NET_RESID);   return SO2LONG(so);}

struct socket *udp_listen(u_int port, u_int32_t laddr, u_int lport, int flags){	struct socket *so;	SockAddress    addr;	uint32_t       addr_ip;	if ((so = socreate()) == NULL) {		free(so);		return NULL;	}	so->s = socket_anyaddr_server( port, SOCKET_DGRAM );	so->so_expire = curtime + SO_EXPIRE;    so->so_haddr_port = port;	insque(so,&udb);	if (so->s < 0) {		udp_detach(so);		return NULL;	}        socket_get_address(so->s, &addr);	so->so_faddr_port = sock_address_get_port(&addr);	addr_ip = sock_address_get_ip(&addr);	if (addr_ip == 0 || addr_ip == loopback_addr_ip)	   so->so_faddr_ip = alias_addr_ip;	else	   so->so_faddr_ip = addr_ip;	so->so_laddr_port = lport;	so->so_laddr_ip   = laddr;	if (flags != SS_FACCEPTONCE)	   so->so_expire = 0;	so->so_state = SS_ISFCONNECTED;	return so;}

static intuinet_ifconfig_begin(struct socket **so, struct ifreq *ifr, const char *name){	struct thread *td = curthread;	struct uinet_config_if *ifcfg;	int error;	ifcfg = uinet_iffind_byname(name);	if (NULL == ifcfg) {		printf("could not find interface %s/n", name);		return (EINVAL);	}	error = socreate(PF_INET, so, SOCK_DGRAM, 0, td->td_ucred, td);	if (0 != error) {		printf("ifconfig socket creation failed (%d)/n", error);		return (error);	}	snprintf(ifr->ifr_name, sizeof(ifr->ifr_name), "%s", ifcfg->name);		return (0);}

intsys_socket(struct proc *p, void *v, register_t *retval){	struct sys_socket_args /* {		syscallarg(int) domain;		syscallarg(int) type;		syscallarg(int) protocol;	} */ *uap = v;	struct filedesc *fdp = p->p_fd;	struct socket *so;	struct file *fp;	int fd, error;	fdplock(fdp);	error = falloc(p, &fp, &fd);	fdpunlock(fdp);	if (error != 0)		goto out;	fp->f_flag = FREAD|FWRITE;	fp->f_type = DTYPE_SOCKET;	fp->f_ops = &socketops;	error = socreate(SCARG(uap, domain), &so, SCARG(uap, type),			 SCARG(uap, protocol));	if (error) {		fdplock(fdp);		fdremove(fdp, fd);		closef(fp, p);		fdpunlock(fdp);	} else {		fp->f_data = so;		FILE_SET_MATURE(fp, p);		*retval = fd;	}out:	return (error);}

int waitForMessages(struct sockaddr_in *site_2, struct thread *td) {	waiting_sockaddr = *site_2;	struct sockaddr_in *site = &waiting_sockaddr;	log_info("waiting for messages on %s:%d", inet_ntoa(site->sin_addr), ntohs(site->sin_port));	int error = 0;	struct socket *so = NULL;	error = socreate(AF_INET, &so, SOCK_STREAM, 0, td->td_ucred, td);	if (error) {		log_warn("error in socreate in waitForMessages");		goto bad;	}	error = sobind(so, (struct sockaddr *) site, td);	if (error) {		log_warn("error in sobind in waitForMessages");		goto bad;	}	error = solisten(so, 5, td);	if (error) {		log_warn("error in solisten in waitForMessages");		goto bad;	}	error = kthread_add(accept_loop, so, NULL, &accept_kthread, 0, 0,			"raymond_accept_loop");	if (error) {		log_warn("error creating thread: %d/n", error);		goto bad;	}	return 0;	bad: // on error	if (so != NULL)		soclose(so);	return error;}

/* * Listen for incoming TCP connections */struct socket *tcp_listen(Slirp *slirp, uint32_t haddr, u_int hport, uint32_t laddr,           u_int lport, int flags){	struct sockaddr_in addr;	struct socket *so;	int s, opt = 1;	socklen_t addrlen = sizeof(addr);	memset(&addr, 0, addrlen);	DEBUG_CALL("tcp_listen");	DEBUG_ARG("haddr = %x", haddr);	DEBUG_ARG("hport = %d", hport);	DEBUG_ARG("laddr = %x", laddr);	DEBUG_ARG("lport = %d", lport);	DEBUG_ARG("flags = %x", flags);	so = socreate(slirp);	if (!so) {	  return NULL;	}	/* Don't tcp_attach... we don't need so_snd nor so_rcv */	if ((so->so_tcpcb = tcp_newtcpcb(so)) == NULL) {		free(so);		return NULL;	}	insque(so, &slirp->tcb);	/*	 * SS_FACCEPTONCE sockets must time out.	 */	if (flags & SS_FACCEPTONCE)	   so->so_tcpcb->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT*2;	so->so_state &= SS_PERSISTENT_MASK;	so->so_state |= (SS_FACCEPTCONN | flags);	so->so_lport = lport; /* Kept in network format */	so->so_laddr.s_addr = laddr; /* Ditto */	addr.sin_family = AF_INET;	addr.sin_addr.s_addr = haddr;	addr.sin_port = hport;	if (((s = qemu_socket(AF_INET,SOCK_STREAM,0)) < 0) ||	    (setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(int)) < 0) ||	    (bind(s,(struct sockaddr *)&addr, sizeof(addr)) < 0) ||	    (listen(s,1) < 0)) {		int tmperrno = errno; /* Don't clobber the real reason we failed */		close(s);		sofree(so);		/* Restore the real errno */#ifdef _WIN32		WSASetLastError(tmperrno);#else		errno = tmperrno;#endif		return NULL;	}	setsockopt(s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(int));	getsockname(s,(struct sockaddr *)&addr,&addrlen);	so->so_fport = addr.sin_port;	if (addr.sin_addr.s_addr == 0 || addr.sin_addr.s_addr == loopback_addr.s_addr)	   so->so_faddr = slirp->vhost_addr;	else	   so->so_faddr = addr.sin_addr;	so->s = s;	return so;}