/*
* open an RxRPC socket and bind it to be a server for callback notifications
* - the socket is left in blocking mode and non-blocking ops use MSG_DONTWAIT
*/
int afs_open_socket(void)
{
struct sockaddr_rxrpc srx;
struct socket *socket;
int ret;
_enter("");
skb_queue_head_init(&afs_incoming_calls);
afs_async_calls = create_singlethread_workqueue("kafsd");
if (!afs_async_calls) {
_leave(" = -ENOMEM [wq]");
return -ENOMEM;
}
ret = sock_create_kern(AF_RXRPC, SOCK_DGRAM, PF_INET, &socket);
if (ret < 0) {
destroy_workqueue(afs_async_calls);
_leave(" = %d [socket]", ret);
return ret;
}
socket->sk->sk_allocation = GFP_NOFS;
/* bind the callback manager's address to make this a server socket */
srx.srx_family = AF_RXRPC;
srx.srx_service = CM_SERVICE;
srx.transport_type = SOCK_DGRAM;
srx.transport_len = sizeof(srx.transport.sin);
srx.transport.sin.sin_family = AF_INET;
srx.transport.sin.sin_port = htons(AFS_CM_PORT);
memset(&srx.transport.sin.sin_addr, 0,
sizeof(srx.transport.sin.sin_addr));
ret = kernel_bind(socket, (struct sockaddr *) &srx, sizeof(srx));
if (ret < 0) {
sock_release(socket);
_leave(" = %d [bind]", ret);
return ret;
}
rxrpc_kernel_intercept_rx_messages(socket, afs_rx_interceptor);
afs_socket = socket;
_leave(" = 0");
return 0;
}
static int xs_bind(struct rpc_xprt *xprt, struct socket *sock)
{
struct sockaddr_in myaddr = {
.sin_family = AF_INET,
};
int err;
unsigned short port = xprt->port;
/* only bind for reserved port, or if the the srcaddr is set */
if (xprt->tcp_flags & XPRT_SRCADDR_PRESENT) {
if (!xprt->resvport) {
if (xprt->srcaddr.sin_addr.s_addr == INADDR_ANY)
goto out_skip;
port = 0;
}
myaddr.sin_addr = xprt->srcaddr.sin_addr;
} else {
if (!xprt->resvport)
goto out_skip;
}
do {
myaddr.sin_port = htons(port);
err = kernel_bind(sock, (struct sockaddr *) &myaddr,
sizeof(myaddr));
if (!xprt->resvport)
break;
if (err == 0) {
xprt->port = port;
break;
}
if (port <= xprt_min_resvport)
port = xprt_max_resvport;
else
port--;
} while (err == -EADDRINUSE && port != xprt->port);
dprintk("RPC: xs_bind "NIPQUAD_FMT":%u: %s (%d)\n",
NIPQUAD(myaddr.sin_addr), port, err ? "failed" : "ok", err);
return err;
out_skip:
dprintk("RPC: xs_bind not binding socket (srcaddr %s)\n",
(xprt->tcp_flags & XPRT_SRCADDR_PRESENT) ? "present" :
"absent");
return 0;
}
int udp_sock_create4(struct net *net, struct udp_port_cfg *cfg,
struct socket **sockp)
{
int err;
struct socket *sock = NULL;
struct sockaddr_in udp_addr;
err = sock_create_kern(AF_INET, SOCK_DGRAM, 0, &sock);
if (err < 0)
goto error;
sk_change_net(sock->sk, net);
udp_addr.sin_family = AF_INET;
udp_addr.sin_addr = cfg->local_ip;
udp_addr.sin_port = cfg->local_udp_port;
err = kernel_bind(sock, (struct sockaddr *)&udp_addr,
sizeof(udp_addr));
if (err < 0)
goto error;
if (cfg->peer_udp_port) {
udp_addr.sin_family = AF_INET;
udp_addr.sin_addr = cfg->peer_ip;
udp_addr.sin_port = cfg->peer_udp_port;
err = kernel_connect(sock, (struct sockaddr *)&udp_addr,
sizeof(udp_addr), 0);
if (err < 0)
goto error;
}
sock->sk->sk_no_check_tx = !cfg->use_udp_checksums;
*sockp = sock;
return 0;
error:
if (sock) {
kernel_sock_shutdown(sock, SHUT_RDWR);
sk_release_kernel(sock->sk);
}
*sockp = NULL;
return err;
}
int sclp_sock_create4(struct net *net, struct sclp_port_cfg *cfg, struct socket **sockp)
{
int err;
struct socket *sock = NULL;
struct sockaddr_in sclp_addr;
err = sock_create_kern(AF_INET, SOCK_SCLP, 0, &sock);
if (err < 0)
goto error;
sk_change_net(sock->sk, net);
sclp_addr.sin_family = AF_INET;
sclp_addr.sin_addr = cfg->local_ip;
sclp_addr.sin_port = cfg->local_sclp_port;
err = kernel_bind(sock, (struct sockaddr*)&sclp_addr, sizeof(sclp_addr));
if (err < 0)
goto error;
if (cfg->peer_sclp_port) {
sclp_addr.sin_family = AF_INET;
sclp_addr.sin_addr = cfg->peer_ip;
sclp_addr.sin_port = cfg->peer_sclp_port;
err = kernel_connect(sock, (struct sockaddr*)&sclp_addr, sizeof(sclp_addr), 0);
if (err < 0)
goto error;
}
*sockp = sock;
return 0;
error:
if (sock) {
kernel_sock_shutdown(sock, SHUT_RDWR);
sk_release_kernel(sock->sk);
}
*sockp = NULL;
return err;
}
static void socket_open_server(struct diag_socket_info *info)
{
int ret = 0;
struct sockaddr_msm_ipc srv_addr = { 0 };
if (!info)
return;
ret = sock_create(AF_MSM_IPC, SOCK_DGRAM, 0, &info->hdl);
if (ret < 0 || !info->hdl) {
pr_err("diag: In %s, socket not initialized for %s\n", __func__,
info->name);
return;
}
write_lock_bh(&info->hdl->sk->sk_callback_lock);
info->hdl->sk->sk_user_data = (void *)(info);
info->hdl->sk->sk_data_ready = socket_data_ready;
info->hdl->sk->sk_write_space = socket_flow_cntl;
write_unlock_bh(&info->hdl->sk->sk_callback_lock);
srv_addr.family = AF_MSM_IPC;
srv_addr.address.addrtype = MSM_IPC_ADDR_NAME;
srv_addr.address.addr.port_name.service = info->svc_id;
srv_addr.address.addr.port_name.instance = info->ins_id;
ret = kernel_bind(info->hdl, (struct sockaddr *)&srv_addr,
sizeof(srv_addr));
if (ret) {
pr_err("diag: In %s, failed to bind, ch: %s, svc_id: %d ins_id: %d, err: %d\n",
__func__, info->name, info->svc_id, info->ins_id, ret);
return;
}
DIAG_LOG(DIAG_DEBUG_PERIPHERALS, "%s opened server svc: %d ins: %d",
info->name, info->svc_id, info->ins_id);
}
int rpl_udp_sock_create(struct net *net, struct udp_port_cfg *cfg,
struct socket **sockp)
{
int err;
struct socket *sock = NULL;
#if IS_ENABLED(CONFIG_IPV6)
if (cfg->family == AF_INET6) {
struct sockaddr_in6 udp6_addr;
err = sock_create_kern(net, AF_INET6, SOCK_DGRAM, 0, &sock);
if (err < 0)
goto error;
udp6_addr.sin6_family = AF_INET6;
memcpy(&udp6_addr.sin6_addr, &cfg->local_ip6,
sizeof(udp6_addr.sin6_addr));
udp6_addr.sin6_port = cfg->local_udp_port;
err = kernel_bind(sock, (struct sockaddr *)&udp6_addr,
sizeof(udp6_addr));
if (err < 0)
goto error;
if (cfg->peer_udp_port) {
udp6_addr.sin6_family = AF_INET6;
memcpy(&udp6_addr.sin6_addr, &cfg->peer_ip6,
sizeof(udp6_addr.sin6_addr));
udp6_addr.sin6_port = cfg->peer_udp_port;
err = kernel_connect(sock,
(struct sockaddr *)&udp6_addr,
sizeof(udp6_addr), 0);
}
if (err < 0)
goto error;
} else
#endif
if (cfg->family == AF_INET) {
struct sockaddr_in udp_addr;
err = sock_create_kern(net, AF_INET, SOCK_DGRAM, 0, &sock);
if (err < 0)
goto error;
udp_addr.sin_family = AF_INET;
udp_addr.sin_addr = cfg->local_ip;
udp_addr.sin_port = cfg->local_udp_port;
err = kernel_bind(sock, (struct sockaddr *)&udp_addr,
sizeof(udp_addr));
if (err < 0)
goto error;
if (cfg->peer_udp_port) {
udp_addr.sin_family = AF_INET;
udp_addr.sin_addr = cfg->peer_ip;
udp_addr.sin_port = cfg->peer_udp_port;
err = kernel_connect(sock,
(struct sockaddr *)&udp_addr,
sizeof(udp_addr), 0);
if (err < 0)
goto error;
}
} else {
return -EPFNOSUPPORT;
}
*sockp = sock;
return 0;
error:
if (sock) {
kernel_sock_shutdown(sock, SHUT_RDWR);
sock_release(sock);
}
*sockp = NULL;
return err;
}
void energy::Fitting::track(DataFrame& frame, LinearSystem& sys, bool rigid_only, bool eval_error, float & push_error, float & pull_error) {
// TICTOC_SCOPE(timer,"Energy::Fitting");
///--- Make sure sensor has necessary data
assert( sensor_depth_texture->check_loaded(frame.id) );
// TICTOC_BLOCK(timer,"Worker::track_cuda::(KinematicChainTransfer)")
{
kernel_upload_kinematic(skeleton->getJointTransformations(),skeleton->getKinematicChain());
kernel_upload_cylinders(cylinders->serialize());
}
{
cv::Mat& sensor_silhouette = handfinder->sensor_silhouette;
static int last_uploaded_id=-1; ///< avoid multiple uploads
static cv::Mat sensor_silhouette_flipped;
if(last_uploaded_id!=frame.id){
// TICTOC_SCOPE(t_dtform,"Energy::Fitting::dtform");
cv::flip(sensor_silhouette, sensor_silhouette_flipped, 0 /*flip rows*/ );
distance_transform.exec(sensor_silhouette_flipped.data, 125);
kernel_upload_dtform_idxs(distance_transform.idxs_image_ptr());
//---- WARNING THIS CORRUPTS DATA!!
// cv::normalize(distance_transform.dsts_image(), distance_transform.dsts_image(), 0.0, 1.0, cv::NORM_MINMAX);
// cv::imshow("dt", distance_transform.dsts_image());
kernel_upload_sensor_data(sensor_silhouette_flipped.data);
last_uploaded_id = frame.id;
}
}
///---------------------------------------------------
///---------------------------------------------------
// cudaDeviceSynchronize();
///---------------------------------------------------
///---------------------------------------------------
///--- Map resources to CUDA context
// TIMED_BLOCK(timer,"Worker::track_cuda::(bind+kernel)")
{
// TICTOC_BLOCK(timer,"Worker::track_cuda::(BindOpenGL)")
{
offscreenrend->fb->bind(); ///< with glFinish() only takes 20 microseconds
cudax::render_color = render_color.bind();
cudax::render_points = render_xyz.bind();
cudax::sensor_depth = sensor_depth.bind();
}
// TICTOC_BLOCK(timer,"Worker::track_cuda::(kernel)")
{
kernel_bind();
bool reweight = settings->fit3D_reweight;
if(rigid_only && settings->fit3D_reweight && !(settings->fit3D_reweight_rigid))
reweight = false; ///< allows fast rigid motion (mostly visible on PrimeSense @60FPS)
// std::cout << "rigid?" << rigid_only << "reweight?" << reweight << std::endl;
kernel(sys.lhs.data(), sys.rhs.data(), push_error, pull_error, eval_error, reweight);
kernel_unbind();
}
///--- debug
// std::ofstream("mat/JtJ_gpu.txt") << sys.lhs << std::endl;
// std::ofstream("mat/Jte_gpu.txt") << sys.rhs << std::endl;
if(settings->debug_show_constraints_image){
int w = camera->height(), h = camera->width();
cv::Mat opencv_image = cv::Mat(w, h, CV_8UC3, cv::Scalar(0,0,0));
kernel_constraint_type_image(opencv_image.data, w, h);
cv::flip(opencv_image, opencv_image, 0);
cv::imshow("constraint types", opencv_image);
}
// TICTOC_BLOCK(timer,"Worker::track_cuda::(unbind)")
{
render_color.unbind();
render_xyz.unbind();
sensor_depth.unbind();
offscreenrend->fb->unbind();
}
}
///--- @note debug
// cv::imshow("debug_image", debug_image);
}
int
lnet_sock_read(struct socket *sock, void *buffer, int nob, int timeout)
{
int rc;
long jiffies_left = timeout * msecs_to_jiffies(MSEC_PER_SEC);
unsigned long then;
struct timeval tv;
LASSERT(nob > 0);
LASSERT(jiffies_left > 0);
for (;;) {
struct kvec iov = {
.iov_base = buffer,
.iov_len = nob
};
struct msghdr msg = {
.msg_flags = 0
};
/* Set receive timeout to remaining time */
jiffies_to_timeval(jiffies_left, &tv);
rc = kernel_setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO,
(char *)&tv, sizeof(tv));
if (rc) {
CERROR("Can't set socket recv timeout %ld.%06d: %d\n",
(long)tv.tv_sec, (int)tv.tv_usec, rc);
return rc;
}
then = jiffies;
rc = kernel_recvmsg(sock, &msg, &iov, 1, nob, 0);
jiffies_left -= jiffies - then;
if (rc < 0)
return rc;
if (!rc)
return -ECONNRESET;
buffer = ((char *)buffer) + rc;
nob -= rc;
if (!nob)
return 0;
if (jiffies_left <= 0)
return -ETIMEDOUT;
}
}
EXPORT_SYMBOL(lnet_sock_read);
static int
lnet_sock_create(struct socket **sockp, int *fatal, __u32 local_ip,
int local_port)
{
struct sockaddr_in locaddr;
struct socket *sock;
int rc;
int option;
/* All errors are fatal except bind failure if the port is in use */
*fatal = 1;
rc = sock_create(PF_INET, SOCK_STREAM, 0, &sock);
*sockp = sock;
if (rc) {
CERROR("Can't create socket: %d\n", rc);
return rc;
}
option = 1;
rc = kernel_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
(char *)&option, sizeof(option));
if (rc) {
CERROR("Can't set SO_REUSEADDR for socket: %d\n", rc);
goto failed;
}
if (local_ip || local_port) {
memset(&locaddr, 0, sizeof(locaddr));
locaddr.sin_family = AF_INET;
locaddr.sin_port = htons(local_port);
if (!local_ip)
locaddr.sin_addr.s_addr = htonl(INADDR_ANY);
else
locaddr.sin_addr.s_addr = htonl(local_ip);
rc = kernel_bind(sock, (struct sockaddr *)&locaddr,
sizeof(locaddr));
if (rc == -EADDRINUSE) {
CDEBUG(D_NET, "Port %d already in use\n", local_port);
*fatal = 0;
goto failed;
}
if (rc) {
CERROR("Error trying to bind to port %d: %d\n",
local_port, rc);
goto failed;
}
}
return 0;
failed:
sock_release(sock);
return rc;
}
int
lnet_sock_setbuf(struct socket *sock, int txbufsize, int rxbufsize)
{
int option;
int rc;
if (txbufsize) {
option = txbufsize;
rc = kernel_setsockopt(sock, SOL_SOCKET, SO_SNDBUF,
(char *)&option, sizeof(option));
if (rc) {
CERROR("Can't set send buffer %d: %d\n",
option, rc);
return rc;
}
}
if (rxbufsize) {
option = rxbufsize;
rc = kernel_setsockopt(sock, SOL_SOCKET, SO_RCVBUF,
(char *)&option, sizeof(option));
if (rc) {
CERROR("Can't set receive buffer %d: %d\n",
option, rc);
return rc;
}
}
return 0;
}
static struct vxlan_sock *vxlan_socket_create(struct net *net, __be16 port,
vxlan_rcv_t *rcv, void *data)
{
struct vxlan_sock *vs;
struct sock *sk;
struct sockaddr_in vxlan_addr = {
.sin_family = AF_INET,
.sin_addr.s_addr = htonl(INADDR_ANY),
.sin_port = port,
};
int rc;
vs = kmalloc(sizeof(*vs), GFP_KERNEL);
if (!vs) {
pr_debug("memory alocation failure\n");
return ERR_PTR(-ENOMEM);
}
INIT_WORK(&vs->del_work, vxlan_del_work);
/* Create UDP socket for encapsulation receive. */
rc = sock_create_kern(AF_INET, SOCK_DGRAM, IPPROTO_UDP, &vs->sock);
if (rc < 0) {
pr_debug("UDP socket create failed\n");
kfree(vs);
return ERR_PTR(rc);
}
/* Put in proper namespace */
sk = vs->sock->sk;
sk_change_net(sk, net);
rc = kernel_bind(vs->sock, (struct sockaddr *) &vxlan_addr,
sizeof(vxlan_addr));
if (rc < 0) {
pr_debug("bind for UDP socket %pI4:%u (%d)\n",
&vxlan_addr.sin_addr, ntohs(vxlan_addr.sin_port), rc);
sk_release_kernel(sk);
kfree(vs);
return ERR_PTR(rc);
}
vs->rcv = rcv;
vs->data = data;
/* Disable multicast loopback */
inet_sk(sk)->mc_loop = 0;
rcu_assign_sk_user_data(vs->sock->sk, vs);
/* Mark socket as an encapsulation socket. */
udp_sk(sk)->encap_type = 1;
udp_sk(sk)->encap_rcv = vxlan_udp_encap_recv;
udp_encap_enable();
return vs;
}
struct vxlan_sock *vxlan_sock_add(struct net *net, __be16 port,
vxlan_rcv_t *rcv, void *data,
bool no_share, u32 flags)
{
return vxlan_socket_create(net, port, rcv, data);
}
void vxlan_sock_release(struct vxlan_sock *vs)
{
ASSERT_OVSL();
rcu_assign_sk_user_data(vs->sock->sk, NULL);
queue_work(system_wq, &vs->del_work);
}
/* Create a new IPv4 subflow.
*
* We are in user-context and meta-sock-lock is hold.
*/
int mptcp_init4_subsockets(struct sock *meta_sk, const struct mptcp_loc4 *loc,
struct mptcp_rem4 *rem)
{
struct tcp_sock *tp;
struct sock *sk;
struct sockaddr_in loc_in, rem_in;
struct socket_alloc sock_full;
struct socket *sock = (struct socket *)&sock_full;
int ret;
/** First, create and prepare the new socket */
memcpy(&sock_full, meta_sk->sk_socket, sizeof(sock_full));
sock->state = SS_UNCONNECTED;
sock->ops = NULL;
ret = inet_create(sock_net(meta_sk), sock, IPPROTO_TCP, 1);
if (unlikely(ret < 0)) {
net_err_ratelimited("%s inet_create failed ret: %d\n",
__func__, ret);
return ret;
}
sk = sock->sk;
tp = tcp_sk(sk);
/* All subsockets need the MPTCP-lock-class */
lockdep_set_class_and_name(&(sk)->sk_lock.slock, &meta_slock_key, meta_slock_key_name);
lockdep_init_map(&(sk)->sk_lock.dep_map, meta_key_name, &meta_key, 0);
ret = mptcp_add_sock(meta_sk, sk, loc->loc4_id, rem->rem4_id, GFP_KERNEL);
if (ret) {
net_err_ratelimited("%s mptcp_add_sock failed ret: %d\n",
__func__, ret);
goto error;
}
tp->mptcp->slave_sk = 1;
/* Initializing the timer for an MPTCP subflow */
timer_setup(&tp->mptcp->mptcp_ack_timer, mptcp_ack_handler, 0);
/** Then, connect the socket to the peer */
loc_in.sin_family = AF_INET;
rem_in.sin_family = AF_INET;
loc_in.sin_port = 0;
if (rem->port)
rem_in.sin_port = rem->port;
else
rem_in.sin_port = inet_sk(meta_sk)->inet_dport;
loc_in.sin_addr = loc->addr;
rem_in.sin_addr = rem->addr;
if (loc->if_idx)
sk->sk_bound_dev_if = loc->if_idx;
ret = kernel_bind(sock, (struct sockaddr *)&loc_in,
sizeof(struct sockaddr_in));
if (ret < 0) {
net_err_ratelimited("%s: token %#x bind() to %pI4 index %d failed, error %d\n",
__func__, tcp_sk(meta_sk)->mpcb->mptcp_loc_token,
&loc_in.sin_addr, loc->if_idx, ret);
goto error;
}
mptcp_debug("%s: token %#x pi %d src_addr:%pI4:%d dst_addr:%pI4:%d ifidx: %d\n",
__func__, tcp_sk(meta_sk)->mpcb->mptcp_loc_token,
tp->mptcp->path_index, &loc_in.sin_addr,
ntohs(loc_in.sin_port), &rem_in.sin_addr,
ntohs(rem_in.sin_port), loc->if_idx);
ret = kernel_connect(sock, (struct sockaddr *)&rem_in,
sizeof(struct sockaddr_in), O_NONBLOCK);
if (ret < 0 && ret != -EINPROGRESS) {
net_err_ratelimited("%s: MPTCP subsocket connect() failed, error %d\n",
__func__, ret);
goto error;
}
MPTCP_INC_STATS(sock_net(meta_sk), MPTCP_MIB_JOINSYNTX);
sk_set_socket(sk, meta_sk->sk_socket);
sk->sk_wq = meta_sk->sk_wq;
return 0;
error:
/* May happen if mptcp_add_sock fails first */
if (!mptcp(tp)) {
tcp_close(sk, 0);
} else {
local_bh_disable();
mptcp_sub_force_close(sk);
local_bh_enable();
}
return ret;
}
int udpserver_start(struct request_state* req)
{
int err;
// wait queue declare -- this used for waiting on the UDP socket
// when there is no data available to read in to stop sitting in
// a tight spin locking loop.
udpserver = (struct udpserver_state*) ALLOCMEM(sizeof(struct udpserver_state),
GFP_KERNEL);
memset(udpserver, 0, sizeof(struct udpserver_state));
udpserver->req = req;
// Create and initialise a UDP socket for this connection
#ifdef __KERNEL__
err = sock_create_kern(AF_INET, SOCK_DGRAM, IPPROTO_UDP, &udpserver->sock);
if (err < 0)
{
printk(KERN_ERR "[Unbuckle] UDP Server -- %d unable to create socket\n", err);
kfree(udpserver);
return err;
}
#else
udpserver->sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (udpserver->sock < 0)
{
printf("[Unbuckle] UDP Server -- %d unable to create socket\n", errno);
free(udpserver);
return udpserver->sock;
}
#endif
udpserver->inet_addr.sin_family = AF_INET;
udpserver->inet_addr.sin_port = htons(UDP_PORT);
udpserver->inet_addr.sin_addr.s_addr = htonl(INADDR_ANY);
/* bind the socket */
#ifdef __KERNEL__
err = kernel_bind(udpserver->sock, (struct sockaddr*) &udpserver->inet_addr,
sizeof(struct sockaddr_in));
if (err < 0)
{
printk(KERN_ERR "[Unbuckle] UDP Server -- %d unable to bind socket\n", err);
sock_release(udpserver->sock);
kfree(udpserver);
return err;
}
#else
err = bind(udpserver->sock, (struct sockaddr*) &udpserver->inet_addr,
sizeof(struct sockaddr_in));
if (err < 0)
{
printf("[Unbuckle] UDP Server -- %d unable to bind socket\n", errno);
close(udpserver->sock);
free(udpserver);
return err;
}
#endif
req->len_recvbuf = UDP_RECV_BUFFER;
req->recvbuf = (char*) ALLOCMEM(req->len_recvbuf, GFP_KERNEL);
#ifdef __KERNEL__
if (ksize(req->recvbuf) < req->len_recvbuf)
{
printk(KERN_WARNING
"[Unbuckle] Asked for a receive buffer of %lu, but got %lu.\n",
req->len_recvbuf, ksize(req->recvbuf)
);
req->len_recvbuf = ksize(req->recvbuf);
}
#endif
udpserver_init_sendbuffers(req);
return err;
}
int init_server(void *conf)
{
int ret=0;
int flags=1;
sock_entry_t *se;
struct linger ling= {0,0};
//create workqueue
if(!wq) {
wq=create_singlethread_workqueue("kkvserver");
if(!wq) {
#ifdef DEBUG_KKV_NETWORK
printk("create_workqueue() failed in server_init()\n");
#endif
return -ENOMEM;
}
}
if(!svr) {
svr=kmalloc(sizeof(kkv_server),GFP_KERNEL);
INIT_WORK(&svr->work,server_work);
}
//create socket
se=(sock_entry_t *)conf;
ret=sock_create_kern(se->family,se->type,se->protocol,&svr->socket);
if(ret<0) {
#ifdef DEBUG_KKV_NETWORK
printk("sock_create_kern() failed=%d, family=%d, type=%d, protocol=%d\n",
ret,se->family,se->type,se->protocol);
#endif
goto out0;
}
set_server_sock_callbacks(svr->socket,svr);
ret=kernel_setsockopt(svr->socket,SOL_SOCKET,SO_REUSEADDR,(char*)&flags,sizeof(flags));
if(ret<0) {
#ifdef DEBUG_KKV_NETWORK
printk("kernel_setsockopt() failed=%d, level=%d, name=%d\n",ret,SOL_SOCKET,SO_REUSEADDR);
#endif
goto out1;
}
ret=kernel_setsockopt(svr->socket,SOL_SOCKET,SO_KEEPALIVE,(char*)&flags,sizeof(flags));
if(ret<0) {
#ifdef DEBUG_KKV_NETWORK
printk("kernel_setsockopt() failed=%d, level=%d, name=%d\n",ret,SOL_SOCKET,SO_KEEPALIVE);
#endif
goto out1;
}
ret=kernel_setsockopt(svr->socket,SOL_SOCKET,SO_LINGER,(char*)&ling,sizeof(ling));
if(ret<0) {
#ifdef DEBUG_KKV_NETWORK
printk("kernel_setsockopt() failed=%d, level=%d, name=%d\n",ret,SOL_SOCKET,SO_LINGER);
#endif
goto out1;
}
ret=kernel_setsockopt(svr->socket,SOL_TCP,TCP_NODELAY,(char*)&flags,sizeof(flags));
if(ret<0) {
#ifdef DEBUG_KKV_NETWORK
printk("kernel_setsockopt() failed=%d, level=%d, name=%d\n",ret,IPPROTO_TCP,TCP_NODELAY);
#endif
goto out1;
}
ret=kernel_bind(svr->socket,(struct sockaddr*)se->addr,se->addrlen);
if(ret<0) {
#ifdef DEBUG_KKV_NETWORK
printk("kernel_bind() failed=%d\n",ret);
#endif
goto out1;
}
ret=kernel_listen(svr->socket,1024);
if(ret<0) {
#ifdef DEBUG_KKV_NETWORK
printk("kernel_listen() failed=%d\n",ret);
#endif
goto out1;
}
return 0;
out1:
sock_release(svr->socket);
out0:
svr->socket=NULL;
return ret;
}
static struct socket *
udp_tx_sock_create (struct in_addr if_address,
uint16_t port,
struct in_addr dest_addr,
uint32_t bufsize)
{
struct socket *sk;
struct sockaddr_in saddr;
char loop = 0;
int err = 0;
do {
err = sock_create(PF_INET, SOCK_DGRAM, 0, &sk);
if (err < 0) {
break;
}
memset(&saddr, 0, sizeof(saddr));
saddr.sin_addr = if_address;
saddr.sin_family = AF_INET;
saddr.sin_port = 0;
err = kernel_bind(sk,
(struct sockaddr *) &saddr,
sizeof(saddr));
if (err < 0) {
break;
}
err = kernel_setsockopt(sk,
IPPROTO_IP,
IP_MULTICAST_LOOP,
&loop,
sizeof(loop));
if (err < 0) {
break;
}
memset(&saddr, 0, sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_addr = dest_addr;
saddr.sin_port = port;
err = kernel_connect(sk,
(struct sockaddr *)&saddr,
sizeof(saddr),
0);
if (err < 0) {
break;
}
if (bufsize) {
err = kernel_setsockopt(sk,
SOL_SOCKET,
SO_SNDBUF,
(char *)&bufsize,
sizeof(bufsize));
if (err < 0) {
break;
}
}
} while (0);
if (err < 0) {
kernel_sock_shutdown(sk, SHUT_RDWR);
sock_release(sk);
sk = NULL;
}
return (sk);
}
static int threadfn(void *data)
{
struct socket *sock;
struct sockaddr_in addr;
int size,i;
char buf[bufsize+1];
if (sock_create_kern(AF_INET, SOCK_STREAM, IPPROTO_TCP, &sock) < 0) {
err("sock_create_kern");
goto out;
}
sock->sk->sk_reuse = 1;
memset(&addr, '\0', sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = htons(9734);
if (kernel_bind(sock, &addr, sizeof(addr)) < 0) {
err("kernel_bind");
goto err;
}
if (kernel_listen(sock, 1024) < 0) {
err("kernel_listen");
goto err;
}
while (!kthread_should_stop()) {
struct socket *newsock;
struct inet_connection_sock *icsk = inet_csk(sock->sk);
struct socket_wq *wq;
rcu_read_lock();
wq = rcu_dereference(sock->sk->sk_wq);
wait_event_interruptible(wq->wait,!reqsk_queue_empty(&icsk->icsk_accept_queue) || kthread_should_stop());
if (!reqsk_queue_empty(&icsk->icsk_accept_queue)) {
if (kernel_accept(sock, &newsock, MSG_WAITALL) != 0) {
err("kernel_accept");
goto err;
}
printk(KERN_INFO "Server : accept a new connection request.\n");
// transfer_data(newsock);
memset(&buf, 0, bufsize+1);
size = receive(newsock, buf, bufsize/2);
printk(KERN_INFO "Server : received %d bytes\n", size);
//data processing
printk("Server : received data: %s\n", buf);
size = receive(newsock, buf, bufsize/2);
if (size < 0)
{
printk(KERN_INFO ": error getting datagram, sock_recvmsg error = %d\n", size);
break;
}
else
{
printk(KERN_INFO "Server : received %d bytes\n", size);
//data processing
printk("Server : received data: %s\n", buf);
for( i=0;i<bufsize/2;i++)
{
buf[i]+=1;
}
buf[i]=0 ;
// sending
//printk("buf=%s\n",buf);
size=send(newsock, buf, bufsize/2+1);
if(size<0)
printk("Server : error send\n");
}
//printk("ch =%c\n",ch);
sock_release(newsock);
}
}
err:
sock_release(sock);
out:
return 0;
}
int vdev_socket_task(void*data) {
struct sockaddr_in s_addr;
unsigned short portnum=8891;
int ret=0;
memset(&s_addr,0,sizeof(s_addr));
s_addr.sin_family=AF_INET;
s_addr.sin_port=htons(portnum);
s_addr.sin_addr.s_addr=htonl(INADDR_ANY);
/*create a socket*/
ret=sock_create_kern(AF_INET, SOCK_STREAM, 0, &server_sock);
if(ret) {
printk("vdev server:socket_create error = %d\n",ret);
return -1;
}
printk("vdev server: socket_create ok!\n");
/*bind the socket*/
ret=kernel_bind(server_sock, (struct sockaddr *)&s_addr, sizeof(s_addr));
if (ret < 0) {
printk("vdev server: bind error = %d\n",ret);
sock_release(server_sock);
return -1;
}
printk("vdev server: bind ok!\n");
/*listen*/
ret=kernel_listen(server_sock, 5);
if(ret < 0) {
printk("vdev server: listen error = %d\n",ret);
sock_release(server_sock);
return -1;
}
printk("vdev server: listen ok!\n");
/*accept*/
for(;;)
{
ret=kernel_accept(server_sock, &client_sock, 0);
if (ret<0) {
printk("vdev server: accept error = %d\n",ret);
sock_release(server_sock);
return -1;
}
printk("vdev server: accept ok!\n");
/*receive message from client*/
for(;;)
{
char cmd=-1;
ret = vdev_socket_recv(&cmd, 1);
if(ret < 0) {
printk("vdev socket recv error\n");
break;
}
ret = process_framework_event(cmd);
if(ret < 0) {
printk("vdev socket process error\n");
break;
}
}//for
}
}
