精华内容
下载资源
问答
  • 数据库中数据文件,控制文件,日志文件,参数文件的存取路径: ①数据文件: select * from V$datafile; c:oracle\product\10.2.0\db_1\database\sysaux01.dbf c:oracle\product\10.2.0\...

    数据库中数据文件,控制文件,日志文件,参数文件的存取路径:

     

     

    ①数据文件: select * from V$datafile;

    c:oracle\product\10.2.0\db_1\database\sysaux01.dbf

    c:oracle\product\10.2.0\db_1\database\sysaux02.dbf

    c:oracle\product\10.2.0\db_1\database\users01.dbf

    c:oracle\product\10.2.0\db_1\database\data_rent.dbf

    ...

     

     

     

     

     

     

     

    ②控制文件:select * from v$controlfile;

    c:oracle\product\10.2.0\oradata\orcl\control01.ctl

    c:oracle\product\10.2.0\oradata\orcl\control02.ctl

    c:oracle\product\10.2.0\oradata\orcl\control03.ctl

     

     

     

     

     

    ③日志文件: select * from v$logfile;

    c:oracle\product\10.2.0\oradata\orcl\redo01.log

    c:oracle\product\10.2.0\oradata\orcl\redo02.log

    c:oracle\product\10.2.0\oradata\orcl\redo03.log

     

     

     

     

     

    ④参数文件:   (select * from v$archived_log;  --测试无结果- -)

    c:oracle\product\10.2.0\db_1\database\initrcl.ora 

     

     

     

     

    转载于:https://www.cnblogs.com/code1992/archive/2012/12/25/2832147.html

    展开全文
  • WINDOWS 2003共享文件存取枚举控制

    千次阅读 2010-12-22 14:03:00
    网上找到对枚举描述最清晰文章了,收之~   使用Access-Based Enumeration来实现没有权限访问共享文件夹用户,无法看到该共享文件夹目的。具体操作步骤如下: <br />1. 请到以下...

    网上找到的对枚举描述最清晰的文章了,收之~

     

    使用Access-Based Enumeration来实现没有权限访问共享文件夹的用户,无法看到该共享文件夹的目的。具体的操作步骤如下:

    1. 请到以下网站下载并安装Access-Based Enumeration,如果您的系统是Windows 2003 Server的话,确认更新了SP1补丁。

    Windows Server 2003 Access-based Enumeration
    http://www.microsoft.com/downloads/details.aspx?FamilyId=04A563D9-78D9-4342-A485-B030AC442084&displaylang=en

    2. 在安装完成后共享文件夹的"属性"里会多出一个"access-based enumeration "项,在C盘(NTFS分区)上建一个名为Shared的共享文件夹这个文件夹下面包含A和B两个子文件夹, A文件夹只有特定用户可以访问,而B文件夹任何用户都可以访问,并且把设为完全共享。

    3. 右击文件夹A,然后"属性"——"安全"——高级——将“允许父项的继承权限传播到该对像和所有子对像。包括那些在此明确定义的项目(A)”前面的勾去掉,弹出一个对话框单击“复制”单击“应用”。

    4. 回到属性对话框删除”USERS”用户,点击“确定”,完成的权限设置。

    5. 右键点击shared文件夹——"属性"——“Enable access-based enumeration or this shared folder”,如果想把这个设置应用到计算机所有已共享的文件夹上请选择”Apply this folder’s setting to all existing shared folders on this computer”。

    6. 在命令提示符下输入regsvr32 abeui.dll,注册一个ABEUI.DLL文件。

    7. 您再从客户端访问共享文件夹,就会发现A文件夹已经是无法看见了。

    请注意:
    1、ABE功能对本地管理员无效。
    2、ABE改变了共享目录的访问方式,会增加服务器的CPU利用率并会降低访问速度。
    3、只有已经共享的目录属性里才会出现ABE属性页。

    展开全文
  • 六,存取控制

    2015-05-12 13:37:18
    前面章节介绍的沙箱就是说的存取控制器,存取控制器就是沙箱的实现。回顾一下沙箱的基本要素,这些都是建立存取控制的基础 基本要素: 1,代码源 2,权限 3,策略:管理员可以设置策略文件,策略文件上面描述了所有...

    安全管理器大部分功能都是在存取控制器基础上实现的,可以说存取控制器是可以取代安全管理器的。


    一般来说安全管理器是调用存取控制器的功能!


    前面章节介绍的沙箱就是说的存取控制器,存取控制器就是沙箱的实现。回顾一下沙箱的基本要素,这些都是建立存取控制的基础

    基本要素:

    1,代码源

    2,权限

    3,策略:管理员可以设置策略文件,策略文件上面描述了所有的权限;在安全管理器中,策略对象表示为对所有权限的封装(内存)

    4,保护域:利于权限的检索,指对某代码源相应权限的封装


    我们先详细解读每一个要素的实现,然后再解释存取控制器是如何工作的


    一,CodeSource类(java.security.CodeSource)  —————— 代码源

    主要方法:

    http://www.yq1012.com/api/java/security/CodeSource.html


    二,权限类, Permission类

    http://www.yq1012.com/api/java/security/Permission.html

    1,权限的三个特性:类型、名、操作


    注意:权限是类型的一个实例

    如:在策略文件中定义一个权限对象

    permission java.util.PropertyPermission "java.version", "read";

    上面描述的权限在内存中的表示为:permission p = new java.util.PropertyPermission("java.version", "read");

    可以看出对象是java.util.PropertyPermission类型的一个实例,构造时带名和操作参数。


    对于我们这些普通java开发者,很少定义权限类,但是我们可以自定义权限类,只不过在实现”名、操作“的通配匹配上算法有点复杂,

    另外,BasicPermission类提供了层次式通配匹配操作,我们可以直接继承或依赖他,也可以只继承Permission类来自行完成需要的匹配算法。


    以下是参考书籍上的一个例子,

    ----此例子的名只是一个单值,并不是层次的,所以不需要复杂的匹配,操作只有2个,view和update,操作配置算法用或操作就完成,很简单

    ----如果名是层次的,要写路径覆盖算法,代码太多,这里只是简单的说明我们如何编写自己的权限类,

    ----注意equals(Object o),implies(Permission p) ,getActions() 核心方法的实现细节,他们都是抽象的,要自己实现的匹配逻辑

    import java.security.*;
    import java.util.*;
    
    public class XYZPayrollPermission extends Permission {
    
        protected int mask;
        static private int VIEW = 0x01;
        static private int UPDATE = 0x02;
    
        public XYZPayrollPermission(String name) {
            // Our permission must always have an action, so we
            // choose a default one here.
            this(name, "view");
        }
    
        public XYZPayrollPermission(String name, String action) {
            // Our superclass, however, does not support actions
            // so we don't provide one to that.
            super(name);
            parse(action);
        }
    
        private void parse(String action) {
            // Look in the action string for the words view and
            // update, separated by white space or by a comma
            StringTokenizer st = new StringTokenizer(action, ",\t ");
    
            mask = 0;
            while (st.hasMoreTokens()) {
                String tok = st.nextToken();
                if (tok.equals("view"))
                    mask |= VIEW;
                else if (tok.equals("update"))
                    mask |= UPDATE;
                else throw new IllegalArgumentException(
                                        "Unknown action " + tok);
            }
        }
    
        public boolean implies(Permission permission) {
            if (!(permission instanceof XYZPayrollPermission))
                return false;
            
            XYZPayrollPermission p = (XYZPayrollPermission) permission;
            String name = getName();
            // The name must be either the wildcard *, which signifies
            // all possible names, or the name must match our name
            if (!name.equals("*") && !name.equals(p.getName()))
                return false;
            // Similarly, the requested actions must all match actions
            // that we've been constructed with.
            if ((mask & p.mask) != p.mask)
                return false;
            // Only if both the action and name match do we return true.
            return true;
        }
    
        public boolean equals(Object o) {
            if (!(o instanceof XYZPayrollPermission))
                return false;
            
            // For equality, we check the name and action mask.
            // We must provide a method definition like this, since
            // the security system expects us to do a deep check for
            // equality rather than relying on object reference
            // equality.
            XYZPayrollPermission p = (XYZPayrollPermission) o;
            return ((p.getName().equals(getName())) && (p.mask == mask));
        }
    
        public int hashCode() {
            // We must always provide a hash code for permissions,
            // because the hashes must match if the permissions compare
            // as equals. The default implementation of this method
            // wouldn't provide that.
            return getName().hashCode() ^ mask;
        }
    
        public String getActions() {
            // This method must return the same string, no matter how
            // the action list was passed to the constructor.
            if (mask == 0)
                return "";
            else if (mask == VIEW)
                return "view";
            else if (mask == UPDATE)
                return "update";
            else if (mask == (VIEW | UPDATE))
                return "view, update";
            else throw new IllegalArgumentException("Unknown mask");
        }
    
        public PermissionCollection newPermissionsCollection() {
            // More about this in a later example.
            return new XYZPayrollPermissionCollection();
        }
    
        public static void main(String[] args) {
            XYZPayrollPermission p1 = new XYZPayrollPermission("sdo", "view");
            XYZPayrollPermission p2 = new XYZPayrollPermission(args[0], args[1]);
            System.out.println("P1 is " + p1);
            System.out.println("P2 is " + p2);
            System.out.println("P1 -> P2 is " + p1.implies(p2));
            System.out.println("P2 -> P1 is " + p2.implies(p1));
        }
    }


    2,权限集(抽线类):PermissionCollection类,某一个权限类的所有实例的集合,用途:1-存储权限;2-检查是否包含指定权限

    3,权限集集合:Permissions类,他继承权限集PermissionCollection,和权限集表现一样的接口,因此作用一样,只不过他更强,他可以存储多个不同类型的权限集,也可用于不同类型权限的检索


    以下是参考书籍上的一个例子,

    import java.util.*;
    import java.security.*;
    import java.util.*;
    
    public class XYZPayrollPermissionCollection extends PermissionCollection {
        private Hashtable permissions;
        // We keep track of whether the * name has been added to make
        // the implies method simpler.
        private boolean addedAdmin;
        private int adminMask;
    
        XYZPayrollPermissionCollection() {
            permissions = new Hashtable();
            addedAdmin = false;
        }
    
        public void add(Permission p) {
            // Required test
            if (isReadOnly())
                throw new IllegalArgumentException("Read only collection");
    
            // This is a homogenous collection, as are all 
            // PermissionCollections that you'll implement.
            if (!(p instanceof XYZPayrollPermission))
                throw new IllegalArgumentException("Wrong permission type");
    
            XYZPayrollPermission xyz = (XYZPayrollPermission) p;
            String name = xyz.getName();
            XYZPayrollPermission other = 
                           (XYZPayrollPermission) permissions.get(name);
            if (other != null)
                xyz = merge(xyz, other);
            // An administrative permission. The administrative permission
            // may have only view or only update or both, and multiple
            // admin permissions may be added, so the masks are OR-ed
            // together.
            if (name.equals("*")) {
                addedAdmin = true;
                adminMask = xyz.mask | adminMask;
            }
            permissions.put(name, xyz);
        }
    
        public Enumeration elements() {
            return permissions.elements();
        }
    
        public boolean implies(Permission p) {
            if (!(p instanceof XYZPayrollPermission))
                return false;
            XYZPayrollPermission xyz = (XYZPayrollPermission) p;
            // If the admin name is present, then all names are implied;
            // we need check only the permissions.
            if (addedAdmin && (adminMask & xyz.mask) == xyz.mask)
                return true;
            // Otherwise, we can just see if the given individual is
            // in our table and if so, see if the permissions match.
            Permission inTable = (Permission) permissions.get(xyz.getName());
            if (inTable == null)
                return false;
            return inTable.implies(xyz);
        }
    
        // This is called when the same name is added twice to the
        // permissions; we merge the action lists and only store the
        // name once.
        private XYZPayrollPermission merge(XYZPayrollPermission a,
                                           XYZPayrollPermission b) {
            String aAction = a.getActions();
            if (aAction.equals(""))
                return b;
            String bAction = b.getActions();
            if (bAction.equals(""))
                return a;
            return new XYZPayrollPermission(a.getName(), aAction + "," + bAction);
        }
    }

    三,Policy类  策略


    权限集要和代码源相关联,之后我们才能判断出代码具有什么样的权限。策略类定义了这种关联。

    如果要自己写策略,

    ----就需要解读策略文件,或者权限存于数据库,你需要自己的一套解读方式

    ----需要为代码源关联权限集,注意权限集的创建并不是由策略完成的,策略只是保存数据,创建权限的工作由运行时的类加载器搞定

    ----策略类需要读文件或网络的权限,往往是特权,特权在本文后面介绍


    其实我在读完存取控制后,就开始担心java安全策略的效率,但等到读完类加载器后,这些顾虑都没有了,策略对象里面代码源的权限集并不是启动java的时候就生成的,而是由类加载器实时完成的。

    所以我们并不用担心JAVA虚拟机安全的处理速度,更不用担心检索速度(内存速度)


    例子:

    例子展示了策略对象的主要功能

    ----存储权限 (具体的权限由类加载器生成,然后抛给策略对象的)

    ----检索代码基的权限集

    import java.security.*;
    import java.util.*;
    
    public class MyPolicy extends Policy {
    
        // This inner class defines a simple set of permissions:
        // either everything is allowed (the implies() method always
        // returns true, and the collection contains an AllPermission
        // object) or everything is prohibited (the implies()
        // method always returns false and the collection is empty).
        static class SimplePermissions extends PermissionCollection {
            boolean allow;
            Permissions perms;
    
            SimplePermissions(boolean b) {
                allow = b;
                perms = new Permissions();
                if (allow)
                    perms.add(new AllPermission());
            }
    
            public void add(Permission p) {
                if (isReadOnly())
                    throw new SecurityException(
                                 "Can't add to this collection");
                perms.add(p);
            }
    
            public Enumeration elements() {
                return perms.elements();
            }
    
            public boolean implies(Permission p) {
                return allow;
            }
        }
    
        // We never change the policy
        public void refresh() {}
    
        //If the code was loaded from a file, return a collection
        // that implies all permissions. Otherwise, return an
        // empty collection (one that implies no permissions).
        public PermissionCollection getPermissions(CodeSource cs) {
            if (cs.getLocation().getProtocol().equals("file"))
                return new SimplePermissions(true);
            return new SimplePermissions(false);
        }
    }

    在虚拟机中,任何时候只有一个策略对象,

    我们可以替换系统的策略类,通过程序化或者管理手段配置

    程序化: setPolicy(Policy p)

    管理手段:

    ---java.security中 plicy.provider=sun.security.provider.PolicyFile 替换为自己的类

    ---把自己的类放如rt.jar中,或者在运行虚拟机时正确适合参数以指定引导路径 java -Xbootclasspath:/files/policyfile  ...


    四,保护域 ProtectionDomain

    前面谈过Permissions对象——权限集集和,他和某一个代码基关联起来就是保护域

    也就是说,他存储了某个代码基的所有权限集集和

    具体核心方法请参考API文档 


    保护域对开发人员是透明的,我们不需要了解他的API细节,

    但我们要知道,每一个java类都属于且仅属于一个保护域,定义类时,保护域可以来自默认的安全模型(策略文件),也可由类加载器拓展(或替换)。



     

    五、存取控制器  AccessController


    前面介绍了存取控制器的要素,存取控制器没有实例,构造函数私有,有一组静态方法用于确定是否得到权限以实现某个操作


    例子演示了他简单的用法

    <span style="font-size:12px;">import java.applet.*;
    import java.net.*;
    import java.security.*;
    
    public class AccessTest extends Applet {
        public void init() {
            SocketPermission sp = new SocketPermission(
                                getParameter("host") + ":6000", "connect");
            try {
                AccessController.checkPermission(sp);
                System.out.println("Ok to open socket");
            } catch (AccessControlException ace) {
                System.out.println(ace);
            }
        }
    }</span>

    1,存取控制是如何工作的——如何检索权限的

    ----存取控制器方法调用后,存取控制开始工作

    ----存取控制器检索堆栈中最后压入栈的类,存取控制类除外,检索类代码基是否有相应权限,以上代码是检索是否有套接字权限,host:6000

    ----有权限,就检测堆栈前一个类,直到堆栈完毕。

    ----没有权限,就抛出运行时异常,线程完毕。


    来自于不同加载器和不同签名jar包的类,由加载器设置权限集合,所以类加载器为了安全考虑,必须首先检索父加载器是否加载了类,


    这里不能画图 唉!


    2,特权接口,PrivilegedAction 和 PrivilegedExceptionAction 接口

    实现特权接口的类,就是特权类,只有一个方法就是run(); 


    如果我们把一段程序封装在特权类中,我们就能让存取控制器网开一面,阻止存取控制递归检索堆栈中的权限

    话题:A类有套接字locahost:6000权限,B类没有,如果B调用A,那么网络访问就会失败,但这种情况下,我们希望A能顺利访问网络,怎么办呢?

    解答:特权类

               我们改造类A,让A访问网络的代码封装在特权类中,这样不管调用A的类是否具备套接字权限,A的对象都能顺利访问网络


    <span style="font-size:12px;">import java.net.*;
    import java.io.*;
    import java.security.*;
    
    public class A {
        public A() {
            try {
                // This class is used by the doPrivilged() method to
                // open a socket
                class doSocket implements PrivilegedExceptionAction {
                    public Object run() throws UnknownHostException,
                                         IOException {
                        return new Socket("localhost", 6000);
                    }
                };
                doSocket ds = new doSocket();
                Socket s = (Socket) AccessController.doPrivileged(ds);
            } catch (PrivilegedActionException pae) {
                Exception e = pae.getException();
                if (e instanceof UnknownHostException) {
                    // process host exception
                }
                else if (e instanceof IOException) {
                    // process IOException
                }
                else {
                    // e must be a runtime exception
                    throw (RuntimeException) e;
                }
            }
        }
    }</span>

    我们看看例子堆栈的情况

    -----new Socket("localhost",6000) 会在内部调用存取控制器, 存取控制器会递归堆栈检索指定权限 :new java.net.SocketPermission("localhost",6000)

    -----存取控制先检索类核心API  Socket 是否有套接字权限

    ------有,继续检索doSocket类套接字权限

    -----doSocket为特权类,他会设置断点,阻止存取控制继续检索,从而返回,

    -----存取控制器返回“真”,套接字访问顺利完成


    如果A类的对象,被任何其他类型的对象调用,A都能有特权访问套接字了


    例子的分析,大家可能有疑惑,我们更进一步分析下

    -----程序执行首先要进堆栈,然后出栈,

    -----语句AccessController.doPrivileged(ds),会让ds.run靠后进栈,之后让new Socket("localhost",6000)最后进栈,也就是说存取控制器回调run,

    -----new Socket("localhost",6000)会进一步让AccessController.checkPermission()方法进栈,checkPermission()才是检索类权限的真正指令流

    -----等checkPermission()执行完毕后,知道有权限才让new Socket("localhost",6000)正常返回,否则,如果没有权限,抛出运行时异常,堆栈结束了

    -----AccessController.doPrivilleged()是很早进入栈的,但他进栈时,在栈中设置了一个断点,断点会阻止checkPermission()方法中检索代码的执行,

    -----因此checkPermission()执行中途,检测到堆栈断点,返回,不会去检索栈中其他类的权限了,从而达到了特权的目的。


    没法画图,唉






    
    展开全文
  • chmod----改变一个或多个文件的存取模式(mode) Linux/Unix 的文件调用权限分为三级 : 文件拥有者、群组、其他。利用 chmod 可以藉以控制文件如何被他人所调用。使用权限: 所有使用者 chmod [options] mode files ...

    chmod----改变一个或多个文件的存取模式(mode)

    Linux/Unix 的文件调用权限分为三级 : 文件拥有者、群组、其他。利用 chmod 可以藉以控制文件如何被他人所调用。 使用权限 : 所有使用者

    chmod [options] mode files

    只能文件属主或特权用户才能使用该功能来改变文件存取模式。mode可以是数字形式或以who opcode permission形式表示。who是可选的,默认是a(所有用户)。只能选择一个opcode(操作码)。可指定多个mode,以逗号分开。

    语法

    chmod [-cfvR] [--help] [--version] mode file...

    参数说明

    mode : 权限设定字串,格式如下 :

    [ugoa...][[+-=][rwxX]...][,...]

    其中:

    • u 表示该文件的拥有者,g 表示与该文件的拥有者属于同一个群体(group)者,o 表示其他以外的人,a 表示这三者皆是。u用户 g组 o其它  a 所有用户(默认)
    • + 表示增加权限、- 表示取消权限、= 表示唯一设定权限。
    • r 表示可读取,w 表示可写入,x 表示可执行,X 表示只有当该文件是个子目录或者该文件已经被设定过为可执行。

    其他参数说明:

    • -c : 若该文件权限确实已经更改,才显示其更改动作(-c,--changes只输出被改变文件的信息)
    • -f : 若该文件权限无法被更改也不要显示错误讯息(--silent,--quiet,当chmod不能改变文件模式时,不通知文件的用户)
    • -v : 显示权限变更的详细资料
    • -R : 对目前目录下的所有文件与子目录进行相同的权限变更(即以递回的方式逐个变更)--recursive可递归遍历子目录,把修改应到目录下所有文件和子目录
    • --help : 显示辅助说明、输出帮助信息。
    • --version : 显示版本
    • --reference=filename参照filename的权限来设置权限

    •  -v,--verbose无论修改是否成功,输出每个文件的信息

    作为选择,我们多数用三位八进制数字的形式来表示权限,第一位指定属主的权限,第二位指定组权限,第三位指定其他用户的权限,每位通过4(读)、2(写)、1(执行)三种数值的和来确定权限。如6(4+2)代表有读写权,7(4+2+1)有读、写和执行的权限。

    还可设置第四位,它位于三位权限序列的前面,第四位数字取值是4,2,1,代表意思如下:

    4,执行时设置用户ID,用于授权给基于文件属主的进程,而不是给创建此进程的用户。

    2,执行时设置用户组ID,用于授权给基于文件所在组的进程,而不是基于创建此进程的用户。

    1,设置粘着位。

    实例:

    $ chmod u+x file                      给file的属主增加执行权限

    $ chmod 751 file                      给file的属主分配读、写、执行(7)的权限,给file的所在组分配读、执行(5)的权限,给其他用户分配执行(1)的权限

    $ chmod u=rwx,g=rx,o=x file      上例的另一种形式

    $ chmod =r file                     为所有用户分配读权限

    $ chmod 444 file                   同上例

    $ chmod a-wx,a+r   file          同上例

    $ chmod -R u+r directory           递归地给directory目录下所有文件和子目录的属主分配读的权限

    $ chmod 4755                            设置用ID,给属主分配读、写和执行权限,给组和其他用户分配读、执行的权限。

    其中a,b,c各为一个数字,分别表示User、Group、及Other的权限。

    r=4,w=2,x=1

    • 若要rwx属性则4+2+1=7;
    • 若要rw-属性则4+2=6;
    • 若要r-x属性则4+1=5。
    chmod a=rwx file

    chmod 777 file

    效果相同

    chmod ug=rwx,o=x file

    chmod 771 file
    展开全文
  • 数据库与文件进行数据存取的区别: 其区别... (3)文件系统用操作系统中的存取方法对数据进行管理,数据库系统用DBMS统一管理和控制数据。 (4)文件系统实现以文件为单位的数据共享,数据库系统实现以记录和字段为单位的
  • 本例中需要将字典以特定分隔符/结尾符输出到文件里 repr()与str比较: 参考该博客: http://blog.csdn.net/u013961718/article/details/51100464 总之,即str是显示给人看,repr()给python看 例: for ...
  • 目录实现之文件的按名存取

    千次阅读 2016-10-19 15:06:37
    为了实现用户对文件的按名存取: -------->系统必须首先利用用户提供的文件名 ----------->对文件目录进行查询 ------------->找出该文件的文件控制块FCB --------------->(对UNIX系统即要找出该文件的索引节点,...
  • 文件访问控制机制代码+报告

    千次阅读 2018-07-20 11:05:32
    用访问控制矩阵实现对文件的存取控制 能够成功创建主体,客体,并且可添加对对象进行的操作权限,例如读R,写W,执行E;能够成功删除文件对象的某个权限以及成功删除整个文件。 系统具有人性化,如果出现删除的...
  • 一:控制器 读取TXT文件步骤:①:得到文件路径;  ②:实例化streamreader  ③:读取来自当前流所有字符;  ④:释放资源; 数据转化:⑤:转化为JArray #region 读取txt文件 var Pathtxt = Server....
  • Domino数据库存取控制列表(ACL)

    千次阅读 2011-03-02 13:51:00
    在Domino中,数据库的存取控制列表是Domino安全性的重要组成部分,也是决定每个用户能否访问数据库的主要设置。每个数据库都有自己的存取控制列表(Access Control List, 以下简称ACL)。打开一个数据库,选择菜单...
  • 用户账号一方面可以帮助系统管理员对使用系统用户进行跟踪,并控制他们对系统资源访问;另一方面也可以帮助用户组织文件,并为用户提供安全性保护。每个用户账号都拥有一个惟一用户名和各自口令。用户在...
  • Domino数据库存取控制列表(ACL)基本知识 在Domino中,数据库的存取控制列表是Domino安全性的重要组成部分,也是决定每个用户能否访问数据库的主要设置。每个数据库都有自己的存取控制列表(Access Control List, ...
  • 文件的控制取决于文件主或超级用户。 文件或目录的创建者对创建的文件或目录拥有特别使用权。 利用chown命令可以更改某个或目录的所有权。2)用户组 当系统管理员为用户建立账号之后,会分配一个组ID和一个特定...
  • 文件的控制取决于文件主或超级用户。  文件或目录的创建者对创建的文件或目录拥有特别使用权。  利用chown命令可以更改某个或目录的所有权。 2)用户组  当系统管理员为用户建立账号之后,会分配一个组ID...
  • 操作系统提高文件读取性能的原理分析(自己的理解) 操作系统读取文件简述文件概述文件控制块FCB文件的存取控制文件的存取方法 操作系统读取文件简述 假设一个文件类型为Xx,例如 name.Xx = 33333344444444441111111...
  • 指令名称 : chmod 使用权限 : 所有使用者 .../Unix 档案存取权限分为三级 : 档案拥有者、群组、其他。利用 chmod 能藉以控制档案怎么被他人所存取。 把计 : mode : 权限设定字串,格式如下 : [ugoa...][[+-...
  • Oracle控制文件

    2019-09-27 20:44:39
    一、控制文件的作用 Control File 是一个较小的二进制文件,描述数据库结构,包括: 01、数据库建立的日期; 02、数据库名; 03、数据库中所有数据文件和日志文件的文件名及路径; 04、恢复数据库时所需的同步...
  • 首先,文件名是一个字符串,操作速度慢且占空间大,而文件...其次,文件被打开后其控制信息(FCB)被缓冲到内存系统空间,文件描述符作为用户打开文件表中入口地址直接与内存FCB建立起联系,而文件名无法做到这一点。
  • Linux对每个文件设置一个16位数字来完成对文件的存取控制,这个数字称为文件属性。如同我们在前面说的那样,Linux并不使用文件名来区分文件的类型,文件的性质用文件属性来描述。在这个16位数字中有9位用于设置用户...
  • C#以二进制方式存取文件

    千次阅读 2013-07-17 13:44:01
    昨天讨论了怎么把内存对象序列化然后以二进制文件的形式储存和读取。但是,不是所有的数据都需要将整个对象写到文件里,如果我们想要写一些数据怎么办呢?这时就只需用到System.IO名称空间里的BinaryWriter和...
  • 控制文件

    2016-05-31 21:13:53
    控制文件包含:数据库名字 、数据库创建的时间戳、数据库数据文件和联机重做日志文件的名字和位置、数据库有多少表空间的名字 、联机重做日志的序列号、检查点的信息、备份机以及备份文件的信息 。   备份控制...
  • 数据库控制文件

    2011-03-20 17:08:41
    控制文件中包含了所属数据库的信息,实力启动及正常工作期间都需要存取这些信息,控制文件的内容只能由oracle修改,数据库管理员或用户都不应该编辑控制文件 控制文件中主要包含以下内容:1、数据库名2、数...
  • 前端对cookie的存取操作 cookie是浏览器提供的一种机制,它将document 对象的cookie属性提供给JavaScript。可以由JavaScript对其进行控制,而并不是JavaScript本身的性质。cookie是存于用户硬盘的一个文件,这个文件...
  • 为了防止文件共享可能会导致文件被破坏或未经核准的用户修改文件,文件系统必须控制用户对文件的存取,即解决对文件的读、写、执行的许可问题。为此,必须在文件系统中建立相应的文件保护机制。 文件保护通过口令...
  • BFILE数据的存取

    千次阅读 2011-10-12 10:12:27
    bfile字段实际的文件存储在文件系统中,字段中存储...oracle来说是只读,也不参与事务性控制和数据恢复 bfile基本操作如下: 1.先在oracle数据库中下面我们建立一个目录别名,用于将文件定位指针映射到文
  • 文件保护概念

    千次阅读 2016-10-17 14:02:02
    为了防止文件共享可能会导致文件被破坏或者未经核准的用户修改文件,文件系统必须控制用户对文件的存取,即:解决对文件的读、写、执行的许可问题。因此必须建立相应的文件保护机制:口令保护、加密保护、访问控制...
  • 嵌入式系统通用驱动程序接口及其实现-EERPOM存取位置标准化存储单元 结构保存永久性数据 每次读 写位置 要一致 才能恢复 flash 程序存储器宽间 RAM 空间 EEPROM空间 由我们决定。 编译器所决定 LED控制器...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,835
精华内容 734
关键字:

文件的存取控制