rom/devs/console/consoletask.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Code executed by the console.device task.
   6     Lang: english
   7 */
   8
   9 #include <exec/lists.h>
  10 #include <proto/exec.h>
  11 #include <proto/intuition.h>
  12 #include <proto/console.h>
  13 #include <exec/io.h>
  14 #include <exec/alerts.h>
  15 #include <dos/dos.h>
  16 #include <devices/input.h>
  17 #include <devices/rawkeycodes.h>
  18
  19 #include "console_gcc.h"
  20 #include "consoleif.h"
  21
  22 #define DEBUG 0
  23 #include <aros/debug.h>
  24
  25 VOID con_inject(struct ConsoleBase *ConsoleDevice, struct ConUnit *cu, const UBYTE *data, LONG size)
  26 {
  27     struct intConUnit *icu = ICU(cu);
  28     ObtainSemaphore(&ConsoleDevice->consoleTaskLock);
  29     if (data && size)
  30     {
  31         struct intPasteData *p = AllocMem(sizeof(struct intPasteData), MEMF_ANY);
  32         if (p)
  33         {
  34             if (size < 0)
  35                 size = strlen(data);
  36             p->pasteBuffer = AllocMem(size, MEMF_ANY);
  37             if (p->pasteBuffer)
  38             {
  39                 CopyMem((APTR)data, p->pasteBuffer, size);
  40                 p->pasteBufferSize = size;
  41                 p->unit = icu;
  42                 AddTail((struct List*)&icu->pasteData, (struct Node*)p);
  43                 D(bug("con_inject(%x %x %x %d)\n", icu, p, p->pasteBuffer, p->pasteBufferSize));
  44             } else {
  45                 FreeMem(p, sizeof(struct intPasteData));
  46             }
  47         }
  48     }
  49     ReleaseSemaphore(&ConsoleDevice->consoleTaskLock);
  50     /* Wake up possible waiting CMD_READs */
  51     Signal(ConsoleDevice->consoleTask, SIGBREAKF_CTRL_D);
  52 }
  53
  54 /* Protos */
  55 static BOOL checkconunit(Object *unit, struct ConsoleBase *ConsoleDevice);
  56 static void answer_read_request(struct IOStdReq *req, struct ConsoleBase *ConsoleDevice);
  57
  58 static VOID answer_requests(APTR unit,struct ConsoleBase *ConsoleDevice)
  59 {
  60   struct IOStdReq *req, *nextreq;
  61   /* See if there are any queued io read requests that wants to be replied */
  62   ForeachNodeSafe(&ConsoleDevice->readRequests, req, nextreq)
  63     {
  64       if ((APTR)req->io_Unit == (APTR)unit)
  65         {
  66           /* Paranoia */
  67           if (0 != ICU(req->io_Unit)->numStoredChars)
  68             {
  69               Remove((struct Node *)req);
  70               answer_read_request(req, ConsoleDevice);
  71             }
  72         }
  73     }
  74 }
  75
  76 static ULONG pasteData(struct intConUnit * icu, struct ConsoleBase * ConsoleDevice)
  77 {
  78   /* Check if we have data to paste to the input buffer */
  79   struct intPasteData * pd = (struct intPasteData *)GetHead(&icu->pasteData);
  80   if (pd)
  81     {
  82       ULONG tocopy = MIN(pd->pasteBufferSize - icu->pasteBufferPos
  83                          , CON_INPUTBUF_SIZE - icu->numStoredChars);
  84
  85       D(bug("Pasting %ld bytes\n",tocopy));
  86       CopyMem(pd->pasteBuffer + icu->pasteBufferPos
  87               , icu->inputBuf + icu->numStoredChars
  88               , tocopy
  89               );
  90       icu->numStoredChars += tocopy;
  91       icu->pasteBufferPos += tocopy;
  92
  93       if (icu->pasteBufferPos >= pd->pasteBufferSize)
  94         {
  95           FreeMem(pd->pasteBuffer, pd->pasteBufferSize);
  96           Remove((struct Node *)pd);
  97           FreeMem(pd,sizeof(struct intPasteData));
  98           icu->pasteBufferPos = 0;
  99         }
 100
 101       answer_requests((APTR)icu, ConsoleDevice);
 102       return tocopy;
 103     }
 104   return 0;
 105 }
 106
 107 VOID consoleTaskEntry(struct ConsoleBase *ConsoleDevice)
 108 {
 109     BOOL success = FALSE;
 110     LONG waitsigs = 0L, wakeupsig, commandsig, inputsig;
 111
 112
 113     /* CD input handler puts data into this port */
 114     struct MsgPort *inputport;
 115
 116
 117     /* Used for input.device */
 118     struct MsgPort *inputmp;
 119
 120     /* Add the CDInputHandler to input.device's list of input handlers */
 121     inputmp = CreateMsgPort();
 122     if (inputmp)
 123     {
 124         struct IOStdReq *inputio;
 125         inputio = (struct IOStdReq *)CreateIORequest(inputmp, sizeof (struct IOStdReq));
 126         if (inputio)
 127         {
 128             /* Open the input.device */
 129             if (!OpenDevice("input.device", -1, (struct IORequest *)inputio, 0UL))
 130             {
 131                 /* Initialize the inputhandler itself */
 132                 ConsoleDevice->inputHandler = initCDIH(ConsoleDevice);
 133                 if (ConsoleDevice->inputHandler)
 134                 {
 135                     inputio->io_Data = ConsoleDevice->inputHandler;
 136                     inputio->io_Command = IND_ADDHANDLER;
 137
 138                     DoIO((struct IORequest *)inputio);
 139                     success = TRUE;
 140                 }
 141                 CloseDevice((struct IORequest *)inputio);
 142
 143             }
 144
 145             DeleteIORequest((struct IORequest *)inputio);
 146         }
 147
 148         DeleteMsgPort(inputmp);
 149     }
 150
 151     NEWLIST(&ConsoleDevice->readRequests);
 152
 153     /* if not successfull,  throw an alert */
 154     if (!success)
 155     {
 156         Alert(AT_DeadEnd | AN_ConsoleDev | AG_OpenDev | AO_Unknown);
 157     }
 158
 159     D(bug("Console task initialized\n"));
 160
 161
 162     /* Get console.device input handler's port */
 163     inputport = ((struct cdihData *)ConsoleDevice->inputHandler->is_Data)->inputPort;
 164
 165     inputsig    = 1 << inputport->mp_SigBit;
 166     commandsig  = 1 << ConsoleDevice->commandPort->mp_SigBit;
 167
 168     waitsigs = inputsig|commandsig|SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_D;
 169
 170     for (;;)
 171     {
 172         wakeupsig = Wait(waitsigs);
 173
 174         /* Anyone wanting to kill us ? */
 175         if (wakeupsig & SIGBREAKF_CTRL_C)
 176         {
 177             break;
 178         }
 179
 180         ObtainSemaphore(&ConsoleDevice->consoleTaskLock);
 181
 182         if (wakeupsig & SIGBREAKF_CTRL_D) {
 183             struct IOStdReq *req;
 184             BOOL active = TRUE;
 185             D(bug("SIGBREAKF_CTRL_D\n"));
 186             /* console.device pasted data? */
 187             while (active) {
 188                 active = FALSE;
 189                 ForeachNode(&ConsoleDevice->readRequests, req) {
 190                     if (pasteData(ICU(req->io_Unit), ConsoleDevice)) {
 191                         answer_requests(NULL, ConsoleDevice);
 192                         active = TRUE;
 193                         break;
 194                     }
 195                 }
 196             }
 197         }
 198
 199         if (wakeupsig & inputsig)
 200         {
 201             /* A message from the console device input handler */
 202             struct cdihMessage *cdihmsg;
 203
 204             while ( (cdihmsg = (struct cdihMessage *)GetMsg(inputport)) )
 205             {
 206
 207                 /* Check that the ConUnit has not been disposed,
 208                    while the message was passed
 209                 */
 210                 if (checkconunit(cdihmsg->unit, ConsoleDevice))
 211                 {
 212                     switch(cdihmsg->ie.ie_Class)
 213                     {
 214                         case IECLASS_CLOSEWINDOW:
 215                         /* this is a hack. It would actually be up to the */
 216                         /* console.device user (CON: handler for example) to */
 217                         /* activate CLOSEWINDOW raw events (SET RAW EVENTS cmd) */
 218                         /* and then look out for this in the input stream (CMD_READ) */
 219                             /* fall through */
 220
 221                     case IECLASS_RAWKEY:
 222                       {
 223                             #define MAPRAWKEY_BUFSIZE 80
 224
 225                         UBYTE  inputBuf[MAPRAWKEY_BUFSIZE + 1];
 226                         LONG actual;
 227                         ULONG tocopy;
 228                         struct InputEvent e;
 229
 230                         /* Mouse wheel support */
 231                         if (cdihmsg->ie.ie_Code == RAWKEY_NM_WHEEL_UP ||
 232                             cdihmsg->ie.ie_Code == RAWKEY_NM_WHEEL_DOWN)
 233                           {
 234                             e.ie_EventAddress =
 235                               (cdihmsg->ie.ie_Code == RAWKEY_NM_WHEEL_UP) ?
 236                               (APTR)1 : (APTR)2;
 237                             e.ie_Class = IECLASS_GADGETDOWN;
 238                             Console_HandleGadgets(cdihmsg->unit, &e);
 239                             e.ie_Class = IECLASS_GADGETUP;
 240                             Console_HandleGadgets(cdihmsg->unit, &e);
 241                           }
 242                         else
 243                           {
 244
 245                             /* Convert it to ANSI chars */
 246
 247                             if (cdihmsg->ie.ie_Class == IECLASS_CLOSEWINDOW)
 248                               {
 249                                 /* HACK */
 250                                 inputBuf[0] = 28; /* CTRL-\ */
 251                                 actual = 1;
 252                                 /* HACK */
 253                               }
 254                             else
 255                               {
 256                                 actual = RawKeyConvert(&cdihmsg->ie
 257                                                        ,inputBuf
 258                                                        ,MAPRAWKEY_BUFSIZE
 259                                                        ,NULL);
 260
 261                                 if (cdihmsg->ie.ie_Qualifier == IEQUALIFIER_RCOMMAND && actual == 1)
 262                                   {
 263                                     switch(inputBuf[0])
 264                                       {
 265                                       case 'c':
 266                                         D(bug("Console_Copy\n"));
 267                                         Console_Copy(cdihmsg->unit);
 268                                         actual = 0;
 269                                         break;
 270                                       case 'v':
 271                                         D(bug("Console_Paste\n"));
 272                                         Console_Paste(cdihmsg->unit);
 273                                         /* We have likely put something into the input buffer */
 274                                         if (ICU(cdihmsg->unit)->numStoredChars) answer_requests(cdihmsg->unit,ConsoleDevice);
 275                                         actual = 0;
 276                                         break;
 277                                       }
 278                                   }
 279                               }
 280
 281                             D(bug("RawKeyConvert returned %ld\n", actual));
 282
 283
 284                             if (actual > 0)
 285                               {
 286                                 /* Copy received characters to the console unit input buffer.
 287                                    If the buffer is full, then console input will be lost
 288                                 */
 289                                 tocopy = MIN(actual, CON_INPUTBUF_SIZE - ICU(cdihmsg->unit)->numStoredChars);
 290                                 /* Copy the input over to the unit's buffer */
 291                                 CopyMem(inputBuf
 292                                         , ICU(cdihmsg->unit)->inputBuf + ICU(cdihmsg->unit)->numStoredChars
 293                                         , tocopy
 294                                         );
 295
 296                                 ICU(cdihmsg->unit)->numStoredChars += tocopy;
 297
 298                                 answer_requests(cdihmsg->unit,ConsoleDevice);
 299                               } /* if (actual > 0) */
 300                           }
 301
 302                       } /* IECLASS_RAWKEY */
 303                       break;
 304
 305                     case IECLASS_GADGETDOWN:
 306                     case IECLASS_GADGETUP:
 307                     case IECLASS_TIMER:
 308                     case IECLASS_RAWMOUSE:
 309                       Console_HandleGadgets(cdihmsg->unit,&(cdihmsg->ie));
 310                         //.ie_Class, (APTR)cdihmsg->ie.ie_EventAddress);
 311                       break;
 312
 313                     case IECLASS_REFRESHWINDOW: /* Intentional fallthrough */
 314                     case IECLASS_SIZEWINDOW:
 315                         {
 316                             Console_NewWindowSize(cdihmsg->unit);
 317                         } /* IECLASS_NEWSIZE */
 318                         break;
 319                         default:
 320                           D(bug("cdihmsg->ie.ie_Class = %d\n", cdihmsg->ie.ie_Class));
 321                     } /* switch(cdihmsg->ie.ie_Class) */
 322
 323
 324                 } /* if (checkconunit(cdihmsg->unit, ConsoleDevice)) */
 325
 326                 /* Tell the input handler we're done */
 327                 ReplyMsg((struct Message *)cdihmsg);
 328
 329             } /* while ( (cdihmsg = (struct cdihMessage *)GetMsg(inputport)) ) */
 330
 331         } /* if (wakeupsig & inputsig) */
 332
 333         if (wakeupsig & commandsig)
 334         {
 335             /* We got a command from the outside. Investigate it */
 336             struct IOStdReq *req;
 337
 338
 339             while ((req = (struct IOStdReq *)GetMsg(ConsoleDevice->commandPort)))
 340             {
 341               pasteData(ICU(req->io_Unit), ConsoleDevice);
 342
 343                 switch (req->io_Command)
 344                 {
 345                     case CMD_READ:
 346                       if (0 != ICU(req->io_Unit)->numStoredChars)
 347                           {
 348                             answer_read_request(req, ConsoleDevice);
 349                           }
 350                         else
 351                           {
 352                             /* Not enough bytes in the buffer to fill the request, put it on hold */
 353
 354                             /* ioReq allready removed from the queue qith GetMsg() */
 355
 356                             AddTail((struct List *)&ConsoleDevice->readRequests, (struct Node *)req);
 357                         }
 358                         break;
 359
 360                 default:
 361                         kprintf("!!! UNKNOWN COMMAND RECEIVED BY CONSOLE TASK !!!\n");
 362                         kprintf("!!! THIS SHOULD NEVER HAPPEN !!!\n");
 363                         break;
 364                 }
 365
 366             } /* while ((req = (struct IOStdReq *)GetMsg(ConsoleDevice->commandPort))) */
 367
 368         } /* if (wakeupsig & commandsig) */
 369
 370         ReleaseSemaphore(&ConsoleDevice->consoleTaskLock);
 371
 372     } /* forever */
 373
 374 /* FIXME: Do cleanup here */
 375
 376 }
 377
 378 /********** checkconunit()  *******************************/
 379
 380 /* Checks that the supplied unit has not been disposed */
 381 static BOOL checkconunit(Object *unit, struct ConsoleBase *ConsoleDevice)
 382 {
 383     Object *o, *ostate;
 384     BOOL found = FALSE;
 385
 386     ObtainSemaphoreShared(&ConsoleDevice->unitListLock);
 387
 388     ostate = (Object *)ConsoleDevice->unitList.mlh_Head;
 389     while ( (o = NextObject(&ostate)) && (!found) )
 390     {
 391         if (o == unit)
 392         {
 393             found = TRUE;
 394         }
 395     }
 396
 397     ReleaseSemaphore(&ConsoleDevice->unitListLock);
 398     return found;
 399 }
 400
 401 /******** answer_read_request() ***************************/
 402
 403 static void answer_read_request(struct IOStdReq *req, struct ConsoleBase *ConsoleDevice)
 404 {
 405     Object *unit;
 406
 407     D(bug("answer_read_request\n"));
 408     /* This function assumes that there are at least one character
 409        available in the unitsinput buffer
 410     */
 411
 412     unit = (Object *)req->io_Unit;
 413
 414     req->io_Actual = MIN(ICU(unit)->numStoredChars, req->io_Length);
 415
 416     /* Copy characters from the buffer into the request */
 417     CopyMem( (APTR)ICU(unit)->inputBuf
 418             , req->io_Data
 419             , req->io_Actual
 420     );
 421
 422     if (ICU(unit)->numStoredChars > req->io_Length)
 423     {
 424         ULONG i;
 425
 426         ICU(unit)->numStoredChars -= req->io_Actual;
 427
 428         /* We have to move the rest of the bytes to the start
 429            of the buffer.
 430
 431            NOTE: we could alternatively use a circular buffer
 432         */
 433
 434         for (i = 0; i < ICU(unit)->numStoredChars; i ++)
 435         {
 436             ICU(unit)->inputBuf[i] = ICU(unit)->inputBuf[i + req->io_Actual];
 437         }
 438     }
 439     else
 440     {
 441         /* No more unread characters in the buffer */
 442         ICU(unit)->numStoredChars = 0;
 443
 444     }
 445
 446     req->io_Error = 0;
 447     /* All done. Just reply the request */
 448
 449     /* stegerg: the caller of answer_read_request is responsible for the Remove,
 450                 because the Remove must be used only if the req was in
 451                 the readrequests list
 452       Remove((struct Node *)req);
 453
 454     */
 455
 456
 457 /* kprintf("receiving task=%s, sigbit=%d\n, mode=%d"
 458         , ((struct Task *)req->io_Message.mn_ReplyPort->mp_SigTask)->tc_Node.ln_Name
 459         , req->io_Message.mn_ReplyPort->mp_SigBit
 460         , req->io_Message.mn_ReplyPort->mp_Flags
 461 );
 462 */
 463     ReplyMsg((struct Message *)req);
 464
 465     return;
 466 }