rom/devs/console/consoletask.c

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