]> pd.if.org Git - zpackage/blob - src/add.c
remove -O3 from sqlite3 compile options
[zpackage] / src / add.c
1 #define _POSIX_C_SOURCE 200809L
2 #include <stdlib.h>
3 #include <stdio.h>
4 #include <string.h>
5
6 #include <sys/types.h>
7 #include <sys/stat.h>
8 #include <dirent.h>
9 #include <unistd.h>
10 #include <pwd.h>
11 #include <grp.h>
12 #include <errno.h>
13 #include <fcntl.h>
14
15 #include "zpm.h"
16 #include "sqlite/sqlite3.h"
17
18 struct opts {
19         char *package, *version;
20         int release;
21         int complete, addcontent, isconfig, opt_l, recursive, verbose;
22         int followsymlinks;
23         int xargs, noclear;
24         int striparg, init;
25         mode_t clmode;
26
27         char *cltype, *clhash, *clmtime, *prefix, *strip, *cltarget;
28         char *clgroup, *cluser;
29 };
30
31 #if 0
32 static void warn(char *fmt, ...) {
33         va_list args;
34
35         va_start(args, fmt);
36         vfprintf(stderr, fmt, args);
37         va_end(args);
38         fprintf(stderr, "\n");
39 }
40 #endif
41
42 static int dieval = EXIT_FAILURE;
43
44 static void die(char *fmt, ...) {
45         va_list args;
46
47         va_start(args, fmt);
48         vfprintf(stderr, fmt, args);
49         va_end(args);
50         fprintf(stderr, "\n");
51         exit(dieval);
52 }
53
54 char *cleanpath(char *path, char *strip, char *prefix) {
55         char *s = path;
56         char *t = s;
57         size_t len = 0;
58         char *new;
59
60         if (strip) {
61                 len = strlen(strip);
62                 if (strncmp(path, strip, len)) {
63                         /* strip is not a prefix */
64                         return 0;
65                 }
66                 s += len;
67         }
68
69         len += strlen(s)+1;
70
71         new = malloc(len);
72         if (!new) {
73                 return NULL;
74         }
75         memset(new, 0, len);
76
77         t = new;
78
79         if (*s == 0) {
80                 /* path is only stripped */
81                 return new;
82         }
83
84         if (prefix) {
85                 strcpy(new, prefix);
86                 t = new + strlen(prefix);
87         }
88
89         /* skip leading curdir */
90         if (*s && *s == '.' && s[1] && s[1] == '/') {
91                 s += 2;
92         }
93
94         /* skip leading slashes */
95         while (*s == '/') {
96                 s++;
97         }
98
99         if (*t != '/') {
100                 *t++ = '/';
101         }
102
103         for (; *s; s++) {
104                 /* skip multiple slashes */
105                 if (*s == '/' && s[1] && s[1] == '/') {
106                         continue;
107                 }
108                 /* skip trailing slash */
109                 if (*s == '/' && !s[1]) {
110                         continue;
111                 }
112
113                 /* skip curdirs */
114                 if (*s == '/' && s[1] && s[1] == '.' && s[2] && s[2] == '/') {
115                         s += 1;
116                         continue;
117                 }
118
119                 if (*s == '/' && s[1] && s[1] == '.' && s[2] == 0) {
120                         s += 1;
121                         continue;
122                 }
123
124                 *t++ = *s;
125         }
126         *t = 0;
127
128         return new;
129 }
130
131 char *getuser(uid_t uid) {
132         struct passwd *pw;
133
134         pw = getpwuid(uid);
135         if (pw) {
136                 return strdup(pw->pw_name);
137         }
138         return 0;
139 }
140
141 char *getgroup(uid_t uid) {
142         struct passwd *pw;
143
144         pw = getpwuid(uid);
145         if (pw) {
146                 return strdup(pw->pw_name);
147         }
148         return 0;
149 }
150
151 void free_file(struct zpm_file *file) {
152         free(file->path);
153         free(file->owner);
154         free(file->group);
155         free(file->target);
156         file->path = file->owner = file->group = file->target = 0;
157 }
158
159 int stat_file(struct zpm_file *file, char *path, struct opts *opt) {
160                 struct stat st;
161                 int rv;
162
163                 file->data = path;
164
165                 errno = 0;
166                 if (opt->followsymlinks) {
167                         rv = stat(path, &st);
168                 } else {
169                         rv = lstat(path, &st);
170                 }
171
172                 if (rv == -1) {
173                         return 0;
174                 }
175
176                 switch (st.st_mode & S_IFMT) {
177                         case S_IFBLK: file->type = 'b'; break;
178                         case S_IFCHR: file->type = 'c'; break;
179                         case S_IFDIR: file->type = 'd'; break;
180                         case S_IFIFO: file->type = 'p'; break;
181                         case S_IFLNK: file->type = 'l'; break;
182                         case S_IFREG: file->type = 'r'; break;
183                         case S_IFSOCK: file->type = 's'; break;
184                         default: file->type = 0; break;
185                 }
186
187                 file->configuration = opt->isconfig;
188
189                 if (file->type == 0) {
190                         return 0;
191                 }
192
193                 if (file->type == 'l') {
194                         if (opt->cltarget) {
195                                 file->target = strdup(opt->cltarget);
196                         } else {
197                                 char linkval[4096];
198                                 size_t n;
199                                 n = readlink(path, linkval, sizeof linkval);
200                                 if (n >= sizeof linkval) {
201                                         return 0;
202                                 }
203                                 linkval[n] = 0;
204                                 file->target = strdup(linkval);
205                         }
206                 }
207                 
208                 /* strip and prefix */
209                 file->path = cleanpath(path, opt->strip, opt->prefix);
210                 if (file->path == 0) {
211                         free_file(file);
212                         return 0;
213                 }
214
215                 if (opt->clmode) {
216                         file->mode = opt->clmode & 07777;
217                 } else {
218                         file->mode = st.st_mode & 07777;
219                 }
220
221                 if (opt->cluser) {
222                         file->owner = strdup(opt->cluser);
223                 } else {
224                         file->owner = getuser(st.st_uid);
225                 }
226
227                 if (file->owner == 0) {
228                         free_file(file);
229                         return 0;
230                 }
231
232                 if (opt->clgroup) {
233                         file->group = strdup(opt->clgroup);
234                 } else {
235                         file->group = getgroup(st.st_gid);
236                 }
237                 if (file->group == 0) {
238                         free_file(file);
239                         return 0;
240                 }
241
242                 file->mtime = st.st_mtime;
243
244                 return 1;
245 }
246
247 int add_file(struct zpm *zpm, struct zpm_file *file, struct opts *opt);
248
249 char *pathcat(char *dir, char *path) {
250         size_t dirlen = 0, pathlen = 0;
251         char *cat;
252
253         /* chop off trailing / on dir */
254         if (dir) {
255                 dirlen = strlen(dir);
256                 while (dirlen && dir[dirlen-1] == '/') {
257                         dirlen--;
258                 }
259         }
260
261         if (path) {
262                 pathlen = strlen(path);
263                 while (*path && *path == '/') {
264                         path++;
265                         pathlen--;
266                 }
267         }
268
269         cat = malloc(dirlen + pathlen + 2);
270         if (cat) {
271                 strncpy(cat, dir, dirlen);
272                 cat[dirlen] = '/';
273                 strcpy(cat+dirlen+1, path);
274         }
275         return cat;
276 }
277
278 int add_dir(struct zpm *zpm, char *path, struct opts *opt) {
279         DIR *dir;
280         struct dirent *de;
281         struct zpm_file file = { 0 };
282         int fail = 0;
283
284         char *dpath = 0;
285
286         dir = opendir(path);
287
288         if (!dir) {
289                 zpm_seterror(zpm, "can't open dir %s: %s", path, strerror(errno));
290                 return 0;
291         }
292
293         while ((de = readdir(dir))) {
294                 if (!strcmp(de->d_name, ".")) {
295                         continue;
296                 }
297                 if (!strcmp(de->d_name, "..")) {
298                         continue;
299                 }
300
301                 dpath = pathcat(path, de->d_name);
302                 if (!dpath) {
303                         zpm_seterror(zpm, "pathcat failed");
304                         fail = 1;
305                         break;
306                 }
307                 
308                 if (!stat_file(&file, dpath, opt)) {
309                         zpm_seterror(zpm, "stat %s failed: %s",
310                                         dpath, strerror(errno));
311                         fail = 1;
312                         break;
313                 }
314
315                 if (!add_file(zpm, &file, opt)) {
316                         free_file(&file);
317                         fail = 1;
318                         break;
319                 }
320                 free_file(&file);
321                 free(dpath);
322         }
323         closedir(dir);
324         return fail ? 0 : 1;
325 }
326
327 int add_file(struct zpm *zpm, struct zpm_file *file, struct opts *opt) {
328         char hash[ZPM_HASH_STRLEN+1];
329
330         if (file->path[0] != 0) {
331                 if (file->type == 'r') {
332                         if (opt->addcontent) {
333                                 if (zpm_import(zpm, file->data, 0, hash)) {
334                                         strcpy(file->hash, hash);
335                                 } else {
336                                         return 0;
337                                 }
338                         } else {
339                                 zpm_hash(file->data, hash, 0);
340                                 strcpy(file->hash, hash);
341                         }
342                 }
343
344                 zpm_db_run(zpm, "insert or replace into packagefiles "
345                                 "(package,version,release,path,mode,mtime,username,"
346                                 "groupname,filetype,hash,configuration,target)"
347                                 " values "
348                                 "(%Q, %Q, %d, %Q, %o, %d, %Q, %Q, '%c', %Q, %d, %Q)",
349                                 opt->package, opt->version, opt->release, file->path,
350                                 file->mode, (int)file->mtime, file->owner, file->group,
351                                 file->type,
352                                 file->type == 'r' ? file->hash : NULL,
353                                 file->configuration,
354                                 file->type == 'l' ? file->target : NULL
355                           );
356
357                 if (zpm->error) {
358                         return 0;
359                 }
360
361                 if (opt->verbose > 1) {
362                         printf("%c%o %s:%s %s\n", file->type, file->mode, file->owner, file->group, file->path);
363                 } else if (opt->verbose > 0) {
364
365                         printf("%s\n", file->path);
366                         fflush(stdout);
367                 }
368         }
369
370         if (opt->recursive && file->type == 'd') {
371                 if (!add_dir(zpm, file->data, opt)) {
372                         return 0;
373                 }
374         }
375
376         return 1;
377 }
378
379 int main(int ac, char **av) {
380         struct zpm zpm;
381         struct opts opt = { 0 };
382         int i;
383         int option;
384         char *pkgstr = 0, *pkgid = 0;
385
386         char package[128];
387         char version[64];
388         int release;
389
390         char hash[ZPM_HASH_STRLEN+1];
391
392         char *dbfile = getenv("ZPMDB");
393
394         if (!dbfile) {
395                 dbfile = "/var/lib/zpm/local.db";
396         }
397
398         opt.addcontent = 1;
399
400         while ((option = getopt(ac, av, "iCF:H:M:NP:S:T:cf:g:hlm:ru:vxzp:")) != -1) {
401                 switch (option) {
402                         case 'f': dbfile = optarg; break;
403                         case 'i': opt.init = 1; break;
404                         case 'C': opt.complete = 1; break;
405                         case 'F': opt.cltype = optarg; break;
406                         case 'H': opt.clhash = optarg; break;
407                         case 'M': opt.clmtime = optarg; break;
408                         case 'N': opt.addcontent = 0; break;
409                         case 'P': opt.prefix = optarg; break;
410                         case 'S': opt.strip = optarg; break;
411                         case 's': opt.striparg = 1; break;
412                         case 'T': opt.cltarget = optarg; break;
413                         case 'c': opt.isconfig = 1; break;
414                         case 'g': opt.clgroup = optarg; break;
415                         case 'h': opt.followsymlinks = 1; break;
416                         case 'l': opt.opt_l = 1; break;
417                         case 'm': opt.clmode = strtol(optarg, NULL, 8); break;
418                         case 'r': opt.recursive = 1; break;
419                         case 'u': opt.cluser = optarg; break;
420                         case 'v': opt.verbose++; break;
421                         case 'x': opt.xargs = 1; dieval = 255; break;
422                         case 'z': opt.noclear = 1; break;
423                         case 'p': pkgstr = optarg; break;
424                         default:
425                                   exit(EXIT_FAILURE);
426                                   break;
427                 }
428         }
429
430         if (ac < optind) {
431                 exit(EXIT_FAILURE);
432         }
433
434         if (opt.init) {
435                 if (!zpm_init(&zpm, dbfile)) {
436                         die("can't open zpm db %s", dbfile);
437                 }
438                 if (opt.verbose) {
439                         fprintf(stderr, "inited %s\n", dbfile);
440                 }
441         } else {
442                 if (!zpm_open(&zpm, dbfile)) {
443                         die("can't open zpm db %s", dbfile);
444                 }
445         }
446
447
448 #if 0
449         i = sqlite3_config(SQLITE_CONFIG_MMAP_SIZE,98222080);
450         if (i != SQLITE_OK) {
451                 exit(3);
452         }
453 #endif
454
455         if (!pkgstr) {
456                 pkgstr = dbfile;
457         }
458         pkgid = zpm_findpkg(&zpm, pkgstr, NULL);
459         if (!pkgid) {
460                 int rv;
461                 if (opt.init) {
462                         rv = zpm_parse_package(pkgstr, package, version, &release);
463                         if (rv != 3) {
464                                 die("incomplete package string '%s'\n", pkgstr);
465                         } else {
466                                 rv = zpm_create_package(&zpm, package, version, release);
467                                 pkgid = zpm_findpkg(&zpm, pkgstr, NULL);
468                                 if (!rv) {
469                                         die("unable to create package %s\n", pkgstr);
470                                 }
471                         }
472                 } else {
473                         die("package %s not found\n", pkgstr);
474                 }
475         }
476
477         zpm_parse_package(pkgid, package, version, &release);
478         opt.package = package;
479         opt.version = version;
480         opt.release = release;
481
482         if (opt.verbose) {
483                 printf("adding to %s %s\n", dbfile, pkgid);
484         }
485         fflush(stdout);
486
487         //zpm_begin(&zpm);
488
489         struct zpm_file file;
490         for (i=optind; av[i]; i++) {
491                 if (!stat_file(&file, av[i], &opt)) {
492                         die("can't stat %s: %s", av[i], strerror(errno));
493                 }
494                 file.data = av[i];
495                 if (opt.striparg) {
496                         opt.strip = av[i];
497                 }
498
499                 if (add_file(&zpm, &file, &opt)) {
500                         free_file(&file);
501                 } else {
502                         die("error: %s", zpm.errmsg);
503                 }
504         }
505
506         if (opt.complete) {
507                 zpm_db_run(&zpm, "update packages set build_time = %d where package = %Q and version = %Q and release = %d", time(NULL), package, version, release);
508                 zpm_package_hash(&zpm, pkgid, hash);
509                 zpm_package_sethash(&zpm, pkgid, hash);
510         } else if (!opt.noclear) {
511                 zpm_db_run(&zpm, "update packages set build_time = null, hash = null where package = %Q and version = %Q and release = %d", package, version, release);
512         }
513         /* TODO error check */
514
515         //zpm_commit(&zpm);
516         zpm_close(&zpm);
517         return 0;
518 }