rom/filesys/ram/handler.c

   1 /*
   2
   3 File: handler.c
   4 Author: Neil Cafferkey
   5 Copyright (C) 2001-2008 Neil Cafferkey
   6 Copyright (C) 2011 The AROS Development Team
   7
   8 This file is free software; you can redistribute it and/or modify it
   9 under the terms of the GNU Lesser General Public License as
  10 published by the Free Software Foundation; either version 2.1 of the
  11 License, or (at your option) any later version.
  12
  13 This file is distributed in the hope that it will be useful, but
  14 WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16 Lesser General Public License for more details.
  17
  18 You should have received a copy of the GNU Lesser General Public
  19 License along with this file; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  21 MA 02111-1307, USA.
  22
  23 */
  24
  25 #include <aros/debug.h>
  26 #include <aros/asmcall.h>
  27
  28 #include "handler_protos.h"
  29
  30
  31 /* Global variables */
  32
  33 #ifndef __AROS__
  34 struct ExecBase *SysBase;
  35 #endif
  36
  37 /* Data prototypes */
  38
  39 #ifndef __AROS__
  40 extern struct ExecBase *AbsExecBase;
  41 #endif
  42
  43 /* Function prototypes */
  44
  45 static struct DosPacket *GetPacket(struct MsgPort *port);
  46 static VOID ReplyPacket(struct MsgPort *proc_port, struct DosPacket *packet,
  47    PINT result1, PINT result2);
  48 static TEXT *BStr(struct Handler *h, UBYTE *b_str);
  49 static TEXT *BStr2(struct Handler *h, UBYTE *b_str);
  50
  51 #ifdef __AROS__
  52 LONG RAMMain(struct ExecBase *SysBase)
  53 #else
  54 LONG RAMMain(void)
  55 #endif
  56 {
  57    struct Handler *handler;
  58    struct MsgPort *proc_port;
  59    struct DosPacket *packet;
  60    PINT result;
  61    BOOL exit;
  62    LONG link_type;
  63    APTR link_target;
  64    ULONG port_signals;
  65    struct Message *message;
  66
  67    /* Open libraries */
  68    handler = AllocMem(sizeof(struct Handler), MEMF_CLEAR);
  69    if(handler == NULL)
  70         return RETURN_FAIL;
  71
  72 #ifndef __AROS__
  73    SysBase = AbsExecBase;
  74 #endif
  75
  76    DOSBase = (struct DosLibrary *)OpenLibrary(DOSNAME, DOS_VERSION);
  77    if(DOSBase == NULL) {
  78         FreeMem(handler, sizeof(struct Handler));
  79         return RETURN_FAIL;
  80    }
  81
  82    /* Process start-up packet */
  83
  84    proc_port = &((*(struct Process *)FindTask(NULL)).pr_MsgPort);
  85
  86    WaitPort(proc_port);
  87    packet = GetPacket(proc_port);
  88
  89    exit = CmdStartup(handler, BStr(handler, BADDR(packet->dp_Arg1)),
  90       BADDR(packet->dp_Arg3), proc_port);
  91
  92    ReplyPacket(proc_port, packet, DOSBOOL(!exit), IoErr());
  93
  94    /* Set up port signals */
  95
  96    port_signals = 1 << (proc_port->mp_SigBit);
  97    Signal(proc_port->mp_SigTask, port_signals);
  98    if(!exit)
  99       port_signals |= 1 << (handler->notify_port->mp_SigBit);
 100
 101    /* Service packet requests */
 102
 103    while(!exit)
 104    {
 105       Wait(port_signals);
 106
 107       /* Accept returning messages from notification clients */
 108
 109       while((message = GetMsg(handler->notify_port)) != NULL)
 110       {
 111          ReceiveNotifyReply(handler, (APTR)message);
 112       }
 113
 114       /* Service packet requests */
 115
 116       while((packet = GetPacket(proc_port)) != NULL)
 117       {
 118          result = DOSTRUE;
 119          SetIoErr(0);
 120
 121          switch(packet->dp_Type)
 122          {
 123          case ACTION_DIE:
 124
 125             if(!CmdDie(handler))
 126                result = DOSFALSE;
 127             exit = result;
 128             break;
 129
 130          case ACTION_IS_FILESYSTEM:
 131
 132             if(!CmdIsFileSystem())
 133                result = DOSFALSE;
 134             break;
 135
 136          case ACTION_FINDOUTPUT:
 137
 138             if(!CmdFind(handler, BADDR(packet->dp_Arg1),
 139                BADDR(packet->dp_Arg2), BStr(handler, BADDR(packet->dp_Arg3)),
 140                MODE_NEWFILE))
 141                result = DOSFALSE;
 142             break;
 143
 144          case ACTION_FINDUPDATE:
 145
 146             if(!CmdFind(handler, BADDR(packet->dp_Arg1),
 147                BADDR(packet->dp_Arg2), BStr(handler, BADDR(packet->dp_Arg3)),
 148                MODE_READWRITE))
 149                result = DOSFALSE;
 150             break;
 151
 152          case ACTION_FINDINPUT:
 153
 154             if(!CmdFind(handler, BADDR(packet->dp_Arg1),
 155                BADDR(packet->dp_Arg2), BStr(handler, BADDR(packet->dp_Arg3)),
 156                MODE_OLDFILE))
 157                result = DOSFALSE;
 158             break;
 159
 160          case ACTION_FH_FROM_LOCK:
 161
 162             result = CmdFHFromLock(handler, BADDR(packet->dp_Arg1),
 163                BADDR(packet->dp_Arg2));
 164             break;
 165
 166          case ACTION_END:
 167
 168             if(!CmdEnd(handler, (APTR)packet->dp_Arg1))
 169                result = DOSFALSE;
 170             break;
 171
 172          case ACTION_READ:
 173
 174             result = CmdRead(handler, (struct Opening *)packet->dp_Arg1,
 175                (UBYTE *)packet->dp_Arg2, packet->dp_Arg3);
 176             break;
 177
 178          case ACTION_WRITE:
 179
 180             result = CmdWrite(handler, (struct Opening *)packet->dp_Arg1,
 181                (UBYTE *)packet->dp_Arg2, packet->dp_Arg3);
 182             break;
 183
 184          case ACTION_SEEK:
 185             result = CmdSeek(handler, (struct Opening *)packet->dp_Arg1,
 186                packet->dp_Arg2, packet->dp_Arg3);
 187             break;
 188
 189          case ACTION_SET_FILE_SIZE:
 190
 191             result = CmdSetFileSize(handler, (APTR)packet->dp_Arg1,
 192                packet->dp_Arg2, packet->dp_Arg3);
 193             break;
 194
 195          case ACTION_LOCATE_OBJECT:
 196
 197             result = (PINT)MKBADDR(CmdLocateObject(handler,
 198                BADDR(packet->dp_Arg1), BStr(handler, BADDR(packet->dp_Arg2)),
 199                packet->dp_Arg3));
 200             break;
 201
 202          case ACTION_FREE_LOCK:
 203
 204             if(!CmdFreeLock(handler, BADDR(packet->dp_Arg1)))
 205                result = DOSFALSE;
 206             break;
 207
 208          case ACTION_COPY_DIR:
 209
 210             result = (PINT)MKBADDR(CmdCopyDir(handler, BADDR(packet->dp_Arg1)));
 211             break;
 212
 213          case ACTION_COPY_DIR_FH:
 214
 215             result = (PINT)MKBADDR(CmdCopyDirFH(handler, (APTR)packet->dp_Arg1));
 216             break;
 217
 218          case ACTION_PARENT:
 219
 220             result = (PINT)MKBADDR(CmdParent(handler, BADDR(packet->dp_Arg1)));
 221             break;
 222
 223          case ACTION_PARENT_FH:
 224
 225             result = (PINT)MKBADDR(CmdParentFH(handler, (APTR)packet->dp_Arg1));
 226             break;
 227
 228          case ACTION_SAME_LOCK:
 229
 230             if(!CmdSameLock(handler, BADDR(packet->dp_Arg1), BADDR(packet->dp_Arg2)))
 231                result = DOSFALSE;
 232             break;
 233
 234          case ACTION_CREATE_DIR:
 235
 236             result = (PINT)MKBADDR(CmdCreateDir(handler, BADDR(packet->dp_Arg1),
 237                BStr(handler, BADDR(packet->dp_Arg2))));
 238             break;
 239
 240          case ACTION_EXAMINE_OBJECT:
 241
 242             if(!CmdExamineObject(handler, BADDR(packet->dp_Arg1),
 243                BADDR(packet->dp_Arg2)))
 244                result = DOSFALSE;
 245             break;
 246
 247          case ACTION_EXAMINE_FH:
 248
 249             if(!CmdExamineFH(handler, (APTR)packet->dp_Arg1,
 250                BADDR(packet->dp_Arg2)))
 251                result = DOSFALSE;
 252             break;
 253
 254          case ACTION_EXAMINE_NEXT:
 255
 256             if(!CmdExamineNext(handler, BADDR(packet->dp_Arg2)))
 257                result = DOSFALSE;
 258             break;
 259
 260          case ACTION_EXAMINE_ALL:
 261
 262             if(!CmdExamineAll(handler, BADDR(packet->dp_Arg1),
 263                (APTR)packet->dp_Arg2, packet->dp_Arg3, packet->dp_Arg4,
 264                (APTR)packet->dp_Arg5))
 265                result = DOSFALSE;
 266             break;
 267
 268          case ACTION_EXAMINE_ALL_END:
 269
 270             CmdExamineAllEnd(handler, BADDR(packet->dp_Arg1),
 271                (APTR)packet->dp_Arg2, packet->dp_Arg3, packet->dp_Arg4,
 272                (APTR)packet->dp_Arg5);
 273             break;
 274
 275          case ACTION_INFO:
 276
 277             if(!CmdInfo(handler, BADDR(packet->dp_Arg2)))
 278                result = DOSFALSE;
 279             break;
 280
 281          case ACTION_DISK_INFO:
 282
 283             if(!CmdInfo(handler, BADDR(packet->dp_Arg1)))
 284                result = DOSFALSE;
 285             break;
 286
 287          case ACTION_SET_PROTECT:
 288
 289             if(!CmdSetProtect(handler, BADDR(packet->dp_Arg2),
 290                BStr(handler, BADDR(packet->dp_Arg3)), packet->dp_Arg4))
 291                result = DOSFALSE;
 292             break;
 293
 294          case ACTION_SET_COMMENT:
 295
 296             if(!CmdSetComment(handler, BADDR(packet->dp_Arg2),
 297                BStr(handler, BADDR(packet->dp_Arg3)),
 298                BStr2(handler, BADDR(packet->dp_Arg4))))
 299                result = DOSFALSE;
 300             break;
 301
 302          case ACTION_RENAME_OBJECT:
 303
 304             if(!CmdRenameObject(handler, BADDR(packet->dp_Arg1),
 305                BStr(handler, BADDR(packet->dp_Arg2)), BADDR(packet->dp_Arg3),
 306                BStr2(handler, BADDR(packet->dp_Arg4))))
 307                result = DOSFALSE;
 308             break;
 309
 310          case ACTION_RENAME_DISK:
 311
 312             if(!CmdRenameDisk(handler, BStr(handler, BADDR(packet->dp_Arg1))))
 313                result = DOSFALSE;
 314             break;
 315
 316          case ACTION_SET_DATE:
 317
 318             if(!CmdSetDate(handler, BADDR(packet->dp_Arg2),
 319                BStr(handler, BADDR(packet->dp_Arg3)), (APTR)packet->dp_Arg4))
 320                result = DOSFALSE;
 321             break;
 322
 323          case ACTION_DELETE_OBJECT:
 324
 325             if(!CmdDeleteObject(handler, BADDR(packet->dp_Arg1),
 326                BStr(handler, BADDR(packet->dp_Arg2))))
 327                result = DOSFALSE;
 328             break;
 329
 330          case ACTION_CURRENT_VOLUME:
 331
 332             result = (PINT)MKBADDR(CmdCurrentVolume(handler));
 333             break;
 334
 335          case ACTION_CHANGE_MODE:
 336
 337             result = CmdChangeMode(handler, packet->dp_Arg1, BADDR(packet->dp_Arg2),
 338                packet->dp_Arg3);
 339             break;
 340
 341          case ACTION_MAKE_LINK:
 342
 343             link_target = (APTR)packet->dp_Arg3;
 344             link_type = packet->dp_Arg4;
 345             if(link_type == LINK_HARD)
 346                link_target = BADDR(link_target);
 347             if(!CmdMakeLink(handler, BADDR(packet->dp_Arg1),
 348                BStr(handler, BADDR(packet->dp_Arg2)), link_target, link_type))
 349                result = DOSFALSE;
 350             break;
 351
 352          case ACTION_READ_LINK:
 353
 354             result = CmdReadLink(handler, BADDR(packet->dp_Arg1),
 355                (APTR)packet->dp_Arg2, (APTR)packet->dp_Arg3,
 356                packet->dp_Arg4);
 357             break;
 358
 359          case ACTION_WRITE_PROTECT:
 360
 361             if(!CmdWriteProtect(handler, packet->dp_Arg1,
 362                (ULONG)packet->dp_Arg2))
 363                result = DOSFALSE;
 364             break;
 365
 366          case ACTION_FLUSH:
 367
 368             if(!CmdFlush())
 369                result = DOSFALSE;
 370             break;
 371
 372          case ACTION_ADD_NOTIFY:
 373
 374             if(!CmdAddNotify(handler, (APTR)packet->dp_Arg1))
 375                result = DOSFALSE;
 376             break;
 377
 378          case ACTION_REMOVE_NOTIFY:
 379
 380             if(!CmdRemoveNotify(handler, (APTR)packet->dp_Arg1))
 381                result = DOSFALSE;
 382             break;
 383
 384          default:
 385             result = DOSFALSE;
 386             SetIoErr(ERROR_ACTION_NOT_KNOWN);
 387          }
 388
 389          ReplyPacket(proc_port, packet, result, IoErr());
 390       }
 391
 392    }
 393
 394    CloseLibrary((APTR)DOSBase);
 395
 396    DeleteHandler(handler);
 397
 398    return RETURN_OK;
 399 }
 400
 401 static struct DosPacket *GetPacket(struct MsgPort *port)
 402 {
 403    struct Message *message;
 404    struct DosPacket *packet;
 405
 406    message = GetMsg(port);
 407    if(message != NULL)
 408       packet = (struct DosPacket *)((struct Node *)message)->ln_Name;
 409    else
 410       packet = NULL;
 411
 412    return packet;
 413 }
 414
 415
 416
 417 static VOID ReplyPacket(struct MsgPort *proc_port, struct DosPacket *packet,
 418    PINT result1, PINT result2)
 419 {
 420    struct MsgPort *port;
 421    struct Message *message;
 422
 423    port = packet->dp_Port;
 424    message = packet->dp_Link;
 425
 426    packet->dp_Port = proc_port;
 427    packet->dp_Res1 = result1;
 428    packet->dp_Res2 = result2;
 429
 430    PutMsg(port, message);
 431
 432    return;
 433 }
 434
 435 static TEXT *BStr(struct Handler *h, UBYTE *b_str)
 436 {
 437    UBYTE length;
 438
 439 #ifdef AROS_FAST_BSTR
 440    length = StrSize(b_str);
 441    CopyMem(b_str, h->b_buffer, length);
 442 #else
 443    length = *b_str;
 444    if(length != 0)
 445       CopyMem(b_str + 1, h->b_buffer, length);
 446 #endif
 447    *(h->b_buffer + length) = '\0';
 448
 449    return h->b_buffer;
 450 }
 451
 452
 453
 454 static TEXT *BStr2(struct Handler *h, UBYTE *b_str)
 455 {
 456    UBYTE length;
 457
 458 #ifdef AROS_FAST_BSTR
 459    length = StrSize(b_str);
 460    CopyMem(b_str, h->b_buffer2, length);
 461 #else
 462    length = *b_str;
 463    if(length != 0)
 464       CopyMem(b_str + 1, h->b_buffer2, length);
 465 #endif
 466    *(h->b_buffer2 + length) = '\0';
 467
 468    return h->b_buffer2;
 469 }
 470
 471
 472
 473 UBYTE *MkBStr(struct Handler *h, TEXT *str)
 474 {
 475    UBYTE length;
 476
 477    length = StrLen(str);
 478 #ifdef AROS_FAST_BSTR
 479    CopyMem(str, h->b_buffer, length + 1);
 480 #else
 481    if(length != 0)
 482       CopyMem(str, h->b_buffer + 1, length);
 483    *h->b_buffer = length;
 484 #endif
 485
 486    return h->b_buffer;
 487 }
 488
 489
 490