Use 0-length MSG_DATA when MSG_NOOP is not available
[rsync.git] / chmod.c
1 /*
2  * Implement the core of the --chmod option.
3  *
4  * Copyright (C) 2002 Scott Howard
5  * Copyright (C) 2005-2009 Wayne Davison
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License along
18  * with this program; if not, visit the http://fsf.org website.
19  */
20
21 #include "rsync.h"
22
23 extern mode_t orig_umask;
24
25 #define FLAG_X_KEEP (1<<0)
26 #define FLAG_DIRS_ONLY (1<<1)
27 #define FLAG_FILES_ONLY (1<<2)
28
29 struct chmod_mode_struct {
30         struct chmod_mode_struct *next;
31         int ModeAND, ModeOR;
32         char flags;
33 };
34
35 #define CHMOD_ADD 1
36 #define CHMOD_SUB 2
37 #define CHMOD_EQ  3
38
39 #define STATE_ERROR 0
40 #define STATE_1ST_HALF 1
41 #define STATE_2ND_HALF 2
42
43 /* Parse a chmod-style argument, and break it down into one or more AND/OR
44  * pairs in a linked list.  We return a pointer to new items on succcess
45  * (appending the items to the specified list), or NULL on error. */
46 struct chmod_mode_struct *parse_chmod(const char *modestr,
47                                       struct chmod_mode_struct **root_mode_ptr)
48 {
49         int state = STATE_1ST_HALF;
50         int where = 0, what = 0, op = 0, topbits = 0, topoct = 0, flags = 0;
51         struct chmod_mode_struct *first_mode = NULL, *curr_mode = NULL,
52                                  *prev_mode = NULL;
53
54         while (state != STATE_ERROR) {
55                 if (!*modestr || *modestr == ',') {
56                         int bits;
57
58                         if (!op) {
59                                 state = STATE_ERROR;
60                                 break;
61                         }
62                         prev_mode = curr_mode;
63                         curr_mode = new_array(struct chmod_mode_struct, 1);
64                         if (prev_mode)
65                                 prev_mode->next = curr_mode;
66                         else
67                                 first_mode = curr_mode;
68                         curr_mode->next = NULL;
69
70                         if (where)
71                                 bits = where * what;
72                         else {
73                                 where = 0111;
74                                 bits = (where * what) & ~orig_umask;
75                         }
76
77                         switch (op) {
78                         case CHMOD_ADD:
79                                 curr_mode->ModeAND = CHMOD_BITS;
80                                 curr_mode->ModeOR  = bits + topoct;
81                                 break;
82                         case CHMOD_SUB:
83                                 curr_mode->ModeAND = CHMOD_BITS - bits - topoct;
84                                 curr_mode->ModeOR  = 0;
85                                 break;
86                         case CHMOD_EQ:
87                                 curr_mode->ModeAND = CHMOD_BITS - (where * 7) - (topoct ? topbits : 0);
88                                 curr_mode->ModeOR  = bits + topoct;
89                                 break;
90                         }
91
92                         curr_mode->flags = flags;
93
94                         if (!*modestr)
95                                 break;
96                         modestr++;
97
98                         state = STATE_1ST_HALF;
99                         where = what = op = topoct = topbits = flags = 0;
100                 }
101
102                 if (state != STATE_2ND_HALF) {
103                         switch (*modestr) {
104                         case 'D':
105                                 if (flags & FLAG_FILES_ONLY)
106                                         state = STATE_ERROR;
107                                 flags |= FLAG_DIRS_ONLY;
108                                 break;
109                         case 'F':
110                                 if (flags & FLAG_DIRS_ONLY)
111                                         state = STATE_ERROR;
112                                 flags |= FLAG_FILES_ONLY;
113                                 break;
114                         case 'u':
115                                 where |= 0100;
116                                 topbits |= 04000;
117                                 break;
118                         case 'g':
119                                 where |= 0010;
120                                 topbits |= 02000;
121                                 break;
122                         case 'o':
123                                 where |= 0001;
124                                 break;
125                         case 'a':
126                                 where |= 0111;
127                                 break;
128                         case '+':
129                                 op = CHMOD_ADD;
130                                 state = STATE_2ND_HALF;
131                                 break;
132                         case '-':
133                                 op = CHMOD_SUB;
134                                 state = STATE_2ND_HALF;
135                                 break;
136                         case '=':
137                                 op = CHMOD_EQ;
138                                 state = STATE_2ND_HALF;
139                                 break;
140                         default:
141                                 state = STATE_ERROR;
142                                 break;
143                         }
144                 } else {
145                         switch (*modestr) {
146                         case 'r':
147                                 what |= 4;
148                                 break;
149                         case 'w':
150                                 what |= 2;
151                                 break;
152                         case 'X':
153                                 flags |= FLAG_X_KEEP;
154                                 /* FALL THROUGH */
155                         case 'x':
156                                 what |= 1;
157                                 break;
158                         case 's':
159                                 if (topbits)
160                                         topoct |= topbits;
161                                 else
162                                         topoct = 04000;
163                                 break;
164                         case 't':
165                                 topoct |= 01000;
166                                 break;
167                         default:
168                                 state = STATE_ERROR;
169                                 break;
170                         }
171                 }
172                 modestr++;
173         }
174
175         if (state == STATE_ERROR) {
176                 free_chmod_mode(first_mode);
177                 return NULL;
178         }
179
180         if (!(curr_mode = *root_mode_ptr))
181                 *root_mode_ptr = first_mode;
182         else {
183                 while (curr_mode->next)
184                         curr_mode = curr_mode->next;
185                 curr_mode->next = first_mode;
186         }
187
188         return first_mode;
189 }
190
191
192 /* Takes an existing file permission and a list of AND/OR changes, and
193  * create a new permissions. */
194 int tweak_mode(int mode, struct chmod_mode_struct *chmod_modes)
195 {
196         int IsX = mode & 0111;
197         int NonPerm = mode & ~CHMOD_BITS;
198
199         for ( ; chmod_modes; chmod_modes = chmod_modes->next) {
200                 if ((chmod_modes->flags & FLAG_DIRS_ONLY) && !S_ISDIR(NonPerm))
201                         continue;
202                 if ((chmod_modes->flags & FLAG_FILES_ONLY) && S_ISDIR(NonPerm))
203                         continue;
204                 mode &= chmod_modes->ModeAND;
205                 if ((chmod_modes->flags & FLAG_X_KEEP) && !IsX && !S_ISDIR(NonPerm))
206                         mode |= chmod_modes->ModeOR & ~0111;
207                 else
208                         mode |= chmod_modes->ModeOR;
209         }
210
211         return mode | NonPerm;
212 }
213
214 /* Free the linked list created by parse_chmod. */
215 int free_chmod_mode(struct chmod_mode_struct *chmod_modes)
216 {
217         struct chmod_mode_struct *next;
218
219         while (chmod_modes) {
220                 next = chmod_modes->next;
221                 free(chmod_modes);
222                 chmod_modes = next;
223         }
224         return 0;
225 }