Changeset 9d9bfaf in rtems-libbsd


Ignore:
Timestamp:
Oct 14, 2013, 2:14:19 PM (6 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
4.11, afaeccc05a556f6aa25ba044a7e49d6aa634a59e, freebsd-9.3, master
Children:
57f2002
Parents:
ec702ab
git-author:
Sebastian Huber <sebastian.huber@…> (10/14/13 14:14:19)
git-committer:
Sebastian Huber <sebastian.huber@…> (10/31/13 12:18:48)
Message:

Use send/recv functions from FreeBSD

Use recvfrom(), recvmsg(), sendto() and sendmsg() from FreeBSD.

Files:
1 deleted
6 edited

Legend:

Unmodified
Added
Removed
  • Makefile

    rec702ab r9d9bfaf  
    8080LIB_C_FILES += rtemsbsd/rtems/rtems-bsd-synch.c
    8181LIB_C_FILES += rtemsbsd/rtems/rtems-bsd-syscall-api.c
    82 LIB_C_FILES += rtemsbsd/rtems/rtems-bsd-syscalls.c
    8382LIB_C_FILES += rtemsbsd/rtems/rtems-bsd-sysctlbyname.c
    8483LIB_C_FILES += rtemsbsd/rtems/rtems-bsd-sysctl.c
  • freebsd-to-rtems.py

    rec702ab r9d9bfaf  
    637637                'rtems/rtems-bsd-synch.c',
    638638                'rtems/rtems-bsd-syscall-api.c',
    639                 'rtems/rtems-bsd-syscalls.c',
    640639                'rtems/rtems-bsd-sysctlbyname.c',
    641640                'rtems/rtems-bsd-sysctl.c',
  • freebsd/sys/kern/uipc_syscalls.c

    rec702ab r9d9bfaf  
    9999#endif /* __rtems__ */
    100100
    101 #ifndef __rtems__
    102101static int sendit(struct thread *td, int s, struct msghdr *mp, int flags);
    103102static int recvit(struct thread *td, int s, struct msghdr *mp, void *namelenp);
    104103
     104#ifndef __rtems__
    105105static int accept1(struct thread *td, struct accept_args *uap, int compat);
    106106static int do_sendfile(struct thread *td, struct sendfile_args *uap, int compat);
     
    864864        return (error);
    865865}
    866 
     866#endif /* __rtems__ */
     867
     868#ifdef __rtems__
     869static int
     870kern_sendit( struct thread *td, int s, struct msghdr *mp, int flags,
     871    struct mbuf *control, enum uio_seg segflg);
     872#endif /* __rtems__ */
    867873static int
    868874sendit(td, s, mp, flags)
     
    987993                if (error == EPIPE && !(so->so_options & SO_NOSIGPIPE) &&
    988994                    !(flags & MSG_NOSIGNAL)) {
     995#ifndef __rtems__
    989996                        PROC_LOCK(td->td_proc);
    990997                        tdksignal(td, SIGPIPE, NULL);
    991998                        PROC_UNLOCK(td->td_proc);
     999#else /* __rtems__ */
     1000                /* FIXME: Determine if we really want to use signals */
     1001#endif /* __rtems__ */
    9921002                }
    9931003        }
     
    10051015}
    10061016
     1017#ifndef __rtems__
    10071018int
    10081019sendto(td, uap)
     1020#else /* __rtems__ */
     1021static int
     1022rtems_bsd_sendto(td, uap)
     1023#endif /* __rtems__ */
    10091024        struct thread *td;
    10101025        struct sendto_args /* {
     
    10341049        return (error);
    10351050}
    1036 
     1051#ifdef __rtems__
     1052ssize_t
     1053sendto(int socket, const void *message, size_t length, int flags,
     1054    const struct sockaddr *dest_addr, socklen_t dest_len)
     1055{
     1056        struct thread *td = rtems_bsd_get_curthread_or_null();
     1057        struct sendto_args ua = {
     1058                .s = socket,
     1059                .buf = (caddr_t) message,
     1060                .len = length,
     1061                .flags = flags,
     1062                .to = (caddr_t) dest_addr,
     1063                .tolen = dest_len
     1064        };
     1065        int error;
     1066
     1067        if (td != NULL) {
     1068                error = rtems_bsd_sendto(td, &ua);
     1069        } else {
     1070                error = ENOMEM;
     1071        }
     1072
     1073        if (error == 0) {
     1074                return td->td_retval[0];
     1075        } else {
     1076                rtems_set_errno_and_return_minus_one(error);
     1077        }
     1078}
     1079#endif /* __rtems__ */
     1080
     1081#ifndef __rtems__
    10371082#ifdef COMPAT_OLDSOCK
    10381083int
     
    10881133}
    10891134#endif
    1090 
     1135#endif /* __rtems__ */
     1136
     1137#ifndef __rtems__
    10911138int
    10921139sendmsg(td, uap)
     1140#else /* __rtems__ */
     1141static int
     1142rtems_bsd_sendmsg(td, uap)
     1143#endif /* __rtems__ */
    10931144        struct thread *td;
    10941145        struct sendmsg_args /* {
     
    11161167        return (error);
    11171168}
    1118 
     1169#ifdef __rtems__
     1170ssize_t
     1171sendmsg(int socket, const struct msghdr *message, int flags)
     1172{
     1173        struct thread *td = rtems_bsd_get_curthread_or_null();
     1174        struct sendmsg_args ua = {
     1175                .s = socket,
     1176                .msg = message,
     1177                .flags = flags
     1178        };
     1179        int error;
     1180
     1181        if (td != NULL) {
     1182                error = rtems_bsd_sendmsg(td, &ua);
     1183        } else {
     1184                error = ENOMEM;
     1185        }
     1186
     1187        if (error == 0) {
     1188                return td->td_retval[0];
     1189        } else {
     1190                rtems_set_errno_and_return_minus_one(error);
     1191        }
     1192}
     1193#endif /* __rtems__ */
     1194
     1195#ifdef __rtems__
     1196static
     1197#endif /* __rtems__ */
    11191198int
    11201199kern_recvit(td, s, mp, fromseg, controlp)
     
    13011380}
    13021381
     1382#ifndef __rtems__
    13031383int
    13041384recvfrom(td, uap)
     1385#else /* __rtems__ */
     1386static int
     1387rtems_bsd_recvfrom(td, uap)
     1388#endif /* __rtems__ */
    13051389        struct thread *td;
    13061390        struct recvfrom_args /* {
     
    13361420        return(error);
    13371421}
    1338 
     1422#ifdef __rtems__
     1423ssize_t
     1424recvfrom(int socket, void *__restrict buffer, size_t length, int flags,
     1425    struct sockaddr *__restrict address, socklen_t *__restrict address_len)
     1426{
     1427        struct thread *td = rtems_bsd_get_curthread_or_null();
     1428        struct recvfrom_args ua = {
     1429                .s = socket,
     1430                .buf = buffer,
     1431                .len = length,
     1432                .flags = flags,
     1433                .from = address,
     1434                .fromlenaddr = address_len
     1435        };
     1436        int error;
     1437
     1438        if (td != NULL) {
     1439                error = rtems_bsd_recvfrom(td, &ua);
     1440        } else {
     1441                error = ENOMEM;
     1442        }
     1443
     1444        if (error == 0) {
     1445                return td->td_retval[0];
     1446        } else {
     1447                rtems_set_errno_and_return_minus_one(error);
     1448        }
     1449}
     1450#endif /* __rtems__ */
     1451
     1452#ifndef __rtems__
    13391453#ifdef COMPAT_OLDSOCK
    13401454int
     
    14101524}
    14111525#endif
    1412 
     1526#endif /* __rtems__ */
     1527
     1528#ifndef __rtems__
    14131529int
    14141530recvmsg(td, uap)
     1531#else /* __rtems__ */
     1532static int
     1533rtems_bsd_recvmsg(td, uap)
     1534#endif /* __rtems__ */
    14151535        struct thread *td;
    14161536        struct recvmsg_args /* {
     
    14431563        free(iov, M_IOV);
    14441564        return (error);
     1565}
     1566#ifdef __rtems__
     1567ssize_t
     1568recvmsg(int socket, struct msghdr *message, int flags)
     1569{
     1570        struct thread *td = rtems_bsd_get_curthread_or_null();
     1571        struct recvmsg_args ua = {
     1572                .s = socket,
     1573                .msg = message,
     1574                .flags = flags
     1575        };
     1576        int error;
     1577
     1578        if (td != NULL) {
     1579                error = rtems_bsd_recvmsg(td, &ua);
     1580        } else {
     1581                error = ENOMEM;
     1582        }
     1583
     1584        if (error == 0) {
     1585                return td->td_retval[0];
     1586        } else {
     1587                rtems_set_errno_and_return_minus_one(error);
     1588        }
    14451589}
    14461590#endif /* __rtems__ */
     
    19622106}
    19632107#endif /* COMPAT_OLDSOCK */
     2108#endif /* __rtems__ */
    19642109
    19652110int
     
    20032148        return (error);
    20042149}
    2005 #endif /* __rtems__ */
    20062150
    20072151int
  • freebsd/sys/sys/sysproto.h

    rec702ab r9d9bfaf  
    128128        char data_l_[PADL_(int)]; int data; char data_r_[PADR_(int)];
    129129};
     130#endif /* __rtems__ */
    130131struct recvmsg_args {
    131132        char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)];
     
    135136struct sendmsg_args {
    136137        char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)];
     138#ifndef __rtems__
    137139        char msg_l_[PADL_(struct msghdr *)]; struct msghdr * msg; char msg_r_[PADR_(struct msghdr *)];
     140#else /* __rtems__ */
     141        char msg_l_[PADL_(struct msghdr *)]; const struct msghdr * msg; char msg_r_[PADR_(struct msghdr *)];
     142#endif /* __rtems__ */
    138143        char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)];
    139144};
     
    146151        char fromlenaddr_l_[PADL_(__socklen_t *__restrict)]; __socklen_t *__restrict fromlenaddr; char fromlenaddr_r_[PADR_(__socklen_t *__restrict)];
    147152};
    148 #endif /* __rtems__ */
    149153struct accept_args {
    150154        char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)];
     
    463467        char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)];
    464468};
     469#endif /* __rtems__ */
    465470struct sendto_args {
    466471        char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)];
     
    469474        char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)];
    470475        char to_l_[PADL_(caddr_t)]; caddr_t to; char to_r_[PADR_(caddr_t)];
     476#ifndef __rtems__
    471477        char tolen_l_[PADL_(int)]; int tolen; char tolen_r_[PADR_(int)];
    472 };
     478#else /* __rtems__ */
     479        char tolen_l_[PADL_(__socklen_t)]; __socklen_t tolen; char tolen_r_[PADR_(__socklen_t)];
    473480#endif /* __rtems__ */
     481};
    474482struct shutdown_args {
    475483        char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)];
  • rtemsbsd/include/machine/rtems-bsd-syscall-api.h

    rec702ab r9d9bfaf  
    7070int     listen(int, int);
    7171
     72ssize_t recvfrom(int, void *, size_t, int, struct sockaddr * __restrict, socklen_t * __restrict);
     73
     74ssize_t recvmsg(int, struct msghdr *, int);
     75
     76ssize_t sendto(int, const void *, size_t, int, const struct sockaddr *, socklen_t);
     77
     78ssize_t sendmsg(int, const struct msghdr *, int);
     79
    7280int     setsockopt(int, int, int, const void *, socklen_t);
    7381
  • testsuite/syscalls01/test_main.c

    rec702ab r9d9bfaf  
    232232
    233233static void
     234init_msg(struct msghdr *msg, struct sockaddr_in *addr, struct iovec *iov,
     235    void *buf, size_t n)
     236{
     237        memset(msg, 0, sizeof(*msg));
     238        memset(iov, 0, sizeof(*iov));
     239        iov->iov_base = buf;
     240        iov->iov_len = n;
     241        msg->msg_name = addr;
     242        msg->msg_namelen = sizeof(*addr);
     243        msg->msg_iov = iov;
     244        msg->msg_iovlen = 1;
     245}
     246
     247static void
    234248no_mem_task(rtems_task_argument arg)
    235249{
     
    9911005        errno = 0;
    9921006        n = write(sd, &buf[0], sizeof(buf));
     1007        assert(n == -1);
     1008        assert(errno == EBADF);
     1009
     1010        assert(rtems_resource_snapshot_check(&snapshot));
     1011}
     1012
     1013static void
     1014no_mem_socket_send_and_sendto_and_sendmsg(int fd)
     1015{
     1016        struct sockaddr_in addr;
     1017        struct iovec iov;
     1018        struct msghdr msg;
     1019        ssize_t n;
     1020        char buf[1];
     1021
     1022        init_addr(&addr);
     1023        init_msg(&msg, &addr, &iov, &buf[0], sizeof(buf));
     1024
     1025        errno = 0;
     1026        n = send(fd, &buf[0], sizeof(buf), 0);
     1027        assert(n == -1);
     1028        assert(errno == ENOMEM);
     1029
     1030        errno = 0;
     1031        n = sendto(fd, &buf[0], sizeof(buf), 0,
     1032            (const struct sockaddr *) &addr, sizeof(addr));
     1033        assert(n == -1);
     1034        assert(errno == ENOMEM);
     1035
     1036        errno = 0;
     1037        n = sendmsg(fd, &msg, 0);
     1038        assert(n == -1);
     1039        assert(errno == ENOMEM);
     1040}
     1041
     1042static void
     1043test_socket_send_and_sendto_and_sendmsg(void)
     1044{
     1045        rtems_resource_snapshot snapshot;
     1046        struct sockaddr_in addr;
     1047        struct iovec iov;
     1048        struct msghdr msg;
     1049        int sd;
     1050        int rv;
     1051        ssize_t n;
     1052        char buf[1];
     1053
     1054        puts("test socket send, sendto and sendmsg");
     1055
     1056        rtems_resource_snapshot_take(&snapshot);
     1057
     1058        init_addr(&addr);
     1059        init_msg(&msg, &addr, &iov, &buf[0], sizeof(buf));
     1060
     1061        sd = socket(PF_INET, SOCK_DGRAM, 0);
     1062        assert(sd >= 0);
     1063
     1064        do_no_mem_test(no_mem_socket_send_and_sendto_and_sendmsg, sd);
     1065
     1066        errno = 0;
     1067        n = send(sd, &buf[0], sizeof(buf), 0);
     1068        assert(n == -1);
     1069        assert(errno == EDESTADDRREQ);
     1070
     1071        errno = 0;
     1072        n = sendto(sd, &buf[0], sizeof(buf), 0,
     1073            (const struct sockaddr *) &addr, sizeof(addr));
     1074        assert(n == -1);
     1075        assert(errno == ENETUNREACH);
     1076
     1077        errno = 0;
     1078        n = sendmsg(sd, &msg, 0);
     1079        assert(n == -1);
     1080        assert(errno == ENETUNREACH);
     1081
     1082        rv = close(sd);
     1083        assert(rv == 0);
     1084
     1085        errno = 0;
     1086        n = send(sd, &buf[0], sizeof(buf), 0);
     1087        assert(n == -1);
     1088        assert(errno == EBADF);
     1089
     1090        errno = 0;
     1091        n = sendto(sd, &buf[0], sizeof(buf), 0,
     1092            (const struct sockaddr *) &addr, sizeof(addr));
     1093        assert(n == -1);
     1094        assert(errno == EBADF);
     1095
     1096        errno = 0;
     1097        n = sendmsg(sd, &msg, 0);
     1098        assert(n == -1);
     1099        assert(errno == EBADF);
     1100
     1101        assert(rtems_resource_snapshot_check(&snapshot));
     1102}
     1103
     1104static void
     1105no_mem_socket_recv_and_recvfrom_and_recvmsg(int fd)
     1106{
     1107        struct sockaddr_in addr;
     1108        socklen_t addr_len;
     1109        struct iovec iov;
     1110        struct msghdr msg;
     1111        ssize_t n;
     1112        char buf[1];
     1113
     1114        init_addr(&addr);
     1115        init_msg(&msg, &addr, &iov, &buf[0], sizeof(buf));
     1116
     1117        errno = 0;
     1118        n = recv(fd, &buf[0], sizeof(buf), 0);
     1119        assert(n == -1);
     1120        assert(errno == ENOMEM);
     1121
     1122        errno = 0;
     1123        addr_len = sizeof(addr);
     1124        n = recvfrom(fd, &buf[0], sizeof(buf), 0,
     1125            (struct sockaddr *) &addr, &addr_len);
     1126        assert(n == -1);
     1127        assert(errno == ENOMEM);
     1128
     1129        errno = 0;
     1130        n = recvmsg(fd, &msg, 0);
     1131        assert(n == -1);
     1132        assert(errno == ENOMEM);
     1133}
     1134
     1135static void
     1136test_socket_recv_and_recvfrom_and_recvmsg(void)
     1137{
     1138        rtems_resource_snapshot snapshot;
     1139        struct sockaddr_in addr;
     1140        socklen_t addr_len;
     1141        struct iovec iov;
     1142        struct msghdr msg;
     1143        int sd;
     1144        int rv;
     1145        ssize_t n;
     1146        char buf[1];
     1147        int enable = 1;
     1148
     1149        puts("test socket recv, recvfrom and recvmsg");
     1150
     1151        rtems_resource_snapshot_take(&snapshot);
     1152
     1153        init_addr(&addr);
     1154        init_msg(&msg, &addr, &iov, &buf[0], sizeof(buf));
     1155
     1156        sd = socket(PF_INET, SOCK_DGRAM, 0);
     1157        assert(sd >= 0);
     1158
     1159        rv = ioctl(sd, FIONBIO, &enable);
     1160        assert(rv == 0);
     1161
     1162        do_no_mem_test(no_mem_socket_recv_and_recvfrom_and_recvmsg, sd);
     1163
     1164        errno = 0;
     1165        n = recv(sd, &buf[0], sizeof(buf), 0);
     1166        assert(n == -1);
     1167        assert(errno == EAGAIN);
     1168
     1169        errno = 0;
     1170        addr_len = sizeof(addr);
     1171        n = recvfrom(sd, &buf[0], sizeof(buf), 0,
     1172            (struct sockaddr *) &addr, &addr_len);
     1173        assert(n == -1);
     1174        assert(errno == EAGAIN);
     1175
     1176        errno = 0;
     1177        n = recvmsg(sd, &msg, 0);
     1178        assert(n == -1);
     1179        assert(errno == EAGAIN);
     1180
     1181        rv = close(sd);
     1182        assert(rv == 0);
     1183
     1184        errno = 0;
     1185        n = recv(sd, &buf[0], sizeof(buf), 0);
     1186        assert(n == -1);
     1187        assert(errno == EBADF);
     1188
     1189        errno = 0;
     1190        addr_len = sizeof(addr);
     1191        n = recvfrom(sd, &buf[0], sizeof(buf), 0,
     1192            (struct sockaddr *) &addr, &addr_len);
     1193        assert(n == -1);
     1194        assert(errno == EBADF);
     1195
     1196        errno = 0;
     1197        n = recvmsg(sd, &msg, 0);
    9931198        assert(n == -1);
    9941199        assert(errno == EBADF);
     
    10141219        test_socket_getsockname();
    10151220        test_socket_read_and_write();
     1221        test_socket_send_and_sendto_and_sendmsg();
     1222        test_socket_recv_and_recvfrom_and_recvmsg();
    10161223
    10171224        puts("*** END OF " TEST_NAME " TEST ***");
Note: See TracChangeset for help on using the changeset viewer.