--- IO-AIO/AIO.xs	2007/05/09 06:45:12	1.98
+++ IO-AIO/AIO.xs	2007/06/01 13:25:51	1.101
@@ -20,6 +20,7 @@
 #include <fcntl.h>
 #include <signal.h>
 #include <sched.h>
+#include <utime.h>
 
 #if HAVE_SENDFILE
 # if __linux
@@ -47,6 +48,13 @@
 /* buffer size for various temporary buffers */
 #define AIO_BUFSIZE 65536
 
+/* use NV for 32 bit perls as it allows larger offsets */
+#if IVSIZE >= 8
+# define SvVAL64 SvIV
+#else
+# define SvVAL64 SvNV
+#endif
+
 #define dBUF	 				\
   char *aio_buf;				\
   LOCK (wrklock);				\
@@ -60,9 +68,12 @@
 enum {
   REQ_QUIT,
   REQ_OPEN, REQ_CLOSE,
-  REQ_READ, REQ_WRITE, REQ_READAHEAD,
-  REQ_SENDFILE,
+  REQ_READ, REQ_WRITE,
+  REQ_READAHEAD, REQ_SENDFILE,
   REQ_STAT, REQ_LSTAT, REQ_FSTAT,
+  REQ_UTIME, REQ_FUTIME,
+  REQ_CHMOD, REQ_FCHMOD,
+  REQ_CHOWN, REQ_FCHOWN,
   REQ_FSYNC, REQ_FDATASYNC,
   REQ_UNLINK, REQ_RMDIR, REQ_MKDIR, REQ_RENAME,
   REQ_MKNOD, REQ_READDIR,
@@ -78,16 +89,17 @@
 {
   struct aio_cb *volatile next;
 
-  SV *callback, *fh;
+  SV *callback;
   SV *sv1, *sv2;
   void *ptr1, *ptr2;
   off_t offs;
   size_t size;
   ssize_t result;
+  double nv1, nv2;
 
   STRLEN stroffset;
   int type;
-  int int1, int2;
+  int int1, int2, int3;
   int errorno;
   mode_t mode; /* open */
 
@@ -100,7 +112,7 @@
 
 enum {
   FLAG_CANCELLED     = 0x01, /* request was cancelled */
-  FLAG_SV1_RO_OFF    = 0x40, /* data was set readonly */
+  FLAG_SV2_RO_OFF    = 0x40, /* data was set readonly */
   FLAG_PTR2_FREE     = 0x80, /* need to free(ptr2) */
 };
 
@@ -314,7 +326,7 @@
 
 static int poll_cb ();
 static int req_invoke (aio_req req);
-static void req_free (aio_req req);
+static void req_destroy (aio_req req);
 static void req_cancel (aio_req req);
 
 /* must be called at most once */
@@ -390,12 +402,12 @@
 
       if (!req_invoke (grp))
         {
-          req_free (grp);
+          req_destroy (grp);
           unblock_sig ();
           croak (0);
         }
 
-      req_free (grp);
+      req_destroy (grp);
       unblock_sig ();
     }
 }
@@ -404,8 +416,8 @@
 {
   dSP;
 
-  if (req->flags & FLAG_SV1_RO_OFF)
-    SvREADONLY_off (req->sv1);
+  if (req->flags & FLAG_SV2_RO_OFF)
+    SvREADONLY_off (req->sv2);
 
   if (!(req->flags & FLAG_CANCELLED) && SvOK (req->callback))
     {
@@ -480,9 +492,9 @@
           case REQ_READLINK:
             if (req->result > 0)
               {
-                SvCUR_set (req->sv1, req->result);
-                *SvEND (req->sv1) = 0;
-                PUSHs (req->sv1);
+                SvCUR_set (req->sv2, req->result);
+                *SvEND (req->sv2) = 0;
+                PUSHs (req->sv2);
               }
             break;
 
@@ -496,8 +508,8 @@
             break;
 
           case REQ_READ:
-            SvCUR_set (req->sv1, req->stroffset + (req->result > 0 ? req->result : 0));
-            *SvEND (req->sv1) = 0;
+            SvCUR_set (req->sv2, req->stroffset + (req->result > 0 ? req->result : 0));
+            *SvEND (req->sv2) = 0;
             PUSHs (sv_2mortal (newSViv (req->result)));
             break;
 
@@ -533,7 +545,7 @@
   return !SvTRUE (ERRSV);
 }
 
-static void req_free (aio_req req)
+static void req_destroy (aio_req req)
 {
   if (req->self)
     {
@@ -541,7 +553,6 @@
       SvREFCNT_dec (req->self);
     }
 
-  SvREFCNT_dec (req->fh);
   SvREFCNT_dec (req->sv1);
   SvREFCNT_dec (req->sv2);
   SvREFCNT_dec (req->callback);
@@ -573,7 +584,7 @@
   req_cancel_subs (req);
 }
 
-static void *aio_proc(void *arg);
+static void *aio_proc (void *arg);
 
 static void start_thread (void)
 {
@@ -743,7 +754,7 @@
             {
               if (!req_invoke (req))
                 {
-                  req_free (req);
+                  req_destroy (req);
                   unblock_sig ();
                   croak (0);
                 }
@@ -751,7 +762,7 @@
               count++;
             }
 
-          req_free (req);
+          req_destroy (req);
 
           if (maxreqs && !--maxreqs)
             break;
@@ -834,6 +845,34 @@
 }
 #endif
 
+#ifndef HAVE_FUTIMES
+
+# define utimes(path,times)  aio_utimes  (path, times)
+# define futimes(fd,times)   aio_futimes (fd, times)
+
+int aio_utimes (const char *filename, const struct timeval times[2])
+{
+  if (times)
+    {
+      struct utimbuf buf;
+
+      buf.actime  = times[0].tv_sec;
+      buf.modtime = times[1].tv_sec;
+
+      return utime (filename, &buf);
+    }
+  else
+    return utime (filename, 0);
+}
+
+int aio_futimes (int fd, const struct timeval tv[2])
+{
+  errno = ENOSYS;
+  return -1;
+}
+
+#endif
+
 #if !HAVE_FDATASYNC
 # define fdatasync fsync
 #endif
@@ -1101,8 +1140,12 @@
       if (!(req->flags & FLAG_CANCELLED))
         switch (req->type)
           {
-            case REQ_READ:      req->result = pread     (req->int1, req->ptr1, req->size, req->offs); break;
-            case REQ_WRITE:     req->result = pwrite    (req->int1, req->ptr1, req->size, req->offs); break;
+            case REQ_READ:      req->result = req->offs >= 0
+                                            ? pread     (req->int1, req->ptr1, req->size, req->offs)
+                                            : read      (req->int1, req->ptr1, req->size); break;
+            case REQ_WRITE:     req->result = req->offs >= 0
+                                            ? pwrite    (req->int1, req->ptr1, req->size, req->offs)
+                                            : write     (req->int1, req->ptr1, req->size); break;
 
             case REQ_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break;
             case REQ_SENDFILE:  req->result = sendfile_ (req->int1, req->int2, req->offs, req->size, self); break;
@@ -1111,6 +1154,11 @@
             case REQ_LSTAT:     req->result = lstat     (req->ptr1, (Stat_t *)req->ptr2); break;
             case REQ_FSTAT:     req->result = fstat     (req->int1, (Stat_t *)req->ptr2); break;
 
+            case REQ_CHOWN:     req->result = chown     (req->ptr1, req->int2, req->int3); break;
+            case REQ_FCHOWN:    req->result = fchown    (req->int1, req->int2, req->int3); break;
+            case REQ_CHMOD:     req->result = chmod     (req->ptr1, req->mode); break;
+            case REQ_FCHMOD:    req->result = fchmod    (req->int1, req->mode); break;
+
             case REQ_OPEN:      req->result = open      (req->ptr1, req->int1, req->mode); break;
             case REQ_CLOSE:     req->result = close     (req->int1); break;
             case REQ_UNLINK:    req->result = unlink    (req->ptr1); break;
@@ -1130,12 +1178,36 @@
               {
                 struct timeval tv;
 
-                tv.tv_sec  = req->int1;
-                tv.tv_usec = req->int2;
+                tv.tv_sec  = req->nv1;
+                tv.tv_usec = (req->nv1 - tv.tv_usec) * 1000000.;
 
                 req->result = select (0, 0, 0, 0, &tv);
               }
 
+            case REQ_UTIME:
+            case REQ_FUTIME:
+              {
+                struct timeval tv[2];
+                struct timeval *times;
+
+                if (req->nv1 != -1. || req->nv2 != -1.)
+                  {
+                    tv[0].tv_sec  = req->nv1;
+                    tv[0].tv_usec = (req->nv1 - tv[0].tv_sec) * 1000000.;
+                    tv[1].tv_sec  = req->nv2;
+                    tv[1].tv_usec = (req->nv2 - tv[1].tv_sec) * 1000000.;
+
+                    times = tv;
+                  }
+                else
+                  times = 0;
+
+
+                req->result = req->type == REQ_FUTIME
+                              ? futimes (req->int1, times)
+                              : utimes  (req->ptr1, times);
+              }
+
             case REQ_GROUP:
             case REQ_NOP:
               break;
@@ -1144,7 +1216,7 @@
               goto quit;
 
             default:
-              req->result = ENOSYS;
+              req->result = -1;
               break;
           }
 
@@ -1211,17 +1283,17 @@
   aio_req prv;
 
   while (prv = reqq_shift (&req_queue))
-    req_free (prv);
+    req_destroy (prv);
 
   while (prv = reqq_shift (&res_queue))
-    req_free (prv);
+    req_destroy (prv);
 
   while (wrk_first.next != &wrk_first)
     {
       worker *wrk = wrk_first.next;
 
       if (wrk->req)
-        req_free (wrk->req);
+        req_destroy (wrk->req);
 
       worker_clear (wrk);
       worker_free (wrk);
@@ -1317,11 +1389,7 @@
         RETVAL
 
 void
-aio_open (pathname,flags,mode,callback=&PL_sv_undef)
-	SV8 *	pathname
-        int	flags
-        int	mode
-        SV *	callback
+aio_open (SV8 *pathname, int flags, int mode, SV *callback=&PL_sv_undef)
 	PROTOTYPE: $$$;$
 	PPCODE:
 {
@@ -1337,9 +1405,7 @@
 }
 
 void
-aio_close (fh,callback=&PL_sv_undef)
-	SV *	fh
-        SV *	callback
+aio_close (SV *fh, SV *callback=&PL_sv_undef)
 	PROTOTYPE: $;$
         ALIAS:
            aio_close     = REQ_CLOSE
@@ -1350,20 +1416,14 @@
         dREQ;
 
         req->type = ix;
-        req->fh   = newSVsv (fh);
+        req->sv1  = newSVsv (fh);
         req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh)));
 
         REQ_SEND (req);
 }
 
 void
-aio_read (fh,offset,length,data,dataoffset,callback=&PL_sv_undef)
-	SV *	fh
-        UV	offset
-        UV	length
-        SV8 *	data
-        UV	dataoffset
-        SV *	callback
+aio_read (SV *fh, SV *offset, UV length, SV8 *data, UV dataoffset, SV *callback=&PL_sv_undef)
         ALIAS:
            aio_read  = REQ_READ
            aio_write = REQ_WRITE
@@ -1401,19 +1461,19 @@
           dREQ;
 
           req->type = ix;
-          req->fh   = newSVsv (fh);
+          req->sv1  = newSVsv (fh);
           req->int1 = PerlIO_fileno (ix == REQ_READ ? IoIFP (sv_2io (fh))
                                                     : IoOFP (sv_2io (fh)));
-          req->offs = offset;
+          req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;
           req->size = length;
-          req->sv1  = SvREFCNT_inc (data);
+          req->sv2  = SvREFCNT_inc (data);
           req->ptr1 = (char *)svptr + dataoffset;
           req->stroffset = dataoffset;
 
           if (!SvREADONLY (data))
             {
               SvREADONLY_on (data);
-              req->flags |= FLAG_SV1_RO_OFF;
+              req->flags |= FLAG_SV2_RO_OFF;
             }
 
           REQ_SEND;
@@ -1421,9 +1481,7 @@
 }
 
 void
-aio_readlink (path,callback=&PL_sv_undef)
-	SV8 *	path
-        SV *	callback
+aio_readlink (SV8 *path, SV *callback=&PL_sv_undef)
 	PROTOTYPE: $$;$
         PPCODE:
 {
@@ -1434,61 +1492,50 @@
         SvPOK_on (data);
 
         req->type = REQ_READLINK;
-        req->fh   = newSVsv (path);
-        req->ptr2 = SvPVbyte_nolen (req->fh);
-        req->sv1  = data;
+        req->sv1  = newSVsv (path);
+        req->ptr2 = SvPVbyte_nolen (req->sv1);
+        req->sv2  = data;
         req->ptr1 = SvPVbyte_nolen (data);
 
         REQ_SEND;
 }
 
 void
-aio_sendfile (out_fh,in_fh,in_offset,length,callback=&PL_sv_undef)
-        SV *	out_fh
-        SV *	in_fh
-        UV	in_offset
-        UV	length
-        SV *	callback
+aio_sendfile (SV *out_fh, SV *in_fh, SV *in_offset, UV length, SV *callback=&PL_sv_undef)
 	PROTOTYPE: $$$$;$
         PPCODE:
 {
 	dREQ;
 
         req->type = REQ_SENDFILE;
-        req->fh   = newSVsv (out_fh);
+        req->sv1  = newSVsv (out_fh);
         req->int1 = PerlIO_fileno (IoIFP (sv_2io (out_fh)));
         req->sv2  = newSVsv (in_fh);
         req->int2 = PerlIO_fileno (IoIFP (sv_2io (in_fh)));
-        req->offs = in_offset;
+        req->offs = SvVAL64 (in_offset);
         req->size = length;
 
         REQ_SEND;
 }
 
 void
-aio_readahead (fh,offset,length,callback=&PL_sv_undef)
-        SV *	fh
-        UV	offset
-        IV	length
-        SV *	callback
+aio_readahead (SV *fh, SV *offset, IV length, SV *callback=&PL_sv_undef)
 	PROTOTYPE: $$$;$
         PPCODE:
 {
 	dREQ;
 
         req->type = REQ_READAHEAD;
-        req->fh   = newSVsv (fh);
+        req->sv1  = newSVsv (fh);
         req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh)));
-        req->offs = offset;
+        req->offs = SvVAL64 (offset);
         req->size = length;
 
         REQ_SEND;
 }
 
 void
-aio_stat (fh_or_path,callback=&PL_sv_undef)
-        SV8 *		fh_or_path
-        SV *		callback
+aio_stat (SV8 *fh_or_path, SV *callback=&PL_sv_undef)
         ALIAS:
            aio_stat  = REQ_STAT
            aio_lstat = REQ_LSTAT
@@ -1499,22 +1546,21 @@
         req->ptr2 = malloc (sizeof (Stat_t));
         if (!req->ptr2)
           {
-            req_free (req);
+            req_destroy (req);
             croak ("out of memory during aio_stat statdata allocation");
           }
 
         req->flags |= FLAG_PTR2_FREE;
+        req->sv1 = newSVsv (fh_or_path);
 
         if (SvPOK (fh_or_path))
           {
             req->type = ix;
-            req->sv1  = newSVsv (fh_or_path);
             req->ptr1 = SvPVbyte_nolen (req->sv1);
           }
         else
           {
             req->type = REQ_FSTAT;
-            req->fh   = newSVsv (fh_or_path);
             req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
           }
 
@@ -1522,9 +1568,78 @@
 }
 
 void
-aio_unlink (pathname,callback=&PL_sv_undef)
-	SV8 *	pathname
-	SV *	callback
+aio_utime (SV8 *fh_or_path, SV *atime, SV *mtime, SV *callback=&PL_sv_undef)
+	PPCODE:
+{
+	dREQ;
+
+        req->nv1 = SvOK (atime) ? SvNV (atime) : -1.;
+        req->nv2 = SvOK (mtime) ? SvNV (mtime) : -1.;
+        req->sv1 = newSVsv (fh_or_path);
+
+        if (SvPOK (fh_or_path))
+          {
+            req->type = REQ_UTIME;
+            req->ptr1 = SvPVbyte_nolen (req->sv1);
+          }
+        else
+          {
+            req->type = REQ_FUTIME;
+            req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
+          }
+
+        REQ_SEND;
+}
+
+void
+aio_chmod (SV8 *fh_or_path, int mode, SV *callback=&PL_sv_undef)
+	PPCODE:
+{
+	dREQ;
+
+        req->mode = mode;
+        req->sv1  = newSVsv (fh_or_path);
+
+        if (SvPOK (fh_or_path))
+          {
+            req->type = REQ_CHMOD;
+            req->ptr1 = SvPVbyte_nolen (req->sv1);
+          }
+        else
+          {
+            req->type = REQ_FCHMOD;
+            req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
+          }
+
+        REQ_SEND;
+}
+
+void
+aio_chown (SV8 *fh_or_path, SV *uid, SV *gid, SV *callback=&PL_sv_undef)
+	PPCODE:
+{
+	dREQ;
+
+        req->int2 = SvOK (uid) ? SvIV (uid) : -1;
+        req->int3 = SvOK (gid) ? SvIV (gid) : -1;
+        req->sv1  = newSVsv (fh_or_path);
+
+        if (SvPOK (fh_or_path))
+          {
+            req->type = REQ_CHOWN;
+            req->ptr1 = SvPVbyte_nolen (req->sv1);
+          }
+        else
+          {
+            req->type = REQ_FCHOWN;
+            req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
+          }
+
+        REQ_SEND;
+}
+
+void
+aio_unlink (SV8 *pathname, SV *callback=&PL_sv_undef)
         ALIAS:
            aio_unlink  = REQ_UNLINK
            aio_rmdir   = REQ_RMDIR
@@ -1541,10 +1656,7 @@
 }
 
 void
-aio_mkdir (pathname,mode,callback=&PL_sv_undef)
-	SV8 *	pathname
-        UV	mode
-	SV *	callback
+aio_mkdir (SV8 *pathname, int mode, SV *callback=&PL_sv_undef)
 	PPCODE:
 {
 	dREQ;
@@ -1558,10 +1670,7 @@
 }
 
 void
-aio_link (oldpath,newpath,callback=&PL_sv_undef)
-	SV8 *	oldpath
-	SV8 *	newpath
-	SV *	callback
+aio_link (SV8 *oldpath, SV8 *newpath, SV *callback=&PL_sv_undef)
         ALIAS:
            aio_link    = REQ_LINK
            aio_symlink = REQ_SYMLINK
@@ -1571,8 +1680,8 @@
 	dREQ;
 	
         req->type = ix;
-	req->fh   = newSVsv (oldpath);
-	req->ptr2 = SvPVbyte_nolen (req->fh);
+	req->sv2  = newSVsv (oldpath);
+	req->ptr2 = SvPVbyte_nolen (req->sv2);
 	req->sv1  = newSVsv (newpath);
 	req->ptr1 = SvPVbyte_nolen (req->sv1);
 	
@@ -1580,11 +1689,7 @@
 }
 
 void
-aio_mknod (pathname,mode,dev,callback=&PL_sv_undef)
-	SV8 *	pathname
-        UV	mode
-        UV	dev
-	SV *	callback
+aio_mknod (SV8 *pathname, int mode, UV dev, SV *callback=&PL_sv_undef)
 	PPCODE:
 {
 	dREQ;
@@ -1599,23 +1704,19 @@
 }
 
 void
-aio_busy (delay,callback=&PL_sv_undef)
-	double	delay
-	SV *	callback
+aio_busy (double delay, SV *callback=&PL_sv_undef)
 	PPCODE:
 {
 	dREQ;
 
         req->type = REQ_BUSY;
-        req->int1 = delay < 0. ? 0 : delay;
-        req->int2 = delay < 0. ? 0 : 1000. * (delay - req->int1);
+        req->nv1  = delay < 0. ? 0. : delay;
 
 	REQ_SEND;
 }
 
 void
-aio_group (callback=&PL_sv_undef)
-        SV *	callback
+aio_group (SV *callback=&PL_sv_undef)
 	PROTOTYPE: ;$
         PPCODE:
 {
@@ -1628,8 +1729,7 @@
 }
 
 void
-aio_nop (callback=&PL_sv_undef)
-	SV *	callback
+aio_nop (SV *callback=&PL_sv_undef)
 	PPCODE:
 {
 	dREQ;