drivers/qtn/wlan/ieee80211_qfdr.c - kernel/quantenna - Git at Google

 /*-
  * Copyright (c) 2015 Quantenna Communications, Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * $Id: ieee80211_qfdr.c 2759 2015-12-20 10:48:20Z Jason $
  */
 #ifndef EXPORT_SYMTAB
 #define	EXPORT_SYMTAB
 #endif

 /*
  * IEEE 802.11 sync scan result for Quantenna QFDR.
  */
 #ifndef AUTOCONF_INCLUDED
 #include <linux/config.h>
 #endif
 #include <linux/version.h>
 #include <linux/module.h>
 #include <linux/skbuff.h>
 #include <linux/netdevice.h>
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/in.h>
 #include <linux/workqueue.h>
 #include <linux/kthread.h>
 #include <net/sock.h>

 #include "net80211/if_media.h"

 #include "net80211/ieee80211_var.h"

 #define QFDR_REP_TIMEOUT   (2 * HZ)
 #define QFDR_REQ_MAX_SIZE  512

 static char *local_ip = "0.0.0.0";
 module_param(local_ip, charp, S_IRUGO);
 MODULE_PARM_DESC(local_ip, "qfdr local ip");

 static char *remote_ip = "0.0.0.0";
 module_param(remote_ip, charp, S_IRUGO);
 MODULE_PARM_DESC(remote_ip, "qfdr remote ip");

 static unsigned short req_port = 0;
 module_param(req_port, ushort, S_IRUGO);
 MODULE_PARM_DESC(req_port, "qfdr port to recv req");

 static unsigned short rep_port = 0;
 module_param(rep_port, ushort, S_IRUGO);
 MODULE_PARM_DESC(rep_port, "qfdr port to recv rep");

 static struct socket *sock_send;
 static struct socket *sock_recv_req;
 static struct socket *sock_recv_rep;
 static struct sockaddr_in sin_req;
 static struct sockaddr_in sin_rep;

 static struct task_struct *thread_recv_req;
 static struct completion comp_recv_req_thread;

 static struct socket * qfdr_create_recv_socket(unsigned int addr, unsigned short port)
 {
 	struct sockaddr_in sin_bind;
 	struct socket *socket = NULL;

 	if (sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &socket)) {
 		printk(KERN_ERR "%s: Failed to create socket\n", __func__);
 		return NULL;
 	}

 	sin_bind.sin_family = AF_INET;
 	sin_bind.sin_addr.s_addr = addr;
 	sin_bind.sin_port = htons(port);

 	if (kernel_bind(socket, (struct sockaddr *)&sin_bind, sizeof(sin_bind))) {
 		printk(KERN_ERR "%s: Failed to bind socket to port %pI4:%d\n", __func__, &addr, port);
 		sock_release(socket);
 		return NULL;
 	}

 	return socket;
 }

 static int qfdr_recv(struct socket *sock, char *buffer, size_t buflen)
 {
 	struct msghdr	msg = {NULL};
 	struct kvec	iov;
 	int		len;

 	/* adjust the RCVBUF */
 	if (buflen > sock->sk->sk_rcvbuf)
 		sock->sk->sk_rcvbuf = buflen;

 	iov.iov_base     = buffer;
 	iov.iov_len      = buflen;

 	len = kernel_recvmsg(sock, &msg, &iov, 1, buflen, 0);

 	return len;
 }

 static int qfdr_send(struct socket *sock, char *buffer, size_t buflen, struct sockaddr_in *dest_addr)
 {
 	struct msghdr	msg = {.msg_flags = MSG_DONTWAIT|MSG_NOSIGNAL};
 	struct kvec	iov;
 	int		len;

 	/* adjust the SNDBUF */
 	if (buflen > sock->sk->sk_sndbuf)
 		sock->sk->sk_sndbuf = buflen;

 	msg.msg_name     = dest_addr;
 	msg.msg_namelen  = sizeof(struct sockaddr_in);

 	iov.iov_base     = buffer;
 	iov.iov_len      = buflen;

 	len = kernel_sendmsg(sock, &msg, &iov, 1, buflen);

 	return len;
 }

 int qfdr_remote_giwscan(struct iwscanreq *req)
 {
 	struct qfdr_remote_aplist_req request;
 	char *recvbuf;
 	size_t recvbuf_size;
 	int recvlen;
 	struct qfdr_remote_aplist_rep *rep;

 	request.type = QFDR_GIWSCAN;
 	memcpy(&request.info, req->info, sizeof(struct iw_request_info));
 	request.extra_len = req->end_buf - req->current_ev;
 	strcpy(request.dev_name, req->vap->iv_dev->name);
 	qfdr_send(sock_send, (char *)&request, sizeof(request), &sin_req);

 	recvbuf_size = request.extra_len + sizeof(struct qfdr_remote_aplist_rep);
 	recvbuf = kmalloc(recvbuf_size, GFP_KERNEL);
 	if (!recvbuf) {
 		printk(KERN_ERR "%s: Failed to alloc recvbuf\n", __func__);
 		return 0;
 	}

 	recvlen = qfdr_recv(sock_recv_rep, recvbuf, recvbuf_size);
 	if (recvlen < sizeof(struct qfdr_remote_aplist_rep)) {
 		kfree(recvbuf);
 		if (recvlen < 0)
 			printk(KERN_ERR "%s: Failed to recv rep with errno %d\n", __func__, recvlen);
 		else
 			printk(KERN_ERR "%s: recv invalid rep\n", __func__);
 		return 0;
 	}

 	rep = (struct qfdr_remote_aplist_rep *)recvbuf;
 	if (rep->res != ENOMEM && rep->type == QFDR_GIWSCAN) {
 		memcpy(req->current_ev, rep->extra, rep->length);
 		req->current_ev += rep->length;
 	}
 	kfree(recvbuf);

 	return rep->res;
 }

 int qfdr_remote_ap_scan_results(struct ap_scan_iter *iter)
 {
 	struct qfdr_remote_aplist_req request;
 	char *recvbuf;
 	size_t recvbuf_size;
 	int recvlen;
 	struct qfdr_remote_aplist_rep *rep;

 	request.type = QFDR_AP_SCAN_RESULT;
 	request.extra_len = iter->end_buf - iter->current_env;
 	strcpy(request.dev_name, iter->vap->iv_dev->name);
 	qfdr_send(sock_send, (char *)&request, sizeof(request), &sin_req);

 	recvbuf_size = request.extra_len + sizeof(struct qfdr_remote_aplist_rep);
 	recvbuf = kmalloc(recvbuf_size, GFP_KERNEL);
 	if (!recvbuf) {
 		printk(KERN_ERR "%s: Failed to alloc recvbuf\n", __func__);
 		return 0;
 	}

 	recvlen = qfdr_recv(sock_recv_rep, recvbuf, recvbuf_size);
 	if (recvlen < sizeof(struct qfdr_remote_aplist_rep)) {
 		kfree(recvbuf);
 		if (recvlen < 0)
 			printk(KERN_ERR "%s: Failed to recv rep with errno %d\n", __func__, recvlen);
 		else
 			printk(KERN_ERR "%s: recv invalid rep\n", __func__);
 		return 0;
 	}

 	rep = (struct qfdr_remote_aplist_rep *)recvbuf;
 	if (rep->res != ENOMEM && rep->type == QFDR_AP_SCAN_RESULT) {
 		memcpy(iter->current_env, rep->extra, rep->length);
 		iter->current_env += rep->length;
 		iter->ap_counts += rep->ap_counts;
 	}
 	kfree(recvbuf);

 	return rep->res;
 }

 int qfdr_remote_siwscan(char *dev_name, struct iw_point *data)
 {
 	struct qfdr_remote_scan_req *request;
 	int req_len = sizeof(struct qfdr_remote_scan_req);

 	if (data)
 		req_len += data->length;
 	if (req_len > QFDR_REQ_MAX_SIZE) {
 		printk(KERN_ERR "%s: qfdr peer canonly recv %d bytes req\n", __func__, QFDR_REQ_MAX_SIZE);
 		return -EINVAL;
 	}
 	request = kmalloc(req_len, GFP_KERNEL);
 	if (!request) {
 		printk(KERN_ERR "%s: Failed to alloc buf\n", __func__);
 		return -ENOMEM;
 	}

 	strcpy(request->dev_name, dev_name);
 	if (data) {
 		request->type = QFDR_SIWSCAN;
 		request->flags = data->flags;
 		request->length = data->length;
 		memcpy(request->pointer, data->pointer, data->length);
 	} else {
 		request->type = QFDR_SIWSCAN_SIMPLE;
 	}

 	qfdr_send(sock_send, (char *)request, req_len, &sin_req);
 	kfree(request);

 	return 0;
 }

 static void qfdr_process_req(char *recvbuf, int recvlen)
 {
 	int type = *((int *)recvbuf);
 	struct qfdr_remote_aplist_rep rep_nomem = {ENOMEM, 0, 0, 0};
 	struct qfdr_remote_aplist_rep *rep;

 	if (type == QFDR_GIWSCAN) {
 		rep = qfdr_giwscan_for_remote((struct qfdr_remote_aplist_req *)recvbuf);
 		if (rep) {
 			qfdr_send(sock_send, (char *)rep, sizeof(struct qfdr_remote_aplist_rep) + rep->length, &sin_rep);
 			kfree(rep);
 		} else {
 			rep = &rep_nomem;
 			rep->type = QFDR_GIWSCAN;
 			qfdr_send(sock_send, (char *)rep, sizeof(struct qfdr_remote_aplist_rep) + rep->length, &sin_rep);
 		}
 	} else if (type == QFDR_AP_SCAN_RESULT) {
 		rep = qfdr_ap_scan_results_for_remote((struct qfdr_remote_aplist_req *)recvbuf);
 		if (rep) {
 			qfdr_send(sock_send, (char *)rep, sizeof(struct qfdr_remote_aplist_rep) + rep->length, &sin_rep);
 			kfree(rep);
 		} else {
 			rep = &rep_nomem;
 			rep->type = QFDR_AP_SCAN_RESULT;
 			qfdr_send(sock_send, (char *)rep, sizeof(struct qfdr_remote_aplist_rep) + rep->length, &sin_rep);
 		}
 	} else if (type == QFDR_SIWSCAN_SIMPLE || type == QFDR_SIWSCAN) {
 		qfdr_siwscan_for_remote((struct qfdr_remote_scan_req *)recvbuf);
 	}
 }

 static int qfdr_recv_req_thread(void *data)
 {
 	char *recvbuf;
 	int recvlen;

 	recvbuf = kmalloc(QFDR_REQ_MAX_SIZE, GFP_KERNEL);
 	if (!recvbuf) {
 		printk(KERN_ERR "%s: Failed to alloc recvbuf\n", __func__);
 		return -ENOMEM;
 	}

 	allow_signal(SIGTERM);

 	while (!signal_pending(current)) {
 		recvlen = qfdr_recv(sock_recv_req, recvbuf, QFDR_REQ_MAX_SIZE);
 		if (recvlen > 0) {
 			qfdr_process_req(recvbuf, recvlen);
 		} else {
 			printk(KERN_WARNING "%s: broken pipe on socket\n", __func__);
 		}
 	}

 	kfree(recvbuf);
 	complete(&comp_recv_req_thread);
 	thread_recv_req = NULL;

 	return 0;
 }

 /*
  * Module glue.
  */
 MODULE_AUTHOR("Quantenna, Jason.Wang");
 MODULE_DESCRIPTION("802.11 wireless support: Quantenna QFDR sync scan result");
 #ifdef MODULE_LICENSE
 MODULE_LICENSE("Dual BSD/GPL");
 #endif

 static int __init init_wlan_qfdr(void)
 {
 	unsigned int local_addr, remote_addr;

 	local_addr = in_aton(local_ip);
 	if (local_addr == INADDR_ANY || local_addr == INADDR_NONE) {
 		printk(KERN_ERR "%s: Invalid local IP %pI4\n", __func__, &local_addr);
 		return -EINVAL;
 	}

 	remote_addr = in_aton(remote_ip);
 	if (remote_addr == INADDR_ANY || remote_addr == INADDR_NONE) {
 		printk(KERN_ERR "%s: Invalid remote IP %pI4\n", __func__, &remote_addr);
 		return -EINVAL;
 	}

 	if (req_port == 0) {
 		printk(KERN_ERR "%s: Invalid req port %u, must be greater than 0\n", __func__, req_port);
 		return -EINVAL;
 	}

 	if (rep_port == 0 || rep_port == req_port) {
 		printk(KERN_ERR "%s: Invalid rep port %u, must be greater than 0 and not same as req port\n", __func__, rep_port);
 		return -EINVAL;
 	}

 	if (sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock_send)) {
 		printk(KERN_ERR "%s: Failed to create send socket\n", __func__);
 		goto fail;
 	}

 	sock_recv_req = qfdr_create_recv_socket(local_addr, req_port);
 	if (!sock_recv_req) {
 		printk(KERN_ERR "%s: Failed to create req recv socket\n", __func__);
 		goto fail;
 	}

 	sock_recv_rep = qfdr_create_recv_socket(local_addr, rep_port);
 	if (!sock_recv_rep) {
 		printk(KERN_ERR "%s: Failed to create rep recv socket\n", __func__);
 		goto fail;
 	}

 	/* set the RCVTIMEO */
 	sock_recv_rep->sk->sk_rcvtimeo = QFDR_REP_TIMEOUT;

 	sin_req.sin_family = AF_INET;
 	sin_req.sin_addr.s_addr = remote_addr;
 	sin_req.sin_port = htons(req_port);

 	sin_rep.sin_family = AF_INET;
 	sin_rep.sin_addr.s_addr = remote_addr;
 	sin_rep.sin_port = htons(rep_port);

 	thread_recv_req = kthread_run(qfdr_recv_req_thread, NULL, "qfdr");
 	if (IS_ERR(thread_recv_req)) {
 		printk(KERN_ERR "%s: Failed to start qfdr_recv_req_thread\n", __func__);
 		goto fail;
 	}

 	init_completion(&comp_recv_req_thread);
 	ieee80211_register_qfdr_remote_siwscan_hook(qfdr_remote_siwscan);
 	ieee80211_register_qfdr_remote_giwscan_hook(qfdr_remote_giwscan);
 	ieee80211_register_qfdr_remote_ap_scan_results_hook(qfdr_remote_ap_scan_results);

 	printk(KERN_INFO "Load qfdr module successfully, local ip:%pI4, remote ip:%pI4, req_port:%u, rep_port:%u\n", &local_addr, &remote_addr, req_port, rep_port);
 	return 0;
 fail:
 	if (sock_send)
 		sock_release(sock_send);
 	if (sock_recv_req)
 		sock_release(sock_recv_req);
 	if (sock_recv_rep)
 		sock_release(sock_recv_rep);

 	return -EAGAIN;
 }
 module_init(init_wlan_qfdr);

 static void __exit exit_wlan_qfdr(void)
 {
 	ieee80211_register_qfdr_remote_siwscan_hook(NULL);
 	ieee80211_register_qfdr_remote_giwscan_hook(NULL);
 	ieee80211_register_qfdr_remote_ap_scan_results_hook(NULL);
 	if (thread_recv_req) {
 		send_sig(SIGTERM, thread_recv_req, 0);
 		wait_for_completion(&comp_recv_req_thread);
 	}

 	if (sock_send)
 		sock_release(sock_send);
 	if (sock_recv_req)
 		sock_release(sock_recv_req);
 	if (sock_recv_rep)
 		sock_release(sock_recv_rep);
 }
 module_exit(exit_wlan_qfdr);
	/*-
	* Copyright (c) 2015 Quantenna Communications, Inc.
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	* 3. The name of the author may not be used to endorse or promote products
	* derived from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*
	* $Id: ieee80211_qfdr.c 2759 2015-12-20 10:48:20Z Jason $
	*/
	#ifndef EXPORT_SYMTAB
	#define EXPORT_SYMTAB
	#endif

	/*
	* IEEE 802.11 sync scan result for Quantenna QFDR.
	*/
	#ifndef AUTOCONF_INCLUDED
	#include <linux/config.h>
	#endif
	#include <linux/version.h>
	#include <linux/module.h>
	#include <linux/skbuff.h>
	#include <linux/netdevice.h>
	#include <linux/init.h>
	#include <linux/delay.h>
	#include <linux/in.h>
	#include <linux/workqueue.h>
	#include <linux/kthread.h>
	#include <net/sock.h>

	#include "net80211/if_media.h"

	#include "net80211/ieee80211_var.h"

	#define QFDR_REP_TIMEOUT (2 * HZ)
	#define QFDR_REQ_MAX_SIZE 512

	static char *local_ip = "0.0.0.0";
	module_param(local_ip, charp, S_IRUGO);
	MODULE_PARM_DESC(local_ip, "qfdr local ip");

	static char *remote_ip = "0.0.0.0";
	module_param(remote_ip, charp, S_IRUGO);
	MODULE_PARM_DESC(remote_ip, "qfdr remote ip");

	static unsigned short req_port = 0;
	module_param(req_port, ushort, S_IRUGO);
	MODULE_PARM_DESC(req_port, "qfdr port to recv req");

	static unsigned short rep_port = 0;
	module_param(rep_port, ushort, S_IRUGO);
	MODULE_PARM_DESC(rep_port, "qfdr port to recv rep");

	static struct socket *sock_send;
	static struct socket *sock_recv_req;
	static struct socket *sock_recv_rep;
	static struct sockaddr_in sin_req;
	static struct sockaddr_in sin_rep;

	static struct task_struct *thread_recv_req;
	static struct completion comp_recv_req_thread;

	static struct socket * qfdr_create_recv_socket(unsigned int addr, unsigned short port)
	{
	struct sockaddr_in sin_bind;
	struct socket *socket = NULL;

	if (sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &socket)) {
	printk(KERN_ERR "%s: Failed to create socket\n", __func__);
	return NULL;
	}

	sin_bind.sin_family = AF_INET;
	sin_bind.sin_addr.s_addr = addr;
	sin_bind.sin_port = htons(port);

	if (kernel_bind(socket, (struct sockaddr *)&sin_bind, sizeof(sin_bind))) {
	printk(KERN_ERR "%s: Failed to bind socket to port %pI4:%d\n", __func__, &addr, port);
	sock_release(socket);
	return NULL;
	}

	return socket;
	}

	static int qfdr_recv(struct socket sock, char buffer, size_t buflen)
	{
	struct msghdr msg = {NULL};
	struct kvec iov;
	int len;

	/* adjust the RCVBUF */
	if (buflen > sock->sk->sk_rcvbuf)
	sock->sk->sk_rcvbuf = buflen;

	iov.iov_base = buffer;
	iov.iov_len = buflen;

	len = kernel_recvmsg(sock, &msg, &iov, 1, buflen, 0);

	return len;
	}

	static int qfdr_send(struct socket sock, char buffer, size_t buflen, struct sockaddr_in *dest_addr)
	{
	struct msghdr msg = {.msg_flags = MSG_DONTWAIT\|MSG_NOSIGNAL};
	struct kvec iov;
	int len;

	/* adjust the SNDBUF */
	if (buflen > sock->sk->sk_sndbuf)
	sock->sk->sk_sndbuf = buflen;

	msg.msg_name = dest_addr;
	msg.msg_namelen = sizeof(struct sockaddr_in);

	iov.iov_base = buffer;
	iov.iov_len = buflen;

	len = kernel_sendmsg(sock, &msg, &iov, 1, buflen);

	return len;
	}

	int qfdr_remote_giwscan(struct iwscanreq *req)
	{
	struct qfdr_remote_aplist_req request;
	char *recvbuf;
	size_t recvbuf_size;
	int recvlen;
	struct qfdr_remote_aplist_rep *rep;

	request.type = QFDR_GIWSCAN;
	memcpy(&request.info, req->info, sizeof(struct iw_request_info));
	request.extra_len = req->end_buf - req->current_ev;
	strcpy(request.dev_name, req->vap->iv_dev->name);
	qfdr_send(sock_send, (char *)&request, sizeof(request), &sin_req);

	recvbuf_size = request.extra_len + sizeof(struct qfdr_remote_aplist_rep);
	recvbuf = kmalloc(recvbuf_size, GFP_KERNEL);
	if (!recvbuf) {
	printk(KERN_ERR "%s: Failed to alloc recvbuf\n", __func__);
	return 0;
	}

	recvlen = qfdr_recv(sock_recv_rep, recvbuf, recvbuf_size);
	if (recvlen < sizeof(struct qfdr_remote_aplist_rep)) {
	kfree(recvbuf);
	if (recvlen < 0)
	printk(KERN_ERR "%s: Failed to recv rep with errno %d\n", __func__, recvlen);
	else
	printk(KERN_ERR "%s: recv invalid rep\n", __func__);
	return 0;
	}

	rep = (struct qfdr_remote_aplist_rep *)recvbuf;
	if (rep->res != ENOMEM && rep->type == QFDR_GIWSCAN) {
	memcpy(req->current_ev, rep->extra, rep->length);
	req->current_ev += rep->length;
	}
	kfree(recvbuf);

	return rep->res;
	}

	int qfdr_remote_ap_scan_results(struct ap_scan_iter *iter)
	{
	struct qfdr_remote_aplist_req request;
	char *recvbuf;
	size_t recvbuf_size;
	int recvlen;
	struct qfdr_remote_aplist_rep *rep;

	request.type = QFDR_AP_SCAN_RESULT;
	request.extra_len = iter->end_buf - iter->current_env;
	strcpy(request.dev_name, iter->vap->iv_dev->name);
	qfdr_send(sock_send, (char *)&request, sizeof(request), &sin_req);

	recvbuf_size = request.extra_len + sizeof(struct qfdr_remote_aplist_rep);
	recvbuf = kmalloc(recvbuf_size, GFP_KERNEL);
	if (!recvbuf) {
	printk(KERN_ERR "%s: Failed to alloc recvbuf\n", __func__);
	return 0;
	}

	recvlen = qfdr_recv(sock_recv_rep, recvbuf, recvbuf_size);
	if (recvlen < sizeof(struct qfdr_remote_aplist_rep)) {
	kfree(recvbuf);
	if (recvlen < 0)
	printk(KERN_ERR "%s: Failed to recv rep with errno %d\n", __func__, recvlen);
	else
	printk(KERN_ERR "%s: recv invalid rep\n", __func__);
	return 0;
	}

	rep = (struct qfdr_remote_aplist_rep *)recvbuf;
	if (rep->res != ENOMEM && rep->type == QFDR_AP_SCAN_RESULT) {
	memcpy(iter->current_env, rep->extra, rep->length);
	iter->current_env += rep->length;
	iter->ap_counts += rep->ap_counts;
	}
	kfree(recvbuf);

	return rep->res;
	}

	int qfdr_remote_siwscan(char dev_name, struct iw_point data)
	{
	struct qfdr_remote_scan_req *request;
	int req_len = sizeof(struct qfdr_remote_scan_req);

	if (data)
	req_len += data->length;
	if (req_len > QFDR_REQ_MAX_SIZE) {
	printk(KERN_ERR "%s: qfdr peer canonly recv %d bytes req\n", __func__, QFDR_REQ_MAX_SIZE);
	return -EINVAL;
	}
	request = kmalloc(req_len, GFP_KERNEL);
	if (!request) {
	printk(KERN_ERR "%s: Failed to alloc buf\n", __func__);
	return -ENOMEM;
	}

	strcpy(request->dev_name, dev_name);
	if (data) {
	request->type = QFDR_SIWSCAN;
	request->flags = data->flags;
	request->length = data->length;
	memcpy(request->pointer, data->pointer, data->length);
	} else {
	request->type = QFDR_SIWSCAN_SIMPLE;
	}

	qfdr_send(sock_send, (char *)request, req_len, &sin_req);
	kfree(request);

	return 0;
	}

	static void qfdr_process_req(char *recvbuf, int recvlen)
	{
	int type = ((int )recvbuf);
	struct qfdr_remote_aplist_rep rep_nomem = {ENOMEM, 0, 0, 0};
	struct qfdr_remote_aplist_rep *rep;

	if (type == QFDR_GIWSCAN) {
	rep = qfdr_giwscan_for_remote((struct qfdr_remote_aplist_req *)recvbuf);
	if (rep) {
	qfdr_send(sock_send, (char *)rep, sizeof(struct qfdr_remote_aplist_rep) + rep->length, &sin_rep);
	kfree(rep);
	} else {
	rep = &rep_nomem;
	rep->type = QFDR_GIWSCAN;
	qfdr_send(sock_send, (char *)rep, sizeof(struct qfdr_remote_aplist_rep) + rep->length, &sin_rep);
	}
	} else if (type == QFDR_AP_SCAN_RESULT) {
	rep = qfdr_ap_scan_results_for_remote((struct qfdr_remote_aplist_req *)recvbuf);
	if (rep) {
	qfdr_send(sock_send, (char *)rep, sizeof(struct qfdr_remote_aplist_rep) + rep->length, &sin_rep);
	kfree(rep);
	} else {
	rep = &rep_nomem;
	rep->type = QFDR_AP_SCAN_RESULT;
	qfdr_send(sock_send, (char *)rep, sizeof(struct qfdr_remote_aplist_rep) + rep->length, &sin_rep);
	}
	} else if (type == QFDR_SIWSCAN_SIMPLE \|\| type == QFDR_SIWSCAN) {
	qfdr_siwscan_for_remote((struct qfdr_remote_scan_req *)recvbuf);
	}
	}

	static int qfdr_recv_req_thread(void *data)
	{
	char *recvbuf;
	int recvlen;

	recvbuf = kmalloc(QFDR_REQ_MAX_SIZE, GFP_KERNEL);
	if (!recvbuf) {
	printk(KERN_ERR "%s: Failed to alloc recvbuf\n", __func__);
	return -ENOMEM;
	}

	allow_signal(SIGTERM);

	while (!signal_pending(current)) {
	recvlen = qfdr_recv(sock_recv_req, recvbuf, QFDR_REQ_MAX_SIZE);
	if (recvlen > 0) {
	qfdr_process_req(recvbuf, recvlen);
	} else {
	printk(KERN_WARNING "%s: broken pipe on socket\n", __func__);
	}
	}

	kfree(recvbuf);
	complete(&comp_recv_req_thread);
	thread_recv_req = NULL;

	return 0;
	}

	/*
	* Module glue.
	*/
	MODULE_AUTHOR("Quantenna, Jason.Wang");
	MODULE_DESCRIPTION("802.11 wireless support: Quantenna QFDR sync scan result");
	#ifdef MODULE_LICENSE
	MODULE_LICENSE("Dual BSD/GPL");
	#endif

	static int __init init_wlan_qfdr(void)
	{
	unsigned int local_addr, remote_addr;

	local_addr = in_aton(local_ip);
	if (local_addr == INADDR_ANY \|\| local_addr == INADDR_NONE) {
	printk(KERN_ERR "%s: Invalid local IP %pI4\n", __func__, &local_addr);
	return -EINVAL;
	}

	remote_addr = in_aton(remote_ip);
	if (remote_addr == INADDR_ANY \|\| remote_addr == INADDR_NONE) {
	printk(KERN_ERR "%s: Invalid remote IP %pI4\n", __func__, &remote_addr);
	return -EINVAL;
	}

	if (req_port == 0) {
	printk(KERN_ERR "%s: Invalid req port %u, must be greater than 0\n", __func__, req_port);
	return -EINVAL;
	}

	if (rep_port == 0 \|\| rep_port == req_port) {
	printk(KERN_ERR "%s: Invalid rep port %u, must be greater than 0 and not same as req port\n", __func__, rep_port);
	return -EINVAL;
	}

	if (sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock_send)) {
	printk(KERN_ERR "%s: Failed to create send socket\n", __func__);
	goto fail;
	}

	sock_recv_req = qfdr_create_recv_socket(local_addr, req_port);
	if (!sock_recv_req) {
	printk(KERN_ERR "%s: Failed to create req recv socket\n", __func__);
	goto fail;
	}

	sock_recv_rep = qfdr_create_recv_socket(local_addr, rep_port);
	if (!sock_recv_rep) {
	printk(KERN_ERR "%s: Failed to create rep recv socket\n", __func__);
	goto fail;
	}

	/* set the RCVTIMEO */
	sock_recv_rep->sk->sk_rcvtimeo = QFDR_REP_TIMEOUT;

	sin_req.sin_family = AF_INET;
	sin_req.sin_addr.s_addr = remote_addr;
	sin_req.sin_port = htons(req_port);

	sin_rep.sin_family = AF_INET;
	sin_rep.sin_addr.s_addr = remote_addr;
	sin_rep.sin_port = htons(rep_port);

	thread_recv_req = kthread_run(qfdr_recv_req_thread, NULL, "qfdr");
	if (IS_ERR(thread_recv_req)) {
	printk(KERN_ERR "%s: Failed to start qfdr_recv_req_thread\n", __func__);
	goto fail;
	}

	init_completion(&comp_recv_req_thread);
	ieee80211_register_qfdr_remote_siwscan_hook(qfdr_remote_siwscan);
	ieee80211_register_qfdr_remote_giwscan_hook(qfdr_remote_giwscan);
	ieee80211_register_qfdr_remote_ap_scan_results_hook(qfdr_remote_ap_scan_results);

	printk(KERN_INFO "Load qfdr module successfully, local ip:%pI4, remote ip:%pI4, req_port:%u, rep_port:%u\n", &local_addr, &remote_addr, req_port, rep_port);
	return 0;
	fail:
	if (sock_send)
	sock_release(sock_send);
	if (sock_recv_req)
	sock_release(sock_recv_req);
	if (sock_recv_rep)
	sock_release(sock_recv_rep);

	return -EAGAIN;
	}
	module_init(init_wlan_qfdr);

	static void __exit exit_wlan_qfdr(void)
	{
	ieee80211_register_qfdr_remote_siwscan_hook(NULL);
	ieee80211_register_qfdr_remote_giwscan_hook(NULL);
	ieee80211_register_qfdr_remote_ap_scan_results_hook(NULL);
	if (thread_recv_req) {
	send_sig(SIGTERM, thread_recv_req, 0);
	wait_for_completion(&comp_recv_req_thread);
	}

	if (sock_send)
	sock_release(sock_send);
	if (sock_recv_req)
	sock_release(sock_recv_req);
	if (sock_recv_rep)
	sock_release(sock_recv_rep);
	}
	module_exit(exit_wlan_qfdr);