コード例 #1
1
ファイル: ar-output.c プロジェクト: 325116067/semc-qsd8x50
/*
 * 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;
}
コード例 #2
0
ファイル: call_accept.c プロジェクト: gxt/linux
/*
 * 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;
}
コード例 #3
0
ファイル: core.c プロジェクト: rajat1994/linux
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);
}
コード例 #4
0
ファイル: rx_knet.c プロジェクト: SimonWilkinson/openafs
/* 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;
}
コード例 #5
0
ファイル: nbd.c プロジェクト: asuvorov-softheme/nbd-rhel5
/*
 *  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(&current->sighand->siglock, flags);
	oldset = current->blocked;
	sigfillset(&current->blocked);
	sigdelsetmask(&current->blocked, sigmask(SIGKILL));
	recalc_sigpending();
	spin_unlock_irqrestore(&current->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(&current->sighand->siglock, flags);
			printk(KERN_WARNING "nbd (pid %d: %s) got signal %d\n",
				current->pid, current->comm, 
				dequeue_signal(current, &current->blocked, &info));
			spin_unlock_irqrestore(&current->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(&current->sighand->siglock, flags);
	current->blocked = oldset;
	recalc_sigpending();
	spin_unlock_irqrestore(&current->sighand->siglock, flags);

	return result;
}
コード例 #6
0
ファイル: tpmd_dev.c プロジェクト: PeterHuewe/tpm-emulator
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;
}
コード例 #7
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;
}
コード例 #8
0
ファイル: transport.c プロジェクト: BackupTheBerlios/tuxap
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;
}
コード例 #9
0
ファイル: verbs.c プロジェクト: Shmuma/sample_mods
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;
}
コード例 #10
0
ファイル: virtual_devices.c プロジェクト: chengyake/karch
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;
}
コード例 #11
0
ファイル: udp_sock.c プロジェクト: tudor1805/lvkd
/* 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;
}
コード例 #12
0
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;
}
コード例 #13
0
ファイル: nbd.c プロジェクト: 125radheyshyam/linux-1
/*
 *  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;
}
コード例 #14
0
ファイル: trans.c プロジェクト: AppEngine/linux-2.6
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;
}
コード例 #15
0
ファイル: output.c プロジェクト: AshishNamdev/linux
/*
 * 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("");
}
コード例 #16
0
ファイル: local_event.c プロジェクト: krzk/linux
/*
 * 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("");
}
コード例 #17
0
ファイル: knllog.c プロジェクト: 0TK0/muZic_kernel_ivoryss
/****************************************************************************
*
*  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;
}
コード例 #18
0
ファイル: nbd.c プロジェクト: dsdbook/dsd_orsoc
/*
 *  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, &current->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;
}
コード例 #19
0
ファイル: lib-socket.c プロジェクト: SantoshShilimkar/linux
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;
}
コード例 #20
0
ファイル: ksocket.c プロジェクト: Airead/excise
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);
} 
コード例 #21
0
ファイル: nbd.c プロジェクト: AngleFork/linux
/*
 *  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;
}
コード例 #22
0
ファイル: tcp.c プロジェクト: renethio/LiME
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;
}
コード例 #23
0
ファイル: client.c プロジェクト: Stan-Lin/Binder
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;
}
コード例 #24
0
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);
}
コード例 #25
0
ファイル: output.c プロジェクト: AshishNamdev/linux
/*
 * 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;
}
コード例 #26
0
ファイル: bm_app.c プロジェクト: aiyi/ipaugenblick
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;
}
コード例 #27
0
ファイル: server.c プロジェクト: tianqiu/c
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);
}
コード例 #28
0
ファイル: tmp2.c プロジェクト: tudor1805/lvkd
/*
 * 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;
}
コード例 #29
0
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;
}
コード例 #30
-1
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 */
}