security

Index

LONG secAccess_Control(
         ULONG contextflags,
         APTR context,
         struct secExtOwner * task,
         ULONG objectowner,
         LONG objectprot,
         LONG access_type );

BOOL secAddMonitor(
         struct secMonitor * monitor );

struct secGroupInfo * secAllocGroupInfo();

struct secUserInfo * secAllocUserInfo();

BOOL secCheckPasswd(
         struct TagItem * taglist );

BOOL secCheckPasswdTags(
         TAG tag, ... );

APTR secContextLocate(
         secPluginModule * module,
         ULONG id,
         struct Task * caller,
         ULONG size );

LONG secEnumChildren(
         struct Task * parent,
         struct Task ** children,
         LONG size );

Enumerate the children of a given task.

parent - the Task we are interested in (and may be NULL -> calling task),
children - an array we should populate
size - the size of the supplied array (children)

If the size is too small, we return -(num children) to indicate the size of
the buffer needed for a successful call.
This means that a program could call us with a size of -1 to ask us how big
the buffer should be.

This is designed to replace secGetChildren/secFreeTaskVec.

void secFreeExtOwner(
         struct secExtOwner * owner );

Free an Extended Owner structure

void secFreeGroupInfo(
         struct secGroupInfo * info );

void secFreeUserInfo(
         struct secUserInfo * info );

BOOL secFreeze(
         struct Task * task );

Freeze a task or process

This function may be called by root only!

BOOL secFSRendezVous();

Freeze a task or process

This function may be called by root only!

BPTR secGetConfigDirLock();

Get a Shared Lock on the Directory of the Configuration File

ULONG secGetDefProtection(
         struct Task * task );

UWORD secgetgid();

struct secGroupInfo * secGetGroupInfo(
         struct secGroupInfo * info,
         ULONG keytype );

BPTR secGetPasswdDirLock();

Get a Shared Lock on the Directory of the Password File

int secgetpgid(
         int pid );

LONG secGetPktDefProtection(
         struct DosPacket * pkt );

struct secExtOwner * secGetPktOwner(
         struct DosPacket * pkt );

ULONG secGetRelationshipA(
         struct secExtOwner * user,
         ULONG owner,
         struct TagItem * taglist );

ULONG secGetRelationship(
         struct secExtOwner * user,
         ULONG owner,
         TAG tag, ... );

struct secExtOwner * secGetTaskExtOwner(
         struct Task * task );

ULONG secGetTaskOwner(
         struct Task * task );

UWORD secgetuid();

struct secUserInfo * secGetUserInfo(
         struct secUserInfo * info,
         ULONG keytype );

BOOL secKill(
         struct Task * task );

BOOL secLimitDOSSetProtection(
         BOOL flag );

BOOL secLoadPlugin(
         STRPTR name );

struct secPointers * secLocksecBase();

ULONG secLoginA(
         struct TagItem * taglist );

ULONG secLogin(
         TAG tag, ... );

ULONG secLogout();

struct secPrivGroupInfo * secPasswd(
         STRPTR oldpwd,
         STRPTR newpwd );

void secPluginOperationComplete(
         APTR context,
         ULONG result );

ULONG secRegisterHandler(
         struct plugin_ops * ops );

void secRemMonitor(
         struct secMonitor * monitor );

BOOL secSetDefProtectionA(
         struct TagItem * taglist );

BOOL secSetDefProtection(
         TAG tag, ... );

int secsetegid(
         UWORD gid );

int secseteuid(
         UWORD uid );

int secsetgid(
         UWORD gid );

BOOL secSetProtection(
         STRPTR name,
         LONG mask );

int secsetreuid(
         int ruid,
         int euid );

int secsetuid(
         UWORD uid );

BOOL secUnfreeze(
         struct Task * task );

Unfreeze a task or process

This function may be called by root only!

BOOL secUnloadPlugin(
         STRPTR name );

void secUnlocksecBase(
         struct secPointers * secP );

void secUnRegisterHandler(
         struct plugin_ops * ops );

struct secExtOwner * secUserInfo2ExtOwner(
         struct secUserInfo * info );