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

void *app_glue_create_socket(int family,int type){	struct timeval tv;	struct socket *sock = NULL;	if(sock_create_kern(family,type,0,&sock)) {		syslog(LOG_ERR,"cannot create socket %s %d/n",__FILE__,__LINE__);		return NULL;	}	tv.tv_sec = -1;	tv.tv_usec = 0;	if(sock_setsockopt(sock,SOL_SOCKET,SO_RCVTIMEO,(char *)&tv,sizeof(tv))) {		syslog(LOG_ERR,"%s %d cannot set notimeout option/n",__FILE__,__LINE__);	}	tv.tv_sec = -1;	tv.tv_usec = 0;	if(sock_setsockopt(sock,SOL_SOCKET,SO_SNDTIMEO,(char *)&tv,sizeof(tv))) {		syslog(LOG_ERR,"%s %d cannot set notimeout option/n",__FILE__,__LINE__);	}	if(type != SOCK_STREAM) {		if(sock->sk) {            		sock_reset_flag(sock->sk,SOCK_USE_WRITE_QUEUE);            		sock->sk->sk_data_ready = app_glue_sock_readable;            		sock->sk->sk_write_space = app_glue_sock_write_space;            		app_glue_sock_write_space(sock->sk);		}	}	return sock;}

/* * sock_tcp_server() *  Initialize a tcp server socket. On success, a valid socket number will return. */int sock_tcp_server(const char *hostname, int port){    int oldfl = 0;    int sock;        /* create a socket */    if ((sock = sock_create("tcp")) < 0)	net_error("initialize server socket failed/n");    /* set it to non-blocking operation */    oldfl = fcntl(sock, F_GETFL, 0);    if (!(oldfl & O_NONBLOCK))	fcntl(sock, F_SETFL, oldfl | O_NONBLOCK);    /* setup for a fast restart to avoid bind addr in use errors */    sock_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, 1);        /* bind it to the appropriate port */    if ((sock_bind(sock, hostname, port)) == -1)	return -1;        /* go ahead and listen to the socket */    if (listen(sock, TCP_BACKLOG) != 0)	return -1;    return sock;}

int ksetsockopt(ksocket_t socket, int level, int optname, void *optval, int optlen){	struct socket *sk;	int ret;#ifndef KSOCKET_ADDR_SAFE	mm_segment_t old_fs;#endif	sk = (struct socket *)socket;#ifndef KSOCKET_ADDR_SAFE	old_fs = get_fs();	set_fs(KERNEL_DS);#endif	if (level == SOL_SOCKET)		ret = sock_setsockopt(sk, level, optname, optval, optlen);	else		ret = sk->ops->setsockopt(sk, level, optname, optval, optlen);#ifndef KSOCKET_ADDR_SAFE		set_fs(old_fs);#endif	return ret;}

static intlibcfs_sock_create (cfs_socket_t **sockp, int *fatal,                    __u32 local_ip, int local_port){        struct sockaddr_in  locaddr;        cfs_socket_t    *sock;        int             option;        int             optlen;        int             rc;        /* All errors are fatal except bind failure if the port is in use */        *fatal = 1;        sock = _MALLOC(sizeof(cfs_socket_t), M_TEMP, M_WAITOK|M_ZERO);        if (!sock) {                CERROR("Can't allocate cfs_socket./n");                return -ENOMEM;        }        *sockp = sock;        sock->s_magic = CFS_SOCK_MAGIC;        rc = -sock_socket(PF_INET, SOCK_STREAM, 0,                           libcfs_sock_upcall, sock, &C2B_SOCK(sock));        if (rc != 0)                 goto out;        option = 1;        optlen = sizeof(option);        rc = -sock_setsockopt(C2B_SOCK(sock), SOL_SOCKET,                               SO_REUSEADDR, &option, optlen);        if (rc != 0)                goto out;        /* can't specify a local port without a local IP */        LASSERT (local_ip == 0 || local_port != 0);        if (local_ip != 0 || local_port != 0) {                bzero (&locaddr, sizeof (locaddr));                locaddr.sin_len = sizeof(struct sockaddr_in);                locaddr.sin_family = AF_INET;                locaddr.sin_port = htons (local_port);                locaddr.sin_addr.s_addr = (local_ip != 0) ? htonl(local_ip) : INADDR_ANY;                rc = -sock_bind(C2B_SOCK(sock), (struct sockaddr *)&locaddr);                if (rc == -EADDRINUSE) {                        CDEBUG(D_NET, "Port %d already in use/n", local_port);                        *fatal = 0;                        goto out;                }                if (rc != 0) {                        CERROR("Error trying to bind to port %d: %d/n",                               local_port, rc);                        goto out;                }        }        return 0;out:        if (C2B_SOCK(sock) != NULL)                 sock_close(C2B_SOCK(sock));        FREE(sock, M_TEMP);        return rc;}

static int setup_tcp(void){	struct sockaddr_in saddr = {};	mm_segment_t fs;	int buffersize = PAGE_SIZE;	int ret;	ret = sock_create_kern(AF_INET, SOCK_STREAM, IPPROTO_TCP, &server);	if (unlikely(ret < 0)) {		DBG("error creating socket");		return ret;	}	saddr.sin_family = AF_INET;	saddr.sin_port = htons(tcp_port);	saddr.sin_addr.s_addr = INADDR_ANY;	fs = get_fs();	set_fs(KERNEL_DS);	ret = sock_setsockopt(server, SOL_SOCKET, SO_SNDBUF,			(void *)&buffersize, sizeof(buffersize));	set_fs(fs);	if (unlikely(ret < 0)) {		DBG("error setting buffsize");		goto out_err;	}	ret = server->ops->bind(server, (struct sockaddr *)&saddr,				sizeof(saddr));	if (unlikely(ret < 0)) {		DBG("error binding socket");		goto out_err;	}	ret = server->ops->listen(server, 1);	if (unlikely(ret < 0)) {		DBG("error listening on socket");		goto out_err;	}	ret = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &client);	if (ret < 0) {		DBG("error creating accept socket");		goto out_err;	}out:	return ret;out_err:	server->ops->shutdown(server, 0);	server->ops->release(server);	goto out;}

static int compat_sock_setsockopt(struct socket *sock, int level, int optname,				char __user *optval, unsigned int optlen){	if (optname == SO_ATTACH_FILTER)		return do_set_attach_filter(sock, level, optname,					    optval, optlen);	if (optname == SO_RCVTIMEO || optname == SO_SNDTIMEO)		return do_set_sock_timeout(sock, level, optname, optval, optlen);	return sock_setsockopt(sock, level, optname, optval, optlen);}

int send(struct socket *sock, struct sockaddr_in *addr, void * data, int len){		struct msghdr msg;        struct iovec iov;        mm_segment_t oldfs;        int size = 0;	u_int32_t space;        if (sock->sk==NULL)           return 0;	int interface=1;	if(sock_setsockopt(sock,SOL_SOCKET,SO_BROADCAST,(char *)&interface,sizeof(interface))<0)		{		printk(KERN_WARNING "No Broadcast");		}        iov.iov_base = (char *) data;        iov.iov_len = len;	memset(&my_work->addr, 0, sizeof(struct sockaddr));        memset(&my_work->addr_send, 0, sizeof(struct sockaddr));        my_work->addr_send.sin_family = AF_INET;        //my_work->addr_send.sin_addr.s_addr = htonl(INADDR_SEND);        my_work->addr_send.sin_addr.s_addr = in_aton("255.255.255.255");	//sock->sk->sk_flags.SOCK_BROADCAST=1;        my_work->addr_send.sin_port = htons(CONNECT_PORT);	        msg.msg_flags = 0;        msg.msg_name = (void *) & my_work->addr_send;        msg.msg_namelen  = sizeof(struct sockaddr_in);        msg.msg_control = NULL;        msg.msg_controllen = 0;        msg.msg_iov = &iov;        msg.msg_iovlen = 1;        msg.msg_control = NULL;	if((space = sock_wspace(sock->sk))<len)	{		printk(KERN_INFO "ERROR");		return -ENOMEM;	}	sock_set_flag(my_work->sock_send,SOCK_BROADCAST); 	//sock->sk->broadcast=1;        oldfs = get_fs();        set_fs(KERNEL_DS);        size = sock_sendmsg(sock,&msg,len);	if(size<0)		printk(KERN_WARNING "ERROR SEND MSG:%d:",size);        set_fs(oldfs);//	printk(KERN_INFO MODULE_NAME":Message Sent from new program");	        return size;	}

static int inet_setsockopt(struct socket *sock, int level, int optname,		    char *optval, int optlen){  	struct sock *sk = (struct sock *) sock->data;  	if (level == SOL_SOCKET)		return sock_setsockopt(sk,level,optname,optval,optlen);	if (sk->prot->setsockopt==NULL)		return(-EOPNOTSUPP);	else		return sk->prot->setsockopt(sk,level,optname,optval,optlen);}

int sim_sock_setsockopt (struct SimSocket *socket, int level, int optname,			 const void *optval, int optlen){  struct socket *sock = (struct socket *)socket;  char *coptval = (char *)optval;  int err;  if (level == SOL_SOCKET)    err = sock_setsockopt(sock, level, optname, coptval, optlen);  else    err = sock->ops->setsockopt(sock, level, optname, coptval, optlen);  return err;}

static int _omni_sock_setsockopt(struct socket *sock, int level, int optname, char *optval, unsigned int optlen){	mm_segment_t oldfs = get_fs();	char __user *uoptval;	int err;	uoptval = (char __user __force *) optval;	set_fs(KERNEL_DS);	if (level == SOL_SOCKET)		err = sock_setsockopt(sock, level, optname, uoptval, optlen);	else		err = sock->ops->setsockopt(sock, level, optname, uoptval, optlen);	set_fs(oldfs);	return err;}

static int do_set_attach_filter(struct socket *sock, int level, int optname,				char __user *optval, unsigned int optlen){	struct compat_sock_fprog __user *fprog32 = (struct compat_sock_fprog __user *)optval;	struct sock_fprog __user *kfprog = compat_alloc_user_space(sizeof(struct sock_fprog));	compat_uptr_t ptr;	u16 len;	if (!access_ok(VERIFY_READ, fprog32, sizeof(*fprog32)) ||	    !access_ok(VERIFY_WRITE, kfprog, sizeof(struct sock_fprog)) ||	    __get_user(len, &fprog32->len) ||	    __get_user(ptr, &fprog32->filter) ||	    __put_user(len, &kfprog->len) ||	    __put_user(compat_ptr(ptr), &kfprog->filter))		return -EFAULT;	return sock_setsockopt(sock, level, optname, (char __user *)kfprog,			      sizeof(struct sock_fprog));}

static int do_set_sock_timeout(struct socket *sock, int level,		int optname, char __user *optval, unsigned int optlen){	struct compat_timeval __user *up = (struct compat_timeval __user *)optval;	struct timeval ktime;	mm_segment_t old_fs;	int err;	if (optlen < sizeof(*up))		return -EINVAL;	if (!access_ok(VERIFY_READ, up, sizeof(*up)) ||	    __get_user(ktime.tv_sec, &up->tv_sec) ||	    __get_user(ktime.tv_usec, &up->tv_usec))		return -EFAULT;	old_fs = get_fs();	set_fs(KERNEL_DS);	err = sock_setsockopt(sock, level, optname, (char *)&ktime, sizeof(ktime));	set_fs(old_fs);	return err;}

int setup_tcp() {	struct sockaddr_in saddr;	int r;		mm_segment_t fs;	int buffsize = PAGE_SIZE;#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,5)	r = sock_create_kern(AF_INET, SOCK_STREAM, IPPROTO_TCP, &control);#else	r = sock_create(AF_INET, SOCK_STREAM, IPPROTO_TCP, &control);#endif    	if (r < 0) {		DBG("Error creating control socket");		return r;	}		memset(&saddr, 0, sizeof(saddr));		saddr.sin_family = AF_INET;   	saddr.sin_port = htons(port);   	if (localhostonly) {   		saddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);   	} else {		saddr.sin_addr.s_addr = htonl(INADDR_ANY);   	}		fs = get_fs();	set_fs(KERNEL_DS);	sock_setsockopt(control, SOL_SOCKET, SO_SNDBUF, (void *) &buffsize, sizeof (int));	set_fs(fs);	if (r < 0) {		DBG("Error setting buffsize %d", r);		return r;	}	r = control->ops->bind(control,(struct sockaddr*) &saddr,sizeof(saddr));	if (r < 0) {		DBG("Error binding control socket");		return r;	}	r = control->ops->listen(control,1);	if (r) {		DBG("Error listening on socket");		return r;	}#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,5)	r = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &accept);#else	r = sock_create(PF_INET, SOCK_STREAM, IPPROTO_TCP, &accept);#endif    	if (r < 0) {		DBG("Error creating accept socket");		return r;	}	r = accept->ops->accept(control,accept,0);	if (r < 0) {		DBG("Error accepting socket");		return r;	}	return 0;}

intlibcfs_sock_read (cfs_socket_t *sock, void *buffer, int nob, int timeout){        size_t          rcvlen;        int             rc;        cfs_duration_t  to = cfs_time_seconds(timeout);        cfs_time_t      then;        struct timeval  tv;        LASSERT(nob > 0);        for (;;) {                struct iovec  iov = {                        .iov_base = buffer,                        .iov_len  = nob                };                struct  msghdr  msg = {                        .msg_name       = NULL,                        .msg_namelen    = 0,                        .msg_iov        = &iov,                        .msg_iovlen     = 1,                        .msg_control    = NULL,                        .msg_controllen = 0,                        .msg_flags      = 0,                };                cfs_duration_usec(to, &tv);                rc = -sock_setsockopt(C2B_SOCK(sock), SOL_SOCKET, SO_RCVTIMEO,                                      &tv, sizeof(tv));                if (rc != 0) {                        CERROR("Can't set socket recv timeout "                                        "%ld.%06d: %d/n",                                        (long)tv.tv_sec, (int)tv.tv_usec, rc);                        return rc;                }                then = cfs_time_current();                rc = -sock_receive(C2B_SOCK(sock), &msg, 0, &rcvlen);                to -= cfs_time_current() - then;                if (rc != 0 && rc != -EWOULDBLOCK)                        return rc;                if (rcvlen == nob)                        return 0;                if (to <= 0)                        return -EAGAIN;                buffer = ((char *)buffer) + rcvlen;                nob -= rcvlen;        }        return 0;}intlibcfs_sock_write (cfs_socket_t *sock, void *buffer, int nob, int timeout){        size_t          sndlen;        int             rc;        cfs_duration_t  to = cfs_time_seconds(timeout);        cfs_time_t      then;        struct timeval  tv;        LASSERT(nob > 0);        for (;;) {                struct iovec  iov = {                        .iov_base = buffer,                        .iov_len  = nob                };                struct  msghdr  msg = {                        .msg_name       = NULL,                        .msg_namelen    = 0,                        .msg_iov        = &iov,                        .msg_iovlen     = 1,                        .msg_control    = NULL,                        .msg_controllen = 0,                        .msg_flags      = (timeout == 0) ? MSG_DONTWAIT : 0,                };                if (timeout != 0) {                        cfs_duration_usec(to, &tv);                        rc = -sock_setsockopt(C2B_SOCK(sock), SOL_SOCKET, SO_SNDTIMEO,                                              &tv, sizeof(tv));                        if (rc != 0) {                                CERROR("Can't set socket send timeout "                                       "%ld.%06d: %d/n",                                       (long)tv.tv_sec, (int)tv.tv_usec, rc);                                return rc;                        }                }                then = cfs_time_current();                rc = -sock_send(C2B_SOCK(sock), &msg,                                 ((timeout == 0) ? MSG_DONTWAIT : 0), &sndlen);                to -= cfs_time_current() - then;                if (rc != 0 && rc != -EWOULDBLOCK)                        return rc;                if (sndlen == nob)                        return 0;//.........这里部分代码省略.........

int xi_lpx_connect(xi_socket_t *oso, struct sockaddr_lpx daddr, struct sockaddr_lpx saddr, int timeoutsec){    xi_socket_t so = NULL;	errno_t	error;	struct timeval timeout;#ifndef __KPI_SOCKET__	struct sockopt sopt;	boolean_t funnel_state;#endif		*oso = NULL;		error = xi_sock_socket(AF_LPX, SOCK_STREAM, 0, NULL, NULL, &so);	if(error) {		DebugPrint(1, false, "socreate error %d/n", error);        goto bad;	}	error = xi_sock_bind(so, (struct sockaddr *) &saddr);		if(error) {		DebugPrint(1, false, "xi_lpx_connect: sobind error/n");		goto bad;	}#if 0    DebugPrint(4, false, "xi_lpx_connect to ");    for(i=0; i<6; i++)        DebugPrint(4, false, "02x ", daddr.slpx_node[i]);#endif	    error = xi_sock_connect(so, (struct sockaddr *)&daddr, 0);    if(error) {        DebugPrint(4, false, "soconnect error %d/n", error);        goto bad;    }		#ifndef __KPI_SOCKET__	do {//		struct sockaddr_lpx sin;		int s;				funnel_state = thread_funnel_set(network_flock, TRUE);				s = splnet();		while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {			//        IOLog("before sleep/n");			(void) tsleep((caddr_t)&so->so_timeo, PSOCK | PCATCH, "xiscsicon", 0);			//        IOLog("after sleep/n");			break;		}		//    IOLog("so->so_error = %d/n", so->so_error);		if (so->so_error) {			error = so->so_error;			so->so_error = 0;			splx(s);			goto bad;		}		splx(s);				(void) thread_funnel_set(network_flock, FALSE);			} while(0);#endif // __KPI_SOCKET__		*oso = so;	// Set Read Timeout.	timeout.tv_sec = timeoutsec;	timeout.tv_usec = 0;	#ifdef __KPI_SOCKET__	error = sock_setsockopt(							so,							SOL_SOCKET,							SO_RCVTIMEO,							&timeout,							sizeof(struct timeval)							); #else 	sopt.sopt_dir = SOPT_SET;	sopt.sopt_level = SOL_SOCKET;	sopt.sopt_name = SO_RCVTIMEO;	sopt.sopt_val = &timeout;	sopt.sopt_valsize = sizeof(struct timeval);	sopt.sopt_p = current_proc();		funnel_state = thread_funnel_set(network_flock, TRUE);		error = sosetopt(so, &sopt);	(void) thread_funnel_set(network_flock, FALSE);#endif	if(error) {        DebugPrint(1, false, "xi_lpx_connect: Can't set Receive Time out. error %d/n", error);				goto bad;		}		//.........这里部分代码省略.........

/* * Do a remote procedure call (RPC) and wait for its reply. * If from_p is non-null, then we are doing broadcast, and * the address from whence the response came is saved there. */intkrpc_call(	struct sockaddr_in *sa,	u_int sotype, u_int prog, u_int vers, u_int func,	mbuf_t *data,			/* input/output */	struct sockaddr_in *from_p)	/* output */{	socket_t so;	struct sockaddr_in *sin;	mbuf_t m, nam, mhead;	struct rpc_call *call;	struct rpc_reply *reply;	int error, timo, secs;	size_t len;	static u_int32_t xid = ~0xFF;	u_int16_t tport;	size_t maxpacket = 1<<16;	/*	 * Validate address family.	 * Sorry, this is INET specific...	 */	if (sa->sin_family != AF_INET)		return (EAFNOSUPPORT);	/* Free at end if not null. */	nam = mhead = NULL;	/*	 * Create socket and set its recieve timeout.	 */	if ((error = sock_socket(AF_INET, sotype, 0, 0, 0, &so)))		goto out1;	{		struct timeval tv;		tv.tv_sec = 1;		tv.tv_usec = 0;		if ((error = sock_setsockopt(so, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv))))		    goto out;	}	/*	 * Enable broadcast if necessary.	 */	if (from_p && (sotype == SOCK_DGRAM)) {		int on = 1;		if ((error = sock_setsockopt(so, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on))))			goto out;	}	/*	 * Bind the local endpoint to a reserved port,	 * because some NFS servers refuse requests from	 * non-reserved (non-privileged) ports.	 */	if ((error = mbuf_get(MBUF_WAITOK, MBUF_TYPE_SONAME, &m)))		goto out;	sin = mbuf_data(m);	bzero(sin, sizeof(*sin));	mbuf_setlen(m, sizeof(*sin));	sin->sin_len = sizeof(*sin);	sin->sin_family = AF_INET;	sin->sin_addr.s_addr = INADDR_ANY;	tport = IPPORT_RESERVED;	do {		tport--;		sin->sin_port = htons(tport);		error = sock_bind(so, (struct sockaddr*)sin);	} while (error == EADDRINUSE &&			 tport > IPPORT_RESERVED / 2);	mbuf_freem(m);	m = NULL;	if (error) {		printf("bind failed/n");		goto out;	}	/*	 * Setup socket address for the server.	 */	if ((error = mbuf_get(MBUF_WAITOK, MBUF_TYPE_SONAME, &nam)))		goto out;	sin = mbuf_data(nam);	mbuf_setlen(nam, sa->sin_len);	bcopy((caddr_t)sa, (caddr_t)sin, sa->sin_len);	if (sotype == SOCK_STREAM) {		struct timeval tv;		tv.tv_sec = 60;		tv.tv_usec = 0;//.........这里部分代码省略.........

//.........这里部分代码省略.........                CHECK_GROUP_ACCES(so->id, tmp.gid, "group computation");                if (copy_from_user(&psize, tmp.prog, sizeof(size_t)))                        return -EFAULT;                pr_devel("[PFQ|%d] computation size: %zu/n", so->id, psize);                ucsize = sizeof(size_t) * 2 + psize * sizeof(struct pfq_functional_descr);                descr = kmalloc(ucsize, GFP_KERNEL);                if (descr == NULL) {                        pr_devel("[PFQ|%d] computation: out of memory!/n", so->id);                        return -ENOMEM;                }                if (copy_from_user(descr, tmp.prog, ucsize)) {                        pr_devel("[PFQ|%d] computation: copy_from_user error!/n", so->id);                        kfree(descr);                        return -EFAULT;                }                /* print user computation */                pr_devel_computation_descr(descr);		/* ensure the correctness of the specified functional computation */		if (pfq_validate_computation_descr(descr) < 0) {                        pr_devel("[PFQ|%d] invalid expression!/n", so->id);                        return -EFAULT;		}                /* allocate context */                context = pfq_context_alloc(descr);                if (context == NULL) {                        pr_devel("[PFQ|%d] context: alloc error!/n", so->id);                        kfree(descr);                        return -EFAULT;                }                /* allocate struct pfq_computation_tree */                comp = pfq_computation_alloc(descr);                if (comp == NULL) {                        pr_devel("[PFQ|%d] computation: alloc error!/n", so->id);                        kfree(context);                        kfree(descr);                        return -EFAULT;                }                /* link the functional computation */                if (pfq_computation_rtlink(descr, comp, context) < 0) {                        pr_devel("[PFQ|%d] computation aborted!", so->id);			kfree(context);			kfree(descr);			kfree(comp);                        return -EPERM;                }		/* print executable tree data structure */		pr_devel_computation_tree(comp);		/* exec init functions */		if (pfq_computation_init(comp) < 0) {                        pr_devel("[PFQ|%d] computation initialization aborted!", so->id);                        kfree(context);                        kfree(descr);                        kfree(comp);                        return -EPERM;		}                /* set the new program */                if (pfq_set_group_prog(tmp.gid, comp, context) < 0) {                        pr_devel("[PFQ|%d] set group program error!/n", so->id);                        kfree(context);                        kfree(descr);                        kfree(comp);                        return -EPERM;                }		kfree(descr);                return 0;        } break;        default:        {                found = false;        } break;        }        return found ? 0 : sock_setsockopt(sock, level, optname, optval, optlen);}

//.........这里部分代码省略.........			return -EACCES;		}                if (copy_from_user(&psize, tmp.prog, sizeof(size_t)))                        return -EFAULT;                pr_devel("[PFQ|%d] computation size: %zu/n", so->id.value, psize);                ucsize = sizeof(size_t) * 2 + psize * sizeof(struct pfq_functional_descr);                descr = kmalloc(ucsize, GFP_KERNEL);                if (descr == NULL) {                        printk(KERN_INFO "[PFQ|%d] computation: out of memory!/n", so->id.value);                        return -ENOMEM;                }                if (copy_from_user(descr, tmp.prog, ucsize)) {                        printk(KERN_INFO "[PFQ|%d] computation: copy_from_user error!/n", so->id.value);                        err = -EFAULT;                        goto error;                }                /* print user computation */                pr_devel_computation_descr(descr);		/* check the correctness of computation */		if (pfq_check_computation_descr(descr) < 0) {                        printk(KERN_INFO "[PFQ|%d] invalid expression!/n", so->id.value);                        err = -EFAULT;                        goto error;		}                /* allocate context */                context = pfq_context_alloc(descr);                if (context == NULL) {                        printk(KERN_INFO "[PFQ|%d] context: alloc error!/n", so->id.value);                        err = -EFAULT;                        goto error;                }                /* allocate a pfq_computation_tree */                comp = pfq_computation_alloc(descr);                if (comp == NULL) {                        printk(KERN_INFO "[PFQ|%d] computation: alloc error!/n", so->id.value);                        err = -EFAULT;                        goto error;                }                /* link functions of computation */                if (pfq_computation_rtlink(descr, comp, context) < 0) {                        printk(KERN_INFO "[PFQ|%d] computation aborted!", so->id.value);                        err = -EPERM;                        goto error;                }		/* print executable tree data structure */		pr_devel_computation_tree(comp);		/* run init functions */		if (pfq_computation_init(comp) < 0) {                        printk(KERN_INFO "[PFQ|%d] initialization of computation aborted!", so->id.value);                        pfq_computation_fini(comp);                        err = -EPERM;                        goto error;		}                /* enable functional program */                if (pfq_set_group_prog(gid, comp, context) < 0) {                        printk(KERN_INFO "[PFQ|%d] set group program error!/n", so->id.value);                        err = -EPERM;                        goto error;                }		kfree(descr);                return 0;	error:  kfree(comp);		kfree(context);		kfree(descr);		return err;        } break;        default:        {                found = false;        } break;        }        return found ? 0 : sock_setsockopt(sock, level, optname, optval, optlen);}

//.........这里部分代码省略.........				    get_fs_long(args+2)));	case SYS_LISTEN:		er=verify_area(VERIFY_READ, args, 2 * sizeof(long));		if(er)			return er;		return(sock_listen(get_fs_long(args+0),				   get_fs_long(args+1)));	case SYS_ACCEPT:		er=verify_area(VERIFY_READ, args, 3 * sizeof(long));		if(er)			return er;		return(sock_accept(get_fs_long(args+0),				   (struct sockaddr *)get_fs_long(args+1),				   (int *)get_fs_long(args+2)));	case SYS_GETSOCKNAME:		er=verify_area(VERIFY_READ, args, 3 * sizeof(long));		if(er)			return er;		return(sock_getsockname(get_fs_long(args+0),					(struct sockaddr *)get_fs_long(args+1),					(int *)get_fs_long(args+2)));	case SYS_GETPEERNAME:		er=verify_area(VERIFY_READ, args, 3 * sizeof(long));		if(er)			return er;		return(sock_getpeername(get_fs_long(args+0),					(struct sockaddr *)get_fs_long(args+1),					(int *)get_fs_long(args+2)));	case SYS_SOCKETPAIR:		er=verify_area(VERIFY_READ, args, 4 * sizeof(long));		if(er)			return er;		return(sock_socketpair(get_fs_long(args+0),				       get_fs_long(args+1),				       get_fs_long(args+2),				       (unsigned long *)get_fs_long(args+3)));	case SYS_SEND:		er=verify_area(VERIFY_READ, args, 4 * sizeof(unsigned long));		if(er)			return er;		return(sock_send(get_fs_long(args+0),				 (void *)get_fs_long(args+1),				 get_fs_long(args+2),				 get_fs_long(args+3)));	case SYS_SENDTO:		er=verify_area(VERIFY_READ, args, 6 * sizeof(unsigned long));		if(er)			return er;		return(sock_sendto(get_fs_long(args+0),				   (void *)get_fs_long(args+1),				   get_fs_long(args+2),				   get_fs_long(args+3),				   (struct sockaddr *)get_fs_long(args+4),				   get_fs_long(args+5)));	case SYS_RECV:		er=verify_area(VERIFY_READ, args, 4 * sizeof(unsigned long));		if(er)			return er;		return(sock_recv(get_fs_long(args+0),				 (void *)get_fs_long(args+1),				 get_fs_long(args+2),				 get_fs_long(args+3)));	case SYS_RECVFROM:		er=verify_area(VERIFY_READ, args, 6 * sizeof(unsigned long));		if(er)			return er;		return(sock_recvfrom(get_fs_long(args+0),				     (void *)get_fs_long(args+1),				     get_fs_long(args+2),				     get_fs_long(args+3),				     (struct sockaddr *)get_fs_long(args+4),				     (int *)get_fs_long(args+5)));	case SYS_SHUTDOWN:		er=verify_area(VERIFY_READ, args, 2* sizeof(unsigned long));		if(er)			return er;		return(sock_shutdown(get_fs_long(args+0),				     get_fs_long(args+1)));	case SYS_SETSOCKOPT:		er=verify_area(VERIFY_READ, args, 5*sizeof(unsigned long));		if(er)			return er;		return(sock_setsockopt(get_fs_long(args+0),				       get_fs_long(args+1),				       get_fs_long(args+2),				       (char *)get_fs_long(args+3),				       get_fs_long(args+4)));	case SYS_GETSOCKOPT:		er=verify_area(VERIFY_READ, args, 5*sizeof(unsigned long));		if(er)			return er;		return(sock_getsockopt(get_fs_long(args+0),				       get_fs_long(args+1),				       get_fs_long(args+2),				       (char *)get_fs_long(args+3),				       (int *)get_fs_long(args+4)));	default:		return(-EINVAL);  }}

//.........这里部分代码省略.........                *txmem = *rxmem = *nagle = 0;                return (-ESHUTDOWN);        }        rc = libcfs_sock_getbuf(conn->ksnc_sock, txmem, rxmem);        if (rc == 0) {                len = sizeof(*nagle);                rc = -sock_getsockopt(sock, IPPROTO_TCP, TCP_NODELAY,                                      nagle, &len);        }        ksocknal_connsock_decref(conn);        if (rc == 0)                *nagle = !*nagle;        else                *txmem = *rxmem = *nagle = 0;        return (rc);}intksocknal_lib_setup_sock (cfs_socket_t *sock){        int             rc;         int             option;         int             keep_idle;         int             keep_intvl;         int             keep_count;         int             do_keepalive;         socket_t        so = C2B_SOCK(sock);        struct linger   linger;        /* Ensure this socket aborts active sends immediately when we close         * it. */        linger.l_onoff = 0;        linger.l_linger = 0;        rc = -sock_setsockopt(so, SOL_SOCKET, SO_LINGER, &linger, sizeof(linger));        if (rc != 0) {                CERROR ("Can't set SO_LINGER: %d/n", rc);                return (rc);        }        if (!*ksocknal_tunables.ksnd_nagle) {                 option = 1;                 rc = -sock_setsockopt(so, IPPROTO_TCP, TCP_NODELAY, &option, sizeof(option));                if (rc != 0) {                         CERROR ("Can't disable nagle: %d/n", rc);                         return (rc);                }         }         rc = libcfs_sock_setbuf(sock,                                *ksocknal_tunables.ksnd_tx_buffer_size,                                *ksocknal_tunables.ksnd_rx_buffer_size);        if (rc != 0) {                CERROR ("Can't set buffer tx %d, rx %d buffers: %d/n",                        *ksocknal_tunables.ksnd_tx_buffer_size,                        *ksocknal_tunables.ksnd_rx_buffer_size, rc);                return (rc);        }        /* snapshot tunables */         keep_idle  = *ksocknal_tunables.ksnd_keepalive_idle;         keep_count = *ksocknal_tunables.ksnd_keepalive_count;         keep_intvl = *ksocknal_tunables.ksnd_keepalive_intvl;        do_keepalive = (keep_idle > 0 && keep_count > 0 && keep_intvl > 0);         option = (do_keepalive ? 1 : 0);         rc = -sock_setsockopt(so, SOL_SOCKET, SO_KEEPALIVE, &option, sizeof(option));         if (rc != 0) {                 CERROR ("Can't set SO_KEEPALIVE: %d/n", rc);                 return (rc);        }                if (!do_keepalive)                return (rc);        rc = -sock_setsockopt(so, IPPROTO_TCP, TCP_KEEPALIVE,                               &keep_idle, sizeof(keep_idle));                return (rc);}voidksocknal_lib_push_conn(ksock_conn_t *conn){         socket_t        sock;         int             val = 1;         int             rc;                 rc = ksocknal_connsock_addref(conn);         if (rc != 0)            /* being shut down */                 return;         sock = C2B_SOCK(conn->ksnc_sock);         rc = -sock_setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val));         LASSERT(rc == 0);        ksocknal_connsock_decref(conn);        return;}

//.........这里部分代码省略.........           if(socket_satelite_data[cmd->ringset_idx].socket) {               if(!socket_satelite_data[cmd->ringset_idx].socket->buffers_available_notification_queue_present) {                   TAILQ_INSERT_TAIL(&buffers_available_notification_socket_list_head,socket_satelite_data[cmd->ringset_idx].socket,buffers_available_notification_queue_entry);                   socket_satelite_data[cmd->ringset_idx].socket->buffers_available_notification_queue_present = 1;		   if(socket_satelite_data[cmd->ringset_idx].socket->type == SOCK_DGRAM)		   	user_set_socket_tx_space(&g_ipaugenblick_sockets[socket_satelite_data[cmd->ringset_idx].ringset_idx].tx_space,sk_stream_wspace(socket_satelite_data[cmd->ringset_idx].socket->sk));               }           }           break;	case IPAUGENBLICK_ROUTE_ADD_COMMAND:   	   memset((void *)&rtentry,0,sizeof(rtentry));	   rtentry.rt_metric = cmd->u.route.metric;	   rtentry.rt_flags = RTF_UP|RTF_GATEWAY;	   p_sockaddr = (struct sockaddr_in *)&rtentry.rt_dst;	   p_sockaddr->sin_family = AF_INET;           p_sockaddr->sin_addr.s_addr = cmd->u.route.dest_ipaddr;	   p_sockaddr = (struct sockaddr_in *)&rtentry.rt_gateway;	   p_sockaddr->sin_family = AF_INET;           p_sockaddr->sin_addr.s_addr = cmd->u.route.next_hop;	   p_sockaddr = (struct sockaddr_in *)&rtentry.rt_genmask;	   p_sockaddr->sin_family = AF_INET;           p_sockaddr->sin_addr.s_addr = cmd->u.route.dest_mask;	   if(ip_rt_ioctl(&init_net,SIOCADDRT,&rtentry)) {		ipaugenblick_log(IPAUGENBLICK_LOG_ERR,"CANNOT ADD ROUTE ENTRY %x %x %x/n",			((struct sockaddr_in *)&rtentry.rt_dst)->sin_addr.s_addr,			((struct sockaddr_in *)&rtentry.rt_gateway)->sin_addr.s_addr,			((struct sockaddr_in *)&rtentry.rt_genmask)->sin_addr.s_addr);	   }	   else {		ipaugenblick_log(IPAUGENBLICK_LOG_INFO,"ROUTE ENTRY %x %x %x is added/n",			((struct sockaddr_in *)&rtentry.rt_dst)->sin_addr.s_addr,			((struct sockaddr_in *)&rtentry.rt_gateway)->sin_addr.s_addr,			((struct sockaddr_in *)&rtentry.rt_genmask)->sin_addr.s_addr);	   }	   break;    	case IPAUGENBLICK_ROUTE_DEL_COMMAND:	   memset((void *)&rtentry,0,sizeof(rtentry));	   p_sockaddr = (struct sockaddr_in *)&rtentry.rt_dst;	   p_sockaddr->sin_family = AF_INET;           p_sockaddr->sin_addr.s_addr = cmd->u.route.dest_ipaddr;	   p_sockaddr = (struct sockaddr_in *)&rtentry.rt_gateway;	   p_sockaddr->sin_family = AF_INET;           p_sockaddr->sin_addr.s_addr = cmd->u.route.next_hop;	   p_sockaddr = (struct sockaddr_in *)&rtentry.rt_genmask;	   p_sockaddr->sin_family = AF_INET;           p_sockaddr->sin_addr.s_addr = cmd->u.route.dest_mask;	   if(ip_rt_ioctl(&init_net,SIOCDELRT,&rtentry)) {		ipaugenblick_log(IPAUGENBLICK_LOG_ERR,"CANNOT DELETE ROUTE ENTRY %x %x %x/n",			((struct sockaddr_in *)&rtentry.rt_dst)->sin_addr.s_addr,			((struct sockaddr_in *)&rtentry.rt_gateway)->sin_addr.s_addr,			((struct sockaddr_in *)&rtentry.rt_genmask)->sin_addr.s_addr);	   }	   else {		ipaugenblick_log(IPAUGENBLICK_LOG_INFO,"ROUTE ENTRY %x %x %x is deleted/n",			((struct sockaddr_in *)&rtentry.rt_dst)->sin_addr.s_addr,			((struct sockaddr_in *)&rtentry.rt_gateway)->sin_addr.s_addr,			((struct sockaddr_in *)&rtentry.rt_genmask)->sin_addr.s_addr);	   }	   break;	case IPAUGENBLICK_CONNECT_CLIENT:	   if(cmd->ringset_idx >= IPAUGENBLICK_CLIENTS_POOL_SIZE) {		break;	   }	   if(!ipaugenblick_clients[cmd->ringset_idx].is_busy) {	   	TAILQ_INSERT_TAIL(&ipaugenblick_clients_list_head,&ipaugenblick_clients[cmd->ringset_idx],queue_entry);		ipaugenblick_clients[cmd->ringset_idx].is_busy = 1;		on_client_connect(cmd->ringset_idx);	   }	   break;	case IPAUGENBLICK_DISCONNECT_CLIENT:	   if(cmd->ringset_idx >= IPAUGENBLICK_CLIENTS_POOL_SIZE) {		break;	   }	   if(ipaugenblick_clients[cmd->ringset_idx].is_busy) {	   	TAILQ_REMOVE(&ipaugenblick_clients_list_head,&ipaugenblick_clients[cmd->ringset_idx],queue_entry);		ipaugenblick_clients[cmd->ringset_idx].is_busy = 0;	   }	   break;	case IPAUGENBLICK_SETSOCKOPT_COMMAND:	   if(socket_satelite_data[cmd->ringset_idx].socket) { 	   	sock_setsockopt(socket_satelite_data[cmd->ringset_idx].socket, cmd->u.setsockopt.level, cmd->u.setsockopt.optname, cmd->u.setsockopt.optval, cmd->u.setsockopt.optlen);	   }	   break;	case IPAUGENBLICK_SOCKET_SHUTDOWN_COMMAND:	   if(socket_satelite_data[cmd->ringset_idx].socket) {		inet_shutdown(socket_satelite_data[cmd->ringset_idx].socket, cmd->u.socket_shutdown.how);		user_sockets_shutdown++;	   }	   break;	case IPAUGENBLICK_SOCKET_DECLINE_COMMAND:	   user_flush_rx_tx((struct socket *)cmd->u.socket_decline.socket_descr);	   app_glue_close_socket((struct socket *)cmd->u.socket_decline.socket_descr);	   user_sockets_closed++;	   break;        default:           ipaugenblick_log(IPAUGENBLICK_LOG_ERR,"unknown cmd %d/n",cmd->cmd);           break;    }    ipaugenblick_free_command_buf(cmd);}

//.........这里部分代码省略.........			return -EACCES;		}                if (copy_from_user(&psize, tmp.prog, sizeof(size_t)))                        return -EFAULT;                pr_devel("[PFQ|%d] computation size: %zu/n", so->id, psize);                ucsize = sizeof(size_t) * 2 + psize * sizeof(struct pfq_lang_functional_descr);                descr = kmalloc(ucsize, GFP_KERNEL);                if (descr == NULL) {                        printk(KERN_INFO "[PFQ|%d] computation: out of memory!/n", so->id);                        return -ENOMEM;                }                if (copy_from_user(descr, tmp.prog, ucsize)) {                        printk(KERN_INFO "[PFQ|%d] computation: copy_from_user error!/n", so->id);                        err = -EFAULT;                        goto error;                }                /* print user computation */                pr_devel_computation_descr(descr);		/* check the correctness of computation */		if (pfq_lang_check_computation_descr(descr) < 0) {                        printk(KERN_INFO "[PFQ|%d] invalid expression!/n", so->id);                        err = -EFAULT;                        goto error;		}                /* allocate context */                context = pfq_lang_context_alloc(descr);                if (context == NULL) {                        printk(KERN_INFO "[PFQ|%d] context: alloc error!/n", so->id);                        err = -EFAULT;                        goto error;                }                /* allocate a pfq_lang_computation_tree */                comp = pfq_lang_computation_alloc(descr);                if (comp == NULL) {                        printk(KERN_INFO "[PFQ|%d] computation: alloc error!/n", so->id);                        err = -EFAULT;                        goto error;                }                /* link functions of computation */                if (pfq_lang_computation_rtlink(descr, comp, context) < 0) {                        printk(KERN_INFO "[PFQ|%d] computation aborted!", so->id);                        err = -EPERM;                        goto error;                }		/* print executable tree data structure */		pr_devel_computation_tree(comp);		/* run init functions */		if (pfq_lang_computation_init(comp) < 0) {                        printk(KERN_INFO "[PFQ|%d] initialization of computation aborted!", so->id);                        pfq_lang_computation_destruct(comp);                        err = -EPERM;                        goto error;		}                /* enable functional program */                if (pfq_set_group_prog(gid, comp, context) < 0) {                        printk(KERN_INFO "[PFQ|%d] set group program error!/n", so->id);                        err = -EPERM;                        goto error;                }		kfree(descr);                return 0;	error:  kfree(comp);		kfree(context);		kfree(descr);		return err;        } break;        default:        {                found = false;        } break;        }        return found ? 0 : sock_setsockopt(sock, level, optname, optval, optlen);}

intksocknal_lib_setup_sock (struct socket *sock){	mm_segment_t    oldmm = get_fs ();	int	     rc;	int	     option;	int	     keep_idle;	int	     keep_intvl;	int	     keep_count;	int	     do_keepalive;	struct linger   linger;	sock->sk->sk_allocation = GFP_NOFS;	/* Ensure this socket aborts active sends immediately when we close	 * it. */	linger.l_onoff = 0;	linger.l_linger = 0;	set_fs (KERNEL_DS);	rc = sock_setsockopt (sock, SOL_SOCKET, SO_LINGER,			      (char *)&linger, sizeof (linger));	set_fs (oldmm);	if (rc != 0) {		CERROR ("Can't set SO_LINGER: %d/n", rc);		return (rc);	}	option = -1;	set_fs (KERNEL_DS);	rc = sock->ops->setsockopt (sock, SOL_TCP, TCP_LINGER2,				    (char *)&option, sizeof (option));	set_fs (oldmm);	if (rc != 0) {		CERROR ("Can't set SO_LINGER2: %d/n", rc);		return (rc);	}	if (!*ksocknal_tunables.ksnd_nagle) {		option = 1;		set_fs (KERNEL_DS);		rc = sock->ops->setsockopt (sock, SOL_TCP, TCP_NODELAY,					    (char *)&option, sizeof (option));		set_fs (oldmm);		if (rc != 0) {			CERROR ("Can't disable nagle: %d/n", rc);			return (rc);		}	}	rc = libcfs_sock_setbuf(sock,				*ksocknal_tunables.ksnd_tx_buffer_size,				*ksocknal_tunables.ksnd_rx_buffer_size);	if (rc != 0) {		CERROR ("Can't set buffer tx %d, rx %d buffers: %d/n",			*ksocknal_tunables.ksnd_tx_buffer_size,			*ksocknal_tunables.ksnd_rx_buffer_size, rc);		return (rc);	}/* TCP_BACKOFF_* sockopt tunables unsupported in stock kernels */	/* snapshot tunables */	keep_idle  = *ksocknal_tunables.ksnd_keepalive_idle;	keep_count = *ksocknal_tunables.ksnd_keepalive_count;	keep_intvl = *ksocknal_tunables.ksnd_keepalive_intvl;	do_keepalive = (keep_idle > 0 && keep_count > 0 && keep_intvl > 0);	option = (do_keepalive ? 1 : 0);	set_fs (KERNEL_DS);	rc = sock_setsockopt (sock, SOL_SOCKET, SO_KEEPALIVE,			      (char *)&option, sizeof (option));	set_fs (oldmm);	if (rc != 0) {		CERROR ("Can't set SO_KEEPALIVE: %d/n", rc);		return (rc);	}	if (!do_keepalive)		return (0);	set_fs (KERNEL_DS);	rc = sock->ops->setsockopt (sock, SOL_TCP, TCP_KEEPIDLE,				    (char *)&keep_idle, sizeof (keep_idle));	set_fs (oldmm);	if (rc != 0) {		CERROR ("Can't set TCP_KEEPIDLE: %d/n", rc);		return (rc);	}	set_fs (KERNEL_DS);	rc = sock->ops->setsockopt (sock, SOL_TCP, TCP_KEEPINTVL,				    (char *)&keep_intvl, sizeof (keep_intvl));	set_fs (oldmm);	if (rc != 0) {		CERROR ("Can't set TCP_KEEPINTVL: %d/n", rc);		return (rc);//.........这里部分代码省略.........

//.........这里部分代码省略.........        switch (a->ai_family) {            case AF_INET: {                inet_inet_ntop(a->ai_family, &((sockaddr_in*)a->ai_addr)->sin_addr, serverHost, sizeof(serverHost));                serverPort = ntohs(((sockaddr_in*)a->ai_addr)->sin_port);                break;            }            case AF_INET6: {                inet_inet_ntop(a->ai_family, &((sockaddr_in6*)a->ai_addr)->sin6_addr, serverHost, sizeof(serverHost));                serverPort = ntohs(((sockaddr_in6*)a->ai_addr)->sin6_port);                break;            }        }        LOG(INFO, "Cloud socket=%d, connecting to %s#%u", s, serverHost, serverPort);        /* We are using fixed source port only for IPv6 connections */        if (protocol == IPPROTO_UDP && a->ai_family == AF_INET6) {            struct sockaddr_storage saddr = {};            saddr.s2_len = sizeof(saddr);            saddr.ss_family = a->ai_family;            /* NOTE: Always binding to 5684 by default */            switch (a->ai_family) {                case AF_INET: {                    ((sockaddr_in*)&saddr)->sin_port = htons(PORT_COAPS);                    break;                }                case AF_INET6: {                    ((sockaddr_in6*)&saddr)->sin6_port = htons(PORT_COAPS);                    break;                }            }            const int one = 1;            if (sock_setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one))) {                LOG(ERROR, "Cloud socket=%d, failed to set SO_REUSEADDR, errno=%d", s, errno);                sock_close(s);                continue;            }            /* Bind socket */            if (sock_bind(s, (const struct sockaddr*)&saddr, sizeof(saddr))) {                LOG(ERROR, "Cloud socket=%d, failed to bind, errno=%d");                sock_close(s);                continue;            }        }        /* FIXME: timeout for TCP */        /* NOTE: we do this for UDP sockets as well in order to automagically filter         * on source address and port */        r = sock_connect(s, a->ai_addr, a->ai_addrlen);        if (r) {            LOG(ERROR, "Cloud socket=%d, failed to connect to %s#%u, errno=%d", s, serverHost, serverPort, errno);            sock_close(s);            continue;        }        LOG(TRACE, "Cloud socket=%d, connected to %s#%u", s, serverHost, serverPort);        /* If we got here, we are most likely connected, however keep track of current addrinfo list         * in order to try the next address if application layer fails to establish the connection         */        if (protocol == IPPROTO_UDP &&            (type == CLOUD_SERVER_ADDRESS_TYPE_NEW_ADDRINFO ||             type == CLOUD_SERVER_ADDRESS_TYPE_CACHED_ADDRINFO)) {            if (s_state.addr) {                /* We are already iterating over a cached addrinfo list */