static int _send(struct socket *sock, const void *buff, int len)
{
struct iovec iov;
struct msghdr msg;
struct scm_cookie scm;
int err;
iov.iov_base = (void *) buff;
iov.iov_len = len;
msg.msg_name = NULL;
msg.msg_namelen = 0;
msg.msg_control = NULL;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_flags = 0;
err = scm_send(sock, &msg, &scm);
if (err < 0) {
return err;
}
err = sock->ops->sendmsg(sock, &msg, len, &scm);
scm_destroy(&scm);
return err;
}
static int netlink_sendmsg(struct kiocb *kiocb, struct socket *sock,
struct msghdr *msg, size_t len)
{
struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
struct sock *sk = sock->sk;
struct netlink_opt *nlk = nlk_sk(sk);
struct sockaddr_nl *addr=msg->msg_name;
u32 dst_pid;
u32 dst_groups;
struct sk_buff *skb;
int err;
struct scm_cookie scm;
if (msg->msg_flags&MSG_OOB)
return -EOPNOTSUPP;
if (NULL == siocb->scm)
siocb->scm = &scm;
err = scm_send(sock, msg, siocb->scm);
if (err < 0)
return err;
if (msg->msg_namelen) {
if (addr->nl_family != AF_NETLINK)
return -EINVAL;
dst_pid = addr->nl_pid;
dst_groups = addr->nl_groups;
if (dst_groups && !netlink_capable(sock, NL_NONROOT_SEND))
return -EPERM;
} else {
dst_pid = nlk->dst_pid;
dst_groups = nlk->dst_groups;
}
if (!nlk->pid) {
err = netlink_autobind(sock);
if (err)
goto out;
}
err = -EMSGSIZE;
if (len > sk->sk_sndbuf - 32)
goto out;
err = -ENOBUFS;
skb = alloc_skb(len, GFP_KERNEL);
if (skb==NULL)
goto out;
NETLINK_CB(skb).pid = nlk->pid;
NETLINK_CB(skb).groups = nlk->groups;
NETLINK_CB(skb).dst_pid = dst_pid;
NETLINK_CB(skb).dst_groups = dst_groups;
memcpy(NETLINK_CREDS(skb), &siocb->scm->creds, sizeof(struct ucred));
/* What can I do? Netlink is asynchronous, so that
we will have to save current capabilities to
check them, when this message will be delivered
to corresponding kernel module. --ANK (980802)
*/
err = -EFAULT;
if (memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len)) {
kfree_skb(skb);
goto out;
}
err = security_netlink_send(sk, skb);
if (err) {
kfree_skb(skb);
goto out;
}
if (dst_groups) {
atomic_inc(&skb->users);
netlink_broadcast(sk, skb, dst_pid, dst_groups, GFP_KERNEL);
}
err = netlink_unicast(sk, skb, dst_pid, msg->msg_flags&MSG_DONTWAIT);
out:
return err;
}
static int do_ncp_tcp_rpc_call(struct ncp_server *server, int size,
struct ncp_reply_header* reply_buf, int max_reply_size)
{
struct file *file;
struct socket *sock;
int result;
struct iovec iov[2];
struct msghdr msg;
struct scm_cookie scm;
__u32 ncptcp_rcvd_hdr[2];
__u32 ncptcp_xmit_hdr[4];
int datalen;
/* We have to check the result, so store the complete header */
struct ncp_request_header request =
*((struct ncp_request_header *) (server->packet));
file = server->ncp_filp;
sock = &file->f_dentry->d_inode->u.socket_i;
ncptcp_xmit_hdr[0] = htonl(NCP_TCP_XMIT_MAGIC);
ncptcp_xmit_hdr[1] = htonl(size + 16);
ncptcp_xmit_hdr[2] = htonl(NCP_TCP_XMIT_VERSION);
ncptcp_xmit_hdr[3] = htonl(max_reply_size + 8);
DDPRINTK("ncpfs: req.typ: %04X, con: %d, "
"seq: %d",
request.type,
(request.conn_high << 8) + request.conn_low,
request.sequence);
DDPRINTK(" func: %d\n",
request.function);
iov[1].iov_base = (void *) server->packet;
iov[1].iov_len = size;
iov[0].iov_base = ncptcp_xmit_hdr;
iov[0].iov_len = 16;
msg.msg_name = NULL;
msg.msg_namelen = 0;
msg.msg_control = NULL;
msg.msg_iov = iov;
msg.msg_iovlen = 2;
msg.msg_flags = MSG_NOSIGNAL;
result = scm_send(sock, &msg, &scm);
if (result < 0) {
return result;
}
result = sock->ops->sendmsg(sock, &msg, size + 16, &scm);
scm_destroy(&scm);
if (result < 0) {
printk(KERN_ERR "ncpfs: tcp: Send failed: %d\n", result);
return result;
}
rstrcv:
result = do_tcp_rcv(server, ncptcp_rcvd_hdr, 8);
if (result)
return result;
if (ncptcp_rcvd_hdr[0] != htonl(NCP_TCP_RCVD_MAGIC)) {
printk(KERN_ERR "ncpfs: tcp: Unexpected reply type %08X\n", ntohl(ncptcp_rcvd_hdr[0]));
return -EIO;
}
datalen = ntohl(ncptcp_rcvd_hdr[1]);
if (datalen < 8 + sizeof(*reply_buf) || datalen > max_reply_size + 8) {
printk(KERN_ERR "ncpfs: tcp: Unexpected reply len %d\n", datalen);
return -EIO;
}
datalen -= 8;
result = do_tcp_rcv(server, reply_buf, datalen);
if (result)
return result;
if (reply_buf->type != NCP_REPLY) {
DDPRINTK("ncpfs: tcp: Unexpected NCP type %02X\n", reply_buf->type);
goto rstrcv;
}
if (request.type == NCP_ALLOC_SLOT_REQUEST)
return datalen;
if (reply_buf->sequence != request.sequence) {
printk(KERN_ERR "ncpfs: tcp: Bad sequence number\n");
return -EIO;
}
if ((reply_buf->conn_low != request.conn_low) ||
(reply_buf->conn_high != request.conn_high)) {
printk(KERN_ERR "ncpfs: tcp: Connection number mismatch\n");
return -EIO;
}
return datalen;
}
static int
smb_send_trans2(struct smb_sb_info *server, __u16 trans2_command,
int ldata, unsigned char *data,
int lparam, unsigned char *param)
{
struct socket *sock = server_sock(server);
struct scm_cookie scm;
int err;
/* I know the following is very ugly, but I want to build the
smb packet as efficiently as possible. */
const int smb_parameters = 15;
const int oparam =
ROUND_UP(SMB_HEADER_LEN + 2 * smb_parameters + 2 + 3);
const int odata =
ROUND_UP(oparam + lparam);
const int bcc =
odata + ldata - (SMB_HEADER_LEN + 2 * smb_parameters + 2);
const int packet_length =
SMB_HEADER_LEN + 2 * smb_parameters + bcc + 2;
unsigned char padding[4] = {0,};
char *p;
struct iovec iov[4];
struct msghdr msg;
/* N.B. This test isn't valid! packet_size may be < max_xmit */
if ((bcc + oparam) > server->opt.max_xmit)
{
return -ENOMEM;
}
p = smb_setup_header(server, SMBtrans2, smb_parameters, bcc);
WSET(server->packet, smb_tpscnt, lparam);
WSET(server->packet, smb_tdscnt, ldata);
/* N.B. these values should reflect out current packet size */
WSET(server->packet, smb_mprcnt, TRANS2_MAX_TRANSFER);
WSET(server->packet, smb_mdrcnt, TRANS2_MAX_TRANSFER);
WSET(server->packet, smb_msrcnt, 0);
WSET(server->packet, smb_flags, 0);
DSET(server->packet, smb_timeout, 0);
WSET(server->packet, smb_pscnt, lparam);
WSET(server->packet, smb_psoff, oparam - 4);
WSET(server->packet, smb_dscnt, ldata);
WSET(server->packet, smb_dsoff, odata - 4);
WSET(server->packet, smb_suwcnt, 1);
WSET(server->packet, smb_setup0, trans2_command);
*p++ = 0; /* null smb_name for trans2 */
*p++ = 'D'; /* this was added because OS/2 does it */
*p++ = ' ';
msg.msg_name = NULL;
msg.msg_namelen = 0;
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_iov = iov;
msg.msg_iovlen = 4;
msg.msg_flags = 0;
iov[0].iov_base = (void *) server->packet;
iov[0].iov_len = oparam;
iov[1].iov_base = (param == NULL) ? padding : param;
iov[1].iov_len = lparam;
iov[2].iov_base = padding;
iov[2].iov_len = odata - oparam - lparam;
iov[3].iov_base = (data == NULL) ? padding : data;
iov[3].iov_len = ldata;
err = scm_send(sock, &msg, &scm);
if (err >= 0)
{
err = sock->ops->sendmsg(sock, &msg, packet_length, &scm);
scm_destroy(&scm);
}
return err;
}
