2 * Copyright (c) 2016 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
17 * Copyright (c) 2005-2008 Jelmer Vernooij <jelmer@samba.org>
18 * Copyright (C) 2006-2014 Stefan Metzmacher <metze@samba.org>
19 * Copyright (C) 2013-2014 Andreas Schneider <asn@samba.org>
21 * All rights reserved.
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions
27 * 1. Redistributions of source code must retain the above copyright
28 * notice, this list of conditions and the following disclaimer.
30 * 2. Redistributions in binary form must reproduce the above copyright
31 * notice, this list of conditions and the following disclaimer in the
32 * documentation and/or other materials provided with the distribution.
34 * 3. Neither the name of the author nor the names of its contributors
35 * may be used to endorse or promote products derived from this software
36 * without specific prior written permission.
38 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
39 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
40 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
41 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
42 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
43 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
44 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
45 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
46 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
47 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
53 Socket wrapper library. Passes all socket communication over
54 unix domain sockets if the environment variable SOCKET_WRAPPER_DIR
66 #include <vcl/ldp_socket_wrapper.h>
78 /* Macros for accessing mutexes */
79 #define SWRAP_LOCK(m) do { \
80 pthread_mutex_lock(&(m ## _mutex)); \
83 #define SWRAP_UNLOCK(m) do { \
84 pthread_mutex_unlock(&(m ## _mutex)); \
87 /* Add new global locks here please */
88 #define SWRAP_LOCK_ALL \
89 SWRAP_LOCK(libc_symbol_binding); \
91 #define SWRAP_UNLOCK_ALL \
92 SWRAP_UNLOCK(libc_symbol_binding); \
96 /* The mutex for accessing the global libc.symbols */
97 static pthread_mutex_t libc_symbol_binding_mutex = PTHREAD_MUTEX_INITIALIZER;
99 /* Function prototypes */
102 #define SWRAP_LOG(...)
104 static unsigned int swrap_log_lvl = SWRAP_LOG_WARN;
107 swrap_log (enum swrap_dbglvl_e dbglvl, const char *func,
108 const char *format, ...)
109 PRINTF_ATTRIBUTE (3, 4);
110 #define SWRAP_LOG(dbglvl, ...) swrap_log((dbglvl), __func__, __VA_ARGS__)
113 swrap_log (enum swrap_dbglvl_e dbglvl,
114 const char *func, const char *format, ...)
119 va_start (va, format);
120 vsnprintf (buffer, sizeof (buffer), format, va);
123 if (dbglvl <= swrap_log_lvl)
127 case SWRAP_LOG_ERROR:
129 "SWRAP_ERROR(%d) - %s: %s\n",
130 (int) getpid (), func, buffer);
134 "SWRAP_WARN(%d) - %s: %s\n",
135 (int) getpid (), func, buffer);
137 case SWRAP_LOG_DEBUG:
139 "SWRAP_DEBUG(%d) - %s: %s\n",
140 (int) getpid (), func, buffer);
142 case SWRAP_LOG_TRACE:
144 "SWRAP_TRACE(%d) - %s: %s\n",
145 (int) getpid (), func, buffer);
153 /*********************************************************
154 * SWRAP LOADING LIBC FUNCTIONS
155 *********************************************************/
157 typedef int (*__libc_accept4) (int sockfd,
158 struct sockaddr * addr,
159 socklen_t * addrlen, int flags);
160 typedef int (*__libc_accept) (int sockfd,
161 struct sockaddr * addr, socklen_t * addrlen);
162 typedef int (*__libc_bind) (int sockfd,
163 const struct sockaddr * addr, socklen_t addrlen);
164 typedef int (*__libc_close) (int fd);
165 typedef int (*__libc_connect) (int sockfd,
166 const struct sockaddr * addr,
170 /* TBD: dup and dup2 to be implemented later */
171 typedef int (*__libc_dup) (int fd);
172 typedef int (*__libc_dup2) (int oldfd, int newfd);
175 typedef int (*__libc_fcntl) (int fd, int cmd, ...);
176 typedef FILE *(*__libc_fopen) (const char *name, const char *mode);
178 typedef FILE *(*__libc_fopen64) (const char *name, const char *mode);
181 typedef int (*__libc_eventfd) (int count, int flags);
183 typedef int (*__libc_getpeername) (int sockfd,
184 struct sockaddr * addr,
185 socklen_t * addrlen);
186 typedef int (*__libc_getsockname) (int sockfd,
187 struct sockaddr * addr,
188 socklen_t * addrlen);
189 typedef int (*__libc_getsockopt) (int sockfd,
192 void *optval, socklen_t * optlen);
193 typedef int (*__libc_ioctl) (int d, unsigned long int request, ...);
194 typedef int (*__libc_listen) (int sockfd, int backlog);
195 typedef int (*__libc_open) (const char *pathname, int flags, mode_t mode);
197 typedef int (*__libc_open64) (const char *pathname, int flags, mode_t mode);
198 #endif /* HAVE_OPEN64 */
199 typedef int (*__libc_openat) (int dirfd, const char *path, int flags, ...);
200 typedef int (*__libc_pipe) (int pipefd[2]);
201 typedef int (*__libc_read) (int fd, void *buf, size_t count);
202 typedef ssize_t (*__libc_readv) (int fd, const struct iovec * iov,
204 typedef int (*__libc_recv) (int sockfd, void *buf, size_t len, int flags);
205 typedef int (*__libc_recvfrom) (int sockfd,
209 struct sockaddr * src_addr,
210 socklen_t * addrlen);
211 typedef int (*__libc_recvmsg) (int sockfd, const struct msghdr * msg,
213 typedef int (*__libc_send) (int sockfd, const void *buf, size_t len,
215 typedef ssize_t (*__libc_sendfile) (int out_fd, int in_fd, off_t * offset,
217 typedef int (*__libc_sendmsg) (int sockfd, const struct msghdr * msg,
219 typedef int (*__libc_sendto) (int sockfd, const void *buf, size_t len,
220 int flags, const struct sockaddr * dst_addr,
222 typedef int (*__libc_setsockopt) (int sockfd, int level, int optname,
223 const void *optval, socklen_t optlen);
225 typedef int (*__libc_signalfd) (int fd, const sigset_t * mask, int flags);
227 typedef int (*__libc_socket) (int domain, int type, int protocol);
228 typedef int (*__libc_socketpair) (int domain, int type, int protocol,
230 #ifdef HAVE_TIMERFD_CREATE
231 typedef int (*__libc_timerfd_create) (int clockid, int flags);
233 typedef ssize_t (*__libc_write) (int fd, const void *buf, size_t count);
234 typedef ssize_t (*__libc_writev) (int fd, const struct iovec * iov,
237 typedef int (*__libc_shutdown) (int fd, int how);
239 typedef int (*__libc_select) (int __nfds, fd_set * __restrict __readfds,
240 fd_set * __restrict __writefds,
241 fd_set * __restrict __exceptfds,
242 struct timeval * __restrict __timeout);
245 typedef int (*__libc_pselect) (int __nfds, fd_set * __restrict __readfds,
246 fd_set * __restrict __writefds,
247 fd_set * __restrict __exceptfds,
248 const struct timespec * __restrict __timeout,
249 const __sigset_t * __restrict __sigmask);
252 typedef int (*__libc_epoll_create) (int __size);
254 typedef int (*__libc_epoll_create1) (int __flags);
256 typedef int (*__libc_epoll_ctl) (int __epfd, int __op, int __fd,
257 struct epoll_event * __event);
259 typedef int (*__libc_epoll_wait) (int __epfd, struct epoll_event * __events,
260 int __maxevents, int __timeout);
262 typedef int (*__libc_epoll_pwait) (int __epfd, struct epoll_event * __events,
263 int __maxevents, int __timeout,
264 const __sigset_t * __ss);
266 typedef int (*__libc_poll) (struct pollfd * __fds, nfds_t __nfds,
270 typedef int (*__libc_ppoll) (struct pollfd * __fds, nfds_t __nfds,
271 const struct timespec * __timeout,
272 const __sigset_t * __ss);
276 #define SWRAP_SYMBOL_ENTRY(i) \
282 struct swrap_libc_symbols
284 SWRAP_SYMBOL_ENTRY (accept4);
285 SWRAP_SYMBOL_ENTRY (accept);
286 SWRAP_SYMBOL_ENTRY (bind);
287 SWRAP_SYMBOL_ENTRY (close);
288 SWRAP_SYMBOL_ENTRY (connect);
290 /* TBD: dup and dup2 to be implemented later */
291 SWRAP_SYMBOL_ENTRY (dup);
292 SWRAP_SYMBOL_ENTRY (dup2);
294 SWRAP_SYMBOL_ENTRY (fcntl);
295 SWRAP_SYMBOL_ENTRY (fopen);
297 SWRAP_SYMBOL_ENTRY (fopen64);
300 SWRAP_SYMBOL_ENTRY (eventfd);
302 SWRAP_SYMBOL_ENTRY (getpeername);
303 SWRAP_SYMBOL_ENTRY (getsockname);
304 SWRAP_SYMBOL_ENTRY (getsockopt);
305 SWRAP_SYMBOL_ENTRY (ioctl);
306 SWRAP_SYMBOL_ENTRY (listen);
307 SWRAP_SYMBOL_ENTRY (open);
309 SWRAP_SYMBOL_ENTRY (open64);
311 SWRAP_SYMBOL_ENTRY (openat);
312 SWRAP_SYMBOL_ENTRY (pipe);
313 SWRAP_SYMBOL_ENTRY (read);
314 SWRAP_SYMBOL_ENTRY (readv);
315 SWRAP_SYMBOL_ENTRY (recv);
316 SWRAP_SYMBOL_ENTRY (recvfrom);
317 SWRAP_SYMBOL_ENTRY (recvmsg);
318 SWRAP_SYMBOL_ENTRY (send);
319 SWRAP_SYMBOL_ENTRY (sendfile);
320 SWRAP_SYMBOL_ENTRY (sendmsg);
321 SWRAP_SYMBOL_ENTRY (sendto);
322 SWRAP_SYMBOL_ENTRY (setsockopt);
324 SWRAP_SYMBOL_ENTRY (signalfd);
326 SWRAP_SYMBOL_ENTRY (socket);
327 SWRAP_SYMBOL_ENTRY (socketpair);
328 #ifdef HAVE_TIMERFD_CREATE
329 SWRAP_SYMBOL_ENTRY (timerfd_create);
331 SWRAP_SYMBOL_ENTRY (write);
332 SWRAP_SYMBOL_ENTRY (writev);
334 SWRAP_SYMBOL_ENTRY (shutdown);
335 SWRAP_SYMBOL_ENTRY (select);
337 SWRAP_SYMBOL_ENTRY (pselect);
339 SWRAP_SYMBOL_ENTRY (epoll_create);
340 SWRAP_SYMBOL_ENTRY (epoll_create1);
341 SWRAP_SYMBOL_ENTRY (epoll_ctl);
342 SWRAP_SYMBOL_ENTRY (epoll_wait);
343 SWRAP_SYMBOL_ENTRY (epoll_pwait);
344 SWRAP_SYMBOL_ENTRY (poll);
346 SWRAP_SYMBOL_ENTRY (ppoll);
356 struct swrap_libc_symbols symbols;
360 static struct swrap swrap;
362 #define LIBC_NAME "libc.so"
371 swrap_str_lib (enum swrap_lib lib)
379 /* Compiler would warn us about unhandled enum value if we get here */
385 swrap_load_lib_handle (enum swrap_lib lib)
387 int flags = RTLD_LAZY;
392 flags |= RTLD_DEEPBIND;
398 handle = swrap.libc.handle;
402 handle = dlopen (LIBC_SO, flags);
404 swrap.libc.handle = handle;
409 for (i = 10; i >= 0; i--)
411 char soname[256] = { 0 };
413 snprintf (soname, sizeof (soname), "libc.so.%d", i);
414 handle = dlopen (soname, flags);
421 swrap.libc.handle = handle;
428 SWRAP_LOG (SWRAP_LOG_ERROR,
429 "Failed to dlopen library: %s\n", dlerror ());
437 _swrap_bind_symbol (enum swrap_lib lib, const char *fn_name)
442 handle = swrap_load_lib_handle (lib);
444 func = dlsym (handle, fn_name);
447 SWRAP_LOG (SWRAP_LOG_ERROR,
448 "Failed to find %s: %s\n", fn_name, dlerror ());
452 SWRAP_LOG (SWRAP_LOG_TRACE,
453 "Loaded %s from %s", fn_name, swrap_str_lib (lib));
458 #define swrap_bind_symbol_libc(sym_name) \
459 SWRAP_LOCK(libc_symbol_binding); \
460 if (swrap.libc.symbols._libc_##sym_name.obj == NULL) { \
461 swrap.libc.symbols._libc_##sym_name.obj = \
462 _swrap_bind_symbol(SWRAP_LIBC, #sym_name); \
464 SWRAP_UNLOCK(libc_symbol_binding)
469 * Functions especially from libc need to be loaded individually, you can't load
470 * all at once or gdb will segfault at startup. The same applies to valgrind and
471 * has probably something todo with with the linker.
472 * So we need load each function at the point it is called the first time.
475 libc_accept4 (int sockfd,
476 struct sockaddr *addr, socklen_t * addrlen, int flags)
478 swrap_bind_symbol_libc (accept4);
480 return swrap.libc.symbols._libc_accept4.f (sockfd, addr, addrlen, flags);
484 libc_accept (int sockfd, struct sockaddr *addr, socklen_t * addrlen)
486 swrap_bind_symbol_libc (accept);
488 return swrap.libc.symbols._libc_accept.f (sockfd, addr, addrlen);
492 libc_bind (int sockfd, const struct sockaddr *addr, socklen_t addrlen)
494 swrap_bind_symbol_libc (bind);
496 return swrap.libc.symbols._libc_bind.f (sockfd, addr, addrlen);
502 swrap_bind_symbol_libc (close);
504 return swrap.libc.symbols._libc_close.f (fd);
508 libc_connect (int sockfd, const struct sockaddr *addr, socklen_t addrlen)
510 swrap_bind_symbol_libc (connect);
512 return swrap.libc.symbols._libc_connect.f (sockfd, addr, addrlen);
516 /* TBD: dup and dup2 to be implemented later */
520 swrap_bind_symbol_libc (dup);
522 return swrap.libc.symbols._libc_dup.f (fd);
526 libc_dup2 (int oldfd, int newfd)
528 swrap_bind_symbol_libc (dup2);
530 return swrap.libc.symbols._libc_dup2.f (oldfd, newfd);
536 libc_eventfd (int count, int flags)
538 swrap_bind_symbol_libc (eventfd);
540 return swrap.libc.symbols._libc_eventfd.f (count, flags);
544 DO_NOT_SANITIZE_ADDRESS_ATTRIBUTE int
545 libc_vfcntl (int fd, int cmd, va_list ap)
551 swrap_bind_symbol_libc (fcntl);
553 for (i = 0; i < 4; i++)
555 args[i] = va_arg (ap, long int);
558 rc = swrap.libc.symbols._libc_fcntl.f (fd,
560 args[0], args[1], args[2], args[3]);
565 DO_NOT_SANITIZE_ADDRESS_ATTRIBUTE int
566 libc_vioctl (int fd, int cmd, va_list ap)
572 swrap_bind_symbol_libc (ioctl);
574 for (i = 0; i < 4; i++)
576 args[i] = va_arg (ap, long int);
579 rc = swrap.libc.symbols._libc_ioctl.f (fd,
581 args[0], args[1], args[2], args[3]);
587 libc_getpeername (int sockfd, struct sockaddr *addr, socklen_t * addrlen)
589 swrap_bind_symbol_libc (getpeername);
591 return swrap.libc.symbols._libc_getpeername.f (sockfd, addr, addrlen);
595 libc_getsockname (int sockfd, struct sockaddr *addr, socklen_t * addrlen)
597 swrap_bind_symbol_libc (getsockname);
599 return swrap.libc.symbols._libc_getsockname.f (sockfd, addr, addrlen);
603 libc_getsockopt (int sockfd,
604 int level, int optname, void *optval, socklen_t * optlen)
606 swrap_bind_symbol_libc (getsockopt);
608 return swrap.libc.symbols._libc_getsockopt.f (sockfd,
610 optname, optval, optlen);
614 libc_listen (int sockfd, int backlog)
616 swrap_bind_symbol_libc (listen);
618 return swrap.libc.symbols._libc_listen.f (sockfd, backlog);
621 /* TBD: libc_read() should return ssize_t not an int */
623 libc_read (int fd, void *buf, size_t count)
625 swrap_bind_symbol_libc (read);
627 return swrap.libc.symbols._libc_read.f (fd, buf, count);
631 libc_readv (int fd, const struct iovec * iov, int iovcnt)
633 swrap_bind_symbol_libc (readv);
635 return swrap.libc.symbols._libc_readv.f (fd, iov, iovcnt);
639 libc_recv (int sockfd, void *buf, size_t len, int flags)
641 swrap_bind_symbol_libc (recv);
643 return swrap.libc.symbols._libc_recv.f (sockfd, buf, len, flags);
647 libc_recvfrom (int sockfd,
650 int flags, struct sockaddr *src_addr, socklen_t * addrlen)
652 swrap_bind_symbol_libc (recvfrom);
654 return swrap.libc.symbols._libc_recvfrom.f (sockfd,
656 len, flags, src_addr, addrlen);
660 libc_recvmsg (int sockfd, struct msghdr *msg, int flags)
662 swrap_bind_symbol_libc (recvmsg);
664 return swrap.libc.symbols._libc_recvmsg.f (sockfd, msg, flags);
668 libc_send (int sockfd, const void *buf, size_t len, int flags)
670 swrap_bind_symbol_libc (send);
672 return swrap.libc.symbols._libc_send.f (sockfd, buf, len, flags);
676 libc_sendfile (int out_fd, int in_fd, off_t * offset, size_t len)
678 swrap_bind_symbol_libc (sendfile);
680 return swrap.libc.symbols._libc_sendfile.f (out_fd, in_fd, offset, len);
684 libc_sendmsg (int sockfd, const struct msghdr *msg, int flags)
686 swrap_bind_symbol_libc (sendmsg);
688 return swrap.libc.symbols._libc_sendmsg.f (sockfd, msg, flags);
692 libc_sendto (int sockfd,
695 int flags, const struct sockaddr *dst_addr, socklen_t addrlen)
697 swrap_bind_symbol_libc (sendto);
699 return swrap.libc.symbols._libc_sendto.f (sockfd,
701 len, flags, dst_addr, addrlen);
705 libc_setsockopt (int sockfd,
706 int level, int optname, const void *optval, socklen_t optlen)
708 swrap_bind_symbol_libc (setsockopt);
710 return swrap.libc.symbols._libc_setsockopt.f (sockfd,
712 optname, optval, optlen);
716 libc_socket (int domain, int type, int protocol)
718 swrap_bind_symbol_libc (socket);
720 return swrap.libc.symbols._libc_socket.f (domain, type, protocol);
724 libc_socketpair (int domain, int type, int protocol, int sv[2])
726 swrap_bind_symbol_libc (socketpair);
728 return swrap.libc.symbols._libc_socketpair.f (domain, type, protocol, sv);
732 libc_write (int fd, const void *buf, size_t count)
734 swrap_bind_symbol_libc (write);
736 return swrap.libc.symbols._libc_write.f (fd, buf, count);
740 libc_writev (int fd, const struct iovec * iov, int iovcnt)
742 swrap_bind_symbol_libc (writev);
744 return swrap.libc.symbols._libc_writev.f (fd, iov, iovcnt);
748 libc_shutdown (int fd, int how)
750 swrap_bind_symbol_libc (shutdown);
752 return swrap.libc.symbols._libc_shutdown.f (fd, how);
756 libc_select (int __nfds, fd_set * __restrict __readfds,
757 fd_set * __restrict __writefds,
758 fd_set * __restrict __exceptfds,
759 struct timeval *__restrict __timeout)
761 swrap_bind_symbol_libc (select);
763 return swrap.libc.symbols._libc_select.f (__nfds, __readfds,
765 __exceptfds, __timeout);
770 libc_pselect (int __nfds, fd_set * __restrict __readfds,
771 fd_set * __restrict __writefds,
772 fd_set * __restrict __exceptfds,
773 const struct timespec *__restrict __timeout,
774 const __sigset_t * __restrict __sigmask)
776 swrap_bind_symbol_libc (pselect);
778 return swrap.libc.symbols._libc_pselect.f (__nfds, __readfds,
781 __timeout, __sigmask);
786 libc_epoll_create (int __size)
788 swrap_bind_symbol_libc (epoll_create);
790 return swrap.libc.symbols._libc_epoll_create.f (__size);
794 libc_epoll_create1 (int __flags)
796 swrap_bind_symbol_libc (epoll_create1);
798 return swrap.libc.symbols._libc_epoll_create1.f (__flags);
802 libc_epoll_ctl (int __epfd, int __op, int __fd, struct epoll_event *__event)
804 swrap_bind_symbol_libc (epoll_ctl);
806 return swrap.libc.symbols._libc_epoll_ctl.f (__epfd, __op, __fd, __event);
810 libc_epoll_wait (int __epfd, struct epoll_event *__events,
811 int __maxevents, int __timeout)
813 swrap_bind_symbol_libc (epoll_wait);
815 return swrap.libc.symbols._libc_epoll_wait.f (__epfd, __events,
816 __maxevents, __timeout);
820 libc_epoll_pwait (int __epfd, struct epoll_event *__events,
821 int __maxevents, int __timeout, const __sigset_t * __ss)
823 swrap_bind_symbol_libc (epoll_pwait);
825 return swrap.libc.symbols._libc_epoll_pwait.f (__epfd, __events,
826 __maxevents, __timeout,
831 libc_poll (struct pollfd *__fds, nfds_t __nfds, int __timeout)
833 swrap_bind_symbol_libc (poll);
835 return swrap.libc.symbols._libc_poll.f (__fds, __nfds, __timeout);
840 libc_ppoll (struct pollfd *__fds, nfds_t __nfds,
841 const struct timespec *__timeout, const __sigset_t * __ss)
843 swrap_bind_symbol_libc (ppoll);
845 return swrap.libc.symbols._libc_ppoll.f (__fds, __nfds, __timeout, __ss);
850 swrap_thread_prepare (void)
856 swrap_thread_parent (void)
862 swrap_thread_child (void)
867 /****************************
869 ***************************/
871 swrap_constructor (void)
874 * If we hold a lock and the application forks, then the child
875 * is not able to unlock the mutex and we are in a deadlock.
876 * This should prevent such deadlocks.
878 pthread_atfork (&swrap_thread_prepare,
879 &swrap_thread_parent, &swrap_thread_child);
882 /****************************
884 ***************************/
887 * This function is called when the library is unloaded and makes sure that
888 * sockets get closed and the unix file for the socket are unlinked.
891 swrap_destructor (void)
893 if (swrap.libc.handle != NULL)
895 dlclose (swrap.libc.handle);
897 if (swrap.libc.socket_handle)
899 dlclose (swrap.libc.socket_handle);
904 * fd.io coding-style-patch-verification: ON
907 * eval: (c-set-style "gnu")