util-vserver 0.30.214
[util-vserver.git] / src / vhashify-init.hc
1 // $Id: vhashify-init.hc 1967 2005-03-23 02:10:23Z ensc $    --*- c -*--
2
3 // Copyright (C) 2005 Enrico Scholz <enrico.scholz@informatik.tu-chemnitz.de>
4 //  
5 // This program is free software; you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation; version 2 of the License.
8 //  
9 // This program is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //  
14 // You should have received a copy of the GNU General Public License
15 // along with this program; if not, write to the Free Software
16 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17
18 #include "pathconfig.h"
19 #include "lib_internal/util-dotfile.h"
20
21 #include <sys/param.h>
22
23 static UNUSED void
24 freeHashList(HashDirCollection *hash_vec)
25 {
26   for (struct HashDirInfo *itm = Vector_begin(hash_vec);
27        itm!=Vector_end(hash_vec);
28        ++itm) {
29     free(const_cast(char *)(itm->path.d));
30   }
31
32   Vector_free(hash_vec);
33 }
34
35 static size_t
36 initHashList(HashDirCollection *hash_vec, char const *hashdir)
37 {
38   int           cur_dir = Eopen(".", O_RDONLY|O_DIRECTORY, 0);
39   Echdir(hashdir);
40   
41   DIR           *d      = Eopendir(".");
42   struct dirent *ep;
43   size_t        l   = strlen(hashdir);
44   size_t        res = 0;
45
46   while ((ep=readdir(d)) != 0) {
47     struct stat         st;
48
49     if (isDotfile(ep->d_name) ||
50         stat(ep->d_name, &st)==-1 || !S_ISDIR(st.st_mode))
51       continue;
52
53     if (HashDirInfo_findDevice(hash_vec, st.st_dev)!=0) {
54       WRITE_MSG(2, "Duplicate hash-dir entry '");
55       WRITE_STR(2, ep->d_name);
56       WRITE_MSG(2, "' found\n");
57       continue;
58     }
59
60     char                *full_path = Emalloc(l + strlen(ep->d_name) + 3);
61     char                *ptr       = full_path + l;
62
63     memcpy(full_path, hashdir, l);
64     while (ptr>full_path && ptr[-1]=='/') --ptr;
65     *ptr++ = '/';
66     strcpy(ptr, ep->d_name);
67     strcat(ptr, "/");   // append a trailing '/'
68
69
70     struct HashDirInfo  tmp = {
71       .device  = st.st_dev,
72       .path    = { full_path, strlen(full_path) },
73     };
74
75     res = MAX(res, tmp.path.l);
76     
77     memcpy(Vector_pushback(hash_vec), &tmp, sizeof tmp);
78   }
79
80   if (Vector_count(hash_vec)==0) {
81     WRITE_MSG(2, "Could not find a place for the hashified files at '");
82     WRITE_STR(2, hashdir);
83     WRITE_MSG(2, "'.\n");
84     exit(wrapper_exit_code);
85   }
86
87   Eclosedir(d);
88   Efchdir(cur_dir);
89   Eclose(cur_dir);
90
91   return res;
92 }
93
94 static bool
95 initHashMethod(struct HashDirConfiguration *conf, char const *filename)
96 {
97   int           fd = open(filename, O_RDONLY);
98   if (fd==-1 && conf->method==0)
99     conf->method = hashFunctionDefault();
100
101   if (fd==-1) {
102     assert(conf->method!=0);
103     if (conf->method==0)      return false;
104     if (global_args->dry_run) return true;      // do not create the file
105     
106     fd = Eopen(filename, O_WRONLY|O_CREAT|O_EXCL|O_NOFOLLOW, 0644);
107     TEMP_FAILURE_RETRY(write(fd, conf->method->name, strlen(conf->method->name)));
108     TEMP_FAILURE_RETRY(write(fd, "\n", 1));
109   }
110   else {
111     off_t       s  = Elseek(fd, 0, SEEK_END);
112     char        buf[s + 1];
113     Elseek(fd, 0, SEEK_SET);
114
115     conf->method=0;
116
117     if (s>0 && read(fd, buf, s+1)==s) {
118       while (s>0 && (buf[s-1]=='\0' || buf[s-1]=='\n'))
119         --s;
120       buf[s] = '\0';
121
122       conf->method = hashFunctionFind(buf);
123       if (conf->method==0) {
124         WRITE_MSG(2, "Can not find hash-function '");
125         WRITE_STR(2, buf);
126         WRITE_MSG(2, "'\n");
127       }
128     }
129     else
130       WRITE_MSG(2, "Can not read configuration file for hash-method\n");
131   }
132
133   if (conf->method!=0 && conf->method->digestsize*8>HASH_MAXBITS) {
134     WRITE_MSG(2, "Wow... what an huge hash-function. I can not handle so much bits; giving up...\n");
135     conf->method=0;
136   }
137   
138   Eclose(fd);
139   return conf->method!=0;
140 }
141
142 static bool
143 initHashBlocks(struct HashDirConfiguration *conf, char const *filename)
144 {
145   int           fd = open(filename, O_RDONLY);
146
147   if (fd==-1) {
148     char                str[sizeof("all,start,middle,end,")] = { [0] = '\0' };
149
150     if (global_args->dry_run) return true;      // do not create the file
151     
152     fd = Eopen(filename, O_WRONLY|O_CREAT|O_EXCL|O_NOFOLLOW, 0644);
153
154     if (conf->blocks== hshALL)    strcat(str, "all\n");
155     if (conf->blocks & hshSTART)  strcat(str, "start\n");
156     if (conf->blocks & hshMIDDLE) strcat(str, "middle\n");
157     if (conf->blocks & hshEND)    strcat(str, "end\n");
158
159     EwriteAll(fd, str, strlen(str));
160   }
161   else {
162     off_t       s  = Elseek(fd, 0, SEEK_END);
163     char        buf[s + 1];
164     Elseek(fd, 0, SEEK_SET);
165     
166     conf->blocks = hshINVALID;
167       
168     if (s>0 && read(fd, buf, s+1)==s) {
169       char      *tok = buf;
170       char      *sep = "\n,\t ";
171
172       buf[s]       = '\0';
173       conf->blocks = hshALL;
174
175       do {
176         char    *ptr = strsep(&tok, sep);
177
178         if (*ptr=='#') { sep = "\n"; continue; }
179         sep = "\n,\t ";
180         if (*ptr=='\0') continue;
181
182         if      (strcasecmp(ptr, "all")   ==0) conf->blocks  = hshALL;
183         else {
184           if (conf->blocks==hshINVALID) conf->blocks = 0;
185           
186           else if (strcasecmp(ptr, "start") ==0) conf->blocks |= hshSTART;
187           else if (strcasecmp(ptr, "middle")==0) conf->blocks |= hshMIDDLE;
188           else if (strcasecmp(ptr, "end")   ==0) conf->blocks |= hshEND;
189           else {
190             WRITE_MSG(2, "Invalid block descriptor '");
191             WRITE_STR(2, ptr);
192             WRITE_MSG(2, "'\n");
193             conf->blocks = hshINVALID;
194             tok = 0;
195           }
196         }
197       } while (tok!=0);
198     }
199     else
200       WRITE_MSG(2, "Can not read configuration file for hash-blocks\n");
201   }
202
203   Eclose(fd);
204   return conf->blocks!=hshINVALID;
205 }
206
207 static bool
208 initHashBlockSize(struct HashDirConfiguration *conf, char const *filename)
209 {
210   if (conf->blocks==hshALL) return true;
211   
212   int           fd = open(filename, O_RDONLY);
213   if (fd==-1) {
214     char                str[sizeof("0x") + sizeof(size_t)*3+2] = {
215       [0] = '0', [1] = 'x'
216     };
217     size_t              len = utilvserver_fmt_xuint(str+2, conf->blocksize);
218
219     if (global_args->dry_run) return true;      // do not create the file
220
221     fd = Eopen(filename, O_WRONLY|O_CREAT|O_EXCL|O_NOFOLLOW, 0644);
222     EwriteAll(fd, str, len+2);
223   }
224   else {
225     off_t       s  = Elseek(fd, 0, SEEK_END);
226     char        buf[s + 1];
227     Elseek(fd, 0, SEEK_SET);
228
229     conf->blocksize = (size_t)(-1);
230
231     if (s>0 && read(fd, buf, s+1)==s) {
232       char      *errptr;
233       
234       while (s>0 && (buf[s-1]=='\0' || buf[s-1]=='\n'))
235         --s;
236       buf[s] = '\0';
237
238       conf->blocksize = strtol(buf, &errptr, 0);
239       if (errptr==buf || (*errptr!='\0' && *errptr!='\n')) {
240         WRITE_MSG(2, "Failed to parse blocksize '");
241         WRITE_STR(2, buf);
242         WRITE_MSG(2, "'\n");
243         conf->blocksize = (size_t)(-1);
244       }
245     }
246     else
247       WRITE_MSG(2, "Can not read configuration file for hash-blocksize\n");
248   }
249
250   Eclose(fd);
251   return conf->blocksize!=(size_t)(-1);
252 }
253
254 static bool
255 initHashConf(struct HashDirConfiguration *conf, char const *hashdir)
256 {
257   size_t                l = strlen(hashdir);
258   char                  tmp[l + MAX(MAX(sizeof("/method"), sizeof("/blocks")),
259                                     sizeof("/blocksize"))];
260
261   memcpy(tmp, hashdir, l);
262
263   return ((strcpy(tmp+l, "/method"),    initHashMethod   (conf, tmp)) &&
264           (strcpy(tmp+l, "/blocks"),    initHashBlocks   (conf, tmp)) &&
265           (strcpy(tmp+l, "/blocksize"), initHashBlockSize(conf, tmp)));
266 }
267
268 static char *
269 searchHashdir(char const *lhs, char const *rhs)
270 {
271   size_t        l1  = strlen(lhs);
272   size_t        l2  = rhs ? strlen(rhs) : 0;
273   char *        res = Emalloc(l1 + l2 + 1);
274   struct stat   st;
275
276   strcpy(res, lhs);
277   if (rhs) strcat(res, rhs);
278
279   if (stat(res, &st)==-1 || !S_ISDIR(st.st_mode)) {
280     free(res);
281     res = 0;
282   }
283
284   return res;
285 }
286
287 static void
288 initModeManually(struct Arguments const UNUSED *args, int argc, char *argv[])
289 {
290   assert(args->hash_dir!=0);
291   
292   if (argc<2) {
293     WRITE_MSG(2, "No exclude list specified\n");
294     exit(1);
295   }
296
297   if (!initHashConf(&global_info.hash_conf, args->hash_dir)) {
298     WRITE_MSG(2, "failed to initialize hash-configuration\n");
299     exit(1);
300   }
301   
302   global_info.hash_dirs_max_size = initHashList(&global_info.hash_dirs,
303                                                 args->hash_dir);
304   MatchList_initManually(&global_info.dst_list, 0, strdup(argv[0]), argv[1]);
305 }
306
307 static void
308 initModeVserver(struct Arguments const UNUSED *args, int argc, char *argv[])
309 {
310   char const                            *hashdir   = args->hash_dir;
311   struct MatchVserverInfo               vserver = {
312     .name        = argv[0],
313     .use_pkgmgmt = true
314   };
315
316   if (!MatchVserverInfo_init(&vserver)) {
317     WRITE_MSG(2, "Failed to initialize unification for vserver\n");
318     exit(1);
319   }
320
321   if (argc!=1) {
322     WRITE_MSG(2, "More than one vserver is not supported\n");
323     exit(1);
324   }
325
326   if (!MatchList_initByVserver(&global_info.dst_list, &vserver)) {
327     WRITE_MSG(2, "unification not configured for this vserver\n");
328     exit(1);
329   }
330
331   if (hashdir==0) hashdir = searchHashdir(vserver.appdir.d, "/hash");
332   if (hashdir==0) hashdir = searchHashdir(CONFDIR "/.defaults/apps/vunify/hash", 0);
333
334   if (hashdir==0) {
335     WRITE_MSG(2, "no hash-directory configured for this vserver.\n");
336     exit(1);
337   }
338
339   if (!initHashConf(&global_info.hash_conf, hashdir)) {
340     WRITE_MSG(2, "failed to initialize hash-configuration\n");
341     exit(1);
342   }
343   
344   global_info.hash_dirs_max_size = initHashList(&global_info.hash_dirs, hashdir);
345
346   free(const_cast(char *)(hashdir));
347   MatchVserverInfo_free(&vserver);
348 }
349