addons/AsyncRequest/source/IoAsyncRequest.c

   1 /*#io
   2 AsyncRequest ioDoc(
   3                         docCopyright("Steve Dekorte", 2004)
   4                         docLicense("BSD revised")
   5                         docCategory("Filesystem")
   6                         docDescription("""Used for doing asynchronous file i/o.
   7 Example use;
   8 <pre>
   9
  10 </pre>
  11 """)
  12 */
  13
  14 #include "IoAsyncRequest.h"
  15 #include "IoState.h"
  16 #include "IoNumber.h"
  17 #include "IoSeq.h"
  18
  19 #define IOCB(self) ((struct aiocb *)(IoObject_dataPointer(self)))
  20 #define IOCB_BUFFER(self) ((void *)(IOCB(self)->aio_buf))
  21
  22 IoTag *IoAsyncRequest_newTag(void *state)
  23 {
  24         IoTag *tag = IoTag_newWithName_("AsyncRequest");
  25         IoTag_state_(tag, state);
  26         IoTag_cloneFunc_(tag, (IoTagCloneFunc *)IoAsyncRequest_rawClone);
  27         IoTag_freeFunc_(tag, (IoTagFreeFunc *)IoAsyncRequest_free);
  28         return tag;
  29 }
  30
  31 IoAsyncRequest *IoAsyncRequest_proto(void *state)
  32 {
  33         IoAsyncRequest *self = IoObject_new(state);
  34         IoObject_tag_(self, IoAsyncRequest_newTag(state));
  35
  36         IoObject_setDataPointer_(self, calloc(1, sizeof(struct aiocb)));
  37
  38         IoState_registerProtoWithFunc_(state, self, IoAsyncRequest_proto);
  39
  40         {
  41                 IoMethodTable methodTable[] = {
  42                 {"setDescriptor", IoAsyncRequest_setDescriptor},
  43                 {"descriptor", IoAsyncRequest_descriptor},
  44                 {"numberOfBytes", IoAsyncRequest_numberOfBytes},
  45                 {"read", IoAsyncRequest_read},
  46                 {"write", IoAsyncRequest_write},
  47                 {"isDone", IoAsyncRequest_isDone},
  48                 {"error", IoAsyncRequest_error},
  49                 {"cancel", IoAsyncRequest_cancel},
  50                 {"sync", IoAsyncRequest_sync},
  51                 {"copyBufferTo", IoAsyncRequest_copyBufferTo},
  52                 {NULL, NULL},
  53                 };
  54                 IoObject_addMethodTable_(self, methodTable);
  55         }
  56
  57         return self;
  58 }
  59
  60 IoAsyncRequest *IoAsyncRequest_rawClone(IoAsyncRequest *proto)
  61 {
  62         IoObject *self = IoObject_rawClonePrimitive(proto);
  63         IoObject_setDataPointer_(self, calloc(1, sizeof(struct aiocb)));
  64         return self;
  65 }
  66
  67 IoAsyncRequest *IoAsyncRequest_new(void *state)
  68 {
  69         IoObject *proto = IoState_protoWithInitFunction_(state, IoAsyncRequest_proto);
  70         return IOCLONE(proto);
  71 }
  72
  73 void IoAsyncRequest_free(IoAsyncRequest *self)
  74 {
  75         int fd = IOCB(self)->aio_fildes;
  76
  77         if (fd)
  78         {
  79                 aio_cancel(fd, IOCB(self));
  80         }
  81
  82         if (IOCB_BUFFER(self))
  83         {
  84                 free(IOCB_BUFFER(self));
  85         }
  86
  87         free(IOCB(self));
  88 }
  89
  90 // -----------------------------------------------------------
  91
  92 IoObject *IoAsyncRequest_setDescriptor(IoAsyncRequest *self, IoObject *locals, IoMessage *m)
  93 {
  94         IOCB(self)->aio_fildes = IoMessage_locals_intArgAt_(m, locals, 0);
  95         return self;
  96 }
  97
  98 IoObject *IoAsyncRequest_descriptor(IoAsyncRequest *self, IoObject *locals, IoMessage *m)
  99 {
 100         return IONUMBER(IOCB(self)->aio_fildes);
 101 }
 102
 103 IoObject *IoAsyncRequest_numberOfBytes(IoAsyncRequest *self, IoObject *locals, IoMessage *m)
 104 {
 105         return IONUMBER(IOCB(self)->aio_nbytes);
 106 }
 107
 108 IoObject *IoAsyncRequest_position(IoAsyncRequest *self, IoObject *locals, IoMessage *m)
 109 {
 110         return IONUMBER(IOCB(self)->aio_offset);
 111 }
 112
 113 IoObject *IoAsyncRequest_read(IoAsyncRequest *self, IoObject *locals, IoMessage *m)
 114 {
 115         int r;
 116
 117         IOCB(self)->aio_offset = (size_t)CNUMBER(IoMessage_locals_numberArgAt_(m, locals, 0));
 118         IOCB(self)->aio_nbytes = IoMessage_locals_intArgAt_(m, locals, 1);
 119
 120         if (!IOCB_BUFFER(self))
 121         {
 122                 IOCB(self)->aio_buf = calloc(1, IOCB(self)->aio_nbytes);
 123         }
 124         else
 125         {
 126                 IOCB(self)->aio_buf = realloc(IOCB_BUFFER(self), IOCB(self)->aio_nbytes);
 127         }
 128
 129         r = aio_read(IOCB(self));
 130
 131         return r == 0 ? self : IONIL(self);
 132 }
 133
 134 IoObject *IoAsyncRequest_write(IoAsyncRequest *self, IoObject *locals, IoMessage *m)
 135 {
 136         int r;
 137         IoSeq *data;
 138         UArray *ba;
 139         int bufferOffset;
 140         int bytesToWrite;
 141
 142         IOCB(self)->aio_offset = (size_t)CNUMBER(IoMessage_locals_numberArgAt_(m, locals, 0));
 143
 144         data = IoMessage_locals_seqArgAt_(m, locals, 1);
 145         ba = IoSeq_rawUArray(data);
 146
 147         bufferOffset = IoMessage_locals_intArgAt_(m, locals, 2);
 148         bytesToWrite = IoMessage_locals_intArgAt_(m, locals, 3);
 149
 150         if (bytesToWrite > UArray_size(ba) - bufferOffset)
 151         {
 152                 bytesToWrite = UArray_size(ba) - bufferOffset;
 153         }
 154
 155         IOCB(self)->aio_nbytes = bytesToWrite;
 156         IOCB(self)->aio_buf = realloc(IOCB_BUFFER(self), bytesToWrite);
 157         memcpy(IOCB_BUFFER(self), UArray_bytes(ba), bytesToWrite);
 158
 159         r = aio_write(IOCB(self));
 160
 161         return r == 0 ? self : IONIL(self);
 162 }
 163
 164 IoObject *IoAsyncRequest_isDone(IoAsyncRequest *self, IoObject *locals, IoMessage *m)
 165 {
 166         int r = aio_error(IOCB(self));
 167         return (r == 0 || r != EINPROGRESS) ? IOTRUE(self) : IOFALSE(self);
 168 }
 169
 170 #include <errno.h>
 171
 172 IoObject *IoAsyncRequest_error(IoAsyncRequest *self, IoObject *locals, IoMessage *m)
 173 {
 174         int r;
 175
 176         errno = 0;
 177
 178         r = aio_error(IOCB(self));
 179
 180         if (r == -1)
 181         {
 182                 char *s = strerror(errno);
 183
 184                 if (errno == 22)
 185                 {
 186                         s = "The iocb argument does not reference an outstanding asynchronous I/O request.";
 187                         printf("AsyncRequest error: %s\n", s);
 188                         //return IOSYMBOL("The iocb argument does not reference an outstanding asynchronous I/O request.");
 189                         return IONIL(self);
 190                 }
 191
 192                 printf("AsyncRequest errno %i : %s' EINVAL = %i\n", errno, s, EINVAL);
 193                 return IOSYMBOL(s);
 194         }
 195
 196         if (r != 0 && r != EINPROGRESS)
 197         {
 198                 char *s = strerror(r);
 199                 printf("AsyncRequest error %i\n", r);
 200                 return IOSYMBOL(s);
 201         }
 202
 203         return IONIL(self);
 204 }
 205
 206 IoObject *IoAsyncRequest_cancel(IoAsyncRequest *self, IoObject *locals, IoMessage *m)
 207 {
 208         int r = aio_cancel(IOCB(self)->aio_fildes, IOCB(self));
 209         return r == 0 ? self : IONIL(self);
 210 }
 211
 212 IoObject *IoAsyncRequest_sync(IoAsyncRequest *self, IoObject *locals, IoMessage *m)
 213 {
 214         int r = aio_fsync(O_SYNC, IOCB(self));
 215         return r == 0 ? self : IONIL(self);
 216 }
 217
 218 IoObject *IoAsyncRequest_copyBufferTo(IoAsyncRequest *self, IoObject *locals, IoMessage *m)
 219 {
 220         if (IOCB_BUFFER(self))
 221         {
 222                 IoSeq *data = IoMessage_locals_mutableSeqArgAt_(m, locals, 0);
 223                 UArray *ba = IoSeq_rawUArray(data);
 224                 UArray_setData_type_size_copy_(ba, IOCB_BUFFER(self), CTYPE_uint8_t, IOCB(self)->aio_nbytes, 1);
 225                 return self;
 226         }
 227
 228         return IONIL(self);
 229 }
 230