Copy of aRts for Trinity modifications

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/dependencies/arts@1070145 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 675 insertions, 0 deletions

diff --git a/artsc/artsdsp.c b/artsc/artsdsp.c
new file mode 100644
index 0000000..368b15f
--- /dev/null
+++ b/artsc/artsdsp.c
@@ -0,0 +1,675 @@
+/* Evil evil evil hack to get OSS apps to cooperate with artsd
+ * This is based on the original esddsp, which esd uses to do the same.
+ *
+ * Copyright (C) 1998 Manish Singh <yosh@gimp.org>
+ * Copyright (C) 2000 Stefan Westerfeld <stefan@space.twc.de> (aRts port)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#define _GNU_SOURCE 1
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef HAVE_SYS_SOUNDCARD_H
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdarg.h>
+#include <sys/types.h>
+#include <sys/soundcard.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+/* #include <sys/mman.h> */
+#include <fcntl.h>
+
+#include <artsc.h>
+#include <dlfcn.h>
+
+#include "arts_export.h"
+/*
+ * NOTE:
+ *
+ * To truly support non-blocking I/O, there is some stuff missing. Namely,
+ * select should be trapped and redirected, as well as the means for making
+ * a stream non-blocking and so on. Maybe poll, too.
+ *
+ * Currently, only apps that are doing blocking I/O will probably work right.
+ */
+
+/**
+ * the stream status: sndfd is -1 when unused, otherwise it is a useless fd
+ * which points to /dev/null, to ensure compatibility with more weird
+ * operations on streams
+ *
+ * settings contains what has already been set (speed, bits, channels), and
+ * is 7 when all of these are true
+ *
+ * stream contains an aRts stream or 0
+ */
+static int sndfd = -1;
+static int settings;
+static int arts_init_done = 0;
+static arts_stream_t stream = 0;
+static arts_stream_t record_stream = 0;
+static int bits = 0;
+static int speed = 0;
+static int channels = 0;
+static int frags;
+
+#if defined(HAVE_IOCTL_INT_INT_DOTS)
+typedef int ioctl_request_t;
+#elif defined(HAVE_IOCTL_INT_ULONG_DOTS)
+typedef unsigned long ioctl_request_t;
+#elif defined(HAVE_IOCTL_INT_ULONGINT_DOTS)
+typedef unsigned long int ioctl_request_t;
+#else
+#error "unknown ioctl type (check config.h, adapt configure test)..."
+#endif
+
+/*
+ * memory mapping emulation
+ */
+static int mmapemu = 0;
+static count_info mmapemu_ocount;
+static char *mmapemu_obuffer = 0;
+static int mmapemu_osize = 0;
+
+/*
+ * original C library functions
+ */
+typedef int (*orig_open_ptr)(const char *pathname, int flags, ...);
+typedef int (*orig_close_ptr)(int fd);
+typedef int (*orig_ioctl_ptr)(int fd, ioctl_request_t request, ...);
+typedef ssize_t (*orig_write_ptr)(int fd, const void *buf, size_t count);
+typedef ssize_t (*orig_read_ptr)(int fd, void *buf, size_t count);
+typedef void* (*orig_mmap_ptr)(void *start, size_t length, int prot,
+                                 int flags, int fd, off_t offset);
+typedef int (*orig_munmap_ptr)(void *start, size_t length);
+typedef FILE* (*orig_fopen_ptr)(const char *path, const char *mode);
+typedef int (*orig_access_ptr)(const char *pathname, int mode);   
+
+static orig_open_ptr orig_open;
+static orig_close_ptr orig_close;
+static orig_ioctl_ptr orig_ioctl;
+static orig_write_ptr orig_write;
+static orig_read_ptr orig_read;
+static orig_mmap_ptr orig_mmap;
+static orig_munmap_ptr orig_munmap;
+static orig_fopen_ptr orig_fopen;
+static orig_access_ptr orig_access;
+
+static int artsdsp_debug = 0;
+static int artsdsp_init = 0;
+
+void *mmap(void  *start,  size_t length, int prot, int flags,
+                     int fd, off_t offset);
+int munmap(void *start, size_t length);
+#define CHECK_INIT() if(!artsdsp_init) artsdsp_doinit();
+
+/*
+ * Initialization - maybe this should be either be a startup only called
+ * routine, or use pthread locks to prevent strange effects in multithreaded
+ * use (however it seems highly unlikely that an application would create
+ * multiple threads before even using one of redirected the system functions
+ * once).
+ */ 
+
+static void artsdsp_doinit()
+{
+	const char *env;
+	artsdsp_init = 1;
+
+	/* debugging? */
+	env = getenv("ARTSDSP_VERBOSE");
+	artsdsp_debug = env && !strcmp(env,"1");
+
+	/* mmap emulation? */
+	env = getenv("ARTSDSP_MMAP");
+	mmapemu = env && !strcmp(env,"1");
+
+	/* resolve original symbols */
+	orig_open = (orig_open_ptr)dlsym(RTLD_NEXT,"open");
+	orig_close = (orig_close_ptr)dlsym(RTLD_NEXT,"close");
+	orig_write = (orig_write_ptr)dlsym(RTLD_NEXT,"write");
+	orig_read = (orig_read_ptr)dlsym(RTLD_NEXT,"read");
+	orig_ioctl = (orig_ioctl_ptr)dlsym(RTLD_NEXT,"ioctl");
+	orig_mmap = (orig_mmap_ptr)dlsym(RTLD_NEXT,"mmap");
+	orig_munmap = (orig_munmap_ptr)dlsym(RTLD_NEXT,"munmap");
+	orig_fopen = (orig_fopen_ptr)dlsym(RTLD_NEXT,"fopen");
+	orig_access = (orig_access_ptr)dlsym(RTLD_NEXT,"access");
+}
+
+static void 
+#ifdef __GNUC__
+  __attribute__( ( format (  printf, 1, 2 ) ) )
+#endif
+artsdspdebug(const char *fmt,...)
+{
+	CHECK_INIT();
+
+	if(artsdsp_debug)
+	{
+		va_list ap;
+		va_start(ap, fmt);
+		(void) vfprintf(stderr, fmt, ap);
+		va_end(ap);
+	}
+}
+
+static void mmapemu_flush()
+{
+  int space;
+
+  if (mmapemu_osize == 0) {
+    return;
+  }
+
+  space = arts_stream_get(stream, ARTS_P_BUFFER_SPACE);
+  artsdspdebug("space = %d\n",space);
+  while(space >= 4096)
+  {
+    arts_write(stream,&mmapemu_obuffer[mmapemu_ocount.ptr],4096);
+    space -= 4096;
+    mmapemu_ocount.ptr += 4096;
+    mmapemu_ocount.ptr %= mmapemu_osize;
+    mmapemu_ocount.blocks++;
+    mmapemu_ocount.bytes += 4096;
+  }
+}
+
+/* returns 1 if the filename points to a sound device */
+static int is_sound_device(const char *pathname)
+{
+  if(!pathname) return 0;
+  if(strcmp(pathname,"/dev/dsp") == 0) return 1;
+  if(strcmp(pathname,"/dev/sound/dsp") == 0) return 1;
+  return 0;
+}
+
+int open (const char *pathname, int flags, ...)
+{
+  va_list args;
+  mode_t mode = 0;
+
+  CHECK_INIT();
+
+  /*
+   * After the documentation, va_arg is not safe if there is no argument to
+   * get "random errors will occur", so only get it in case O_CREAT is set,
+   * and hope that passing 0 to the orig_open function in all other cases
+   * will work.
+   */
+  va_start(args,flags);
+  if(flags & O_CREAT) {
+	/* The compiler will select one of these at compile-tyime if -O is used.
+	 * Otherwise, it may be deferred until runtime.
+	 */
+    if (sizeof(int) >= sizeof(mode_t)) {
+      mode = va_arg(args, int);
+    } else {
+      mode = va_arg(args, mode_t);
+    }
+  }
+  va_end(args);
+
+  if (!is_sound_device(pathname))    /* original open for anything but sound */
+    return orig_open (pathname, flags, mode);
+
+  settings = 0;
+  frags = 0;
+  stream = 0;
+  record_stream = 0;
+
+  artsdspdebug ("aRts: hijacking /dev/dsp open...\n");
+
+  sndfd = orig_open("/dev/null",flags,mode);
+  if(sndfd >= 0)
+  {
+    if(!arts_init_done) {
+	  int rc = arts_init();
+	  if(rc < 0) {
+	    artsdspdebug("error on aRts init: %s\n", arts_error_text(rc));
+	    orig_close(sndfd);
+	    sndfd = -1;
+	    return orig_open (pathname, flags, mode);
+	  }
+	  else arts_init_done = 1;
+    }
+  }
+
+  /* success */
+  return sndfd;
+}
+
+int ioctl (int fd, ioctl_request_t request, ...)
+{
+  int space, size, latency, odelay;
+
+  /*
+   * FreeBSD needs ioctl with varargs. However I have no idea how to "forward"
+   * the variable args ioctl to the orig_ioctl routine. So I expect the ioctl
+   * to have exactly one pointer-like parameter and forward that, hoping that
+   * it works
+   */
+  va_list args;
+  void *argp;
+  va_start(args,request);
+  argp = va_arg(args, void *);
+  va_end(args);
+
+  CHECK_INIT();
+
+  if (fd != sndfd )
+    return orig_ioctl (fd, request, argp);
+  else if (sndfd != -1)
+    {
+      int *arg = (int *) argp;
+      artsdspdebug("aRts: hijacking /dev/dsp ioctl (%d : %x - %p)\n",
+              ( int ) fd, ( int ) request, ( void* ) argp);
+
+      switch (request)
+        {
+        struct audio_buf_info *audiop;
+#ifdef SNDCTL_DSP_RESET
+		case SNDCTL_DSP_RESET:              /* _SIO  ('P', 0) */
+		  artsdspdebug("aRts: SNDCTL_DSP_RESET unsupported\n");
+		  break;
+#endif
+
+#ifdef SNDCTL_DSP_SYNC
+		case SNDCTL_DSP_SYNC:               /* _SIO  ('P', 1) */
+		  artsdspdebug("aRts: SNDCTL_DSP_SYNC unsupported\n");
+		  break;
+#endif
+
+#ifdef SNDCTL_DSP_SPEED
+        case SNDCTL_DSP_SPEED:				/* _SIOWR('P', 2, int) */
+          speed = *arg;
+          settings |= 2;
+          break;
+#endif
+
+#ifdef SNDCTL_DSP_STEREO
+        case SNDCTL_DSP_STEREO:				/* _SIOWR('P', 3, int) */
+          channels = (*arg)?2:1;
+          settings |= 4;
+          break;
+#endif
+
+#ifdef SNDCTL_DSP_GETBLKSIZE
+        case SNDCTL_DSP_GETBLKSIZE:			/* _SIOWR('P', 4, int) */
+          if(mmapemu)
+            *arg = 4096;
+          else if(stream)
+            *arg = arts_stream_get(stream,ARTS_P_PACKET_SIZE);
+          else
+          {
+            int fragSize = frags & 0x7fff;
+            if(fragSize > 1 && fragSize < 16)
+              *arg = (1 << fragSize);
+            else
+              *arg = 16384; /* no idea ;-) */
+          }
+          break;
+#endif
+
+#ifdef SNDCTL_DSP_SETFMT
+        case SNDCTL_DSP_SETFMT:				/* _SIOWR('P',5, int) */
+          bits = (*arg & 0x30) ? 16 : 8;
+          settings |= 1;
+          break;
+#endif
+
+#ifdef SNDCTL_DSP_CHANNELS
+        case SNDCTL_DSP_CHANNELS:			/*  _SIOWR('P', 6, int) */
+          channels = (*arg);
+          settings |= 4;
+          break;
+#endif
+
+#ifdef SOUND_PCM_WRITE_FILTER
+		case SOUND_PCM_WRITE_FILTER:        /* _SIOWR('P', 7, int) */
+		  artsdspdebug("aRts: SNDCTL_DSP_WRITE_FILTER(%d) unsupported\n",*arg);
+		  break;
+#endif
+
+#ifdef SNDCTL_DSP_POST
+		case SNDCTL_DSP_POST:               /* _SIO  ('P', 8) */
+		  artsdspdebug("aRts: SNDCTL_DSP_POST unsupported\n");
+		  break;
+#endif
+
+#ifdef SNDCTL_DSP_SUBDIVIDE
+		case SNDCTL_DSP_SUBDIVIDE:          /* _SIOWR('P', 9, int) */
+		  artsdspdebug("aRts: SNDCTL_DSP_SUBDIVIDE(%d) unsupported\n",*arg);
+		  break;
+#endif
+
+#ifdef SNDCTL_DSP_SETFRAGMENT
+        case SNDCTL_DSP_SETFRAGMENT:        /* _SIOWR('P',10, int) */
+          artsdspdebug("aRts: SNDCTL_DSP_SETFRAGMENT(%x) partially supported\n",
+                          *arg);
+          frags = *arg;
+          break;
+#endif
+
+#ifdef SNDCTL_DSP_GETFMTS
+        case SNDCTL_DSP_GETFMTS:            /* _SIOR ('P',11, int) */
+          *arg = 8 | 16;
+          break;
+#endif
+
+#if defined(SNDCTL_DSP_GETOSPACE) && defined(SNDCTL_DSP_GETISPACE)
+        case SNDCTL_DSP_GETOSPACE:          /* _SIOR ('P',12, audio_buf_info) */
+        case SNDCTL_DSP_GETISPACE:          /* _SIOR ('P',13, audio_buf_info) */
+          audiop = argp;
+		  if(mmapemu)
+		  {
+			audiop->fragstotal = 16;
+			audiop->fragsize = 4096;
+			audiop->bytes = 0;              /* FIXME: is this right? */
+			audiop->fragments = 0;
+		  }
+		  else
+		  {
+            audiop->fragstotal =
+              stream?arts_stream_get(stream, ARTS_P_PACKET_COUNT):10;
+            audiop->fragsize =
+              stream?arts_stream_get(stream, ARTS_P_PACKET_SIZE):16384;
+            audiop->bytes =
+              stream?arts_stream_get(stream, ARTS_P_BUFFER_SPACE):16384;
+            audiop->fragments = audiop->bytes / audiop->fragsize;
+		  }
+          break;
+#endif
+
+#ifdef SNDCTL_DSP_NONBLOCK
+		case SNDCTL_DSP_NONBLOCK:           /* _SIO  ('P',14) */
+		  artsdspdebug("aRts: SNDCTL_DSP_NONBLOCK unsupported\n");
+		  break;
+#endif
+
+#ifdef SNDCTL_DSP_GETCAPS
+        case SNDCTL_DSP_GETCAPS:			/* _SIOR ('P',15, int) */
+		  if(mmapemu)
+			*arg = DSP_CAP_MMAP | DSP_CAP_TRIGGER | DSP_CAP_REALTIME | DSP_CAP_DUPLEX;
+		  else
+			*arg = DSP_CAP_DUPLEX;
+          break;
+#endif
+
+#ifdef SNDCTL_DSP_GETTRIGGER
+		case SNDCTL_DSP_GETTRIGGER:         /* _SIOR ('P',16, int) */
+		  artsdspdebug("aRts: SNDCTL_DSP_GETTRIGGER unsupported\n");
+		  break;
+#endif
+
+#ifdef SNDCTL_DSP_SETTRIGGER
+		case SNDCTL_DSP_SETTRIGGER:         /* _SIOW ('P',16, int) */
+		  artsdspdebug("aRts: SNDCTL_DSP_SETTRIGGER unsupported\n");
+		  break;
+#endif
+
+#ifdef SNDCTL_DSP_GETIPTR
+        case SNDCTL_DSP_GETIPTR:			/* _SIOR ('P',17, count_info) */
+		  artsdspdebug("aRts: SNDCTL_DSP_GETIPTR unsupported\n");
+		  break;
+#endif
+
+#ifdef SNDCTL_DSP_GETOPTR
+        case SNDCTL_DSP_GETOPTR:			/* _SIOR ('P',18, count_info) */
+		  if(mmapemu)
+		  {
+			mmapemu_flush();
+            *((count_info *)arg) = mmapemu_ocount;
+            mmapemu_ocount.blocks = 0;     
+		  }
+		  else
+		  {
+			artsdspdebug("aRts: SNDCTL_DSP_GETOPTR unsupported\n");
+		  }
+		  break;
+#endif
+
+#ifdef SNDCTL_DSP_MAPINBUF
+		case SNDCTL_DSP_MAPINBUF:           /* _SIOR ('P', 19, buffmem_desc) */
+		  artsdspdebug("aRts: SNDCTL_DSP_MAPINBUF unsupported\n");
+		  break;
+#endif
+
+#ifdef SNDCTL_DSP_MAPOUTBUF
+		case SNDCTL_DSP_MAPOUTBUF:          /* _SIOR ('P', 20, buffmem_desc) */
+		  artsdspdebug("aRts: SNDCTL_DSP_MAPOUTBUF unsupported\n");
+		  break;
+#endif
+
+#ifdef SNDCTL_DSP_SETSYNCRO
+		case SNDCTL_DSP_SETSYNCRO:          /* _SIO  ('P', 21) */
+		  artsdspdebug("aRts: SNDCTL_DSP_SETSYNCHRO unsupported\n");
+		  break;
+#endif
+
+#ifdef SNDCTL_DSP_SETDUPLEX
+		case SNDCTL_DSP_SETDUPLEX:          /* _SIO  ('P', 22) */
+		  artsdspdebug("aRts: SNDCTL_DSP_SETDUPLEX unsupported\n");
+		  break;
+#endif
+
+#ifdef SNDCTL_DSP_GETODELAY
+		case SNDCTL_DSP_GETODELAY:          /* _SIOR ('P', 23, int) */
+		  space = arts_stream_get(stream, ARTS_P_BUFFER_SPACE);
+		  size = arts_stream_get(stream, ARTS_P_BUFFER_SIZE);
+		  latency = arts_stream_get(stream, ARTS_P_SERVER_LATENCY);
+		  odelay = size - space + (latency * speed * bits * channels) / 8000;
+		  artsdspdebug("aRts: SNDCTL_DSP_GETODELAY returning %d\n", odelay);
+		  *arg = odelay;
+		  break;
+#endif
+
+        default:
+          artsdspdebug("aRts: unhandled /dev/dsp ioctl (%lx - %p)\n",request, argp);
+          break;
+        }
+
+      if (settings == 7 && !stream)
+        {
+          const char *name = getenv("ARTSDSP_NAME");
+          int fragSize = (frags & 0x7fff);
+          int fragCount = (frags & 0x7fff0000) >> 16;
+
+          artsdspdebug ("aRts: creating stream...\n");
+          stream = arts_play_stream(speed,bits,channels,name?name:"artsdsp");
+
+          if(fragSize > 1 && fragSize < 16)
+          {
+            /*
+             * if fragment settings are way too large (unrealistic), we
+             * will assume that the user didn't mean it, and let the C API
+             * choose a convenient number >= 3
+             */
+            if(fragCount < 2 || fragCount > 8192
+            || (fragCount * (1 << fragSize)) > 128*1024)
+            {
+              frags = 0x00030000+fragSize;
+            }
+
+            arts_stream_set(stream,ARTS_P_PACKET_SETTINGS,frags);
+          }
+		  if(mmapemu)
+		  {
+		    arts_stream_set(stream,ARTS_P_PACKET_SETTINGS,0x0002000c);
+		    mmapemu_ocount.ptr=mmapemu_ocount.blocks=mmapemu_ocount.bytes=0;
+			artsdspdebug("aRts: total latency = %dms, buffer latency = %dms\n",
+			  arts_stream_get(stream,ARTS_P_TOTAL_LATENCY),
+              arts_stream_get(stream, ARTS_P_BUFFER_TIME));
+		  }
+        }
+
+      return 0;
+    }
+
+  return 0;
+}
+
+int close(int fd)
+{
+  CHECK_INIT();
+
+  if (fd != sndfd)
+    return orig_close (fd);
+  else if (sndfd != -1)
+    {
+      artsdspdebug ("aRts: /dev/dsp close...\n");
+      if(stream)
+      {
+        arts_close_stream(stream);
+        stream = 0;
+      }
+      if (record_stream)
+      {
+          arts_close_stream(record_stream);
+          record_stream = 0;
+      }
+	  if(mmapemu && mmapemu_obuffer)
+	  {
+		free(mmapemu_obuffer);
+		mmapemu_obuffer = 0;
+	  }
+
+	  /*
+	   * there are problems with library unloading in conjunction with X11,
+	   * (Arts::X11GlobalComm), so we don't unload stuff again here
+	   */
+
+      /* arts_free(); */
+
+      orig_close(sndfd);
+      sndfd = -1;
+    }
+  return 0;
+}
+
+int access(const char *pathname, int mode)
+{
+  CHECK_INIT();
+
+  if (!is_sound_device(pathname))    /* original open for anything but sound */
+    return orig_access (pathname, mode);
+  else
+    artsdspdebug ("aRts: /dev/dsp access...\n");
+  return 0;
+}
+
+ssize_t write (int fd, const void *buf, size_t count)
+{
+  CHECK_INIT();
+
+  if(fd != sndfd)
+    return orig_write(fd,buf,count);
+  else if(sndfd != -1)
+  {
+    artsdspdebug ("aRts: /dev/dsp write...\n");
+    if(stream != 0)
+    {
+      return arts_write(stream,buf,count);
+    }
+  }
+  return 0;
+}
+
+ssize_t read (int fd, void *buf, size_t count)
+{
+  CHECK_INIT();
+
+  if (fd != sndfd)
+    return orig_read(fd,buf,count);
+  else if (sndfd == -1)
+    return 0;
+
+  if (!record_stream)
+    record_stream = arts_record_stream(speed, bits, channels, "artsdsp");
+  artsdspdebug ( "aRts: /dev/dsp read...\n" );
+  return arts_read(record_stream, buf, count);
+}
+
+void *mmap(void  *start,  size_t length, int prot, int flags,
+             int fd, off_t offset)
+{
+  CHECK_INIT();
+
+  if(fd != sndfd || sndfd == -1)
+    return orig_mmap(start,length,prot,flags,fd,offset);
+  else
+  {
+    artsdspdebug ("aRts: mmap - start = %p, length = %zd, prot = %d\n",
+                                                          start, length, prot);
+    artsdspdebug ("      flags = %d, fd = %d, offset = %ld\n",flags, fd,offset);
+
+	if(mmapemu && length > 0)
+	{
+      mmapemu_osize = length;
+      mmapemu_obuffer = malloc(length);
+	  mmapemu_ocount.ptr = mmapemu_ocount.blocks = mmapemu_ocount.bytes = 0;
+      return mmapemu_obuffer;
+	}
+	else artsdspdebug ("aRts: /dev/dsp mmap (unsupported, try -m option)...\n");
+  }
+  return (void *)-1;
+}
+        
+int munmap(void *start, size_t length)
+{
+  CHECK_INIT();
+
+  if(start != mmapemu_obuffer || mmapemu_obuffer == 0)
+    return orig_munmap(start,length);
+
+  artsdspdebug ("aRts: /dev/dsp munmap...\n");
+  mmapemu_obuffer = 0;
+  free(start);
+
+  return 0;
+}
+
+#ifdef HAVE_ARTSDSP_STDIO_EMU
+
+/*
+ * use #include rather than linking, because we want to keep everything
+ * static inside artsdsp to be sure that we don't override application symbols
+ */
+#include "stdioemu.c"
+
+FILE* fopen(const char *path, const char *mode)
+{
+  CHECK_INIT();
+
+  if (!is_sound_device(path))    /* original open for anything but sound */
+    return orig_fopen (path, mode);
+
+  artsdspdebug ("aRts: hijacking /dev/dsp fopen...\n");
+
+  return fake_fopen(path, mode);
+}
+#endif
+
+#endif
+/*
+ * vim:ts=4
+ */