cegw: Support 32bit user-space under 64bit kernel

[can-eth-gw-linux.git] / net / can / canethgw.c

diff --git a/net/can/canethgw.c b/net/can/canethgw.c
index 5ef2433ac7866964ae22cacb676923ec13652326..283d75846a80ad27b9d8323e75ff19c295d6f208 100644 (file)
--- a/net/can/canethgw.c
+++ b/net/can/canethgw.c
@@ -33,20 +33,22 @@ struct cegw_job
        struct kref refcount;
        struct socket* can_sock;
        struct socket* udp_sock;
-       __u32  udp_dstcnt;
-       struct sockaddr_in udp_dst[0];
+       u32  udp_dstcnt;
+       u32  udp_addrlen;
+       u8   udp_dst[0];
 };
 
 static int cegw_udp2can(void *data);
 static int cegw_udp_send(struct socket *udp_sock, struct can_frame *cf,
-               struct sockaddr_in* addr);
+               struct sockaddr* addr, int addrlen);
 static int cegw_can2udp(void *data);
 static int cegw_can_send(struct socket *can_sock, struct can_frame *cf);
 static int cegw_thread_start(void *data);
 static int cegw_thread_stop(struct cegw_job *job);
 static void cegw_job_release(struct kref *ref);
 
-static int cegw_udp_send(struct socket *udp_sock, struct can_frame *cf, struct sockaddr_in* addr)
+static int cegw_udp_send(struct socket *udp_sock, struct can_frame *cf, struct sockaddr *addr,
+               int addrlen)
 {
        struct msghdr mh;
        struct kvec vec[2];
@@ -54,17 +56,18 @@ static int cegw_udp_send(struct socket *udp_sock, struct can_frame *cf, struct s
        __u16 type = CAN_FRAME;
 
        mh.msg_name = addr;
-       mh.msg_namelen = sizeof(*addr);
+       mh.msg_namelen = addrlen;
        mh.msg_control = NULL;
        mh.msg_controllen = 0;
        mh.msg_flags = 0;
 
        type = cpu_to_be16(type);
        vec[0].iov_base = &type;
+       vec[0].iov_len = sizeof(type);
        vec[1].iov_base = cf;
        vec[1].iov_len = sizeof(*cf);
 
-       err = kernel_sendmsg(udp_sock, &mh, vec, 2, sizeof(*cf));
+       err = kernel_sendmsg(udp_sock, &mh, vec, 2, sizeof(type)+sizeof(*cf));
 
        return err;
 }
@@ -114,7 +117,7 @@ static int cegw_udp2can(void *data)
                vec[1].iov_base = &cf;
                vec[1].iov_len = sizeof(cf);
                ret = kernel_recvmsg(udp_sock, &mh, vec, 2,
-                                    sizeof(cf), 0);
+                                    sizeof(type) + sizeof(cf), 0);
                if (ret != sizeof(type) + sizeof(cf))
                        break;
 
@@ -141,6 +144,7 @@ static int cegw_can2udp(void* data)
 {
        struct msghdr mh;
        struct kvec vec;
+       struct sockaddr *udst;
        struct can_frame cf;
        struct cegw_job* job = (struct cegw_job*)data;
        struct socket* udp_sock = job->udp_sock;
@@ -161,7 +165,8 @@ static int cegw_can2udp(void* data)
 
                cf.can_id = cpu_to_be32(cf.can_id);
                for (i=0; i<job->udp_dstcnt; i++) {
-                       cegw_udp_send(udp_sock, &cf, &job->udp_dst[i]);
+                       udst = (struct sockaddr *)(job->udp_dst + i*job->udp_addrlen);
+                       cegw_udp_send(udp_sock, &cf, udst, job->udp_addrlen);
                }
        }
 
@@ -266,9 +271,11 @@ static int cegw_release(struct inode *inode, struct file *file)
 static long cegw_ioctl_start(struct file *file, unsigned long arg)
 {
        int i;
+       int chckfam;
        int err = 0;
        __u32 dstcnt = 0;
        __u32 addrlen = 0;
+       struct sockaddr *sa;
        struct cegw_ioctl gwctl;
        struct cegw_job *job = NULL;
 
@@ -279,53 +286,64 @@ static long cegw_ioctl_start(struct file *file, unsigned long arg)
        dstcnt = gwctl.udp_dstcnt;
        addrlen = gwctl.udp_addrlen;
 
-       if (addrlen != sizeof(struct sockaddr_in))
+       if (addrlen != sizeof(struct sockaddr_in) && addrlen != sizeof(struct sockaddr_in6))
                return -EAFNOSUPPORT;
 
-       job = kmalloc(GFP_KERNEL, sizeof(*job) + dstcnt*addrlen );
+       /* ToDo: consider dstcnt maximum */
+       job = kmalloc(GFP_KERNEL, sizeof(*job) + dstcnt*addrlen);
        if (job == NULL)
                return -ENOMEM;
 
        err = copy_from_user(&job->udp_dst, (void __user *)(arg + sizeof(struct cegw_ioctl)), dstcnt*addrlen);
        if (err != 0) {
-               kfree(job);
-               return -EFAULT;
+               err = -EFAULT;
+               goto err_free;
        }
 
-       for (i=0; i<dstcnt; i++) {
-               if (job->udp_dst[i].sin_family != AF_INET) {
-                       kfree(job);
-                       return -EAFNOSUPPORT;
+       /* */
+       if (dstcnt > 0)
+               sa = (struct sockaddr *)job->udp_dst;
+               chckfam = sa->sa_family;
+
+       for (i=1; i<dstcnt; i++) {
+               sa = (struct sockaddr *)(job->udp_dst + i*addrlen);
+               if (sa->sa_family != chckfam) {
+                       err = -EAFNOSUPPORT;
+                       goto err_free;
                }
        }
 
        job->udp_sock = sockfd_lookup(gwctl.udp_sock, &err);
-       if (job->udp_sock == NULL) {
-               kfree(job);
-               return err;
-       }
+       if (job->udp_sock == NULL)
+               goto err_free;
 
        job->can_sock = sockfd_lookup(gwctl.can_sock, &err);
-       if (job->can_sock == NULL) {
-               fput(job->udp_sock->file);
-               kfree(job);
-               return err;
-       }
+       if (job->can_sock == NULL)
+               goto err_put_udp;
 
        if (job->can_sock->ops->family != AF_CAN ||
-           job->can_sock->type != CAN_RAW) {
-               kfree(job);
-               return -EBADF;
+           job->can_sock->type != SOCK_RAW) {
+               err = -EBADF;
+               goto err_put_all;
        }
 
        job->udp_dstcnt = dstcnt;
+       job->udp_addrlen = addrlen;
 
        err = cegw_thread_start(job);
        if (err != 0)
-               return err;
+               return err; /* cegw_thread_start performs cleaup for us.  */
 
        file->private_data = job;
        return 0;
+
+err_put_all:
+       fput(job->can_sock->file);
+err_put_udp:
+       fput(job->udp_sock->file);
+err_free:
+       kfree(job);
+       return err;
 }
 
 static long cegw_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
@@ -348,7 +366,8 @@ static const struct file_operations cegw_fops = {
        .owner = THIS_MODULE,
        .open = cegw_open,
        .release = cegw_release,
-       .unlocked_ioctl = cegw_ioctl
+       .unlocked_ioctl = cegw_ioctl,
+       .compat_ioctl = cegw_ioctl,
 };
 
 static struct miscdevice cegw_device = {
@@ -359,7 +378,7 @@ static struct miscdevice cegw_device = {
 
 static int __init cegw_init(void)
 {
-       printk(KERN_INFO "can: can-eth gateway\n");
+       pr_info("can: can-eth gateway\n");
        return misc_register(&cegw_device);
 }