?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Indentation fix, cleanup.
[AROS.git] / rom / filesys / console_handler / con_handler.c
blob5402d60ee8f95f6ce6ede77d65478af6e7044063
1 /*
2 Copyright © 1995-2014, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5
6 #include <proto/exec.h>
7 #include <exec/libraries.h>
8 #include <exec/resident.h>
9 #include <exec/memory.h>
10 #include <exec/io.h>
11 #include <exec/errors.h>
12 #include <exec/alerts.h>
13 #include <utility/tagitem.h>
14 #include <dos/exall.h>
15 #include <dos/dosasl.h>
16 #include <intuition/intuition.h>
17 #include <proto/dos.h>
18 #include <proto/intuition.h>
19 #include <proto/workbench.h>
20 #include <workbench/startup.h>
21 #include <devices/conunit.h>
22
23 #include <stddef.h>
24 #include <string.h>
25
26 #include "con_handler_intern.h"
27 #include "support.h"
28
29 #undef SDEBUG
30 #undef DEBUG
31 #define SDEBUG 0
32 #define DEBUG 0
33 #include <aros/debug.h>
34
35 static char *BSTR2C(BSTR srcs)
36 {
37 UBYTE *src = BADDR(srcs);
38 char *dst;
39
40 dst = AllocVec(src[0] + 1, MEMF_ANY);
41 if (!dst)
42 return NULL;
43 memcpy(dst, src + 1, src[0]);
44 dst[src[0]] = 0;
45 return dst;
46 }
47 static WORD isdosdevicec(CONST_STRPTR s)
48 {
49 UBYTE b = 0;
50 while (s[b])
51 {
52 if (s[b] == ':')
53 return b;
54 b++;
55 }
56 return -1;
57 }
58
59 #define ioReq(x) ((struct IORequest *)x)
60
61 static const struct NewWindow default_nw =
62 {
63 0, /* LeftEdge */
64 0, /* TopEdge */
65 -1, /* Width */
66 -1, /* Height */
67 1, /* DetailPen */
68 0, /* BlockPen */
69 0, /* IDCMP */
70 WFLG_DEPTHGADGET |
71 WFLG_SIZEGADGET |
72 WFLG_DRAGBAR |
73 WFLG_SIZEBRIGHT |
74 WFLG_SMART_REFRESH |
75 WFLG_ACTIVATE,
76 0, /* FirstGadget */
77 0, /* CheckMark */
78 "CON:", /* Title */
79 0, /* Screen */
80 0, /* Bitmap */
81 100, /* MinWidth */
82 70, /* MinHeight */
83 32767, /* MaxWidth */
84 32767, /* MaxHeight */
85 WBENCHSCREEN /* type */
86 };
87
88
89 static LONG MakeConWindow(struct filehandle *fh)
90 {
91 LONG err = 0;
92
93 if (fh->otherwindow == NULL)
94 {
95 struct TagItem win_tags[] =
96 {
97 { WA_PubScreen, 0 },
98 { WA_AutoAdjust, TRUE },
99 { WA_PubScreenName, 0 },
100 { WA_PubScreenFallBack, TRUE },
101 { TAG_DONE }
102 };
103
104 win_tags[2].ti_Data = (IPTR) fh->screenname;
105 D(bug("[contask] Opening window on screen %s, IntuitionBase = 0x%p\n", fh->screenname, IntuitionBase));
106
107 /* Autoadjust doesn't enforce the window's width and height to be larger than
108 minwidth and minheight, so we set it here to avoid crashes in devs/console
109 if a user does e.g. dir >con:0/0/0/0
110 */
111 fh->nw.Width = fh->nw.Width > fh->nw.MinWidth ? fh->nw.Width : -1;
112 fh->nw.Height = (fh->flags & FHFLG_BOOTCON && fh->nw.Height == -1) ||
113 fh->nw.Height > fh->nw.MinHeight ? fh->nw.Height : fh->nw.MinHeight;
114
115 fh->window = OpenWindowTagList(&fh->nw, (struct TagItem *) win_tags);
116 }
117 else
118 {
119 D(bug("[contask] Using window %p\n", fh->otherwindow));
120 fh->window = fh->otherwindow;
121 }
122
123 if (fh->window)
124 {
125 D(bug("contask: window opened\n"));
126 fh->conreadio->io_Data = (APTR) fh->window;
127 fh->conreadio->io_Length = sizeof(struct Window);
128
129 if (0 == OpenDevice("console.device", CONU_SNIPMAP, ioReq(fh->conreadio), 0))
130 {
131 const UBYTE lf_on[] =
132 { 0x9B, 0x32, 0x30, 0x68 }; /* Set linefeed mode */
133
134 D(bug("contask: device opened\n"));
135
136 fh->flags |= FHFLG_CONSOLEDEVICEOPEN;
137
138 fh->conwriteio = *fh->conreadio;
139 fh->conwriteio.io_Message.mn_ReplyPort = fh->conwritemp;
140
141 /* Turn the console into LF+CR mode so that both
142 linefeed and carriage return is done on
143 */
144 fh->conwriteio.io_Command = CMD_WRITE;
145 fh->conwriteio.io_Data = (APTR) lf_on;
146 fh->conwriteio.io_Length = 4;
147
148 DoIO(ioReq(&fh->conwriteio));
149
150 if (fh->workbenchbase && (fh->appmsgport = CreateMsgPort()))
151 {
152 if ((fh->appwindow = AddAppWindow(0, 0, fh->window, fh->appmsgport, NULL)))
153 D(bug("[CON] Console promoted to be an AppWindow\n"));
154 }
155
156 } /* if (0 == OpenDevice("console.device", CONU_STANDARD, ioReq(fh->conreadio), 0)) */
157 else
158 {
159 err = ERROR_INVALID_RESIDENT_LIBRARY;
160 }
161 if (err)
162 CloseWindow(fh->window);
163
164 } /* if (fh->window) */
165 else
166 {
167 D(bug("[contask] Failed to open a window\n"));
168 err = ERROR_NO_FREE_STORE;
169 }
170
171 return err;
172 }
173
174 static BOOL MakeSureWinIsOpen(struct filehandle *fh)
175 {
176 if (fh->window)
177 return TRUE;
178 return MakeConWindow(fh) == 0;
179 }
180
181 static void close_con(struct filehandle *fh)
182 {
183 /* Clean up */
184
185 D(bug("[CON] Deleting timer request 0x%p\n", fh->timerreq));
186 if (fh->timerreq)
187 {
188 CloseDevice((struct IORequest *) fh->timerreq);
189 DeleteIORequest((struct IORequest *) fh->timerreq);
190 }
191
192 D(bug("[CON] Deleting timer port 0x%p\n", fh->timermp));
193 DeleteMsgPort(fh->timermp);
194
195 if (fh->flags & FHFLG_CONSOLEDEVICEOPEN)
196 {
197 D(bug("[CON] Closing console.device...\n"));
198 CloseDevice((struct IORequest *) fh->conreadio);
199 }
200
201 if (fh->appwindow)
202 {
203 D(bug("[CON] Unpromote console window from being an AppWindow\n"));
204 RemoveAppWindow(fh->appwindow);
205 }
206 if (fh->appmsgport)
207 {
208 struct AppMessage *appmsg;
209 while ((appmsg = (struct AppMessage *) GetMsg(fh->appmsgport)))
210 ReplyMsg ((struct Message *) appmsg);
211 D(bug("[CON] Delete MsgPort for AppWindow\n"));
212 DeleteMsgPort(fh->appmsgport);
213 }
214
215 D(bug("[CON] Closing window 0x%p\n", fh->window));
216 if (fh->window)
217 CloseWindow(fh->window);
218
219 D(bug("[CON] Delete console.device IORequest 0x%p\n", fh->conreadio));
220 DeleteIORequest(ioReq(fh->conreadio));
221
222 D(bug("[CON] Delete console.device MsgPort 0x%p\n", fh->conreadmp));
223 FreeVec(fh->conreadmp);
224
225 if (fh->screenname)
226 FreeVec(fh->screenname);
227 if (fh->wintitle)
228 FreeVec(fh->wintitle);
229 if (fh->pastebuffer)
230 FreeMem(fh->pastebuffer, PASTEBUFSIZE);
231
232 CloseLibrary((struct Library*) fh->intuibase);
233 CloseLibrary((struct Library*) fh->dosbase);
234 CloseLibrary((struct Library*) fh->workbenchbase);
235
236 /* These libraries are opened only if completion was used */
237 if (fh->gfxbase)
238 CloseLibrary((struct Library*) fh->gfxbase);
239 if (fh->gtbase)
240 CloseLibrary(fh->gtbase);
241
242 FreeVec(fh);
243 }
244
245 static struct filehandle *open_con(struct DosPacket *dp, LONG *perr)
246 {
247 char *filename, *fn;
248 struct filehandle *fh;
249 struct DeviceNode *dn;
250 LONG err, ok;
251 LONG i;
252
253 dn = BADDR(dp->dp_Arg3);
254 *perr = ERROR_NO_FREE_STORE;
255 fh = AllocVec(sizeof(struct filehandle), MEMF_PUBLIC | MEMF_CLEAR);
256 if (!fh)
257 return NULL;
258
259 fh->intuibase = (APTR) OpenLibrary("intuition.library", 0);
260 fh->dosbase = (APTR) OpenLibrary("dos.library", 0);
261 fh->utilbase = (APTR) OpenLibrary("utility.library", 0);
262 fh->workbenchbase = (APTR) OpenLibrary("workbench.library", 0);
263 Forbid();
264 fh->inputbase = (struct Device *) FindName(&SysBase->DeviceList, "input.device");
265 Permit();
266
267 if (!fh->intuibase || !fh->dosbase || !fh->utilbase || !fh->inputbase)
268 {
269 CloseLibrary((APTR) fh->utilbase);
270 CloseLibrary((APTR) fh->dosbase);
271 CloseLibrary((APTR) fh->intuibase);
272 CloseLibrary((APTR) fh->workbenchbase);
273 FreeVec(fh);
274 return NULL;
275 }
276
277 fh->timermp = CreateMsgPort();
278 fh->timerreq = (struct timerequest*) CreateIORequest(fh->timermp, sizeof(struct timerequest));
279 OpenDevice(TIMERNAME, UNIT_MICROHZ, (struct IORequest *) fh->timerreq, 0);
280
281 err = 0;
282 filename = BSTR2C((BSTR) dp->dp_Arg1);
283 fn = filename;
284 i = isdosdevicec(fn);
285 if (i >= 0)
286 fn += i + 1;
287
288 fh->contask = FindTask(0);
289
290 NEWLIST(&fh->pendingReads);
291
292 /* Create msgport for console.device communication */
293 fh->conreadmp = AllocVec(sizeof(struct MsgPort) * 2, MEMF_PUBLIC | MEMF_CLEAR);
294 if (fh->conreadmp)
295 {
296
297 fh->conreadmp->mp_Node.ln_Type = NT_MSGPORT;
298 fh->conreadmp->mp_Flags = PA_SIGNAL;
299 fh->conreadmp->mp_SigBit = AllocSignal(-1);
300 fh->conreadmp->mp_SigTask = fh->contask;
301 NEWLIST(&fh->conreadmp->mp_MsgList);
302
303 fh->conwritemp = fh->conreadmp + 1;
304
305 fh->conwritemp->mp_Node.ln_Type = NT_MSGPORT;
306 fh->conwritemp->mp_Flags = PA_SIGNAL;
307 fh->conwritemp->mp_SigBit = AllocSignal(-1);
308 fh->conwritemp->mp_SigTask = fh->contask;
309 NEWLIST(&fh->conwritemp->mp_MsgList);
310
311 fh->conreadio = (struct IOStdReq *) CreateIORequest(fh->conreadmp, sizeof(struct IOStdReq));
312 if (fh->conreadio)
313 {
314 D(bug("contask: conreadio created, parms '%s'\n", fn));
315
316 fh->nw = default_nw;
317
318 if (parse_filename(fh, fn, &fh->nw))
319 {
320 if (!(fh->flags & FHFLG_AUTO))
321 {
322 err = MakeConWindow(fh);
323 if (!err)
324 ok = TRUE;
325 }
326 else
327 {
328 ok = TRUE;
329 }
330 }
331 else
332 err = ERROR_BAD_STREAM_NAME;
333
334 if (!ok)
335 {
336 DeleteIORequest(ioReq(fh->conreadio));
337 }
338
339 } /* if (fh->conreadio) */
340 else
341 {
342 err = ERROR_NO_FREE_STORE;
343 }
344
345 } /* if (fh->conreadmp) */
346 else
347 {
348 err = ERROR_NO_FREE_STORE;
349 }
350
351 if (dn->dn_Startup)
352 fh->flags |= FHFLG_RAW;
353
354 if (!ok)
355 close_con(fh);
356
357 *perr = err;
358 FreeVec(filename);
359 return fh;
360 }
361
362 static void startread(struct filehandle *fh)
363 {
364 if (fh->flags & FHFLG_ASYNCCONSOLEREAD)
365 return;
366 fh->conreadio->io_Command = CMD_READ;
367 fh->conreadio->io_Data = fh->consolebuffer;
368 fh->conreadio->io_Length = CONSOLEBUFFER_SIZE;
369 SendIO((struct IORequest*) fh->conreadio);
370 fh->flags |= FHFLG_ASYNCCONSOLEREAD;
371 }
372
373 static void stopwait(struct filehandle *fh, struct DosPacket *waitingdp, ULONG result)
374 {
375 if (waitingdp)
376 {
377 AbortIO((struct IORequest *) fh->timerreq);
378 WaitIO((struct IORequest *) fh->timerreq);
379 replypkt(waitingdp, result);
380 }
381 }
382
383 static void stopread(struct filehandle *fh, struct DosPacket *waitingdp)
384 {
385 struct Message *msg, *next_msg;
386
387 stopwait(fh, waitingdp, DOSFALSE);
388
389 ForeachNodeSafe(&fh->pendingReads, msg, next_msg)
390 {
391 struct DosPacket *dpr;
392
393 Remove((struct Node *) msg);
394 dpr = (struct DosPacket*) msg->mn_Node.ln_Name;
395 replypkt(dpr, DOSFALSE);
396 }
397 }
398
399 LONG CONMain(struct ExecBase *SysBase)
400 {
401 struct MsgPort *mp;
402 struct DosPacket *dp;
403 struct Message *mn;
404 struct FileHandle *dosfh;
405 LONG error;
406 struct filehandle *fh;
407 struct FileLock *fl;
408 struct DosPacket *waitingdp = NULL;
409
410 D(bug("[CON] started\n"));
411 mp = &((struct Process*) FindTask(NULL))->pr_MsgPort;
412 WaitPort(mp);
413 dp = (struct DosPacket*) GetMsg(mp)->mn_Node.ln_Name;
414 D(bug("[CON] startup message received. port=0x%p path='%b'\n", mp, dp->dp_Arg1));
415
416 fh = open_con(dp, &error);
417 if (!fh)
418 {
419 D(bug("[CON] init failed\n"));
420 goto end;
421 }
422 D(bug("[CON] 0x%p open\n", fh));
423 replypkt(dp, DOSTRUE);
424
425 for (;;)
426 {
427 ULONG conreadmask = 1L << fh->conreadmp->mp_SigBit;
428 ULONG timermask = 1L << fh->timermp->mp_SigBit;
429 ULONG packetmask = 1L << mp->mp_SigBit;
430 ULONG appwindowmask = fh->appmsgport ? 1L << fh->appmsgport->mp_SigBit : 0L;
431 ULONG i = 0, insertedlen = 0;
432 ULONG sigs;
433 UBYTE iconpath[INPUTBUFFER_SIZE];
434 WORD currentpos, currentrest;
435
436 sigs = Wait(packetmask | conreadmask | timermask | appwindowmask);
437
438 if (sigs & appwindowmask)
439 {
440 while ((fh->appmsg = (struct AppMessage *)GetMsg(fh->appmsgport)))
441 {
442 if (fh->appmsg->am_Type == AMTYPE_APPWINDOW)
443 {
444 if (fh->appmsg->am_NumArgs >= 1)
445 {
446 do
447 {
448 if (fh->appmsg->am_ArgList[i].wa_Lock)
449 {
450 NameFromLock(fh->appmsg->am_ArgList[i].wa_Lock,
451 iconpath, INPUTBUFFER_SIZE - 1);
452 AddPart(iconpath, fh->appmsg->am_ArgList[i].wa_Name,
453 INPUTBUFFER_SIZE - 1);
454 D(bug("[CON]: D&D iconpath: %s\n", iconpath));
455
456 if ((insertedlen = strlen(iconpath)))
457 {
458 /*
459 * Get rid of trailing slashes of drawers?
460 if ((iconpath[insertedlen - 1] == '/'))
461 insertedlen--;
462 */
463 if ( strchr(iconpath, ' ')
464 && insertedlen <= (INPUTBUFFER_SIZE - 2))
465 {
466 memmove(iconpath + 1, iconpath, ++insertedlen);
467 iconpath[0] = iconpath[insertedlen++] = '"';
468 }
469 if (insertedlen <= (INPUTBUFFER_SIZE - 1))
470 iconpath[insertedlen++] = ' ';
471
472 currentpos = fh->inputpos;
473 currentrest = fh->inputsize - fh->inputpos;
474 memmove(&fh->inputbuffer[currentpos + insertedlen],
475 &fh->inputbuffer[currentpos],
476 currentrest);
477 CopyMem(iconpath, &fh->inputbuffer[currentpos],
478 insertedlen);
479 fh->inputsize += insertedlen;
480 fh->inputpos += insertedlen;
481
482 do_write(fh, &fh->inputbuffer[currentpos],
483 insertedlen + currentrest);
484 do_movecursor(fh, CUR_LEFT, currentrest);
485 }
486 }
487 } while (++i < fh->appmsg->am_NumArgs);
488 }
489 }
490 ReplyMsg((struct Message *)fh->appmsg);
491 }
492 ActivateWindow(fh->window);
493 }
494
495 if (sigs & timermask)
496 {
497 if (waitingdp)
498 {
499 replypkt(waitingdp, DOSFALSE);
500 waitingdp = NULL;
501 }
502 }
503
504 if (sigs & conreadmask)
505 {
506 GetMsg(fh->conreadmp);
507 fh->flags &= ~FHFLG_ASYNCCONSOLEREAD;
508 if (waitingdp)
509 {
510 stopwait(fh, waitingdp, DOSTRUE);
511 waitingdp = NULL;
512 }
513 D(bug("IO_READ %d\n", fh->conreadio->io_Actual));
514 fh->conbuffersize = fh->conreadio->io_Actual;
515 fh->conbufferpos = 0;
516 /* terminate with 0 char */
517 fh->consolebuffer[fh->conbuffersize] = '\0';
518 if (fh->flags & FHFLG_RAW)
519 {
520 LONG inp;
521 /* raw mode */
522 for (inp = 0; (inp < fh->conbuffersize) && (fh->inputpos < INPUTBUFFER_SIZE);)
523 {
524 fh->inputbuffer[fh->inputpos++] = fh->consolebuffer[inp++];
525 }
526 fh->inputsize = fh->inputstart = fh->inputpos;
527 HandlePendingReads(fh);
528 } /* if (fh->flags & FHFLG_RAW) */
529 else
530 {
531 /* Cooked mode */
532 if (process_input(fh))
533 {
534 /*
535 * process_input() returns TRUE when EOF was received after the WAIT console
536 * has been closed by the owner.
537 */
538 dp = NULL;
539 goto end;
540 }
541 } /* if (fh->flags & FHFLG_RAW) else ... */
542
543 if (fh->flags & FHFLG_CONSOLEDEVICEOPEN) /* device could have been closed */
544 startread(fh);
545 }
546
547 while ((mn = GetMsg(mp)))
548 {
549 dp = (struct DosPacket*) mn->mn_Node.ln_Name;
550 dp->dp_Res2 = 0;
551 D(
552 bug("[CON 0x%p] packet 0x%p:%d 0x%p,0x%p,0x%p\n", fh, dp, dp->dp_Type, dp->dp_Arg1, dp->dp_Arg2,
553 dp->dp_Arg3));
554 error = 0;
555 switch (dp->dp_Type)
556 {
557 case ACTION_FH_FROM_LOCK:
558 fl = BADDR(dp->dp_Arg2);
559 if (fl->fl_Task != mp || fl->fl_Key != (IPTR) fh)
560 {
561 replypkt2(dp, DOSFALSE, ERROR_OBJECT_NOT_FOUND);
562 break;
563 }
564 fh->usecount--;
565 FreeMem(fl, sizeof(*fl));
566 /* Fallthrough */
567 case ACTION_FINDINPUT:
568 case ACTION_FINDOUTPUT:
569 case ACTION_FINDUPDATE:
570 dosfh = BADDR(dp->dp_Arg1);
571 dosfh->fh_Interactive = DOSTRUE;
572 dosfh->fh_Arg1 = (SIPTR) fh;
573 fh->usecount++;
574 fh->breaktask = dp->dp_Port->mp_SigTask;
575 D(bug("[CON] Find fh=%x. Usecount=%d\n", dosfh, fh->usecount));
576 replypkt(dp, DOSTRUE);
577 break;
578 case ACTION_COPY_DIR_FH:
579 fl = AllocMem(sizeof(*fl), MEMF_CLEAR | MEMF_PUBLIC);
580 if (fl == BNULL)
581 {
582 replypkt2(dp, (SIPTR) BNULL, ERROR_NO_FREE_STORE);
583 }
584 else
585 {
586 fh->usecount++;
587 fl->fl_Task = mp;
588 fl->fl_Access = ACCESS_READ;
589 fl->fl_Key = (IPTR) fh;
590 replypkt(dp, (SIPTR) MKBADDR(fl));
591 }
592 break;
593 case ACTION_FREE_LOCK:
594 fl = BADDR(dp->dp_Arg1);
595 fh = (struct filehandle *)fl->fl_Key;
596
597 FreeMem(fl, sizeof(*fl));
598 fh->usecount--;
599
600 replypkt(dp, DOSTRUE);
601 break;
602 case ACTION_END:
603 fh->usecount--;
604 D(bug("[CON] usecount=%d\n", fh->usecount));
605 if (fh->usecount <= 0)
606 {
607 if (fh->flags & FHFLG_WAIT)
608 {
609 D(bug("[CON] Delayed close, waiting...\n"));
610
611 /*
612 * Bounce all pending read and waits (the same as we do when exiting).
613 * However the process is still around, waiting for EOF input.
614 * Our user has just closed his struct FileHandle and dropped us.
615 */
616 stopread(fh, waitingdp);
617 waitingdp = NULL;
618 fh->flags = (fh->flags & ~FHFLG_READPENDING) | FHFLG_WAITFORCLOSE;
619 }
620 else
621 goto end;
622 }
623 replypkt(dp, DOSTRUE);
624 break;
625 case ACTION_READ:
626 if (!MakeSureWinIsOpen(fh))
627 {
628 replypkt2(dp, DOSFALSE, ERROR_NO_FREE_STORE);
629 break;
630 }
631 fh->breaktask = dp->dp_Port->mp_SigTask;
632 startread(fh);
633 con_read(fh, dp);
634 break;
635 case ACTION_WRITE:
636 if (!MakeSureWinIsOpen(fh))
637 {
638 replypkt2(dp, DOSFALSE, ERROR_NO_FREE_STORE);
639 break;
640 }
641 fh->breaktask = dp->dp_Port->mp_SigTask;
642 startread(fh);
643 answer_write_request(fh, dp);
644 break;
645 case ACTION_SCREEN_MODE:
646 {
647 D(bug("ACTION_SCREEN_MODE %s\n", dp->dp_Arg1 ? "RAW" : "CON"));
648 if (dp->dp_Arg1 && !(fh->flags & FHFLG_RAW))
649 {
650 /* Switching from CON: mode to RAW: mode */
651 fh->flags |= FHFLG_RAW;
652 fh->inputstart = fh->inputsize;
653 fh->inputpos = fh->inputsize;
654 HandlePendingReads(fh);
655 }
656 else
657 {
658 /* otherwise just copy the flags */
659 if (dp->dp_Arg1)
660 fh->flags |= FHFLG_RAW;
661 else
662 fh->flags &= ~FHFLG_RAW;
663 }
664 replypkt(dp, DOSTRUE);
665 }
666 break;
667 case ACTION_CHANGE_SIGNAL:
668 {
669 struct Task *old = fh->breaktask;
670 if (dp->dp_Arg2)
671 fh->breaktask = (struct Task*) dp->dp_Arg2;
672 replypkt2(dp, DOSTRUE, (SIPTR) old);
673 }
674 break;
675 case ACTION_WAIT_CHAR:
676 {
677 if (!MakeSureWinIsOpen(fh))
678 {
679 replypkt2(dp, DOSFALSE, ERROR_NO_FREE_STORE);
680 break;
681 }
682 if (fh->inputsize > 0)
683 {
684 replypkt(dp, DOSTRUE);
685 }
686 else if (dp->dp_Arg1 == 0)
687 {
688 replypkt(dp, DOSFALSE);
689 }
690 else
691 {
692 LONG timeout = dp->dp_Arg1;
693 LONG sec = timeout / 1000000;
694 LONG usec = timeout % 1000000;
695
696 fh->timerreq->tr_node.io_Command = TR_ADDREQUEST;
697 fh->timerreq->tr_time.tv_secs = sec;
698 fh->timerreq->tr_time.tv_micro = usec;
699 SendIO((struct IORequest *) fh->timerreq);
700 waitingdp = dp;
701 }
702 startread(fh);
703 }
704 break;
705 case ACTION_IS_FILESYSTEM:
706 replypkt(dp, DOSFALSE);
707 break;
708 case ACTION_DISK_INFO:
709 {
710 /* strange console handler features */
711 struct InfoData *id = BADDR(dp->dp_Arg1);
712 memset(id, 0, sizeof(struct InfoData));
713 id->id_DiskType =
714 (fh->flags & FHFLG_RAW) ? AROS_MAKE_ID('R', 'A', 'W', 0) : AROS_MAKE_ID('C', 'O', 'N', 0);
715 id->id_VolumeNode = (BPTR) fh->window;
716 id->id_InUse = (IPTR) fh->conreadio;
717 replypkt(dp, DOSTRUE);
718 }
719 break;
720 case ACTION_SEEK:
721 /* Yes, DOSTRUE. Check Guru Book for details. */
722 replypkt2(dp, DOSTRUE, ERROR_ACTION_NOT_KNOWN);
723 break;
724 default:
725 bug("[CON] unknown action %d\n", dp->dp_Type);
726 replypkt2(dp, DOSFALSE, ERROR_ACTION_NOT_KNOWN);
727 break;
728 }
729 }
730 }
731 end:
732 D(bug("[CON] 0x%p closing\n", fh));
733 if (fh)
734 {
735 D(bug("[CON] Cancelling read requests...\n"));
736 stopread(fh, waitingdp);
737
738 if (fh->flags & FHFLG_ASYNCCONSOLEREAD)
739 {
740 D(bug("[CON] Aborting console ioReq 0x%p\n", fh->conreadio));
741
742 AbortIO(ioReq(fh->conreadio));
743 WaitIO(ioReq(fh->conreadio));
744 }
745
746 D(bug("[CON] Closing handle...\n"));
747 close_con(fh);
748 }
749
750 if (dp)
751 {
752 D(bug("[CON] Replying packet 0x%p\n", dp));
753 replypkt(dp, DOSFALSE);
754 }
755
756 D(bug("[CON] 0x%p closed\n", fh));
757 return 0;
758 }
Mirror of AROS' svn.