addons/AsyncRequest/source/IoAsyncRequest.c

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