regina/arscmd.c

   1 #include "rexx.h"
   2
   3 #include <proto/alib.h>
   4 #include <proto/exec.h>
   5 #include <proto/dos.h>
   6 #include <proto/utility.h>
   7 #include <utility/tagitem.h>
   8 #include <dos/dos.h>
   9 #include <dos/dostags.h>
  10 #include <dos/dosextens.h>
  11 #include <dos/filesystem.h>
  12 #include <exec/memory.h>
  13 #include <exec/io.h>
  14 #include <exec/lists.h>
  15 #include <exec/nodes.h>
  16
  17 #include <assert.h>
  18 #include <errno.h>
  19
  20 typedef struct {
  21   struct FileHandle *fhin, *fhout;
  22   struct MsgPort *port;
  23   struct IOFileSys *pendingread;
  24   ULONG bytesread;
  25   struct IOFileSys *pendingwrite;
  26   ULONG flags;
  27   BOOL isinput;
  28 } FileHandleInfo;
  29
  30 #define FHI_WAIT          (1<<0)
  31 #define FHI_READRETURNED  (1<<1)
  32
  33 typedef struct {
  34   const tsd_t *TSD;
  35   struct Task *parent, *child;
  36   BYTE psigbit, csigbit;
  37   environment *parentenv;
  38   const char *childcmd;
  39   int retval;
  40   FileHandleInfo files[3];
  41 } AsyncInfo;
  42
  43
  44 static struct IOFileSys *CreateIOFS(ULONG type, struct MsgPort *port, struct FileHandle *fh)
  45 {
  46   struct IOFileSys *iofs = (struct IOFileSys *)AllocMem(sizeof(struct IOFileSys), MEMF_PUBLIC|MEMF_CLEAR);
  47
  48   if (iofs == NULL)
  49     return NULL;
  50
  51   iofs->IOFS.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
  52   iofs->IOFS.io_Message.mn_ReplyPort    = port;
  53   iofs->IOFS.io_Message.mn_Length       = sizeof(struct IOFileSys);
  54   iofs->IOFS.io_Command                 = type;
  55   iofs->IOFS.io_Flags                   = 0;
  56 #if defined(__AROS__) && !defined(AROS_DOS_PACKETS)
  57   iofs->IOFS.io_Device                  = fh->fh_Device;
  58   iofs->IOFS.io_Unit                    = fh->fh_Unit;
  59 #endif
  60
  61   return iofs;
  62 }
  63
  64 static BPTR DupFH(BPTR fh, LONG mode)
  65 {
  66     BPTR ret = NULL;
  67
  68     if (fh)
  69     {
  70         BPTR olddir = CurrentDir(fh);
  71         ret    = Open("", mode);
  72
  73         CurrentDir(olddir);
  74     }
  75
  76     return ret;
  77 }
  78
  79
  80 void DeleteIOFS(struct IOFileSys *iofs)
  81 {
  82   FreeMem(iofs, sizeof(struct IOFileSys));
  83 }
  84
  85
  86 void *create_async_info(const tsd_t *TSD)
  87 {
  88   AsyncInfo *ai = MallocTSD(sizeof(AsyncInfo));
  89   int i;
  90
  91   ai->TSD = TSD;
  92
  93   for(i=0; i<3; i++)
  94     ai->files[i].fhin = NULL;
  95
  96   return (void *)ai;
  97 }
  98
  99 void delete_async_info(void *async_info)
 100 {
 101   AsyncInfo *ai = (AsyncInfo *)async_info;
 102
 103   if (ai == NULL)
 104     return;
 105
 106   assert(ai->files[0].fhin == NULL && ai->files[1].fhin == NULL && ai->files[2].fhin == NULL);
 107
 108   Free_TSD(ai->TSD, ai);
 109 }
 110
 111 void reset_async_info(void *async_info)
 112 {
 113   AsyncInfo *ai = (AsyncInfo *)async_info;
 114
 115   ai->files[0].flags = 0;
 116   ai->files[1].flags = 0;
 117   ai->files[2].flags = 0;
 118 }
 119
 120 void add_async_waiter(void *async_info, int handle, int add_as_read_handle)
 121 {
 122   AsyncInfo *ai = (AsyncInfo *)async_info;
 123
 124   ai->files[handle].flags |= FHI_WAIT;
 125 }
 126
 127 int open_subprocess_connection(const tsd_t *TSD, environpart *ep, void *async_info)
 128 {
 129   AsyncInfo *ai = (AsyncInfo *)async_info;
 130   int slot;
 131
 132   for (slot=0; slot<3 && ai->files[slot].fhin!=NULL; slot++)
 133     ;
 134
 135   if (slot==3)
 136   {
 137     errno = EMFILE;
 138     return -1;
 139   }
 140
 141   /* Reset everything to NULL or 0 */
 142   memset(&ai->files[slot], 0, sizeof(FileHandleInfo));
 143
 144   if (Pipe("PIPEFS:", &(ai->files[slot].fhin), &(ai->files[slot].fhout)) != DOSTRUE)
 145   {
 146     errno = EACCES;
 147     return -1;
 148   }
 149
 150   ai->files[slot].port = CreatePort(NULL, 0);
 151   if (ai->files[slot].port == NULL)
 152   {
 153     Close(ai->files[slot].fhin);
 154     ai->files[slot].fhin = NULL;
 155     Close(ai->files[slot].fhout);
 156     ai->files[slot].fhout = NULL;
 157     errno = ENOMEM;
 158     return -1;
 159   }
 160   ai->files[slot].bytesread = 0;
 161
 162   ai->files[slot].isinput = ep->flags.isinput;
 163   if (ep->flags.isinput)
 164   {
 165     ep->hdls[0] = -1;
 166     ep->hdls[1] = slot;
 167   }
 168   else
 169   {
 170     ep->hdls[0] = slot;
 171     ep->hdls[1] = -1;
 172   }
 173
 174   return 0;
 175 }
 176
 177
 178 void handle_msgs(FileHandleInfo *fhi)
 179 {
 180   struct IOFileSys *iofs;
 181
 182   while ((iofs = (struct IOFileSys *)GetMsg(fhi->port)) != NULL)
 183   {
 184     if (iofs == fhi->pendingread)
 185       fhi->flags |= FHI_READRETURNED;
 186     else if (iofs == fhi->pendingwrite)
 187     {
 188       FreeVec(iofs->io_Union.io_WRITE.io_Buffer);
 189       FreeMem(iofs, sizeof(struct IOFileSys));
 190       fhi->pendingwrite = NULL;
 191     }
 192     else
 193       ReplyMsg((struct Message *)iofs);
 194   }
 195 }
 196
 197
 198 int __regina_close(int handle, void *async_info)
 199 {
 200   AsyncInfo *ai = async_info;
 201   FileHandleInfo *fhi;
 202
 203   assert(handle<3 && handle>=0);
 204
 205   fhi = &ai->files[handle];
 206
 207   handle_msgs(fhi);
 208   if (fhi->pendingread != NULL && !(fhi->flags & FHI_READRETURNED))
 209   {
 210     AbortIO((struct IORequest *)fhi->pendingread);
 211     WaitIO((struct IORequest *)fhi->pendingread);
 212     FreeVec(fhi->pendingread->io_Union.io_READ.io_Buffer);
 213     FreeMem(fhi->pendingread, sizeof(struct IOFileSys));
 214   }
 215   if (fhi->pendingwrite != NULL)
 216   {
 217     AbortIO((struct IORequest *)fhi->pendingwrite);
 218     WaitIO((struct IORequest *)fhi->pendingwrite);
 219     FreeVec(fhi->pendingwrite->io_Union.io_READ.io_Buffer);
 220     FreeMem(fhi->pendingwrite, sizeof(struct IOFileSys));
 221   }
 222   if (fhi->isinput)
 223     Close(fhi->fhout);
 224   else
 225     Close(fhi->fhin);
 226   fhi->fhin = NULL;
 227   DeletePort(fhi->port);
 228
 229   return 0;
 230 }
 231
 232
 233 void restart_file(int handle)
 234 {
 235   /* AROS uses pipes so cannot restart file */
 236   assert(handle == -1);
 237 }
 238
 239 void unblock_handle(int *handle, void *async_info)
 240 {
 241   /* All handles are non-blocking on AROS => do nothing */
 242 }
 243
 244
 245 int __regina_read(int handle, void *buf, unsigned size, void *async_info)
 246 {
 247   AsyncInfo *ai = async_info;
 248   FileHandleInfo *fhi;
 249
 250   assert(handle<3);
 251
 252   fhi = &ai->files[handle];
 253
 254   if (fhi->fhin == NULL)
 255     return -EBADF;
 256
 257   if (fhi->pendingread == NULL)
 258   {
 259     struct IOFileSys *iofs;
 260
 261     fhi->pendingread = iofs = CreateIOFS(FSA_READ, fhi->port, fhi->fhin);
 262     if (iofs == NULL)
 263       return -ENOMEM;
 264
 265     iofs->io_Union.io_READ.io_Buffer = AllocVec(size, MEMF_PUBLIC);
 266     iofs->io_Union.io_READ.io_Length = size;
 267
 268     SendIO(&iofs->IOFS);
 269   }
 270
 271   handle_msgs(fhi);
 272
 273   if (fhi->flags & FHI_READRETURNED)
 274   {
 275     if (fhi->bytesread + size > fhi->pendingread->io_Union.io_READ.io_Length)
 276       size = fhi->pendingread->io_Union.io_READ.io_Length - fhi->bytesread;
 277
 278     memcpy(buf, fhi->pendingread->io_Union.io_READ.io_Buffer, size);
 279     fhi->bytesread += size;
 280
 281     if (fhi->bytesread == fhi->pendingread->io_Union.io_READ.io_Length)
 282     {
 283       FreeVec(fhi->pendingread->io_Union.io_READ.io_Buffer);
 284       FreeMem(fhi->pendingread, sizeof(struct IOFileSys));
 285       fhi->pendingread = NULL;
 286       fhi->bytesread = 0;
 287       fhi->flags &= ~FHI_READRETURNED;
 288     }
 289
 290     return size;
 291   }
 292   else
 293     return -EAGAIN;
 294 }
 295
 296
 297 int __regina_write(int handle, const void *buf, unsigned size, void *async_info)
 298 {
 299   AsyncInfo *ai = (AsyncInfo *)async_info;
 300   FileHandleInfo *fhi;
 301
 302   assert(handle<3);
 303
 304   fhi = &ai->files[handle];
 305
 306   if (buf==NULL && size==0)
 307   {
 308     if (fhi->pendingwrite!=NULL)
 309     {
 310       WaitIO((struct IORequest *)fhi->pendingwrite);
 311       FreeVec(fhi->pendingwrite->io_Union.io_READ.io_Buffer);
 312       FreeMem(fhi->pendingwrite, sizeof(struct IOFileSys));
 313       fhi->pendingwrite = NULL;
 314     }
 315     return 0;
 316   }
 317
 318   if (fhi->fhin == NULL)
 319     return -EBADF;
 320
 321   handle_msgs(fhi);
 322
 323   if (fhi->pendingwrite == NULL)
 324   {
 325     struct IOFileSys *iofs;
 326
 327     fhi->pendingwrite = iofs = CreateIOFS(FSA_WRITE, fhi->port, fhi->fhout);
 328     if (iofs == NULL)
 329       return -ENOMEM;
 330
 331     iofs->io_Union.io_WRITE.io_Buffer = AllocVec(size, MEMF_PUBLIC);
 332     memcpy(iofs->io_Union.io_WRITE.io_Buffer, buf, size);
 333     iofs->io_Union.io_WRITE.io_Length = size;
 334
 335     SendIO(&iofs->IOFS);
 336
 337     return (int)size;
 338   }
 339   else
 340     return -EAGAIN;
 341 }
 342
 343
 344 void wait_async_info(void *async_info)
 345 {
 346   AsyncInfo *ai = (AsyncInfo *)async_info;
 347   int i;
 348   ULONG mask = SIGBREAKF_CTRL_C;
 349
 350   for (i = 0; i < 3; i++)
 351   {
 352     if (ai->files[i].fhin != NULL && ai->files[i].flags & FHI_WAIT &&
 353         (ai->files[i].pendingwrite != NULL || (ai->files[i].pendingread != NULL && !(ai->files[i].flags & FHI_READRETURNED)))
 354        )
 355       mask |= 1<<ai->files[i].port->mp_SigBit;
 356   }
 357
 358   if (mask != SIGBREAKF_CTRL_C)
 359     Wait(mask);
 360 }
 361
 362 GLOBAL_PROTECTION_VAR(startcommand)
 363 static AsyncInfo *childai;
 364
 365 void StartCommand(void)
 366 {
 367   AsyncInfo *ai = childai;
 368   char *cmd;
 369   struct Library *UtilityBase;
 370   struct TagItem *tags;
 371   struct DosLibrary *DOSBase;
 372
 373   DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 0);
 374
 375   ai->child = FindTask(NULL);
 376   ai->csigbit = AllocSignal(-1);
 377   cmd = AllocVec(strlen(ai->childcmd)+1, MEMF_PUBLIC|MEMF_CLEAR);
 378   strcpy(cmd, ai->childcmd);
 379
 380   Signal(ai->parent, 1<<ai->psigbit);
 381   Wait(1<<ai->csigbit);
 382   FreeSignal(ai->csigbit);
 383
 384   UtilityBase = OpenLibrary("utility.library", 0);
 385   if (UtilityBase == NULL)
 386   {
 387     FreeVec(cmd);
 388     ai->retval = 20;
 389     Signal(ai->parent, 1<<ai->psigbit);
 390     CloseLibrary((struct Library *)DOSBase);
 391     return;
 392   }
 393
 394   tags = AllocateTagItems(5);
 395   if (tags == NULL)
 396   {
 397     FreeVec(cmd);
 398     CloseLibrary(UtilityBase);
 399     ai->retval = 20;
 400     Signal(ai->parent, 1<<ai->psigbit);
 401     CloseLibrary((struct Library *)DOSBase);
 402     return;
 403   }
 404
 405   ai->retval = SystemTagList(cmd, NULL);
 406   FreeVec(cmd);
 407
 408   FreeTagItems(tags);
 409   CloseLibrary(UtilityBase);
 410
 411   Signal(ai->parent, 1<<ai->psigbit);
 412
 413   CloseLibrary((struct Library *)DOSBase);
 414 }
 415
 416 int fork_exec(tsd_t *TSD, environment *env, const char *cmdline, void *async_info)
 417 {
 418   AsyncInfo *ai = (AsyncInfo *)async_info;
 419
 420   switch (env->subtype)
 421   {
 422   case SUBENVIR_PATH:
 423   case SUBENVIR_COMMAND:
 424   case SUBENVIR_SYSTEM:
 425     {
 426       int inhndl  = env->input.hdls[1],
 427           outhndl = env->output.hdls[0],
 428           errhndl = env->error.hdls[0];
 429
 430       ai->psigbit = AllocSignal(-1);
 431       if (ai->psigbit < 0)
 432       {
 433         errno = ECHILD;
 434         return -1;
 435       }
 436       ai->parent = FindTask(NULL);
 437       ai->parentenv = env;
 438       ai->childcmd = cmdline;
 439
 440       THREAD_PROTECT(startcommand)
 441       childai = ai;
 442
 443       CreateNewProcTags(NP_Entry, StartCommand,
 444                         NP_Input, (inhndl == -1) ? Input() : ai->files[inhndl].fhin,
 445                         NP_CloseInput, inhndl != -1,
 446                         NP_Output, (outhndl == -1) ? Output() : ai->files[outhndl].fhout,
 447                         NP_CloseOutput, outhndl != -1,
 448                         NP_Error, (errhndl == -1) ? Error() : ai->files[errhndl].fhout,
 449                         NP_CloseError, errhndl != -1,
 450                         NP_Cli, TRUE,
 451                         TAG_DONE, NULL);
 452       Wait(1<<ai->psigbit);
 453       THREAD_UNPROTECT(startcommand)
 454       Signal(ai->child, 1<<ai->csigbit);
 455     }
 456     return (int)ai;
 457     break;
 458
 459   case SUBENVIR_REXX:
 460     errno = ENOSYS;
 461     return -1;
 462   }
 463
 464   errno = ENOSYS;
 465   return -1;
 466 }
 467
 468 int __regina_wait(int process)
 469 {
 470   AsyncInfo *ai = (AsyncInfo *)process;
 471
 472   Wait(1<<ai->psigbit);
 473   FreeSignal(ai->psigbit);
 474   ai->psigbit = -1;
 475
 476   return ai->retval;
 477 }
 478
 479 #include "utsname.h"
 480
 481 int uname(struct utsname *name)
 482 {
 483   strcpy( name->sysname, "AMIGA" );
 484   sprintf( name->version, "%d", 0 );
 485   sprintf( name->release, "%d", 0 );
 486   strcpy( name->nodename, "standalone" );
 487   strcpy( name->machine, "i386" );
 488
 489   return 0;
 490 }