File: README

package info (click to toggle)
libfile-chmod-perl 0.42-1
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, sid, stretch
  • size: 228 kB
  • ctags: 29
  • sloc: perl: 476; makefile: 2
file content (208 lines) | stat: -rw-r--r-- 6,776 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
NAME

    File::chmod - Implements symbolic and ls chmod modes

VERSION

    version 0.42

SYNOPSIS

      use File::chmod;
      $File::chmod::UMASK = 0;
      # It is recommended that you explicitly set $File::chmod::UMASK
      # as the default will change in the future
      #
      # 0 is recommended to behave like system chmod
      # 1 if you want File::chmod to apply your environment set umask.
      # 2 is how we detect that it's internally set, undef will become the
      # default in the future, eventually a lexicaly scoped API may be designed
    
      # chmod takes all three types
      # these all do the same thing
      chmod(0666,@files);
      chmod("=rw",@files);
      chmod("-rw-rw-rw-",@files);
    
      # or
    
      use File::chmod qw( symchmod lschmod );
    
      chmod(0666,@files);           # this is the normal chmod
      symchmod("=rw",@files);       # takes symbolic modes only
      lschmod("-rw-rw-rw-",@files); # takes "ls" modes only
    
      # more functions, read on to understand

DESCRIPTION

    File::chmod is a utility that allows you to bypass system calls or bit
    processing of a file's permissions. It overloads the chmod() function
    with its own that gets an octal mode, a symbolic mode (see below), or
    an "ls" mode (see below). If you wish not to overload chmod(), you can
    export symchmod() and lschmod(), which take, respectively, a symbolic
    mode and an "ls" mode.

    An added feature to version 0.30 is the $UMASK variable, explained in
    detail below; if symchmod() is called and this variable is true, then
    the function uses the (also new) $MASK variable (which defaults to
    umask()) as a mask against the new mode. This mode is on by default,
    and changes the behavior from what you would expect if you are used to
    UNIX chmod. This may change in the future.

    Symbolic modes are thoroughly described in your chmod(1) man page, but
    here are a few examples.

      chmod("+x","file1","file2");  # overloaded chmod(), that is...
      # turns on the execute bit for all users on those two files
    
      chmod("o=,g-w","file1","file2");
      # removes 'other' permissions, and the write bit for 'group'
    
      chmod("=u","file1","file2");
      # sets all bits to those in 'user'

    "ls" modes are the type produced on the left-hand side of an ls -l on a
    directory. Examples are:

      chmod("-rwxr-xr-x","file1","file2");
      # the 0755 setting; user has read-write-execute, group and others
      # have read-execute priveleges
    
      chmod("-rwsrws---","file1","file2");
      # sets read-write-execute for user and group, none for others
      # also sets set-uid and set-gid bits

    The regular chmod() and lschmod() are absolute; that is, they are not
    appending to or subtracting from the current file mode. They set it,
    regardless of what it had been before. symchmod() is useful for
    allowing the modifying of a file's permissions without having to run a
    system call or determining the file's permissions, and then combining
    that with whatever bits are appropriate. It also operates separately on
    each file.

FUNCTIONS - EXPORT

 chmod(MODE,FILES)

    Takes an octal, symbolic, or "ls" mode, and then chmods each file
    appropriately.

 getchmod(MODE,FILES)

    Returns a list of modified permissions, without chmodding files.
    Accepts any of the three kinds of modes.

      @newmodes = getchmod("+x","file1","file2");
      # @newmodes holds the octal permissions of the files'
      # modes, if they were to be sent through chmod("+x"...)

FUNCTIONS - EXPORT_OK

 symchmod(MODE,FILES)

    Takes a symbolic permissions mode, and chmods each file.

 lschmod(MODE,FILES)

    Takes an "ls" permissions mode, and chmods each file.

 getsymchmod(MODE,FILES)

    Returns a list of modified permissions, without chmodding files.
    Accepts only symbolic permission modes.

 getlschmod(MODE,FILES)

    Returns a list of modified permissions, without chmodding files.
    Accepts only "ls" permission modes.

 getmod(FILES)

    Returns a list of the current mode of each file.

VARIABLES

 $File::chmod::DEBUG

    If set to a true value, it will report warnings, similar to those
    produced by chmod() on your system. Otherwise, the functions will not
    report errors. Example: a file can not have file-locking and the
    set-gid bits on at the same time. If $File::chmod::DEBUG is true, the
    function will report an error. If not, you are not warned of the
    conflict. It is set to 1 as default.

 $File::chmod::MASK

    Contains the umask to apply to new file modes when using getsymchmod().
    This defaults to the return value of umask() at compile time. Is only
    applied if $UMASK is true.

 $File::chmod::UMASK

    This is a boolean which tells getsymchmod() whether or not to apply the
    umask found in $MASK. It defaults to true.

PORTING

    This is only good on Unix-like boxes. I would like people to help me
    work on File::chmod for any OS that deserves it. If you would like to
    help, please email me (address below) with the OS and any information
    you might have on how chmod() should work on it; if you don't have any
    specific information, but would still like to help, hey, that's good
    too. I have the following information (from "perlport"):

    Win32

      Only good for changing "owner" read-write access, "group", and
      "other" bits are meaningless. NOTE: Win32::File and
      Win32::FileSecurity already do this. I do not currently see a need to
      port File::chmod.

    MacOS

      Only limited meaning. Disabling/enabling write permission is mapped
      to locking/unlocking the file.

    RISC OS

      Only good for changing "owner" and "other" read-write access.

SEE ALSO

      Stat::lsMode (by Mark-James Dominus, CPAN ID: MJD)
      chmod(1) manpage
      perldoc -f chmod
      perldoc -f stat

BUGS

    Please report any bugs or feature requests on the bugtracker website
    https://github.com/xenoterracide/file-chmod/issues

    When submitting a bug or request, please include a test-file or a patch
    to an existing test-file that illustrates the bug or desired feature.

CONTRIBUTORS

      * David Steinbrunner <dsteinbrunner@pobox.com>

      * Slaven Rezic <slaven@rezic.de>

      * Steve Throckmorton <arrestee@gmail.com>

      * Tim <oylenshpeegul@gmail.com>

AUTHORS

      * Jeff Pinyan <japhy.734+CPAN@gmail.com>

      * Caleb Cushing <xenoterracide@gmail.com>

COPYRIGHT AND LICENSE

    This software is copyright (c) 2015 by Caleb Cushing and Jeff Pinyan.

    This is free software; you can redistribute it and/or modify it under
    the same terms as the Perl 5 programming language system itself.