lib/libc_r/uthread/uthread_fcntl.c

   1 /*
   2  * Copyright (c) 1995-1998 John Birrell <jb@cimlogic.com.au>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the author nor the names of any co-contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * $FreeBSD$
  30  */
  31 #include <stdarg.h>
  32 #include <unistd.h>
  33 #include <fcntl.h>
  34 #include <pthread.h>
  35 #include "pthread_private.h"
  36
  37 __weak_reference(__fcntl, fcntl);
  38
  39 extern int __fcntl_compat(int fd, int cmd, ...);
  40
  41 int
  42 _fcntl(int fd, int cmd,...)
  43 {
  44         int             flags = 0;
  45         int             nonblock;
  46         int             oldfd;
  47         int             ret;
  48         va_list         ap;
  49
  50         /* Lock the file descriptor: */
  51         if ((ret = _FD_LOCK(fd, FD_RDWR, NULL)) == 0) {
  52                 /* Initialise the variable argument list: */
  53                 va_start(ap, cmd);
  54
  55                 /* Process according to file control command type: */
  56                 switch (cmd) {
  57                 /* Duplicate a file descriptor: */
  58                 case F_DUPFD:
  59                         /*
  60                          * Get the file descriptor that the caller wants to
  61                          * use:
  62                          */
  63                         oldfd = va_arg(ap, int);
  64
  65                         /* Initialise the file descriptor table entry: */
  66                         if ((ret = __sys_fcntl(fd, cmd, oldfd)) < 0) {
  67                         }
  68                         /* Initialise the file descriptor table entry: */
  69                         else if (_thread_fd_table_init(ret) != 0) {
  70                                 /* Quietly close the file: */
  71                                 __sys_close(ret);
  72
  73                                 /* Reset the file descriptor: */
  74                                 ret = -1;
  75                         } else {
  76                                 /*
  77                                  * Save the file open flags so that they can
  78                                  * be checked later:
  79                                  */
  80                                 _thread_fd_setflags(ret,
  81                                     _thread_fd_getflags(fd));
  82                         }
  83                         break;
  84                 case F_SETFD:
  85                         flags = va_arg(ap, int);
  86                         ret = __sys_fcntl(fd, cmd, flags);
  87                         break;
  88                 case F_GETFD:
  89                         ret = __sys_fcntl(fd, cmd, 0);
  90                         break;
  91                 case F_GETFL:
  92                         ret = _thread_fd_getflags(fd);
  93                         break;
  94                 case F_SETFL:
  95                         /*
  96                          * Get the file descriptor flags passed by the
  97                          * caller:
  98                          */
  99                         flags = va_arg(ap, int);
 100
 101                         /*
 102                          * Check if the user wants a non-blocking file
 103                          * descriptor:
 104                          */
 105                         nonblock = flags & O_NONBLOCK;
 106
 107                         /* Set the file descriptor flags: */
 108                         if ((ret = __sys_fcntl(fd, cmd, flags | O_NONBLOCK)) != 0) {
 109
 110                         /* Get the flags so that we behave like the kernel: */
 111                         } else if ((flags = __sys_fcntl(fd,
 112                             F_GETFL, 0)) == -1) {
 113                                 /* Error getting flags: */
 114                                 ret = -1;
 115
 116                         /*
 117                          * Check if the file descriptor is non-blocking
 118                          * with respect to the user:
 119                          */
 120                         } else if (nonblock)
 121                                 /* A non-blocking descriptor: */
 122                                 _thread_fd_setflags(fd, flags | O_NONBLOCK);
 123                         else
 124                                 /* Save the flags: */
 125                                 _thread_fd_setflags(fd, flags & ~O_NONBLOCK);
 126                         break;
 127                 default:
 128                         /* Might want to make va_arg use a union */
 129                         ret = __fcntl_compat(fd, cmd, va_arg(ap, void *));
 130                         break;
 131                 }
 132
 133                 /* Free variable arguments: */
 134                 va_end(ap);
 135
 136                 /* Unlock the file descriptor: */
 137                 _FD_UNLOCK(fd, FD_RDWR);
 138         }
 139         /* Return the completion status: */
 140         return (ret);
 141 }
 142
 143 int
 144 __fcntl(int fd, int cmd,...)
 145 {
 146         int     ret;
 147         va_list ap;
 148
 149         _thread_enter_cancellation_point();
 150
 151         va_start(ap, cmd);
 152         switch (cmd) {
 153                 case F_DUPFD:
 154                 case F_SETFD:
 155                 case F_SETFL:
 156                         ret = _fcntl(fd, cmd, va_arg(ap, int));
 157                         break;
 158                 case F_GETFD:
 159                 case F_GETFL:
 160                         ret = _fcntl(fd, cmd);
 161                         break;
 162                 default:
 163                         ret = _fcntl(fd, cmd, va_arg(ap, void *));
 164         }
 165         va_end(ap);
 166
 167         _thread_leave_cancellation_point();
 168
 169         return ret;
 170 }