/* * 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 } }