TITLE NetFS;
AUTHOR "Jonathan Coxhead, jonathan@doves.demon.co.uk, 29 June 1995";

NEEDS OS, FileSwitch;

CONST
   NetFS_LeafNameLimit = .Int: 10,
   NetFS_DiscNameLimit = .Int: 16,
   NetFS_UserNameLimit = .Int: 22,
   NetFS_PasswordLimit = .Int: 23,
   NetFS_FileNameLimit = .Int: 256,
   NetFS_CLILimit      = .Int: 256;

CONST
   Error_NetFSBadName               = .Bits: 0x10500 "Bad file server name",
   Error_NetFSBadCommandCode        = .Bits: 0x10501 "Bad file server command code",
   Error_NetFSUnexpectedCommandCode = .Bits: 0x10502 "Unexpected file server command code",
   Error_NetFSUnknownFunctionCode   = .Bits: 0x10503 "Unknown function code",
   Error_NetFSUnknownStationName    = .Bits: 0x10504 "Unknown station name",
   Error_NetFSUnknownStationNumber  = .Bits: 0x10505 "Unknown station number",
   Error_NetFSStationNotFound       = .Bits: 0x10506 "Station name not found",
   Error_NetFSFileServerNameTooLong = .Bits: 0x10507 "File server name too long",
   Error_NetFSBadFileServerDate     = .Bits: 0x10508 "Bad date",
   Error_NetFSNetFSInternalError    = .Bits: 0x10509 "Fatal internal error",
   Error_NetFSFileServerNotCapable  = .Bits: 0x1050a "Not possible on this file server",
   Error_NetFSBroadcastServerDead   = .Bits: 0x1050b "Broadcast server not responding",
   Error_NetFSFileServerOnly24Bit   = .Bits: 0x1050c "File too big";

CONST
   Error_NetUtilsWrongVersion = .Bits: 0x1053a "NetFS isn't version 5.78",
   Error_NetUtilsNetFSNoGo    = .Bits: 0x1053b "NetFS isn't running as a filing system",
   Error_NetUtilsIsThreaded   = .Bits: 0x1053c "You can't kill NetUtils";

CONST
   Error_NetFSSetFreeSyntax = .Bits: 0x10540 "Syntax: *SetFree <Username> <FreeSpace (in hex)>, ErrorNumber_Syntax",
   Error_NetFSFsCLISyntax   = .Bits: 0x10541 "Syntax: *FSCLI <string>, ErrorNumber_Syntax";

SWI NetFS_ReadFSNumber =
   (  NUMBER 0x40040 "Returns the full station number of your current file
            server",
      EXIT
      (  R0 = .Byte: station_no,
         R1 = .Byte: net_no
   )  );

SWI NetFS_SetFSNumber =
   (  NUMBER 0x40041 "Sets the full station number used as the current
            file server",
      ENTRY
      (  R0 = .Byte: station_no,
         R1 = .Byte: net_no
      ),
      EXIT
      (  R0?, R1?
   )  );

SWI NetFS_ReadFSName =
   (  NUMBER 0x40042 "Reads the name of your current file server",
      ENTRY
      (  R1 = .Ref .String: buffer,
         R2 = .Int: size
      ),
      EXIT
      (  R0?,
         R1! -> .Char: end,
         R2?
   )  );

SWI NetFS_SetFSName =
   (  NUMBER 0x40043 "Sets by name the file server used as your current
            one",
      ENTRY
      (  R0 -> .String: fs_name
   )  );

SWI NetFS_ReadFSTimeouts =
   (  NUMBER 0x40046 "Reads the current values for timeouts used by NetFS",
      EXIT
      (  R0 = .Int: transmit_count,
         R1 = .Int: transmit_delay,
         R2 = .Int: peek_count,
         R3 = .Int: peek_delay,
         R4 = .Int: receive_delay,
         R5 = .Int: broadcast_delay
   )  );

SWI NetFS_SetFSTimeouts =
   (  NUMBER 0x40047 "Sets the current values for timeouts used by NetFS",
      ENTRY
      (  R0 = .Int: transmit_count,
         R1 = .Int: transmit_delay,
         R2 = .Int: peek_count,
         R3 = .Int: peek_delay,
         R4 = .Int: receive_delay,
         R5 = .Int: broadcast_delay
   )  );

TYPE NetFS_FSOp = .Byte;
CONST
   NetFS_FSOpCLI                   = NetFS_FSOp:  0,
   NetFS_FSOpSave                  = NetFS_FSOp:  1,
   NetFS_FSOpLoad                  = NetFS_FSOp:  2,
   NetFS_FSOpEx                    = NetFS_FSOp:  3,
   NetFS_FSOpCat                   = NetFS_FSOp:  4,
   NetFS_FSOpLoadAs                = NetFS_FSOp:  5,
   NetFS_FSOpOpen                  = NetFS_FSOp:  6,
   NetFS_FSOpClose                 = NetFS_FSOp:  7,
   NetFS_FSOpBGet                  = NetFS_FSOp:  8,
   NetFS_FSOpBPut                  = NetFS_FSOp:  9,
   NetFS_FSOpGBPBRead              = NetFS_FSOp: 10,
   NetFS_FSOpGBPBWrite             = NetFS_FSOp: 11,
   NetFS_FSOpReadArgs              = NetFS_FSOp: 12,
   NetFS_FSOpSetArgs               = NetFS_FSOp: 13,
   NetFS_FSOpReadDiscInfo          = NetFS_FSOp: 14,
   NetFS_FSOpReadLogonInfo         = NetFS_FSOp: 15,
   NetFS_FSOpReadDateAndTime       = NetFS_FSOp: 16,
   NetFS_FSOpReadEOFStatus         = NetFS_FSOp: 17,
   NetFS_FSOpReadObject            = NetFS_FSOp: 18,
   NetFS_FSOpSetObject             = NetFS_FSOp: 19,
   NetFS_FSOpDeleteObject          = NetFS_FSOp: 20,
   NetFS_FSOpReadEnv               = NetFS_FSOp: 21,
   NetFS_FSOpOpt                   = NetFS_FSOp: 22,
   NetFS_FSOpLogoff                = NetFS_FSOp: 23,
   NetFS_FSOpReadUserInfo          = NetFS_FSOp: 24,
   NetFS_FSOpReadVersion           = NetFS_FSOp: 25,
   NetFS_FSOpReadFree              = NetFS_FSOp: 26,
   NetFS_FSOpCreateDir             = NetFS_FSOp: 27,
   NetFS_FSOpSetDateAndTime        = NetFS_FSOp: 28,
   NetFS_FSOpCreate                = NetFS_FSOp: 29,
   NetFS_FSOpReadUserFree          = NetFS_FSOp: 30,
   NetFS_FSOpSetUserFree           = NetFS_FSOp: 31,
   NetFS_FSOpReadUserName          = NetFS_FSOp: 32,
   NetFS_FSOpReadLogonInfoExtended = NetFS_FSOp: 33,
   NetFS_FSOpReadUserInfoExtended  = NetFS_FSOp: 34,
   NetFS_FSOpManagerOp             = NetFS_FSOp: 36;

CONST //in standard Rx header
   NetFS_FSOpCLIComplete = .Byte:  0,
   NetFS_FSOpCLIInfo     = .Byte:  4,
   NetFS_FSOpCLIIAm      = .Byte:  5,
   NetFS_FSOpCLISDisc    = .Byte:  6,
   NetFS_FSOpCLIDir      = .Byte:  7,
   NetFS_FSOpCLIUnknown  = .Byte:  8,
   NetFS_FSOpCLILib      = .Byte:  9,
   NetFS_FSOpCLIDiscInfo = .Byte: 10,
   NetFS_FSOpCLIUserInfo = .Byte: 11;

TYPE NetFS_FSOpExType = .Byte;
CONST
   NetFS_FSOpEx          = NetFS_FSOpExType: 0,
   NetFS_FSOpExText      = NetFS_FSOpExType: 1,
   NetFS_FSOpExTitle     = NetFS_FSOpExType: 2,
   NetFS_FSOpExTitleText = NetFS_FSOpExType: 3;

TYPE NetFS_FSOpArgsType = .Byte;
CONST
   NetFS_FSOpArgsPtr  = NetFS_FSOpArgsType: 0,
   NetFS_FSOpArgsExt  = NetFS_FSOpArgsType: 1,
   NetFS_FSOpArgsSize = NetFS_FSOpArgsType: 2;

TYPE NetFS_FSOpReadObjectType = .Byte;
CONST
   NetFS_FSOpReadObjectStamp           = NetFS_FSOpReadObjectType: 1,
   NetFS_FSOpReadObjectLoadAndExecAddr = NetFS_FSOpReadObjectType: 2,
   NetFS_FSOpReadObjectSize            = NetFS_FSOpReadObjectType: 3,
   NetFS_FSOpReadObjectAttr            = NetFS_FSOpReadObjectType: 4,
   NetFS_FSOpReadObjectAllInfo         = NetFS_FSOpReadObjectType: 5,
   NetFS_FSOpReadObjectAttrAndCycleNo  = NetFS_FSOpReadObjectType: 6,
   NetFS_FSOpReadObjectSIN             = NetFS_FSOpReadObjectType: 7;

TYPE NetFS_FSOpSetObjectType = .Byte;
CONST
   NetFS_FSOpSetObjectLoadExecAndAttr = NetFS_FSOpSetObjectType: 1,
   NetFS_FSOpSetObjectLoadAddr        = NetFS_FSOpSetObjectType: 2,
   NetFS_FSOpSetObjectExecAddr        = NetFS_FSOpSetObjectType: 3,
   NetFS_FSOpSetObjectAttr            = NetFS_FSOpSetObjectType: 4,
   NetFS_FSOpSetObjectStamp           = NetFS_FSOpSetObjectType: 5;

TYPE NetFS_FSOpManagerOpType = .Byte;
CONST
   NetFS_FSOpManagerOpReadPasswordCount = NetFS_FSOpManagerOpType: 0,
   NetFS_FSOpManagerOpReadPassword      = NetFS_FSOpManagerOpType: 1,
   NetFS_FSOpManagerOpWritePassword     = NetFS_FSOpManagerOpType: 2,
   NetFS_FSOpManagerOpAddUser           = NetFS_FSOpManagerOpType: 3,
   NetFS_FSOpManagerOpRemoveUser        = NetFS_FSOpManagerOpType: 4,
   NetFS_FSOpManagerOpSetPrivilege      = NetFS_FSOpManagerOpType: 5,
   NetFS_FSOpManagerOpLogoffUser        = NetFS_FSOpManagerOpType: 6,
   NetFS_FSOpManagerOpShutdown          = NetFS_FSOpManagerOpType: 7;

TYPE
   NetFS_CLIRequest = .Struct ([NetFS_CLILimit] .Char: command),
   NetFS_SaveRequest = .Struct (.Bits: load_addr, .Bits: exec_addr,
         [3] .Byte: size, [NetFS_FileNameLimit] .Char: file_name),
   NetFS_SaveReply = .Struct (.Byte: port, [2] .Byte: block_limit,
         [NetFS_LeafNameLimit] .Char: leaf_name),
   NetFS_SaveFinalReply = .Struct (.Byte: attr, [2] .Byte: date),
   NetFS_LoadRequest = .Struct ([NetFS_FileNameLimit] .Char: file_name),
   NetFS_LoadReply = .Struct (.Bits: load_addr, .Bits: exec_addr,
         [3] .Byte: size, .Byte: attr, [2] .Byte: date,
         [NetFS_FileNameLimit] .Char: file_name),
   NetFS_ExRequest = .Struct (NetFS_FSOpExType: ex_type, .Byte: entry, .Byte: count,
         [NetFS_FileNameLimit] .Char: dir_name),
   NetFS_CatRequest = .Struct ([NetFS_FileNameLimit] .Char: dir_name),
   NetFS_CatReply = .Struct ([NetFS_LeafNameLimit] .Char: leaf_name,
         .Char: reserved1, .Char: owner, [3] .Byte: reserved2,
         [NetFS_DiscNameLimit] .Char: disc_name),
   NetFS_OpenRequest = .Struct (.Byte: error_if_absent, .Byte: read_only,
         [NetFS_FileNameLimit] .Char: file_name),
   NetFS_OpenReply = .Struct (.Byte: handle,
         [NetFS_LeafNameLimit] .Char: leaf_name),
   NetFS_CloseRequest = .Struct (.Byte: handle),
   NetFS_BGetRequest = .Struct (.Byte: handle),
   NetFS_BGetReply = .Struct (.Byte: b, .Byte: terminator),
   NetFS_BPutRequest = .Struct (.Byte: handle, .Byte: b),
   NetFS_GBPBRequest = .Struct (.Byte: handle, .Byte: read_next,
         [3] .Byte: size, [3] .Byte: ptr),
   NetFS_GBPBReply = .Struct (.Byte: final_block, [3] .Byte: size),
   NetFS_ReadArgsRequest = .Struct (NetFS_FSOpArgsType: args_type),
   NetFS_ReadArgsReply = .Struct ([3] .Byte: arg),
   NetFS_SetArgsRequest = .Struct (NetFS_FSOpArgsType: args_type, [3] .Byte: arg),
   NetFS_ReadDiscInfoRequest = .Struct (.Byte: first, .Byte: count),
   NetFS_DiscInfo = .Struct (.Byte: phys_no,
         [NetFS_DiscNameLimit] .Char: disc_name),
   NetFS_ReadDiscInfoReply = .Struct (.Byte: count,
         NetFS_DiscInfo: info ...),
   NetFS_ReadLogonInfoRequest = .Struct (.Byte: first, .Byte: count),
   NetFS_LogonInfo = .Struct (.Byte: station, .Byte: net,
         [NetFS_UserNameLimit] .Byte: user_name "User name terminated by 13",
         .Byte: privilege "Privilege byte immediately follows user_name")
         "Structure repeats",
   NetFS_ReadLogonInfoReply = .Struct (.Byte: count,
         NetFS_LogonInfo: info ...),
   NetFS_ReadDateAndTimeReply = .Struct ([2] .Byte: date,
         .Byte: hr, .Byte: min, .Byte: s),
   NetFS_ReadEOFStatusRequest = .Struct (.Byte: handle),
   NetFS_ReadEOFStatusReply = .Struct (.Byte: eof_status),
   NetFS_ReadObjectRequest = .Struct (NetFS_FSOpReadObjectType: read_type,
         [NetFS_FileNameLimit] .Char: file_name),
   NetFS_DeleteObjectRequest = .Struct ([NetFS_FileNameLimit] .Char: file_name),
   NetFS_DeleteObjectReply = .Struct (.Bits: load_addr, .Bits: exec_addr,
         [3] .Byte: size, .Byte: attr),
   NetFS_ReadEnvReply = .Struct (.Byte: len,
         [NetFS_DiscNameLimit] .Char: disc_name,
         [NetFS_LeafNameLimit] .Char: csd_name,
         [NetFS_LeafNameLimit] .Char: lib_name),
   NetFS_OptRequest = .Struct (.Byte: opt),
   NetFS_ReadUserInfoRequest =
         .Struct ([NetFS_UserNameLimit] .Char: user_name),
   NetFS_ReadUserInfoReply = .Struct (.Byte: privilege, .Byte: station,
         .Byte: net),
   NetFS_ReadVersionReply = .Struct ([10] .Char: type, [4] .Char: version),
   NetFS_ReadFreeRequest = .Struct ([NetFS_DiscNameLimit] .Char: disc_name),
   NetFS_ReadFreeReply = .Struct ([3] .Byte: free_sector_count,
         [3] .Byte: sector_count),
   NetFS_CreateDirRequest = .Struct (.Byte: sector_count,
         [NetFS_FileNameLimit] .Char: dir_name),
   NetFS_SetDateAndTimeRequest = .Struct ([2] .Byte: date,
         .Byte: hr, .Byte: min, .Byte: s),
   NetFS_CreateRequest = .Struct (.Bits: load_addr, .Bits: exec_addr,
         [3] .Byte: size, [NetFS_FileNameLimit] .Char: file_name),
   NetFS_CreateReply = .Struct (.Byte: attr, [2] .Byte: date),
   NetFS_ReadUserFreeRequest =
         .Struct ([NetFS_UserNameLimit] .Char: user_name),
   NetFS_ReadUserFreeReply = .Struct ([3] .Byte: user_free),
   NetFS_SetUserFreeRequest = .Struct ([3] .Byte: user_free,
         [NetFS_UserNameLimit] .Char: user_name),
   NetFS_ReadUserNameReply =
         .Struct ([NetFS_UserNameLimit] .Char: user_name),
   NetFS_LogonInfoExtended = .Struct (.Byte: station, .Byte: net,
         .Byte: task, [NetFS_UserNameLimit] .Byte: user_name,
         .Byte: privilege),
   NetFS_ReadLogonInfoExtendedRequest = .Struct (.Byte: first, .Byte: count),
   NetFS_ReadLogonInfoExtendedReply = .Struct (.Byte: count,
         NetFS_LogonInfoExtended: info ...),
   NetFS_ReadUserInfoExtendedRequest = .Struct (.Char: user_name),
   NetFS_ReadUserInfoExtendedReply = .Struct (.Byte: privilege,
         .Byte: station, .Byte: net, .Byte: task);

TYPE
   NetFS_CLIInfoReply = .Struct ([NetFS_LeafNameLimit] .Char: file_name,
         .Char: reserved1, [9] .Char: load_addr, [9] .Char: exec_addr,
         [2] .Char: reserved2, [7] .Char: length,
         [2] .Char: reserved3, [7] .Char: access, [4] .Char: reserved4,
         [9] .Char: date, [6] .Char: sin, .Byte: terminator),
   NetFS_CLIIAmReply = .Struct (.Byte: urd, .Byte: csd, .Byte: lib,
         .Byte: opt),
   NetFS_CLISDiscReply = .Struct (.Byte: urd, .Byte: csd, .Byte: lib),
   NetFS_CLIDirReply = .Struct (.Byte: csd),
   NetFS_CLIUnknownReply = .Struct ([NetFS_CLILimit] .Char: command),
   NetFS_CLILibReply = .Struct (.Byte: lib);

TYPE
   NetFS_ExReply = .Struct (.Byte: ex_count, .Byte: dir_count,
         [NetFS_LeafNameLimit] .Char: name, .Bits: load_addr,
         .Bits: exec_addr, .Byte: attr, [2] .Byte: date, [3] .Byte: sin,
         [3] .Byte: size),
   NetFS_ExTextReply = .Struct (.Byte: ex_count, .Byte: dir_count,
         [1] .Char: text),
   NetFS_ExTitleReply = .Struct (.Byte: ex_count, .Byte: dir_count,
         .Byte: len, [NetFS_LeafNameLimit] .Char: name),
   NetFS_ExTitleTextReply = .Struct (.Byte: ex_count, .Byte: dir_count,
         [1] .Char: text);

TYPE
   NetFS_ReadObjectStampReply = .Struct ([2] .Byte: date),
   NetFS_ReadObjectLoadAndExecAddrReply = .Struct (.Bits: load_addr,
         .Bits: exec_addr),
   NetFS_ReadObjectSizeReply = .Struct ([3] .Byte: size),
   NetFS_ReadObjectAttrReply = .Struct (.Byte: attr),
   NetFS_ReadObjectAllInfoReply = .Struct (.Bits: load_addr,
         .Bits: exec_addr, [3] .Byte: size, .Byte: attr, [2] .Byte: date,
         [2] .Byte: access),
   NetFS_ReadObjectAttrAndCycleNoReply = .Struct ([2] .Byte: reserved,
         .Byte: len, [NetFS_LeafNameLimit] .Byte: dir_name, .Byte: access,
         .Byte: count),
   NetFS_ReadObjectSINReply = .Struct (.Byte: obj_type, [6] .Byte: sin);

TYPE
   NetFS_SetObjectLoadExecAndAttrRequest = .Struct (NetFS_FSOpSetObjectType: set_type, .Bits: load_addr,
         .Bits: exec_addr, .Byte: attr),
   NetFS_SetObjectLoadAddrRequest = .Struct (NetFS_FSOpSetObjectType: set_type, .Bits: load_addr),
   NetFS_SetObjectExecAddrRequest = .Struct (NetFS_FSOpSetObjectType: set_type, .Bits: exec_addr),
   NetFS_SetObjectAttrRequest = .Struct (NetFS_FSOpSetObjectType: set_type, .Byte: attr),
   NetFS_SetObjectStampRequest = .Struct (NetFS_FSOpSetObjectType: set_type, [2] .Byte: date);

TYPE
   NetFS_ManagerOpReadPasswordCountRequest = .Struct (NetFS_FSOpManagerOpType: req_no),
   NetFS_ManagerOpReadPasswordCountReply = .Struct (.Int: user_count),
   NetFS_ManagerOpReadPasswordRequest = .Struct (NetFS_FSOpManagerOpType: req_no,
         [2] .Byte: user_no),
   NetFS_ManagerOpReadPasswordReply = .Struct (.Int: index,
         .Byte: privilege, .Byte: opt, [4] .Char: reserved, .Byte: station,
         .Byte: net, .Byte: logon_permitted,
         [NetFS_UserNameLimit] .Char: user_name,
         [NetFS_PasswordLimit] .Char: password,
         [NetFS_LeafNameLimit] .Char: urd_name),
   NetFS_ManagerOpWritePasswordRequest = .Struct (NetFS_FSOpManagerOpType: req_no,
         [4] .Char: reserved1, .Byte: privilege, .Byte: opt,
         [6] .Byte: reserved2, .Byte: logon_permitted,
         [NetFS_UserNameLimit] .Char: user_name,
         [NetFS_PasswordLimit] .Char: password,
         [NetFS_LeafNameLimit] .Char: urd_name),
   NetFS_ManagerOpAddUserRequest = .Struct (NetFS_FSOpManagerOpType: req_no,
         [NetFS_UserNameLimit] .Char: user_name),
   NetFS_ManagerOpRemoveUserRequest = .Struct (NetFS_FSOpManagerOpType: req_no,
         [NetFS_UserNameLimit] .Char: user_name),
   NetFS_ManagerOpSetPrivilegeRequest = .Struct (NetFS_FSOpManagerOpType: req_no,
         [NetFS_UserNameLimit] .Char: user_name, .Byte: privilege),
   NetFS_ManagerOpLogoffUserRequest = .Struct (NetFS_FSOpManagerOpType: req_no,
         [NetFS_UserNameLimit] .Char: user_name);

TYPE
   NetFS_CLI =
      .Union
      (  NetFS_CLIRequest: request,
         NetFS_CLIInfoReply: info_reply,
         NetFS_CLIIAmReply: i_am_reply,
         NetFS_CLISDiscReply: s_disc_reply,
         NetFS_CLIDirReply: dir_reply,
         NetFS_CLIUnknownReply: unknown_reply,
         NetFS_CLILibReply: lib_reply
      ),

   NetFS_Save =
      .Union
      (  NetFS_SaveRequest: request,
         NetFS_SaveReply: reply,
         NetFS_SaveFinalReply: final_reply
      ),

   NetFS_Load =
      .Union
      (  NetFS_LoadRequest: request,
         NetFS_LoadReply: reply
      ),

   NetFS_Ex =
      .Union
      (  NetFS_ExRequest: request,
         NetFS_ExReply: reply,
         NetFS_ExTextReply: text_reply,
         NetFS_ExTitleReply: title_reply,
         NetFS_ExTitleTextReply: title_text_reply
      ),

   NetFS_Cat =
      .Union
      (  NetFS_CatRequest: request,
         NetFS_CatReply: reply
      ),

   NetFS_Open =
      .Union
      (  NetFS_OpenRequest: request,
         NetFS_OpenReply: reply
      ),

   NetFS_Close =
      .Union
      (  NetFS_CloseRequest: request
      ),

   NetFS_BGet =
      .Union
      (  NetFS_BGetRequest: request,
         NetFS_BGetReply: reply
      ),

   NetFS_BPut =
      .Union
      (  NetFS_BPutRequest: request
      ),

   NetFS_GBPB =
      .Union
      (  NetFS_GBPBRequest: request,
         NetFS_GBPBReply: reply
      ),

   NetFS_ReadArgs =
      .Union
      (  NetFS_ReadArgsRequest: request,
         NetFS_ReadArgsReply: reply
      ),

   NetFS_SetArgs =
      .Union
      (  NetFS_SetArgsRequest: request
      ),

   NetFS_ReadDiscInfo =
      .Union
      (  NetFS_ReadDiscInfoRequest: request,
         NetFS_ReadDiscInfoReply: reply
      ),

   NetFS_ReadLogonInfo =
      .Union
      (  NetFS_ReadLogonInfoRequest: request,
         NetFS_ReadLogonInfoReply: reply
      ),

   NetFS_ReadDateAndTime =
      .Union
      (  NetFS_ReadDateAndTimeReply: reply
      ),

   NetFS_ReadEOFStatus =
      .Union
      (  NetFS_ReadEOFStatusRequest: request,
         NetFS_ReadEOFStatusReply: reply
      ),

   NetFS_ReadObject =
      .Union
      (  NetFS_ReadObjectRequest: request,
         NetFS_ReadObjectStampReply: stamp_reply,
         NetFS_ReadObjectLoadAndExecAddrReply: load_and_exec_addr_reply,
         NetFS_ReadObjectSizeReply: size_reply,
         NetFS_ReadObjectAttrReply: attr_reply,
         NetFS_ReadObjectAllInfoReply: all_info_reply,
         NetFS_ReadObjectAttrAndCycleNoReply: attr_and_cycle_no_reply,
         NetFS_ReadObjectSINReply: sin_reply
      ),

   NetFS_SetObject =
      .Union
      (  NetFS_SetObjectLoadExecAndAttrRequest: load_exec_and_attr_request,
         NetFS_SetObjectLoadAddrRequest: load_addr_request,
         NetFS_SetObjectExecAddrRequest: exec_addr_request,
         NetFS_SetObjectAttrRequest: attr_request,
         NetFS_SetObjectStampRequest: stamp_request
      ),

   NetFS_DeleteObject =
      .Union
      (  NetFS_DeleteObjectRequest: request,
         NetFS_DeleteObjectReply: reply
      ),

   NetFS_ReadEnv =
      .Union
      (  NetFS_ReadEnvReply: reply
      ),

   NetFS_Opt =
      .Union
      (  NetFS_OptRequest: request
      ),

   NetFS_ReadUserInfo =
      .Union
      (  NetFS_ReadUserInfoRequest: request,
         NetFS_ReadUserInfoReply: reply
      ),

   NetFS_ReadVersion =
      .Union
      (  NetFS_ReadVersionReply: reply
      ),

   NetFS_ReadFree =
      .Union
      (  NetFS_ReadFreeRequest: request,
         NetFS_ReadFreeReply: reply
      ),

   NetFS_CreateDir =
      .Union
      (  NetFS_CreateDirRequest: request
      ),

   NetFS_SetDateAndTime =
      .Union
      (  NetFS_SetDateAndTimeRequest: request
      ),

   NetFS_Create =
      .Union
      (  NetFS_CreateRequest: request,
         NetFS_CreateReply: reply
      ),

   NetFS_ReadUserFree =
      .Union
      (  NetFS_ReadUserFreeRequest: request,
         NetFS_ReadUserFreeReply: reply
      ),

   NetFS_SetUserFree =
      .Union
      (  NetFS_SetUserFreeRequest: request
      ),

   NetFS_ReadUserName =
      .Union
      (  NetFS_ReadUserNameReply: reply
      ),

   NetFS_ReadLogonInfoExtended =
      .Union
      (  NetFS_ReadLogonInfoExtendedRequest: request,
         NetFS_ReadLogonInfoExtendedReply: reply
      ),

   NetFS_ReadUserInfoExtended =
      .Union
      (  NetFS_ReadUserInfoExtendedRequest: request,
         NetFS_ReadUserInfoExtendedReply: reply
      ),

   NetFS_ManagerOpReadPasswordCount =
      .Union
      (  NetFS_ManagerOpReadPasswordCountRequest: request,
         NetFS_ManagerOpReadPasswordCountReply: reply
      ),

   NetFS_ManagerOpReadPassword =
      .Union
      (  NetFS_ManagerOpReadPasswordRequest: request,
         NetFS_ManagerOpReadPasswordReply: reply
      ),

   NetFS_ManagerOpWritePassword =
      .Union
      (  NetFS_ManagerOpWritePasswordRequest: request
      ),

   NetFS_ManagerOpAddUser =
      .Union
      (  NetFS_ManagerOpAddUserRequest: request
      ),

   NetFS_ManagerOpRemoveUser =
      .Union
      (  NetFS_ManagerOpRemoveUserRequest: request
      ),

   NetFS_ManagerOpSetPrivilege =
      .Union
      (  NetFS_ManagerOpSetPrivilegeRequest: request
      ),

   NetFS_ManagerOpLogoffUser =
      .Union
      (  NetFS_ManagerOpLogoffUserRequest: request
      );

TYPE
   NetFS_Op =
      .Union
      (  NetFS_CLI: cli,
         NetFS_Save: save,
         NetFS_Load: load,
         NetFS_Ex: ex,
         NetFS_Cat: cat,
         NetFS_Open: open,
         NetFS_Close: close,
         NetFS_BGet: bget,
         NetFS_BPut: bput,
         NetFS_GBPB: gbpb,
         NetFS_ReadArgs: read_args,
         NetFS_SetArgs: set_args,
         NetFS_ReadDiscInfo: read_disc_info,
         NetFS_ReadLogonInfo: read_logon_info,
         NetFS_ReadDateAndTime: read_date_and_time,
         NetFS_ReadEOFStatus: read_eof_status,
         NetFS_ReadObject: read_object,
         NetFS_SetObject: set_object,
         NetFS_DeleteObject: delete_object,
         NetFS_ReadEnv: read_env,
         NetFS_Opt: opt,
         NetFS_ReadUserInfo: read_user_info,
         NetFS_ReadVersion: read_version,
         NetFS_ReadFree: read_free,
         NetFS_CreateDir: create_dir,
         NetFS_SetDateAndTime: set_date_and_time,
         NetFS_Create: create,
         NetFS_ReadUserFree: read_user_free,
         NetFS_SetUserFree: set_user_free,
         NetFS_ReadUserName: read_user_name,
         NetFS_ReadLogonInfoExtended: read_logon_info_extended,
         NetFS_ReadUserInfoExtended: read_user_info_extended,
         NetFS_ManagerOpReadPasswordCount: manager_op_read_password_count,
         NetFS_ManagerOpReadPassword: manager_op_read_password,
         NetFS_ManagerOpWritePassword: manager_op_write_password,
         NetFS_ManagerOpAddUser: manager_op_add_user,
         NetFS_ManagerOpRemoveUser: manager_op_remove_user,
         NetFS_ManagerOpSetPrivilege: manager_op_set_privilege,
         NetFS_ManagerOpLogoffUser: manager_op_logoff_user
      );

SWI NetFS_DoFSOp =
   (  NUMBER 0x40048 "Commands the current file server to perform an
            operation",
      ENTRY
      (  R0 = NetFS_FSOp: fs_op,
         R1 = .Ref NetFS_Op: op,
         R2 = .Int: tx_count,
         R3 = .Int: size
      ),
      EXIT
      (  R0! = .Int: status,
         R3 = .Int: rx_count
   )  );

TYPE
   NetFS_FileServer =
      .Struct
      (  .Byte: station_no,
         .Byte: net_no,
         .Byte: drive,
         [NetFS_DiscNameLimit] .Char: disc_name,
         .Byte: reserved
      );

CONST
   NetFS_NoMore = .Int: -1;

SWI NetFS_EnumerateFSList =
   (  NUMBER 0x40049 "Lists all file servers of which the NetFS software
            currently knows",
      ENTRY
      (  R0 = .Int: context,
         R1 = .Ref NetFS_FileServer: file_server,
         R2 = .Int: size,
         R3 = .Int: server_limit
      ),
      EXIT
      (  R0! = .Int: context_out,
         R3 = .Int: server_count
   )  );

SWI NetFS_EnumerateFS =
   (  NUMBER 0x4004A "Lists all file servers to which the NetFS software
            is currently logged on",
      ENTRY
      (  R0 = .Int: context,
         R1 = .Ref NetFS_FileServer: file_server,
         R2 = .Int: size,
         R3 = .Int: server_limit
      ),
      EXIT
      (  R0! = .Int: context_out,
         R3 = .Int: server_count
   )  );

TYPE NetFS_DateAndTime = [5] .Byte;

SWI NetFS_ConvertDate = (NUMBER 0x4004B "Converts a file server time and
      date to a RISC OS time and date",
      ENTRY (R0 -> NetFS_DateAndTime: n,
      R1 = .Ref OS_DateAndTime: o));

SWI NetFS_DoFSOpToGivenFS =
   (  NUMBER 0x4004C "Commands a given file server to perform an
             operation",
      ENTRY
      (  R0 = NetFS_FSOp: fs_op,
         R1 = .Ref NetFS_Op: op,
         R2 = .Int: tx_count,
         R3 = .Int: size,
         R4 = .Byte: station,
         R5 = .Byte: net
      ),
      EXIT
      (  R0! = .Int: status,
         R3 = .Int: rx_count
   )  );

SWI NetFS_UpdateFSList = (NUMBER 0x4004D "Adds names of discs to the list
      of names held by NetFS",
      ENTRY (R0 = .Byte: station_no, R1 = .Byte: net_no),
      EXIT (R0?, R1?));

TYPE
   NetFS_FileServerContext =
      .Struct
      (  .Byte: station_no,
         .Byte: net_no,
         .Byte: reserved1,
         [NetFS_DiscNameLimit] .Char: disc_name,
         .Byte: reserved2,
         [NetFS_UserNameLimit] .Char: user_name,
         .Byte: reserved3,
         .Byte: reserved4
      );

SWI NetFS_EnumerateFSContexts =
   (  NUMBER 0x4004E "Lists all the entries in the list of file servers
            to which NetFS is currently logged on",
      ENTRY
      (  R0 = .Int: context,
         R1 = .Ref NetFS_FileServerContext: file_server_context,
         R2 = .Int: size,
         R3 = .Int: server_limit
      ),
      EXIT
      (  R0! = .Int: context_out,
         R2?,
         R3 = .Int: server_count
   )  );

SWI NetFS_ReadUserId =
   (  NUMBER 0x4004F "Returns the current user id if logged on to the
            current file server",
      ENTRY
      (  R1 = .Ref .String: buffer,
         R2 = .Int: size
      ),
      EXIT
      (  R0?,
         R1! -> .Char: end,
         R2?
   )  );

SWI NetFS_GetObjectUID =
   (  NUMBER 0x40050 "Gets a unique identifier for an object",
      ENTRY
      (  R1 -> .String: path_name,
         R6 -> .String: special
      ),
      EXIT
      (  R0! = FileSwitch_ObjectType: obj_type,
         R2 = .Bits: load_addr,
         R3 = .Bits: exec_addr,
         R4 = .Int: size,
         R5 = FileSwitch_Attr: attr,
         R6 = .Int: uid0,
         R7 = .Int: uid1
   )  );

SWI NetFS_EnableCache = (NUMBER 0x40051 "Enables a suspended event task");

SWI Service_NetFS =
   (  NUMBER 0x30,
      ENTRY
      (  R1 # 0x55 "Either a *Logon, a *Bye, a *SDisc or a *Mount has
               occurred"
   )  );

SWI Service_NetFSDying =
   (  NUMBER 0x30,
      ENTRY
      (  R1 # 0x5F "NetFS is dying"
   )  )