/* * send a packet through the transport endpoint */ int rxrpc_send_packet(struct rxrpc_transport *trans, struct sk_buff *skb) { struct kvec iov[1]; struct msghdr msg; int ret, opt; _enter(",{%d}", skb->len); iov[0].iov_base = skb->head; iov[0].iov_len = skb->len; msg.msg_name = &trans->peer->srx.transport.sin; msg.msg_namelen = sizeof(trans->peer->srx.transport.sin); msg.msg_control = NULL; msg.msg_controllen = 0; msg.msg_flags = 0; /* send the packet with the don't fragment bit set if we currently * think it's small enough */ if (skb->len - sizeof(struct rxrpc_header) < trans->peer->maxdata) { down_read(&trans->local->defrag_sem); /* send the packet by UDP * - returns -EMSGSIZE if UDP would have to fragment the packet * to go out of the interface * - in which case, we'll have processed the ICMP error * message and update the peer record */ ret = kernel_sendmsg(trans->local->socket, &msg, iov, 1, iov[0].iov_len); up_read(&trans->local->defrag_sem); if (ret == -EMSGSIZE) goto send_fragmentable; _leave(" = %d [%u]", ret, trans->peer->maxdata); return ret; } send_fragmentable: /* attempt to send this message with fragmentation enabled */ _debug("send fragment"); down_write(&trans->local->defrag_sem); opt = IP_PMTUDISC_DONT; ret = kernel_setsockopt(trans->local->socket, SOL_IP, IP_MTU_DISCOVER, (char *) &opt, sizeof(opt)); if (ret == 0) { ret = kernel_sendmsg(trans->local->socket, &msg, iov, 1, iov[0].iov_len); opt = IP_PMTUDISC_DO; kernel_setsockopt(trans->local->socket, SOL_IP, IP_MTU_DISCOVER, (char *) &opt, sizeof(opt)); } up_write(&trans->local->defrag_sem); _leave(" = %d [frag %u]", ret, trans->peer->maxdata); return ret; }
/* * generate a connection-level abort */ static int rxrpc_busy(struct rxrpc_local *local, struct sockaddr_rxrpc *srx, struct rxrpc_wire_header *whdr) { struct msghdr msg; struct kvec iov[1]; size_t len; int ret; _enter("%d,,", local->debug_id); whdr->type = RXRPC_PACKET_TYPE_BUSY; whdr->serial = htonl(1); msg.msg_name = &srx->transport.sin; msg.msg_namelen = sizeof(srx->transport.sin); msg.msg_control = NULL; msg.msg_controllen = 0; msg.msg_flags = 0; iov[0].iov_base = whdr; iov[0].iov_len = sizeof(*whdr); len = iov[0].iov_len; _proto("Tx BUSY %%1"); ret = kernel_sendmsg(local->socket, &msg, iov, 1, len); if (ret < 0) { _leave(" = -EAGAIN [sendmsg failed: %d]", ret); return -EAGAIN; } _leave(" = 0"); return 0; }
static int bnep_send(struct bnep_session *s, void *data, size_t len) { struct socket *sock = s->sock; struct kvec iv = { data, len }; return kernel_sendmsg(sock, &s->msg, &iv, 1, len); }
/* osi_NetSend * * Return codes: * 0 = success * non-zero = failure */ int osi_NetSend(osi_socket sop, struct sockaddr_in *to, struct iovec *iovec, int iovcnt, afs_int32 size, int istack) { struct msghdr msg; int code; #ifdef ADAPT_PMTU int sockerr; int esize; while (1) { sockerr=0; esize = sizeof(sockerr); kernel_getsockopt(sop, SOL_SOCKET, SO_ERROR, (char *)&sockerr, &esize); if (sockerr == 0) break; handle_socket_error(sop); } #endif msg.msg_name = to; msg.msg_namelen = sizeof(*to); msg.msg_control = NULL; msg.msg_controllen = 0; msg.msg_flags = 0; code = kernel_sendmsg(sop, &msg, (struct kvec *) iovec, iovcnt, size); return (code < 0) ? code : 0; }
/* * Send or receive packet. */ static int sock_xmit(struct socket *sock, int send, void *buf, int size, int msg_flags) { int result; struct msghdr msg; struct kvec iov; unsigned long flags; sigset_t oldset; /* Allow interception of SIGKILL only * Don't allow other signals to interrupt the transmission */ spin_lock_irqsave(¤t->sighand->siglock, flags); oldset = current->blocked; sigfillset(¤t->blocked); sigdelsetmask(¤t->blocked, sigmask(SIGKILL)); recalc_sigpending(); spin_unlock_irqrestore(¤t->sighand->siglock, flags); do { sock->sk->sk_allocation = GFP_NOIO; iov.iov_base = buf; iov.iov_len = size; msg.msg_name = NULL; msg.msg_namelen = 0; msg.msg_control = NULL; msg.msg_controllen = 0; msg.msg_flags = msg_flags | MSG_NOSIGNAL; if (send) result = kernel_sendmsg(sock, &msg, &iov, 1, size); else result = kernel_recvmsg(sock, &msg, &iov, 1, size, 0); if (signal_pending(current)) { siginfo_t info; spin_lock_irqsave(¤t->sighand->siglock, flags); printk(KERN_WARNING "nbd (pid %d: %s) got signal %d\n", current->pid, current->comm, dequeue_signal(current, ¤t->blocked, &info)); spin_unlock_irqrestore(¤t->sighand->siglock, flags); result = -EINTR; break; } if (result <= 0) { if (result == 0) result = -EPIPE; /* short read */ break; } size -= result; buf += result; } while (size > 0); spin_lock_irqsave(¤t->sighand->siglock, flags); current->blocked = oldset; recalc_sigpending(); spin_unlock_irqrestore(¤t->sighand->siglock, flags); return result; }
static int tpmd_handle_command(const uint8_t *in, uint32_t in_size) { int res; struct msghdr msg; struct kvec vec; /* send command to tpmd */ memset(&msg, 0, sizeof(msg)); vec.iov_base = (void*)in; vec.iov_len = in_size; res = kernel_sendmsg(tpmd_sock, &msg, &vec, 1, in_size); if (res < 0) { error("sock_sendmsg() failed: %d\n", res); return res; } /* receive response from tpmd */ tpm_response.size = TPM_CMD_BUF_SIZE; tpm_response.data = kmalloc(tpm_response.size, GFP_KERNEL); if (tpm_response.data == NULL) return -1; memset(&msg, 0, sizeof(msg)); vec.iov_base = (void*)tpm_response.data; vec.iov_len = tpm_response.size; res = kernel_recvmsg(tpmd_sock, &msg, &vec, 1, tpm_response.size, 0); if (res < 0) { error("sock_recvmsg() failed: %d\n", res); tpm_response.data = NULL; return res; } tpm_response.size = res; return 0; }
/** * @brief Raises a transport event on the provided event ID (address). This * function is called from a comm_transp provider, such as comm_transp_mvp, * when it needs to signal an event on a given channel. * @param targetEvID opaque event channel ID (interpreted by implementation). * @param transpID ID of transport to signal. * @param eventType event type to raise. * @return 0 if successful, -1 otherwise. */ int CommTranspEvent_Raise(unsigned int targetEvID, CommTranspID *transpID, CommTranspIOEvent eventType) { struct sockaddr_mk guestAddr; struct msghdr msg; struct kvec vec[1]; int rc; CommEvent event; if (!sock || !transpID) return -1; (void)targetEvID; /* Currently unused. */ guestAddr.mk_family = AF_MKSCK; guestAddr.mk_addr.addr = Mksck_AddrInit(transpID->d32[0], MKSCK_PORT_COMM_EV); memset(&msg, 0, sizeof (msg)); msg.msg_name = &guestAddr; msg.msg_namelen = sizeof (guestAddr); event.id = *transpID; event.event = eventType; vec[0].iov_base = &event; vec[0].iov_len = sizeof (event); rc = kernel_sendmsg(sock, &msg, vec, 1, sizeof (event)); rc = (rc < 0) ? -1 : 0; return rc; }
int smb_send(struct socket *ssocket, struct smb_hdr *smb_buffer, unsigned int smb_buf_length, struct sockaddr *sin) { int rc = 0; int i = 0; struct msghdr smb_msg; struct kvec iov; unsigned len = smb_buf_length + 4; if(ssocket == NULL) return -ENOTSOCK; /* BB eventually add reconnect code here */ iov.iov_base = smb_buffer; iov.iov_len = len; smb_msg.msg_name = sin; smb_msg.msg_namelen = sizeof (struct sockaddr); smb_msg.msg_control = NULL; smb_msg.msg_controllen = 0; smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL; /* BB add more flags?*/ /* smb header is converted in header_assemble. bcc and rest of SMB word area, and byte area if necessary, is converted to littleendian in cifssmb.c and RFC1001 len is converted to bigendian in smb_send Flags2 is converted in SendReceive */ smb_buffer->smb_buf_length = cpu_to_be32(smb_buffer->smb_buf_length); cFYI(1, ("Sending smb of length %d ", smb_buf_length)); dump_smb(smb_buffer, len); while (len > 0) { rc = kernel_sendmsg(ssocket, &smb_msg, &iov, 1, len); if ((rc == -ENOSPC) || (rc == -EAGAIN)) { i++; if(i > 60) { cERROR(1, ("sends on sock %p stuck for 30 seconds", ssocket)); rc = -EAGAIN; break; } set_current_state(TASK_INTERRUPTIBLE); schedule_timeout(HZ/2); continue; } if (rc < 0) break; iov.iov_base += rc; iov.iov_len -= rc; len -= rc; } if (rc < 0) { cERROR(1,("Error %d sending data on socket to server.", rc)); } else { rc = 0; } return rc; }
static int send_remote_info (struct socket *sock, struct ib_side_info *info) { struct msghdr hdr; struct kvec iov; int ret; printk (KERN_INFO "send_remote_info\n"); iov.iov_base = info; iov.iov_len = sizeof (*info); memset (&hdr, 0, sizeof (hdr)); while (iov.iov_len) { ret = kernel_sendmsg (sock, &hdr, &iov, 1, iov.iov_len); if (ret < 0) { printk (KERN_INFO "sock_sendmsg error: %d\n", ret); return ret; } if (!ret) break; iov.iov_base += ret; iov.iov_len -= ret; } return 0; }
static int vdev_socket_send(unsigned char* data ,int len) { int length = 0; struct kvec vec; struct msghdr msg; memset(&msg,0,sizeof(msg)); vec.iov_base=data; vec.iov_len=len; if(client_sock == NULL) { return -3; } if(client_sock->state != SS_CONNECTED) { printk("vdev server: send not accept\n"); return -1; } length=kernel_sendmsg(client_sock,&msg,&vec,1,len); /*send message */ if(length<0){ printk("vdev server: kernel_sendmsg error = %d\n",length); return -2; } return 0; }
/* send datagram */ static int my_udp_msgsend(struct socket *s) { int err; /* address to send to */ struct sockaddr_in raddr = { .sin_family = AF_INET, .sin_port = htons(MY_UDP_REMOTE_PORT), .sin_addr = { htonl(INADDR_LOOPBACK) } }; int raddrlen = sizeof(raddr); /* message */ struct msghdr msg; struct iovec iov; char *buffer = MY_TEST_MESSAGE; int len = strlen(buffer) + 1; /* TODO: build message */ memset(&iov, 0, sizeof(iov)) iov.iov_base = buffer; iov.iov_len = len; memset(&msg, 0, sizeof(msg)); msg.msg_name = &raddr; msg.msg_iov = &iov; msg.msg_iovlen = 1; msg.msg_control = NULL; msg.msg_controllen = 0; msg.msg_namelen = raddrlen; /* TODO: send the message down the socket */ err = kernel_sendmsg(sock, &msg, (struct kvec*)&iov, 1, len); /* TODO: return error code */ return err; }
int myclient(void) { struct socket *sock; struct sockaddr_in s_addr; unsigned short portnum = 0x8888; 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 = in_aton("192.168.209.134"); /*server ip is 192.168.209.134*/ sock = (struct socket *) kmalloc(sizeof(struct socket), GFP_KERNEL); /*create a socket*/ ret = sock_create_kern(AF_INET, SOCK_STREAM, 0, &sock); if (ret < 0) { printk("client:socket create error!\n"); return ret; } printk("client: socket create ok!\n"); /*connect server*/ ret = sock->ops->connect(sock, (struct sockaddr *) &s_addr, sizeof(s_addr), 0); if (ret != 0) { printk("client:connect error!\n"); return ret; } printk("client:connect ok!\n"); /*kmalloc sendbuf*/ char *sendbuf = NULL; sendbuf = kmalloc(1024, GFP_KERNEL); if (sendbuf == NULL) { printk("client: sendbuf kmalloc error!\n"); return -1; } memset(sendbuf, 1, 1024); struct kvec vec; struct msghdr msg; vec.iov_base = sendbuf; vec.iov_len = 1024; memset(&msg, 0, sizeof(msg)); ret = kernel_sendmsg(sock, &msg, &vec, 1, 1024); /*send message */ if (ret < 0) { printk("client: kernel_sendmsg error!\n"); return ret; } else if (ret != 1024) { printk("client: ret!=1024"); } printk("client:send ok!\n"); return ret; }
/* * Send or receive packet. */ static int sock_xmit(struct nbd_device *nbd, int send, void *buf, int size, int msg_flags) { struct socket *sock = nbd->sock; int result; struct msghdr msg; struct kvec iov; sigset_t blocked, oldset; unsigned long pflags = current->flags; if (unlikely(!sock)) { dev_err(disk_to_dev(nbd->disk), "Attempted %s on closed socket in sock_xmit\n", (send ? "send" : "recv")); return -EINVAL; } /* Allow interception of SIGKILL only * Don't allow other signals to interrupt the transmission */ siginitsetinv(&blocked, sigmask(SIGKILL)); sigprocmask(SIG_SETMASK, &blocked, &oldset); current->flags |= PF_MEMALLOC; do { sock->sk->sk_allocation = GFP_NOIO | __GFP_MEMALLOC; iov.iov_base = buf; iov.iov_len = size; msg.msg_name = NULL; msg.msg_namelen = 0; msg.msg_control = NULL; msg.msg_controllen = 0; msg.msg_flags = msg_flags | MSG_NOSIGNAL; if (send) result = kernel_sendmsg(sock, &msg, &iov, 1, size); else result = kernel_recvmsg(sock, &msg, &iov, 1, size, msg.msg_flags); if (result <= 0) { if (result == 0) result = -EPIPE; /* short read */ break; } size -= result; buf += result; } while (size > 0); sigprocmask(SIG_SETMASK, &oldset, NULL); tsk_restore_flags(current, pflags, PF_MEMALLOC); if (!send && nbd->xmit_timeout) mod_timer(&nbd->timeout_timer, jiffies + nbd->xmit_timeout); return result; }
int netfs_trans_send(struct netfs_trans *t, struct netfs_state *st) { int err; struct msghdr msg; BUG_ON(!t->iovec.iov_len); BUG_ON(t->iovec.iov_len > 1024*1024*1024); netfs_state_lock_send(st); if (!st->socket) { err = netfs_state_init(st); if (err) goto err_out_unlock_return; } msg.msg_iov = &t->iovec; msg.msg_iovlen = 1; msg.msg_name = NULL; msg.msg_namelen = 0; msg.msg_control = NULL; msg.msg_controllen = 0; msg.msg_flags = MSG_WAITALL; if (t->attached_pages) msg.msg_flags |= MSG_MORE; err = kernel_sendmsg(st->socket, &msg, (struct kvec *)msg.msg_iov, 1, t->iovec.iov_len); if (err <= 0) { printk("%s: failed to send contig transaction: t: %p, gen: %u, size: %zu, err: %d.\n", __func__, t, t->gen, t->iovec.iov_len, err); if (err == 0) err = -ECONNRESET; goto err_out_unlock_return; } dprintk("%s: sent %s transaction: t: %p, gen: %u, size: %zu, page_num: %u.\n", __func__, (t->page_num)?"partial":"full", t, t->gen, t->iovec.iov_len, t->page_num); err = 0; if (t->attached_pages) err = netfs_trans_send_pages(t, st); err_out_unlock_return: if (st->need_reset) netfs_state_exit(st); netfs_state_unlock_send(st); dprintk("%s: t: %p, gen: %u, err: %d.\n", __func__, t, t->gen, err); t->result = err; return err; }
/* * reject packets through the local endpoint */ void rxrpc_reject_packets(struct rxrpc_local *local) { struct sockaddr_rxrpc srx; struct rxrpc_skb_priv *sp; struct rxrpc_wire_header whdr; struct sk_buff *skb; struct msghdr msg; struct kvec iov[2]; size_t size; __be32 code; _enter("%d", local->debug_id); iov[0].iov_base = &whdr; iov[0].iov_len = sizeof(whdr); iov[1].iov_base = &code; iov[1].iov_len = sizeof(code); size = sizeof(whdr) + sizeof(code); msg.msg_name = &srx.transport; msg.msg_control = NULL; msg.msg_controllen = 0; msg.msg_flags = 0; memset(&whdr, 0, sizeof(whdr)); whdr.type = RXRPC_PACKET_TYPE_ABORT; while ((skb = skb_dequeue(&local->reject_queue))) { rxrpc_see_skb(skb, rxrpc_skb_rx_seen); sp = rxrpc_skb(skb); if (rxrpc_extract_addr_from_skb(&srx, skb) == 0) { msg.msg_namelen = srx.transport_len; code = htonl(skb->priority); whdr.epoch = htonl(sp->hdr.epoch); whdr.cid = htonl(sp->hdr.cid); whdr.callNumber = htonl(sp->hdr.callNumber); whdr.serviceId = htons(sp->hdr.serviceId); whdr.flags = sp->hdr.flags; whdr.flags ^= RXRPC_CLIENT_INITIATED; whdr.flags &= RXRPC_CLIENT_INITIATED; kernel_sendmsg(local->socket, &msg, iov, 2, size); } rxrpc_free_skb(skb, rxrpc_skb_rx_freed); } _leave(""); }
/* * Reply to a version request */ static void rxrpc_send_version_request(struct rxrpc_local *local, struct rxrpc_host_header *hdr, struct sk_buff *skb) { struct rxrpc_wire_header whdr; struct rxrpc_skb_priv *sp = rxrpc_skb(skb); struct sockaddr_rxrpc srx; struct msghdr msg; struct kvec iov[2]; size_t len; int ret; _enter(""); if (rxrpc_extract_addr_from_skb(local, &srx, skb) < 0) return; msg.msg_name = &srx.transport; msg.msg_namelen = srx.transport_len; msg.msg_control = NULL; msg.msg_controllen = 0; msg.msg_flags = 0; whdr.epoch = htonl(sp->hdr.epoch); whdr.cid = htonl(sp->hdr.cid); whdr.callNumber = htonl(sp->hdr.callNumber); whdr.seq = 0; whdr.serial = 0; whdr.type = RXRPC_PACKET_TYPE_VERSION; whdr.flags = RXRPC_LAST_PACKET | (~hdr->flags & RXRPC_CLIENT_INITIATED); whdr.userStatus = 0; whdr.securityIndex = 0; whdr._rsvd = 0; whdr.serviceId = htons(sp->hdr.serviceId); iov[0].iov_base = &whdr; iov[0].iov_len = sizeof(whdr); iov[1].iov_base = (char *)rxrpc_version_string; iov[1].iov_len = sizeof(rxrpc_version_string); len = iov[0].iov_len + iov[1].iov_len; _proto("Tx VERSION (reply)"); ret = kernel_sendmsg(local->socket, &msg, iov, 2, len); if (ret < 0) trace_rxrpc_tx_fail(local->debug_id, 0, ret, rxrpc_tx_fail_version_reply); _leave(""); }
/**************************************************************************** * * socksend * * send on a socket. * ***************************************************************************/ static int socksend(char *bufp, int size) { struct msghdr msg; struct iovec iov; int rc = -1; iov.iov_base = bufp; iov.iov_len = size; rc = kernel_sendmsg(knllog.sock, &msg, (struct kvec *) &iov, 1, size); if (rc < 0) { printk(KERN_ERR "sock send, rc=%d\n", rc); } return rc; }
/* * Send or receive packet. */ static int sock_xmit(struct socket *sock, int send, void *buf, int size, int msg_flags) { int result; struct msghdr msg; struct kvec iov; sigset_t blocked, oldset; /* Allow interception of SIGKILL only * Don't allow other signals to interrupt the transmission */ siginitsetinv(&blocked, sigmask(SIGKILL)); sigprocmask(SIG_SETMASK, &blocked, &oldset); do { sock->sk->sk_allocation = GFP_NOIO; iov.iov_base = buf; iov.iov_len = size; msg.msg_name = NULL; msg.msg_namelen = 0; msg.msg_control = NULL; msg.msg_controllen = 0; msg.msg_flags = msg_flags | MSG_NOSIGNAL; if (send) result = kernel_sendmsg(sock, &msg, &iov, 1, size); else result = kernel_recvmsg(sock, &msg, &iov, 1, size, 0); if (signal_pending(current)) { siginfo_t info; printk(KERN_WARNING "nbd (pid %d: %s) got signal %d\n", current->pid, current->comm, dequeue_signal_lock(current, ¤t->blocked, &info)); result = -EINTR; break; } if (result <= 0) { if (result == 0) result = -EPIPE; /* short read */ break; } size -= result; buf += result; } while (size > 0); sigprocmask(SIG_SETMASK, &oldset, NULL); return result; }
int lnet_sock_write(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; struct kvec iov = { .iov_base = buffer, .iov_len = nob }; struct msghdr msg = {NULL,}; LASSERT(nob > 0); /* * Caller may pass a zero timeout if she thinks the socket buffer is * empty enough to take the whole message immediately */ iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC, &iov, 1, nob); for (;;) { msg.msg_flags = !timeout ? MSG_DONTWAIT : 0; if (timeout) { /* Set send timeout to remaining time */ jiffies_to_timeval(jiffies_left, &tv); rc = kernel_setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(tv)); if (rc) { CERROR("Can't set socket send timeout %ld.%06d: %d\n", (long)tv.tv_sec, (int)tv.tv_usec, rc); return rc; } } then = jiffies; rc = kernel_sendmsg(sock, &msg, &iov, 1, nob); jiffies_left -= jiffies - then; if (rc < 0) return rc; if (!rc) { CERROR("Unexpected zero rc\n"); return -ECONNABORTED; } if (!msg_data_left(&msg)) break; if (jiffies_left <= 0) return -EAGAIN; } return 0; }
static int udp_sendto(struct socket *sock, void * buff, size_t len, unsigned flags, struct sockaddr *addr, int addr_len) { struct kvec vec; struct msghdr msg; vec.iov_base=buff; vec.iov_len=len; memset(&msg, 0x00, sizeof(msg)); msg.msg_name=addr; msg.msg_namelen=addr_len; msg.msg_flags = flags | MSG_DONTWAIT; return kernel_sendmsg(sock, &msg, &vec, 1, len); }
/* * Send or receive packet. */ static int sock_xmit(struct nbd_device *nbd, int send, void *buf, int size, int msg_flags) { struct socket *sock = nbd->sock; int result; struct msghdr msg; struct kvec iov; unsigned long pflags = current->flags; if (unlikely(!sock)) { dev_err(disk_to_dev(nbd->disk), "Attempted %s on closed socket in sock_xmit\n", (send ? "send" : "recv")); return -EINVAL; } current->flags |= PF_MEMALLOC; do { sock->sk->sk_allocation = GFP_NOIO | __GFP_MEMALLOC; iov.iov_base = buf; iov.iov_len = size; msg.msg_name = NULL; msg.msg_namelen = 0; msg.msg_control = NULL; msg.msg_controllen = 0; msg.msg_flags = msg_flags | MSG_NOSIGNAL; if (send) result = kernel_sendmsg(sock, &msg, &iov, 1, size); else result = kernel_recvmsg(sock, &msg, &iov, 1, size, msg.msg_flags); if (result <= 0) { if (result == 0) result = -EPIPE; /* short read */ break; } size -= result; buf += result; } while (size > 0); tsk_restore_flags(current, pflags, PF_MEMALLOC); if (!send && nbd->xmit_timeout) mod_timer(&nbd->timeout_timer, jiffies + nbd->xmit_timeout); return result; }
ssize_t write_vaddr_tcp(void * v, size_t is) { ssize_t s; struct kvec iov; struct msghdr msg; memset(&iov, 0, sizeof(struct iovec)); memset(&msg, 0, sizeof(struct msghdr)); iov.iov_base = v; iov.iov_len = is; s = kernel_sendmsg(accept, &msg, &iov, 1, is); return s; }
int send(struct socket* sock, unsigned char* buf, int len) { struct msghdr msg; struct kvec iov; int size = 0; if (sock->sk==NULL) return 0; iov.iov_base = buf; iov.iov_len = len; size = kernel_sendmsg(sock,&msg,&iov,1,len); return size; }
static int cmtp_send_frame(struct cmtp_session *session, unsigned char *data, int len) { struct socket *sock = session->sock; struct kvec iv = { data, len }; struct msghdr msg; BT_DBG("session %p data %p len %d", session, data, len); if (!len) return 0; memset(&msg, 0, sizeof(msg)); return kernel_sendmsg(sock, &msg, &iv, 1, len); }
/* * Send an ABORT call packet. */ int rxrpc_send_abort_packet(struct rxrpc_call *call) { struct rxrpc_connection *conn = NULL; struct rxrpc_abort_buffer pkt; struct msghdr msg; struct kvec iov[1]; rxrpc_serial_t serial; int ret; spin_lock_bh(&call->lock); if (call->conn) conn = rxrpc_get_connection_maybe(call->conn); spin_unlock_bh(&call->lock); if (!conn) return -ECONNRESET; msg.msg_name = &call->peer->srx.transport; msg.msg_namelen = call->peer->srx.transport_len; msg.msg_control = NULL; msg.msg_controllen = 0; msg.msg_flags = 0; pkt.whdr.epoch = htonl(conn->proto.epoch); pkt.whdr.cid = htonl(call->cid); pkt.whdr.callNumber = htonl(call->call_id); pkt.whdr.seq = 0; pkt.whdr.type = RXRPC_PACKET_TYPE_ABORT; pkt.whdr.flags = conn->out_clientflag; pkt.whdr.userStatus = 0; pkt.whdr.securityIndex = call->security_ix; pkt.whdr._rsvd = 0; pkt.whdr.serviceId = htons(call->service_id); pkt.abort_code = htonl(call->abort_code); iov[0].iov_base = &pkt; iov[0].iov_len = sizeof(pkt); serial = atomic_inc_return(&conn->serial); pkt.whdr.serial = htonl(serial); ret = kernel_sendmsg(conn->params.local->socket, &msg, iov, 1, sizeof(pkt)); rxrpc_put_connection(conn); return ret; }
int user_on_transmission_opportunity(struct socket *sock) { struct rte_mbuf *mbuf; struct msghdr msghdr; struct sockaddr_in sockaddrin; struct iovec iov; int i = 0; uint32_t to_send_this_time; uint64_t ts = rte_rdtsc(); user_on_tx_opportunity_called++; to_send_this_time = app_glue_calc_size_of_data_to_send(sock); if(likely(to_send_this_time > 0)) { mbuf = app_glue_get_buffer(); if (unlikely(mbuf == NULL)) { user_on_tx_opportunity_cannot_get_buff++; return 0; } mbuf->pkt.data_len = 1448; sockaddrin.sin_family = AF_INET; sockaddrin.sin_addr.s_addr = inet_addr("192.168.1.2"); sockaddrin.sin_port = htons(7777); msghdr.msg_namelen = sizeof(sockaddrin); msghdr.msg_name = &sockaddrin; msghdr.msg_iov = &iov; iov.head = mbuf; msghdr.msg_iovlen = 1; msghdr.msg_controllen = 0; msghdr.msg_control = 0; msghdr.msg_flags = 0; sock->sk->sk_route_caps |= NETIF_F_SG | NETIF_F_ALL_CSUM; i = kernel_sendmsg(sock, &msghdr, 1448); if(i <= 0) { rte_pktmbuf_free(mbuf); user_on_tx_opportunity_api_failed++; } } else { user_on_tx_opportunity_api_not_called++; } user_on_tx_opportunity_cycles += rte_rdtsc() - ts; return i; }
static void work_handler(struct work_struct *work) { struct work_struct_data *wsdata = (struct work_struct_data *)work; char *recvbuf=NULL; recvbuf=kmalloc(1024,GFP_KERNEL); if(recvbuf==NULL) { printk("server: recvbuf kmalloc error!\n"); return ; } memset(recvbuf, 0, sizeof(recvbuf)); //receive message from client struct kvec vec; struct msghdr msg; memset(&vec,0,sizeof(vec)); memset(&msg,0,sizeof(msg)); vec.iov_base=recvbuf; vec.iov_len=1024; int ret=0; ret=kernel_recvmsg(wsdata->client,&msg,&vec,1,1024,0); //printk("receive message:\n%s\n",recvbuf); //printk("receive size=%d\n",ret); char *buf2; buf2=dealrequest(recvbuf,buf2); kfree(recvbuf); //printk("\nbuf2 de dihzhi:%d\n",buf2); //printk("\n\n%s\n\n",buf2); //send message to client /////////////////////////////// int len; //iFileLen=sizeof(buf2); len=strlen(buf2)*sizeof(char); //printk("\n33==%s\nlen=%d\n",buf2,len); struct kvec vec2; struct msghdr msg2; vec2.iov_base=buf2; vec2.iov_len=len; memset(&msg2,0,sizeof(msg2)); ret= kernel_sendmsg(wsdata->client,&msg2,&vec2,1,len); kfree(buf2); buf2=NULL; //release client socket sock_release(wsdata->client); }
/* * Send a message to the Vkd server */ static int send_msg(char *data, unsigned len) { struct msghdr msg; struct iovec iov; int err; /* address to bind on */ struct sockaddr_vm serv_addr = { .svm_family = AF_VMCI, .svm_port = htons(REMOTE_PORT), .svm_cid = REMOTE_CID }; int addrlen = sizeof(serv_addr); /* create socket */ err = sock_create(AF_VMCI, SOCK_DGRAM, 0, &sock); if (err < 0) { // DLOG("Failed to create socket"); printk(KERN_DEBUG "Failed to create socket {%d}\n", err); goto out; } /*Prepare data for sending*/ memset(&iov, 0, sizeof(iov)); iov.iov_base = data; iov.iov_len = len + 1; /*UDP message*/ memset(&msg, 0, sizeof(msg)); msg.msg_name = &serv_addr; msg.msg_namelen = addrlen; msg.msg_iov = &iov; msg.msg_iovlen = 1; msg.msg_control = NULL; msg.msg_controllen = 0; err = kernel_sendmsg(sock, &msg, (struct kvec*)&iov, 1, len); if (err < 0) DLOG("Failed to send message {%d}"); sock->ops->release(sock); return 0; out: return err; }
int sendto(SOCKET socket_p, const char* buf, int len, int flags, const struct sockaddr *to, int tolen) { int rc; struct msghdr msg; struct kvec iov; msg.msg_control = NULL; msg.msg_controllen = 0; msg.msg_name = (struct sockaddr *)to; // will be struct sock_addr msg.msg_namelen = tolen; msg.msg_flags = 0; iov.iov_len = len; iov.iov_base = (char *)buf; rc = kernel_sendmsg(socket_p, &msg, &iov, 1, len); return rc; }
void btv_send_msg_thru_eth(const unsigned char *buf, int size) { struct socket *sock[NUM_OF_SOCKS]; struct sockaddr ksockaddr[NUM_OF_SOCKS] = {0}; struct msghdr msg; struct kvec iov; printk("Send Message Thru Eth\n"); for (;;) { /* To communicate TVSOC, we have to prepare two sockets for sync and async ports */ sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock[SOCK_FOR_SYNC]); sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock[SOCK_FOR_ASYNC]); /* initialize socket for sync command */ ksockaddr[SOCK_FOR_SYNC].sa_family = PF_INET; /* sockaddr.sin_addr.s_addr = inet_addr((const char*)("198.18.186.199")); */ //*((unsigned short *)&(ksockaddr.sa_data[0])) = 0x409c; /* 0x9c40:40000 */ *((unsigned short *)&(ksockaddr[SOCK_FOR_SYNC].sa_data[0])) = htons(40000); /* 0x9c40:40000 */ //*((unsigned int *)&(ksockaddr.sa_data[2])) = 0x0b9c082b; /* 0x2b:43 0x08:08 0x9c:156 0x0b:11 */ *((unsigned int *)&(ksockaddr[SOCK_FOR_SYNC].sa_data[2])) = 0xc7ba12c6; /* 0xc6:198 0x12:18 0xba:186 0xc7:199 */ /* initialize socket for async command */ ksockaddr[SOCK_FOR_ASYNC].sa_family = PF_INET; *((unsigned short *)&(ksockaddr[SOCK_FOR_ASYNC].sa_data[0])) = htons(40001); /* 0x9d40:40001 */ //*((unsigned int *)&(ksockaddr.sa_data[2])) = 0x0b9c082b; /* 0x2b:43 0x08:08 0x9c:156 0x0b:11 */ *((unsigned int *)&(ksockaddr[SOCK_FOR_ASYNC].sa_data[2])) = 0xc7ba12c6; /* 0xc6:198 0x12:18 0xba:186 0xc7:199 */ while(kernel_connect(sock[SOCK_FOR_SYNC], (struct sockaddr *)&ksockaddr[SOCK_FOR_SYNC], sizeof(struct sockaddr), 0) < 0) { printk("Cannot connect server sync port, Retry \n"); mdelay(REBOOT_CMD_INTERVAL_MSEC); } while(kernel_connect(sock[SOCK_FOR_ASYNC], (struct sockaddr *)&ksockaddr[SOCK_FOR_ASYNC], sizeof(struct sockaddr), 0) < 0) { printk("Cannot connect server async port, Retry \n"); mdelay(REBOOT_CMD_INTERVAL_MSEC); } iov.iov_base = (void *)buf; iov.iov_len = ETH_CMD_SIZE; msg.msg_name = (struct sockaddr *)&ksockaddr[SOCK_FOR_SYNC]; msg.msg_namelen = sizeof(struct sockaddr); msg.msg_iov = (struct iovec *) &iov; msg.msg_iovlen = 1; msg.msg_control = NULL; kernel_sendmsg(sock[SOCK_FOR_SYNC], &msg, &iov, 1, ETH_CMD_SIZE); sock_release(sock[SOCK_FOR_SYNC]); sock_release(sock[SOCK_FOR_ASYNC]); mdelay(ETHER_CMD_INTERVAL); } /* NOREACHED */ }