arch/all-unix/hidd/unixio/unixpkt_class.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Unix filedescriptor/socket IO
   6     Lang: english
   7 */
   8
   9 /* Unix includes */
  10 #define timeval sys_timeval /* We don't want the unix timeval to interfere with the AROS one */
  11 #include <sys/types.h>
  12 #include <fcntl.h>
  13 #include <unistd.h>
  14 #include <sys/stat.h>
  15 #include <sys/ioctl.h>
  16 #include <signal.h>
  17 #include <string.h>
  18 #include <errno.h>
  19
  20 #undef timeval
  21
  22 #define SDEBUG 0
  23 #define DEBUG 0
  24 #include <aros/debug.h>
  25
  26 #define __OOP_NOATTRBASES__
  27
  28 #include <exec/types.h>
  29 #include <exec/lists.h>
  30 #include <exec/interrupts.h>
  31 #include <exec/execbase.h>
  32 #include <exec/semaphores.h>
  33 #include <exec/memory.h>
  34 #include <exec/resident.h>
  35 #include <exec/tasks.h>
  36 #include <exec/ports.h>
  37 #include <exec/nodes.h>
  38 #include <intuition/intuition.h>
  39 #include <utility/tagitem.h>
  40 #include <utility/hooks.h>
  41 #include <hidd/unixio.h>
  42 #include <aros/asmcall.h>
  43 #include <aros/symbolsets.h>
  44
  45 #include <oop/oop.h>
  46 #include <proto/exec.h>
  47 #include <proto/hostlib.h>
  48 #include <proto/intuition.h>
  49 #include <proto/kernel.h>
  50 #include <proto/oop.h>
  51 #include <proto/utility.h>
  52 #include <proto/alib.h>
  53
  54 #include <devices/timer.h>
  55
  56 #include "unixio.h"
  57
  58 #include LC_LIBDEFS_FILE
  59
  60 #include <aros/asmcall.h>
  61
  62 #define HostLibBase data->HostLibBase
  63 #define KernelBase  data->KernelBase
  64
  65 struct uioPacket {
  66     int fd;
  67     struct sockaddr ifaddr;
  68     short ifindex;
  69 };
  70
  71 /*****************************************************************************************
  72
  73     NAME
  74         moHidd_UnixIO_OpenPacket
  75
  76     SYNOPSIS
  77         OOP_DoMethod(OOP_Object *obj, struct pHidd_UnixIO_OpenPacket *msg);
  78
  79         int Hidd_UnixIO_OpenPacket (OOP_Object *obj, const char *Interface, int *errno_ptr);
  80
  81     LOCATION
  82         unixio.hidd
  83
  84     FUNCTION
  85         Open a UNIX packet descriptor to a raw network interface
  86
  87     INPUTS
  88         obj       - An pointer to a UnixIO object
  89         interface - Name of a network interace (ie eth0)
  90         errno_ptr - An optional pointer to a location where error code (value of
  91                 UNIX errno variable) will be written
  92
  93     RESULT
  94         A number of the opened packet descriptor or -1 for an error.
  95
  96     NOTES
  97
  98     EXAMPLE
  99
 100     BUGS
 101
 102     SEE ALSO
 103         moHidd_UnixIO_ClosePacket
 104
 105     INTERNALS
 106
 107     TODO
 108
 109 *****************************************************************************************/
 110
 111 #ifdef HOST_OS_linux
 112 #include <net/if.h>
 113 #include <linux/if_ether.h>
 114 #include <linux/if_packet.h>
 115 #include <stdio.h> // for snprintf
 116
 117 #define htons(x)    AROS_WORD2BE(x)
 118
 119 struct uioPacket *linux_OpenPacket(struct LibCInterface *SysIFace, const char *interface)
 120 {
 121     struct ifreq ifr = {};
 122     struct uioPacket *pd;
 123
 124     D(bug("%s: interface='%s'\n", __func__, interface));
 125     if (strlen(interface) <= (sizeof(ifr.ifr_name)-1)) {
 126         if ((pd = AllocVec(sizeof(*pd), MEMF_ANY | MEMF_CLEAR))) {
 127             int sd;
 128             sd = SysIFace->socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
 129
 130             pd->fd = sd;
 131
 132             D(bug("%s: sd=%d\n", __func__, sd));
 133             if (sd >= 0) {
 134
 135                 strncpy(ifr.ifr_name, interface, sizeof(ifr.ifr_name));
 136                 ifr.ifr_name[sizeof(ifr.ifr_name)-1]=0;
 137
 138                 if (SysIFace->ioctl(sd, SIOCGIFFLAGS, &ifr) >= 0) {
 139                     ifr.ifr_flags |= IFF_PROMISC;
 140                     if (SysIFace->ioctl(sd, SIOCSIFFLAGS, &ifr) >= 0) {
 141                         if (SysIFace->ioctl(sd, SIOCGIFINDEX, &ifr) >= 0) {
 142                             pd->ifindex = ifr.ifr_ifindex;
 143                             if (SysIFace->ioctl(sd, SIOCGIFHWADDR, &ifr) >= 0) {
 144                                 pd->ifaddr = ifr.ifr_hwaddr;
 145                                 struct sockaddr_ll sll = {};
 146                                 sll.sll_family = AF_PACKET;
 147                                 sll.sll_ifindex = pd->ifindex;
 148                                 sll.sll_protocol = htons(ETH_P_ALL);
 149                                 if (SysIFace->bind(sd, (struct sockaddr *)&sll, sizeof(sll)) >= 0) {
 150                                     return pd;
 151                                 } else {
 152                                     D(bug("%s: sd=%d bind\n", __func__, sd));
 153                                 }
 154                             } else {
 155                                 D(bug("%s: sd=%d SIOCGIFHWADDR\n", __func__, sd));
 156                             }
 157                         } else {
 158                             D(bug("%s: sd=%d SIOCGIFINDEX, errno=%d\n", __func__, sd, *(SysIFace->__error())));
 159                         }
 160                     } else {
 161                         D(bug("%s: sd=%d SIOCSIFFLAGS, errno=%d\n", __func__, sd, *(SysIFace->__error())));
 162                     }
 163                 } else {
 164                     D(bug("%s: sd=%d SIOCGIFFLAGS, errno=%d\n", __func__, sd, *(SysIFace->__error())));
 165                 }
 166                 SysIFace->close(sd);
 167             }
 168             FreeVec(pd);
 169         }
 170     }
 171
 172     return NULL;
 173 }
 174 #endif
 175
 176 IPTR UXIO__Hidd_UnixIO__OpenPacket(OOP_Class *cl, OOP_Object *o, struct pHidd_UnixIO_OpenPacket *msg)
 177 {
 178     struct unixio_base *data = UD(cl);
 179     IPTR retval;
 180
 181     D(bug("[UnixIO] OpenFile(%s, 0x%04X, %o)\n", msg->FileName, msg->Flags, msg->Mode));
 182
 183     HostLib_Lock();
 184
 185 #ifdef HOST_OS_linux
 186     retval = (IPTR)linux_OpenPacket(data->SysIFace, msg->Interface);
 187     AROS_HOST_BARRIER
 188 #else
 189     retval = (IPTR)NULL;
 190 #endif
 191
 192     if (msg->ErrNoPtr)
 193         *msg->ErrNoPtr = *data->uio_Public.uio_ErrnoPtr;
 194
 195     HostLib_Unlock();
 196
 197     D(bug("[UnixIO] PD is %d, errno is %d\n", retval, *data->uio_Public.uio_ErrnoPtr));
 198
 199     return retval;
 200 }
 201
 202 /*****************************************************************************************
 203
 204     NAME
 205         moHidd_UnixIO_ClosePacket
 206
 207     SYNOPSIS
 208         OOP_DoMethod(OOP_Object *obj, struct pHidd_UnixIO_ClosePacket *msg);
 209
 210         int Hidd_UnixIO_ClosePacket (OOP_Object *obj, int fd, int *errno_ptr);
 211
 212     LOCATION
 213         unixio.hidd
 214
 215     FUNCTION
 216         Close a UNIX packet descriptor.
 217
 218     INPUTS
 219         obj       - A pointer to a UnixIO object.
 220         pd        - A packet descriptor to close.
 221         errno_ptr - An optional pointer to a location where error code (a value of UNIX
 222                     errno variable) will be written.
 223
 224     RESULT
 225         0 in case of success and -1 on failure.
 226
 227     NOTES
 228         Despite there's no return value, error code still can be set.
 229
 230     EXAMPLE
 231
 232     BUGS
 233
 234     SEE ALSO
 235         moHidd_UnixIO_OpenPacket
 236
 237     INTERNALS
 238
 239     TODO
 240
 241 *****************************************************************************************/
 242 IPTR UXIO__Hidd_UnixIO__ClosePacket(OOP_Class *cl, OOP_Object *o, struct pHidd_UnixIO_ClosePacket *msg)
 243 {
 244     struct unixio_base *data = UD(cl);
 245     int ret = 0;
 246
 247     if (msg->PD)
 248     {
 249         struct uioPacket *pd = msg->PD;
 250
 251         HostLib_Lock();
 252
 253         ret = data->SysIFace->close(pd->fd);
 254         AROS_HOST_BARRIER
 255
 256         if (msg->ErrNoPtr)
 257             *msg->ErrNoPtr = *data->uio_Public.uio_ErrnoPtr;
 258
 259         HostLib_Unlock();
 260
 261         FreeVec(pd);
 262     }
 263
 264     return ret;
 265 }
 266
 267 /*****************************************************************************************
 268
 269     NAME
 270         moHidd_UnixIO_RecvPacket
 271
 272     SYNOPSIS
 273         OOP_DoMethod(OOP_Object *obj, struct pHidd_UnixIO_RecvPacket *msg);
 274
 275         int Hidd_UnixIO_RecvPacket(OOP_Object *obj, int fd, void *buffer, int count, int *errno_ptr);
 276
 277     LOCATION
 278         unixio.hidd
 279
 280     FUNCTION
 281         Read packet from a Unix packet descriptor
 282
 283     INPUTS
 284         obj       - A pointer to a UnixIO object.
 285         pd        - A packet descriptor to read from.
 286         buffer    - A pointer to a buffer for data.
 287         count     - Number of bytes to read.
 288         errno_ptr - An optional pointer to a location where error code (a value of UNIX
 289                     errno variable) will be written.
 290
 291     RESULT
 292         Number of bytes actually read or -1 if error happened.
 293
 294     NOTES
 295         If there's no errno pointer supplied read operation will be automatically repeated if one
 296         of EINTR or EAGAIN error happens. If you supplied valid own errno_ptr you should be ready
 297         to handle these conditions yourself.
 298
 299         This method can be called from within interrupts.
 300
 301     EXAMPLE
 302
 303     BUGS
 304
 305     SEE ALSO
 306         moHidd_UnixIO_SendPacket
 307
 308     INTERNALS
 309
 310     TODO
 311
 312 *****************************************************************************************/
 313 IPTR UXIO__Hidd_UnixIO__RecvPacket(OOP_Class *cl, OOP_Object *o, struct pHidd_UnixIO_RecvPacket *msg)
 314 {
 315     struct unixio_base *data = UD(cl);
 316     int retval = -1;
 317     volatile int err = EINVAL;
 318
 319     if (msg->PD)
 320     {
 321         struct uioPacket *pd = msg->PD;
 322         int user = !KrnIsSuper();
 323
 324         if (user)
 325             HostLib_Lock();
 326
 327 #ifdef HOST_OS_linux
 328         do
 329         {
 330             retval = data->SysIFace->recvfrom(pd->fd, (void *)msg->Buffer, (size_t)msg->Length, MSG_DONTWAIT, NULL, NULL);
 331             AROS_HOST_BARRIER
 332
 333             err = *data->uio_Public.uio_ErrnoPtr;
 334             D(kprintf(" UXIO__Hidd_UnixIO__RecvPacket: retval %d errno %d  buff %x  count %d\n", retval, err, msg->Buffer, msg->Length));
 335
 336             if (msg->ErrNoPtr)
 337                 break;
 338
 339         } while((err == EINTR) || (err == EAGAIN));
 340 #else
 341         (void)pd;
 342 #endif /* HOST_OS_linux */
 343
 344         if (user)
 345             HostLib_Unlock();
 346     }
 347
 348     if (msg->ErrNoPtr)
 349         *msg->ErrNoPtr = err;
 350
 351     D(if (retval == -1) kprintf("UXIO__Hidd_UnixIO__RecvPacket: errno %d  buff %x  count %d\n", err, msg->Buffer, msg->Length));
 352
 353     return retval;
 354 }
 355
 356 /*****************************************************************************************
 357
 358     NAME
 359         moHidd_UnixIO_SendPacket
 360
 361     SYNOPSIS
 362         OOP_DoMethod(OOP_Object *obj, struct pHidd_UnixIO_SendPacket *msg);
 363
 364         int Hidd_UnixIO_SendPacket(OOP_Object *obj, int fd, void *buffer, int count, int *errno_ptr);
 365
 366     LOCATION
 367         unixio.hidd
 368
 369     FUNCTION
 370         Write data to a UNIX packet descriptor.
 371
 372     INPUTS
 373         obj       - A pointer to a UnixIO object.
 374         pd        - A packet descriptor to write to.
 375         buffer    - A pointer to a buffer containing data.
 376         count     - Number of bytes to write.
 377         errno_ptr - An optional pointer to a location where error code (a value of UNIX
 378                     errno variable) will be written.
 379
 380     RESULT
 381         Number of bytes actually written or -1 if error happened.
 382
 383     NOTES
 384         If there's no errno pointer supplied read operation will be automatically repeated if one
 385         of EINTR or EAGAIN error happens. If you supplied valid own errno_ptr you should be ready
 386         to handle these conditions yourself.
 387
 388         This method can be called from within interrupts.
 389
 390     EXAMPLE
 391
 392     BUGS
 393
 394     SEE ALSO
 395         moHidd_UnixIO_RecvPacket
 396
 397     INTERNALS
 398
 399     TODO
 400
 401 *****************************************************************************************/
 402 IPTR UXIO__Hidd_UnixIO__SendPacket(OOP_Class *cl, OOP_Object *o, struct pHidd_UnixIO_SendPacket *msg)
 403 {
 404     struct unixio_base *data = UD(cl);
 405     int retval = -1;
 406     volatile int err = EINVAL;
 407
 408     if (msg->PD)
 409     {
 410         struct uioPacket *pd = msg->PD;
 411         int user = !KrnIsSuper();
 412
 413         if (user)
 414             HostLib_Lock();
 415
 416 #ifdef HOST_OS_linux
 417         struct sockaddr_ll device = {};
 418
 419         device.sll_ifindex = pd->ifindex;
 420         device.sll_family = AF_PACKET;
 421         memcpy(device.sll_addr, pd->ifaddr.sa_data, 6);
 422         device.sll_halen = htons(6);
 423
 424         do
 425         {
 426             retval = data->SysIFace->sendto(pd->fd, (const void *)msg->Buffer, (size_t)msg->Length, 0, (struct sockaddr *)&device, sizeof(device));
 427             AROS_HOST_BARRIER
 428
 429             err = *data->uio_Public.uio_ErrnoPtr;
 430             D(kprintf(" UXIO__Hidd_UnixIO__SendPacket: retval %d errno %d  buff %x  count %d\n", retval, err, msg->Buffer, msg->Length));
 431
 432             if (msg->ErrNoPtr)
 433                 break;
 434
 435         } while((retval < 1) && ((err == EINTR) || (err == EAGAIN) || (err == 0)));
 436 #else
 437         (void)pd;
 438 #endif /* HOST_OS_linux */
 439
 440         if (user)
 441             HostLib_Unlock();
 442     }
 443
 444     if (msg->ErrNoPtr)
 445         *msg->ErrNoPtr = err;
 446
 447     D(if (retval == -1) kprintf("UXIO__Hidd_UnixIO__SendPacket: errno %d  buff %x  count %d\n", err, msg->Buffer, msg->Length));
 448
 449     return retval;
 450 }
 451
 452 IPTR UXIO__Hidd_UnixIO__PacketGetFileDescriptor(OOP_Class *cl, OOP_Object *o, struct pHidd_UnixIO_PacketGetFileDescriptor *msg)
 453 {
 454     if (msg->PD)
 455     {
 456         struct uioPacket *pd = msg->PD;
 457
 458         return pd->fd;
 459     }
 460
 461     return -1;
 462 }
 463
 464 IPTR UXIO__Hidd_UnixIO__PacketGetMACAddress(OOP_Class *cl, OOP_Object *o, struct pHidd_UnixIO_PacketGetMACAddress *msg)
 465 {
 466     if (msg->PD)
 467     {
 468         struct uioPacket *pd = msg->PD;
 469
 470         if (msg->MACAddress)
 471             memcpy(msg->MACAddress, pd->ifaddr.sa_data, 6);
 472
 473         return 6;
 474     }
 475
 476     return -1;
 477 }