source: rtems/cpukit/libnetworking/rtems/rtems_syscall.c @ da154e14

4.11
Last change on this file since da154e14 was da154e14, checked in by Sebastian Huber <sebastian.huber@…>, on May 14, 2012 at 2:55:41 PM

Filesystem: Move operations to mount table entry

The scope of the file system operations is the file system instance.
The scope of the file system node handlers is the file location. The
benefit of moving the operations to the mount table entry is a size
reduction of the file location (rtems_filesystem_location_info_t). The
code size is slightly increased due to additional load instructions.

Restructure rtems_filesystem_mount_table_entry_t to improve cache
efficiency.

  • Property mode set to 100644
File size: 17.1 KB
Line 
1#if HAVE_CONFIG_H
2#include "config.h"
3#endif
4
5#include <string.h>
6#include <stdarg.h>
7/* #include <stdlib.h> */
8#include <stdio.h>
9#include <errno.h>
10
11#include <rtems.h>
12#include <rtems/libio_.h>
13#include <rtems/error.h>
14#include <rtems/rtems_bsdnet.h>
15
16#include <errno.h>
17#include <sys/types.h>
18#include <sys/param.h>
19#include <sys/mbuf.h>
20#include <sys/socket.h>
21#include <sys/socketvar.h>
22#include <sys/protosw.h>
23#include <sys/proc.h>
24#include <sys/fcntl.h>
25#include <sys/filio.h>
26#include <sys/sysctl.h>
27
28#include <net/if.h>
29#include <net/route.h>
30
31/*
32 *  Since we are "in the kernel", these do not get prototyped in sys/socket.h
33 */
34ssize_t send(int, const void *, size_t, int);
35ssize_t recv(int, void *, size_t, int);
36
37/*
38 * Hooks to RTEMS I/O system
39 */
40static const rtems_filesystem_file_handlers_r socket_handlers;
41
42/*
43 * Convert an RTEMS file descriptor to a BSD socket pointer.
44 */
45struct socket *
46rtems_bsdnet_fdToSocket (int fd)
47{
48  rtems_libio_t *iop;
49
50  /* same as rtems_libio_check_fd(_fd) but different return */
51  if ((uint32_t)fd >= rtems_libio_number_iops) {
52    errno = EBADF;
53    return NULL;
54  }
55  iop = &rtems_libio_iops[fd];
56
57  /* same as rtems_libio_check_is_open(iop) but different return */
58  if ((iop->flags & LIBIO_FLAGS_OPEN) == 0) {
59    errno = EBADF;
60    return NULL;
61  }
62
63  if (iop->pathinfo.handlers != &socket_handlers) {
64    errno = ENOTSOCK;
65    return NULL;
66  }
67
68  if (iop->data1 == NULL)
69    errno = EBADF;
70  return iop->data1;
71}
72
73/*
74 * Create an RTEMS file descriptor for a socket
75 */
76static int
77rtems_bsdnet_makeFdForSocket (void *so)
78{
79  rtems_libio_t *iop;
80  int fd;
81
82  iop = rtems_libio_allocate();
83  if (iop == 0)
84      rtems_set_errno_and_return_minus_one( ENFILE );
85
86  fd = iop - rtems_libio_iops;
87  iop->flags |= LIBIO_FLAGS_WRITE | LIBIO_FLAGS_READ;
88  iop->data0 = fd;
89  iop->data1 = so;
90  iop->pathinfo.handlers = &socket_handlers;
91  iop->pathinfo.mt_entry = &rtems_filesystem_null_mt_entry;
92  rtems_filesystem_location_add_to_mt_entry(&iop->pathinfo);
93  return fd;
94}
95
96/*
97 * Package system call argument into mbuf.
98 */
99static int
100sockargstombuf (struct mbuf **mp, const void *buf, int buflen, int type)
101{
102        struct mbuf *m;
103
104        if ((u_int)buflen > MLEN)
105                return (EINVAL);
106        m = m_get(M_WAIT, type);
107        if (m == NULL)
108                return (ENOBUFS);
109        m->m_len = buflen;
110        memcpy (mtod(m, caddr_t), buf, buflen);
111        *mp = m;
112        if (type == MT_SONAME) {
113                struct sockaddr *sa;
114                sa = mtod(m, struct sockaddr *);
115                sa->sa_len = buflen;
116        }
117        return 0;
118}
119
120/*
121 *********************************************************************
122 *                       BSD-style entry points                      *
123 *********************************************************************
124 */
125int
126socket (int domain, int type, int protocol)
127{
128        int fd;
129        int error;
130        struct socket *so;
131
132        rtems_bsdnet_semaphore_obtain ();
133        error = socreate(domain, &so, type, protocol, NULL);
134        if (error == 0) {
135                fd = rtems_bsdnet_makeFdForSocket (so);
136                if (fd < 0)
137                        soclose (so);
138        }
139        else {
140                errno = error;
141                fd = -1;
142        }
143        rtems_bsdnet_semaphore_release ();
144        return fd;
145}
146
147int
148bind (int s, struct sockaddr *name, int namelen)
149{
150        int error;
151        int ret = -1;
152        struct socket *so;
153        struct mbuf *nam;
154
155        rtems_bsdnet_semaphore_obtain ();
156        if ((so = rtems_bsdnet_fdToSocket (s)) != NULL) {
157                error = sockargstombuf (&nam, name, namelen, MT_SONAME);
158                if (error == 0) {
159                        error = sobind (so, nam);
160                        if (error == 0)
161                                ret = 0;
162                        else
163                                errno = error;
164                        m_freem (nam);
165                }
166                else {
167                        errno = error;
168                }
169        }
170        rtems_bsdnet_semaphore_release ();
171        return ret;
172}
173
174int
175connect (int s, struct sockaddr *name, int namelen)
176{
177        int error;
178        int ret = -1;
179        struct socket *so;
180        struct mbuf *nam;
181
182        rtems_bsdnet_semaphore_obtain ();
183        if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {
184                rtems_bsdnet_semaphore_release ();
185                return -1;
186        }
187        if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {
188                errno = EALREADY;
189                rtems_bsdnet_semaphore_release ();
190                return -1;
191        }
192        error = sockargstombuf (&nam, name, namelen, MT_SONAME);
193        if (error) {
194                errno = error;
195                rtems_bsdnet_semaphore_release ();
196                return -1;
197        }
198        error = soconnect (so, nam);
199        if (error)
200                goto bad;
201        if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {
202                m_freem(nam);
203                errno = EINPROGRESS;
204                rtems_bsdnet_semaphore_release ();
205                return -1;
206        }
207        while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
208                error = soconnsleep (so);
209                if (error)
210                        break;
211        }
212        if (error == 0) {
213                error = so->so_error;
214                so->so_error = 0;
215        }
216    bad:
217        so->so_state &= ~SS_ISCONNECTING;
218        m_freem (nam);
219        if (error)
220                errno = error;
221        else
222                ret = 0;
223        rtems_bsdnet_semaphore_release ();
224        return ret;
225}
226
227int
228listen (int s, int backlog)
229{
230        int error;
231        int ret = -1;
232        struct socket *so;
233
234        rtems_bsdnet_semaphore_obtain ();
235        if ((so = rtems_bsdnet_fdToSocket (s)) != NULL) {
236                error = solisten (so, backlog);
237                if (error == 0)
238                        ret = 0;
239                else
240                        errno = error;
241        }
242        rtems_bsdnet_semaphore_release ();
243        return ret;
244}
245
246int
247accept (int s, struct sockaddr *name, int *namelen)
248{
249        int fd;
250        struct socket *head, *so;
251        struct mbuf *nam;
252
253        rtems_bsdnet_semaphore_obtain ();
254        if ((head = rtems_bsdnet_fdToSocket (s)) == NULL) {
255                rtems_bsdnet_semaphore_release ();
256                return -1;
257        }
258        if ((head->so_options & SO_ACCEPTCONN) == 0) {
259                errno = EINVAL;
260                rtems_bsdnet_semaphore_release ();
261                return -1;
262        }
263        if ((head->so_state & SS_NBIO) && head->so_comp.tqh_first == NULL) {
264                errno = EWOULDBLOCK;
265                rtems_bsdnet_semaphore_release ();
266                return -1;
267        }
268        while (head->so_comp.tqh_first == NULL && head->so_error == 0) {
269                if (head->so_state & SS_CANTRCVMORE) {
270                        head->so_error = ECONNABORTED;
271                        break;
272                }
273                head->so_error = soconnsleep (head);
274        }
275        if (head->so_error) {
276                errno = head->so_error;
277                head->so_error = 0;
278                rtems_bsdnet_semaphore_release ();
279                return -1;
280        }
281
282        so = head->so_comp.tqh_first;
283        TAILQ_REMOVE(&head->so_comp, so, so_list);
284        head->so_qlen--;
285
286        fd = rtems_bsdnet_makeFdForSocket (so);
287        if (fd < 0) {
288                TAILQ_INSERT_HEAD(&head->so_comp, so, so_list);
289                head->so_qlen++;
290                soconnwakeup (head);
291                rtems_bsdnet_semaphore_release ();
292                return -1;
293        }
294        so->so_state &= ~SS_COMP;
295        so->so_head = NULL;
296
297        nam = m_get(M_WAIT, MT_SONAME);
298        (void) soaccept(so, nam);
299        if (name) {
300                 /* check length before it is destroyed */
301                if (*namelen > nam->m_len)
302                        *namelen = nam->m_len;
303                memcpy (name, mtod(nam, caddr_t), *namelen);
304        }
305        m_freem(nam);
306        rtems_bsdnet_semaphore_release ();
307        return (fd);
308
309}
310
311/*
312 *  Shutdown routine
313 */
314
315int
316shutdown (int s, int how)
317{
318      struct socket *so;
319      int error;
320
321      rtems_bsdnet_semaphore_obtain ();
322      if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {
323              rtems_bsdnet_semaphore_release ();
324              return -1;
325      }
326      error = soshutdown(so, how);
327      rtems_bsdnet_semaphore_release ();
328      if (error) {
329              errno = error;
330              return -1;
331      }
332      return 0;
333}
334
335/*
336 * All `transmit' operations end up calling this routine.
337 */
338ssize_t
339sendmsg (int s, const struct msghdr *mp, int flags)
340{
341        int ret = -1;
342        int error;
343        struct uio auio;
344        struct iovec *iov;
345        struct socket *so;
346        struct mbuf *to;
347        struct mbuf *control = NULL;
348        int i;
349        int len;
350
351        rtems_bsdnet_semaphore_obtain ();
352        if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {
353                rtems_bsdnet_semaphore_release ();
354                return -1;
355        }
356        auio.uio_iov = mp->msg_iov;
357        auio.uio_iovcnt = mp->msg_iovlen;
358        auio.uio_segflg = UIO_USERSPACE;
359        auio.uio_rw = UIO_WRITE;
360        auio.uio_offset = 0;
361        auio.uio_resid = 0;
362        iov = mp->msg_iov;
363        for (i = 0; i < mp->msg_iovlen; i++, iov++) {
364                if ((auio.uio_resid += iov->iov_len) < 0) {
365                        errno = EINVAL;
366                        rtems_bsdnet_semaphore_release ();
367                        return -1;
368                }
369        }
370        if (mp->msg_name) {
371                error = sockargstombuf (&to, mp->msg_name, mp->msg_namelen, MT_SONAME);
372                if (error) {
373                        errno = error;
374                        rtems_bsdnet_semaphore_release ();
375                        return -1;
376                }
377        }
378        else {
379                to = NULL;
380        }
381        if (mp->msg_control) {
382                if (mp->msg_controllen < sizeof (struct cmsghdr)) {
383                        errno = EINVAL;
384                        if (to)
385                                m_freem(to);
386                        rtems_bsdnet_semaphore_release ();
387                        return -1;
388                }
389                sockargstombuf (&control, mp->msg_control, mp->msg_controllen, MT_CONTROL);
390        }
391        else {
392                control = NULL;
393        }
394        len = auio.uio_resid;
395        error = sosend (so, to, &auio, (struct mbuf *)0, control, flags);
396        if (error) {
397                if (auio.uio_resid != len && (error == EINTR || error == EWOULDBLOCK))
398                        error = 0;
399        }
400        if (error)
401                errno = error;
402        else
403                ret = len - auio.uio_resid;
404        if (to)
405                m_freem(to);
406        rtems_bsdnet_semaphore_release ();
407        return (ret);
408}
409
410/*
411 * Send a message to a host
412 */
413ssize_t
414sendto (int s, const void *buf, size_t buflen, int flags, const struct sockaddr *to, int tolen)
415{
416        struct msghdr msg;
417        struct iovec iov;
418
419        iov.iov_base = (void *)buf;
420        iov.iov_len = buflen;
421        msg.msg_name = (caddr_t)to;
422        msg.msg_namelen = tolen;
423        msg.msg_iov = &iov;
424        msg.msg_iovlen = 1;
425        msg.msg_control = NULL;
426        msg.msg_controllen = 0;
427        return sendmsg (s, &msg, flags);
428}
429
430/*
431 * All `receive' operations end up calling this routine.
432 */
433ssize_t
434recvmsg (int s, struct msghdr *mp, int flags)
435{
436        int ret = -1;
437        int error;
438        struct uio auio;
439        struct iovec *iov;
440        struct socket *so;
441        struct mbuf *from = NULL, *control = NULL;
442        int i;
443        int len;
444
445        rtems_bsdnet_semaphore_obtain ();
446        if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {
447                rtems_bsdnet_semaphore_release ();
448                return -1;
449        }
450        auio.uio_iov = mp->msg_iov;
451        auio.uio_iovcnt = mp->msg_iovlen;
452        auio.uio_segflg = UIO_USERSPACE;
453        auio.uio_rw = UIO_READ;
454        auio.uio_offset = 0;
455        auio.uio_resid = 0;
456        iov = mp->msg_iov;
457        for (i = 0; i < mp->msg_iovlen; i++, iov++) {
458                if ((auio.uio_resid += iov->iov_len) < 0) {
459                        errno = EINVAL;
460                        rtems_bsdnet_semaphore_release ();
461                        return -1;
462                }
463        }
464        len = auio.uio_resid;
465        mp->msg_flags = flags;
466        error = soreceive (so, &from, &auio, (struct mbuf **)NULL,
467                        mp->msg_control ? &control : (struct mbuf **)NULL,
468                        &mp->msg_flags);
469        if (error) {
470                if (auio.uio_resid != len && (error == EINTR || error == EWOULDBLOCK))
471                        error = 0;
472        }
473        if (error) {
474                errno = error;
475        }
476        else {
477                ret = len - auio.uio_resid;
478                if (mp->msg_name) {
479                        len = mp->msg_namelen;
480                        if ((len <= 0) || (from == NULL)) {
481                                len = 0;
482                        }
483                        else {
484                                if (len > from->m_len)
485                                        len = from->m_len;
486                                memcpy (mp->msg_name, mtod(from, caddr_t), len);
487                        }
488                        mp->msg_namelen = len;
489                }
490                if (mp->msg_control) {
491                        struct mbuf *m;
492                        void *ctlbuf;
493
494                        len = mp->msg_controllen;
495                        m = control;
496                        mp->msg_controllen = 0;
497                        ctlbuf = mp->msg_control;
498
499                        while (m && (len > 0)) {
500                                unsigned int tocopy;
501
502                                if (len >= m->m_len)
503                                        tocopy = m->m_len;
504                                else {
505                                        mp->msg_flags |= MSG_CTRUNC;
506                                        tocopy = len;
507                                }
508                                memcpy(ctlbuf, mtod(m, caddr_t), tocopy);
509                                ctlbuf += tocopy;
510                                len -= tocopy;
511                                m = m->m_next;
512                        }
513                        mp->msg_controllen = ctlbuf - mp->msg_control;
514                }
515        }
516        if (from)
517                m_freem (from);
518        if (control)
519                m_freem (control);
520        rtems_bsdnet_semaphore_release ();
521        return (ret);
522}
523
524/*
525 * Receive a message from a host
526 */
527ssize_t
528recvfrom (int s, void *buf, size_t buflen, int flags, const struct sockaddr *from, int *fromlen)
529{
530        struct msghdr msg;
531        struct iovec iov;
532        int ret;
533
534        iov.iov_base = buf;
535        iov.iov_len = buflen;
536        msg.msg_name = (caddr_t)from;
537        if (fromlen)
538                msg.msg_namelen = *fromlen;
539        else
540        msg.msg_namelen = 0;
541        msg.msg_iov = &iov;
542        msg.msg_iovlen = 1;
543        msg.msg_control = NULL;
544        msg.msg_controllen = 0;
545        ret = recvmsg (s, &msg, flags);
546        if ((from != NULL) && (fromlen != NULL) && (ret >= 0))
547                *fromlen = msg.msg_namelen;
548        return ret;
549}
550
551int
552setsockopt (int s, int level, int name, const void *val, int len)
553{
554        struct socket *so;
555        struct mbuf *m = NULL;
556        int error;
557
558        rtems_bsdnet_semaphore_obtain ();
559        if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {
560                rtems_bsdnet_semaphore_release ();
561                return -1;
562        }
563        if (len > MLEN) {
564                errno = EINVAL;
565                rtems_bsdnet_semaphore_release ();
566                return -1;
567        }
568        if (val) {
569                error = sockargstombuf (&m, val, len, MT_SOOPTS);
570                if (error) {
571                        errno = error;
572                        rtems_bsdnet_semaphore_release ();
573                        return -1;
574                }
575        }
576        error = sosetopt(so, level, name, m);
577        if (error) {
578                errno = error;
579                rtems_bsdnet_semaphore_release ();
580                return -1;
581        }
582        rtems_bsdnet_semaphore_release ();
583        return 0;
584}
585
586int
587getsockopt (int s, int level, int name, void *aval, int *avalsize)
588{
589        struct socket *so;
590        struct mbuf *m = NULL, *m0;
591        char *val = aval;
592        int i, op, valsize;
593        int error;
594
595        rtems_bsdnet_semaphore_obtain ();
596        if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {
597                rtems_bsdnet_semaphore_release ();
598                return -1;
599        }
600        if (val)
601                valsize = *avalsize;
602        else
603                valsize = 0;
604        if (((error = sogetopt(so, level, name, &m)) == 0) && val && valsize && m) {
605                op = 0;
606                while (m && op < valsize) {
607                        i = valsize - op;
608                        if (i > m->m_len)
609                                i = m->m_len;
610                        memcpy (val, mtod(m, caddr_t), i);
611                        op += i;
612                        val += i;
613                        m0 = m;
614                        MFREE (m0, m);
615                }
616                *avalsize = op;
617        }
618        if (m != NULL)
619                (void) m_free(m);
620        if (error) {
621                errno = error;
622                rtems_bsdnet_semaphore_release ();
623                return -1;
624        }
625        rtems_bsdnet_semaphore_release ();
626        return 0;
627}
628
629static int
630getpeersockname (int s, struct sockaddr *name, int *namelen, int pflag)
631{
632        struct socket *so;
633        struct mbuf *m;
634        int len = *namelen;
635        int error;
636
637        rtems_bsdnet_semaphore_obtain ();
638        if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {
639                rtems_bsdnet_semaphore_release ();
640                return -1;
641        }
642        m = m_getclr(M_WAIT, MT_SONAME);
643        if (m == NULL) {
644                errno = ENOBUFS;
645                rtems_bsdnet_semaphore_release ();
646                return -1;
647        }
648        if (pflag)
649                error = (*so->so_proto->pr_usrreqs->pru_peeraddr)(so, m);
650        else
651                error = (*so->so_proto->pr_usrreqs->pru_sockaddr)(so, m);
652        if (error) {
653                m_freem(m);
654                errno = error;
655                rtems_bsdnet_semaphore_release ();
656                return -1;
657        }
658        if (len > m->m_len) {
659                len = m->m_len;
660                *namelen = len;
661        }
662        memcpy (name, mtod(m, caddr_t), len);
663        m_freem (m);
664        rtems_bsdnet_semaphore_release ();
665        return 0;
666}
667
668int
669getpeername (int s, struct sockaddr *name, int *namelen)
670{
671        return getpeersockname (s, name, namelen, 1);
672}
673int
674getsockname (int s, struct sockaddr *name, int *namelen)
675{
676        return getpeersockname (s, name, namelen, 0);
677}
678
679int
680sysctl(int *name, u_int namelen, void *oldp,
681       size_t *oldlenp, void *newp, size_t newlen)
682{
683  int    error;
684        size_t j;
685
686  rtems_bsdnet_semaphore_obtain ();
687  error = userland_sysctl (0, name, namelen, oldp, oldlenp, 1, newp, newlen, &j);
688  rtems_bsdnet_semaphore_release ();
689
690  if (oldlenp)
691    *oldlenp = j;
692
693  if (error)
694  {
695    errno = error;
696    return -1;
697  }
698  return 0;
699}
700
701/*
702 ************************************************************************
703 *                      RTEMS I/O HANDLER ROUTINES                      *
704 ************************************************************************
705 */
706static int
707rtems_bsdnet_close (rtems_libio_t *iop)
708{
709        struct socket *so;
710        int error;
711
712        rtems_bsdnet_semaphore_obtain ();
713        if ((so = iop->data1) == NULL) {
714                errno = EBADF;
715                rtems_bsdnet_semaphore_release ();
716                return -1;
717        }
718        error = soclose (so);
719        rtems_bsdnet_semaphore_release ();
720        if (error) {
721                errno = error;
722                return -1;
723        }
724        return 0;
725}
726
727static ssize_t
728rtems_bsdnet_read (rtems_libio_t *iop, void *buffer, size_t count)
729{
730        return recv (iop->data0, buffer, count, 0);
731}
732
733static ssize_t
734rtems_bsdnet_write (rtems_libio_t *iop, const void *buffer, size_t count)
735{
736        return send (iop->data0, buffer, count, 0);
737}
738
739static int
740so_ioctl (rtems_libio_t *iop, struct socket *so, uint32_t   command, void *buffer)
741{
742        switch (command) {
743        case FIONBIO:
744                if (*(int *)buffer) {
745                        iop->flags |= O_NONBLOCK;
746                        so->so_state |= SS_NBIO;
747                }
748                else {
749                        iop->flags &= ~O_NONBLOCK;
750                        so->so_state &= ~SS_NBIO;
751                }
752                return 0;
753
754        case FIONREAD:
755                *(int *)buffer = so->so_rcv.sb_cc;
756                return 0;
757        }
758
759        if (IOCGROUP(command) == 'i')
760                return ifioctl (so, command, buffer, NULL);
761        if (IOCGROUP(command) == 'r')
762                return rtioctl (command, buffer, NULL);
763        return (*so->so_proto->pr_usrreqs->pru_control)(so, command, buffer, 0);
764}
765
766static int
767rtems_bsdnet_ioctl (rtems_libio_t *iop, uint32_t   command, void *buffer)
768{
769        struct socket *so;
770        int error;
771
772        rtems_bsdnet_semaphore_obtain ();
773        if ((so = iop->data1) == NULL) {
774                errno = EBADF;
775                rtems_bsdnet_semaphore_release ();
776                return -1;
777        }
778        error = so_ioctl (iop, so, command, buffer);
779        rtems_bsdnet_semaphore_release ();
780        if (error) {
781                errno = error;
782                return -1;
783        }
784        return 0;
785}
786
787static int
788rtems_bsdnet_fcntl (rtems_libio_t *iop, int cmd)
789{
790        struct socket *so;
791
792        if (cmd == F_SETFL) {
793                rtems_bsdnet_semaphore_obtain ();
794                if ((so = iop->data1) == NULL) {
795                        rtems_bsdnet_semaphore_release ();
796                        return EBADF;
797                }
798                if (iop->flags & LIBIO_FLAGS_NO_DELAY)
799                        so->so_state |= SS_NBIO;
800                else
801                        so->so_state &= ~SS_NBIO;
802                rtems_bsdnet_semaphore_release ();
803        }
804        return 0;
805}
806
807static int
808rtems_bsdnet_fstat (const rtems_filesystem_location_info_t *loc, struct stat *sp)
809{
810        sp->st_mode = S_IFSOCK;
811        return 0;
812}
813
814static const rtems_filesystem_file_handlers_r socket_handlers = {
815        rtems_filesystem_default_open,          /* open */
816        rtems_bsdnet_close,                     /* close */
817        rtems_bsdnet_read,                      /* read */
818        rtems_bsdnet_write,                     /* write */
819        rtems_bsdnet_ioctl,                     /* ioctl */
820        rtems_filesystem_default_lseek,         /* lseek */
821        rtems_bsdnet_fstat,                     /* fstat */
822        rtems_filesystem_default_ftruncate,     /* ftruncate */
823        rtems_filesystem_default_fsync_or_fdatasync,    /* fsync */
824        rtems_filesystem_default_fsync_or_fdatasync,    /* fdatasync */
825        rtems_bsdnet_fcntl                      /* fcntl */
826};
Note: See TracBrowser for help on using the repository browser.