Debian Codegraph @

ext/fcntl/fcntl.c

raw
1 /*
2 * fcntl.c - fcntl interface
3 *
4 * Copyright (c) 2000-2024 Shiro Kawai <[email protected]>
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * 3. Neither the name of the authors nor the names of its contributors
18 * may be used to endorse or promote products derived from this
19 * software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
27 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
28 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34 #define _GNU_SOURCE /* for Linux, this enables additional features */
35
36 #include <gauche.h>
37 #include <string.h>
38 #include <errno.h>
39 #include <gauche/extend.h>
40
41 #include "gauche/fcntl.h"
42
43 /* struct flock */
44
45 static ScmObj flock_allocate(ScmClass *klass, ScmObj initargs);
46
47 SCM_DEFINE_BUILTIN_CLASS(Scm_SysFlockClass,
48 NULL, NULL, NULL,
49 flock_allocate,
50 NULL);
51
52 static ScmObj flock_allocate(ScmClass *klass SCM_UNUSED,
53 ScmObj initargs SCM_UNUSED)
54 {
55 ScmSysFlock *f = SCM_NEW(ScmSysFlock);
56 SCM_SET_CLASS(f, SCM_CLASS_SYS_FLOCK);
57 memset(&f->lock, 0, sizeof(f->lock));
58 return SCM_OBJ(f);
59 }
60
61 #define FLOCK_GET_N_SET(name, type, make, get) \
62 static ScmObj SCM_CPP_CAT3(flock_, name, _get)(ScmSysFlock* t) \
63 { return make(t->lock.name); } \
64 static void SCM_CPP_CAT3(flock_, name, _set)(ScmSysFlock* t, ScmObj v) \
65 { \
66 if (!SCM_INTEGERP(v)) Scm_Error("integer required, but got %S", v); \
67 t->lock.name = (type)get(v); \
68 }
69
70 FLOCK_GET_N_SET(l_type, short, Scm_MakeInteger, Scm_GetInteger)
71 FLOCK_GET_N_SET(l_whence, short, Scm_MakeInteger, Scm_GetInteger)
72 FLOCK_GET_N_SET(l_start, off_t, Scm_OffsetToInteger, Scm_IntegerToOffset)
73 FLOCK_GET_N_SET(l_len, off_t, Scm_OffsetToInteger, Scm_IntegerToOffset)
74 FLOCK_GET_N_SET(l_pid, pid_t, Scm_MakeInteger, Scm_GetInteger)
75
76 static ScmClassStaticSlotSpec flock_slots[] = {
77 SCM_CLASS_SLOT_SPEC("type", flock_l_type_get, flock_l_type_set),
78 SCM_CLASS_SLOT_SPEC("whence", flock_l_whence_get, flock_l_whence_set),
79 SCM_CLASS_SLOT_SPEC("start", flock_l_start_get, flock_l_start_set),
80 SCM_CLASS_SLOT_SPEC("len", flock_l_len_get, flock_l_len_set),
81 SCM_CLASS_SLOT_SPEC("pid", flock_l_pid_get, flock_l_pid_set),
82 SCM_CLASS_SLOT_SPEC_END()
83 };
84
85 ScmObj Scm_MakeSysFlock(void)
86 {
87 return flock_allocate(SCM_CLASS_SYS_FLOCK, SCM_NIL);
88 }
89
90 /*
91 * Fcntl bridge
92 */
93 #if defined(HAVE_FCNTL)
94 static const char *flag_name(int flag)
95 {
96 #define FLAG_NAME(n) case n: return #n
97 switch (flag) {
98 FLAG_NAME(F_GETFD);
99 FLAG_NAME(F_SETFD);
100 FLAG_NAME(F_GETFL);
101 FLAG_NAME(F_SETFL);
102 FLAG_NAME(F_DUPFD);
103 FLAG_NAME(F_GETLK);
104 FLAG_NAME(F_SETLK);
105 FLAG_NAME(F_SETLKW);
106 #if defined(F_GETOWN)
107 FLAG_NAME(F_GETOWN);
108 #endif
109 #if defined(F_SETOWN)
110 FLAG_NAME(F_SETOWN);
111 #endif
112 #if defined(F_GETSIG)
113 FLAG_NAME(F_GETSIG);
114 #endif
115 #if defined(F_SETSIG)
116 FLAG_NAME(F_SETSIG);
117 #endif
118 #if defined(F_GETLEASE)
119 FLAG_NAME(F_GETLEASE);
120 #endif
121 #if defined(F_SETLEASE)
122 FLAG_NAME(F_SETLEASE);
123 #endif
124 #if defined(F_NOTIFY)
125 FLAG_NAME(F_NOTIFY);
126 #endif
127 }
128 return "(unknown flag)";
129 #undef FLAG_NAME
130 }
131 #endif /* HAVE_FCNTL */
132
133 ScmObj Scm_SysFcntl(ScmObj port_or_fd, int op, ScmObj arg)
134 {
135 #if defined(HAVE_FCNTL)
136 int fd = Scm_GetPortFd(port_or_fd, TRUE), r;
137
138 switch (op) {
139 case F_GETFD:; case F_GETFL:;
140 #if defined(F_GETOWN) /* BSD and Linux specific */
141 case F_GETOWN:;
142 #endif /*F_GETOWN*/
143 #if defined(F_GETSIG) /* Linux specific */
144 case F_GETSIG:;
145 #endif /*F_GETSIG */
146 #if defined(F_GETLEASE) /* Linux specific */
147 case F_GETLEASE:;
148 #endif /*F_GETLEASE */
149 SCM_SYSCALL(r, fcntl(fd, op));
150 if (r == -1) { /*NB: F_GETOWN may return a negative value on success*/
151 Scm_SysError("fcntl(%s) failed", flag_name(op));
152 }
153 return Scm_MakeInteger(r);
154 case F_SETFD:; case F_SETFL:; case F_DUPFD:;
155 #if defined(F_SETOWN) /* BSD and Linux specific */
156 case F_SETOWN:;
157 #endif /*F_SETOWN*/
158 #if defined(F_SETSIG) /* Linux specific */
159 case F_SETSIG:;
160 #endif /*F_SETSIG */
161 #if defined(F_SETLEASE) /* Linux specific */
162 case F_SETLEASE:;
163 #endif /*F_SETLEASE */
164 #if defined(F_NOTIFY) /* Linux specific */
165 case F_NOTIFY:;
166 #endif /*F_NOTIFY */
167 if (!SCM_EXACTP(arg)) {
168 Scm_Error("exact integer required for fcntl(%s), but got %S",
169 flag_name(op), arg);
170 }
171 SCM_SYSCALL(r, fcntl(fd, op, Scm_GetInteger(arg)));
172 if (r < 0) {
173 Scm_SysError("fcntl(%s) failed", flag_name(op));
174 }
175 return Scm_MakeInteger(r);
176 case F_GETLK:; case F_SETLK:; case F_SETLKW:;
177 if (!SCM_SYS_FLOCK_P(arg)) {
178 Scm_Error("flock object required for fcntl(%s), but got %S",
179 flag_name(op), arg);
180 }
181 ScmSysFlock *fl = SCM_SYS_FLOCK(arg);
182 SCM_SYSCALL(r, fcntl(fd, op, &fl->lock));
183 if (op == F_SETLK) {
184 if (r >= 0) return SCM_TRUE;
185 if (errno == EAGAIN) return SCM_FALSE;
186 }
187 if (r < 0) Scm_SysError("fcntl(%s) failed", flag_name(op));
188 return SCM_TRUE;
189 default:
190 Scm_Error("unknown operation code (%d) for fcntl", op);
191 return SCM_UNDEFINED; /* dummy */
192 }
193 #else /*!HAVE_FCNTL*/
194 (void)port_or_fd; /* suppress unused var warning */
195 (void)op; /* suppress unused var warning */
196 (void)arg; /* suppress unused var warning */
197 Scm_Error("fcntl not supported on MinGW port");
198 return SCM_UNDEFINED; /*dummy*/
199 #endif /*!HAVE_FCNTL*/
200 }
201
202 /*
203 * Initialization
204 */
205
206 void Scm_Init_fcntl(void)
207 {
208 ScmModule *mod = SCM_FIND_MODULE("gauche.fcntl", SCM_FIND_MODULE_CREATE);
209 Scm_InitStaticClass(&Scm_SysFlockClass, "<sys-flock>",
210 mod, flock_slots, 0);
211 }