xorriso  1.5.4.pl02
About: GNU xorriso creates, loads, manipulates and writes ISO 9660 filesystem images with Rock Ridge extensions. It is suitable for incremental data backup and for production of bootable ISO 9660 images. GNU xorriso is a statical compilation of the libraries libburn, libisofs, libisoburn, and libjte.
  Fossies Dox: xorriso-1.5.4.pl02.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

fs_local.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2007 Vreixo Formoso
3  * Copyright (c) 2009 - 2017 Thomas Schmitt
4  *
5  * This file is part of the libisofs project; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License version 2
7  * or later as published by the Free Software Foundation.
8  * See COPYING file for details.
9  */
10 
11 /*
12  * Filesystem/FileSource implementation to access the local filesystem.
13  */
14 
15 #ifdef HAVE_CONFIG_H
16 #include "../config.h"
17 #endif
18 
19 #include "fsource.h"
20 #include "util.h"
21 #include "aaip_0_2.h"
22 
23 #include <stdlib.h>
24 #include <sys/types.h>
25 #include <sys/stat.h>
26 #include <fcntl.h>
27 #include <errno.h>
28 #include <dirent.h>
29 #include <unistd.h>
30 #include <libgen.h>
31 #include <string.h>
32 
33 /* O_BINARY is needed for Cygwin but undefined elsewhere */
34 #ifndef O_BINARY
35 #define O_BINARY 0
36 #endif
37 
38 static
39 int iso_file_source_new_lfs(IsoFileSource *parent, const char *name,
40  IsoFileSource **src);
41 
42 /*
43  * We can share a local filesystem object, as it has no private atts.
44  */
46 
47 /* IMPORTANT: Any change must be reflected by lfs_clone_src() */
48 typedef struct
49 {
50  /** reference to the parent (if root it points to itself) */
52  char *name;
53  unsigned int openned :2; /* 0: not opened, 1: file, 2:dir */
54  union
55  {
56  int fd;
57  DIR *dir;
58  } info;
60 
61 static
63 {
64  _LocalFsFileSource *data;
65  data = src->data;
66 
67  if (data->parent == src) {
68  return strdup("/");
69  } else {
70  char *path, *new_path;
71  int pathlen;
72 
73  path = lfs_get_path(data->parent);
74  if (path == NULL)
75  return NULL;
76  pathlen = strlen(path);
77  new_path = realloc(path, pathlen + strlen(data->name) + 2);
78  if (new_path == NULL) {
79  free(path);
80  return NULL;
81  }
82  path= new_path;
83  if (pathlen != 1) {
84  /* pathlen can only be 1 for root */
85  path[pathlen] = '/';
86  path[pathlen + 1] = '\0';
87  }
88  return strcat(path, data->name);
89  }
90 }
91 
92 static
94 {
95  _LocalFsFileSource *data;
96  data = src->data;
97  return strdup(data->name);
98 }
99 
100 static
101 int lfs_lstat(IsoFileSource *src, struct stat *info)
102 {
103  char *path;
104 
105  if (src == NULL || info == NULL) {
106  return ISO_NULL_POINTER;
107  }
108  path = lfs_get_path(src);
109  if (path == NULL)
110  return ISO_OUT_OF_MEM;
111 
112  if (lstat(path, info) != 0) {
113  int err;
114 
115  /* error, choose an appropriate return code */
116  switch (errno) {
117  case EACCES:
119  break;
120  case ENOTDIR:
121  case ENAMETOOLONG:
122  case ELOOP:
123  err = ISO_FILE_BAD_PATH;
124  break;
125  case ENOENT:
126  err = ISO_FILE_DOESNT_EXIST;
127  break;
128  case EFAULT:
129  case ENOMEM:
130  err = ISO_OUT_OF_MEM;
131  break;
132  default:
133  err = ISO_FILE_ERROR;
134  break;
135  }
136  free(path);
137  return err;
138  }
139  free(path);
140  return ISO_SUCCESS;
141 }
142 
143 static
144 int lfs_stat(IsoFileSource *src, struct stat *info)
145 {
146  char *path;
147 
148  if (src == NULL || info == NULL) {
149  return ISO_NULL_POINTER;
150  }
151  path = lfs_get_path(src);
152  if (path == NULL)
153  return ISO_OUT_OF_MEM;
154 
155  if (stat(path, info) != 0) {
156  int err;
157 
158  /* error, choose an appropriate return code */
159  switch (errno) {
160  case EACCES:
162  break;
163  case ENOTDIR:
164  case ENAMETOOLONG:
165  case ELOOP:
166  err = ISO_FILE_BAD_PATH;
167  break;
168  case ENOENT:
169  err = ISO_FILE_DOESNT_EXIST;
170  break;
171  case EFAULT:
172  case ENOMEM:
173  err = ISO_OUT_OF_MEM;
174  break;
175  default:
176  err = ISO_FILE_ERROR;
177  break;
178  }
179  free(path);
180  return err;
181  }
182  free(path);
183  return ISO_SUCCESS;
184 }
185 
186 static
188 {
189  int ret;
190  char *path;
191 
192  if (src == NULL) {
193  return ISO_NULL_POINTER;
194  }
195  path = lfs_get_path(src);
196 
197  ret = iso_eaccess(path);
198  free(path);
199  return ret;
200 }
201 
202 static
204 {
205  int err;
206  struct stat info;
207  _LocalFsFileSource *data;
208  char *path;
209 
210  if (src == NULL) {
211  return ISO_NULL_POINTER;
212  }
213 
214  data = src->data;
215  if (data->openned) {
217  }
218 
219  /* is a file or a dir ? */
220  err = lfs_stat(src, &info);
221  if (err < 0) {
222  return err;
223  }
224 
225  path = lfs_get_path(src);
226  if (S_ISDIR(info.st_mode)) {
227  data->info.dir = opendir(path);
228  data->openned = data->info.dir ? 2 : 0;
229  } else {
230  data->info.fd = open(path, O_RDONLY | O_BINARY);
231  data->openned = data->info.fd != -1 ? 1 : 0;
232  }
233  free(path);
234 
235  /*
236  * check for possible errors, note that many of possible ones are
237  * parsed in the lstat call above
238  */
239  if (data->openned == 0) {
240  switch (errno) {
241  case EACCES:
243  break;
244  case EFAULT:
245  case ENOMEM:
246  err = ISO_OUT_OF_MEM;
247  break;
248  default:
249  err = ISO_FILE_ERROR;
250  break;
251  }
252  return err;
253  }
254 
255  return ISO_SUCCESS;
256 }
257 
258 static
260 {
261  int ret;
262  _LocalFsFileSource *data;
263 
264  if (src == NULL) {
265  return ISO_NULL_POINTER;
266  }
267 
268  data = src->data;
269  switch (data->openned) {
270  case 1: /* not dir */
271  ret = close(data->info.fd) == 0 ? ISO_SUCCESS : ISO_FILE_ERROR;
272  break;
273  case 2: /* directory */
274  ret = closedir(data->info.dir) == 0 ? ISO_SUCCESS : ISO_FILE_ERROR;
275  break;
276  default:
277  ret = ISO_FILE_NOT_OPENED;
278  break;
279  }
280  if (ret == ISO_SUCCESS) {
281  data->openned = 0;
282  }
283  return ret;
284 }
285 
286 static
287 int lfs_read(IsoFileSource *src, void *buf, size_t count)
288 {
289  _LocalFsFileSource *data;
290  size_t to_read, done = 0;
291  int ret;
292  uint8_t *buf8;
293 
294  if (src == NULL || buf == NULL) {
295  return ISO_NULL_POINTER;
296  }
297  if (count == 0) {
298  return ISO_WRONG_ARG_VALUE;
299  }
300 
301  data = src->data;
302  switch (data->openned) {
303  case 1: /* not dir */
304  buf8 = (uint8_t *) buf; /* for pointer arithmetic */
305  for (to_read = count; to_read > 0; to_read = count - done) {
306  if (to_read > 1024 * 1024)
307  to_read = 1024 * 1024;
308  ret = read(data->info.fd, buf8 + done, to_read);
309  if (ret < 0) {
310  /* error on read */
311  switch (errno) {
312  case EINTR:
313  return ISO_INTERRUPTED;
314  case EFAULT:
315  return ISO_OUT_OF_MEM;
316  case EIO:
317  return ISO_FILE_READ_ERROR;
318  }
319  return ISO_FILE_ERROR;
320  }
321  if (ret == 0) /* EOF */
322  break;
323  done += ret;
324  }
325  return done;
326  case 2: /* directory */
327  return ISO_FILE_IS_DIR;
328  default:
329  return ISO_FILE_NOT_OPENED;
330  }
331 }
332 
333 static
334 off_t lfs_lseek(IsoFileSource *src, off_t offset, int flag)
335 {
336  _LocalFsFileSource *data;
337  int whence;
338 
339  if (src == NULL) {
340  return (off_t)ISO_NULL_POINTER;
341  }
342  switch (flag) {
343  case 0:
344  whence = SEEK_SET; break;
345  case 1:
346  whence = SEEK_CUR; break;
347  case 2:
348  whence = SEEK_END; break;
349  default:
350  return (off_t)ISO_WRONG_ARG_VALUE;
351  }
352 
353  data = src->data;
354  switch (data->openned) {
355  case 1: /* not dir */
356  {
357  off_t ret;
358  ret = lseek(data->info.fd, offset, whence);
359  if (ret < 0) {
360  /* error on read */
361  switch (errno) {
362  case ESPIPE:
363  ret = (off_t)ISO_FILE_ERROR;
364  break;
365  default:
366  ret = (off_t)ISO_ERROR;
367  break;
368  }
369  }
370  return ret;
371  }
372  case 2: /* directory */
373  return (off_t)ISO_FILE_IS_DIR;
374  default:
375  return (off_t)ISO_FILE_NOT_OPENED;
376  }
377 }
378 
379 static
381 {
382  _LocalFsFileSource *data;
383 
384  if (src == NULL || child == NULL) {
385  return ISO_NULL_POINTER;
386  }
387 
388  data = src->data;
389  switch (data->openned) {
390  case 1: /* not dir */
391  return ISO_FILE_IS_NOT_DIR;
392  case 2: /* directory */
393  {
394  struct dirent *entry;
395  int ret;
396 
397  /* while to skip "." and ".." dirs */
398  while (1) {
399  entry = readdir(data->info.dir);
400  if (entry == NULL) {
401  if (errno == EBADF)
402  return ISO_FILE_ERROR;
403  else
404  return 0; /* EOF */
405  }
406  if (strcmp(entry->d_name, ".") && strcmp(entry->d_name, "..")) {
407  break;
408  }
409  }
410 
411  /* create the new FileSrc */
412  ret = iso_file_source_new_lfs(src, entry->d_name, child);
413  return ret;
414  }
415  default:
416  return ISO_FILE_NOT_OPENED;
417  }
418 }
419 
420 static
421 int lfs_readlink(IsoFileSource *src, char *buf, size_t bufsiz)
422 {
423  int size, ret;
424  char *path;
425 
426  if (src == NULL || buf == NULL) {
427  return ISO_NULL_POINTER;
428  }
429 
430  if (bufsiz <= 0) {
431  return ISO_WRONG_ARG_VALUE;
432  }
433 
434  path = lfs_get_path(src);
435 
436  /*
437  * invoke readlink, with bufsiz -1 to reserve an space for
438  * the NULL character
439  */
440  size = readlink(path, buf, bufsiz);
441  free(path);
442  if (size < 0) {
443  /* error */
444  switch (errno) {
445  case EACCES:
446  return ISO_FILE_ACCESS_DENIED;
447  case ENOTDIR:
448  case ENAMETOOLONG:
449  case ELOOP:
450  return ISO_FILE_BAD_PATH;
451  case ENOENT:
452  return ISO_FILE_DOESNT_EXIST;
453  case EINVAL:
455  case EFAULT:
456  case ENOMEM:
457  return ISO_OUT_OF_MEM;
458  default:
459  return ISO_FILE_ERROR;
460  }
461  }
462 
463  /* NULL-terminate the buf */
464  ret = ISO_SUCCESS;
465  if ((size_t) size >= bufsiz) {
466  ret = ISO_RR_PATH_TOO_LONG;
467  size = bufsiz - 1;
468  }
469  buf[size] = '\0';
470  return ret;
471 }
472 
473 static
475 {
476  return src == NULL ? NULL : lfs;
477 }
478 
479 static
481 {
482  _LocalFsFileSource *data;
483 
484  data = src->data;
485 
486  /* close the file if it is already opened */
487  if (data->openned) {
488  src->class->close(src);
489  }
490  if (data->parent != src) {
492  }
493  free(data->name);
494  free(data);
496 }
497 
498 
499 static
500 int lfs_get_aa_string(IsoFileSource *src, unsigned char **aa_string, int flag)
501 {
502  int ret, no_non_user_perm= 0;
503  size_t num_attrs = 0, *value_lengths = NULL, result_len;
504  ssize_t sret;
505  char *path = NULL, **names = NULL, **values = NULL;
506  unsigned char *result = NULL;
507 
508  *aa_string = NULL;
509 
510  if ((flag & 6 ) == 6) { /* Neither ACL nor xattr shall be read */
511  ret = 1;
512  goto ex;
513  }
514  /* Obtain EAs and ACLs ("access" and "default"). ACLs encoded according
515  to AAIP ACL representation. Clean out st_mode ACL entries.
516  */
517  path = iso_file_source_get_path(src);
518  if (path == NULL) {
519  ret = ISO_NULL_POINTER;
520  goto ex;
521  }
522  ret = aaip_get_attr_list(path, &num_attrs, &names,
523  &value_lengths, &values,
524  (!(flag & 2)) | 2 | (flag & 4) | (flag & 8) | 16);
525  if (ret <= 0) {
526  if (ret == -2)
527  ret = ISO_AAIP_NO_GET_LOCAL;
528  else
529  ret = ISO_FILE_ERROR;
530  goto ex;
531  }
532  if(ret == 2)
533  no_non_user_perm= 1;
534 
535  if (num_attrs == 0)
536  result = NULL;
537  else {
538  sret = aaip_encode(num_attrs, names,
539  value_lengths, values, &result_len, &result, 0);
540  if (sret < 0) {
541  ret = sret;
542  goto ex;
543  }
544  }
545  *aa_string = result;
546  ret = 1 + no_non_user_perm;
547 ex:;
548  if (path != NULL)
549  free(path);
550  if (names != NULL || value_lengths != NULL || values != NULL)
551  aaip_get_attr_list(NULL, &num_attrs, &names, &value_lengths, &values,
552  1 << 15); /* free memory */
553  return ret;
554 }
555 
556 static
557 int lfs_clone_src(IsoFileSource *old_source,
558  IsoFileSource **new_source, int flag)
559 {
560  IsoFileSource *src = NULL;
561  char *new_name = NULL;
562  _LocalFsFileSource *old_data, *new_data = NULL;
563 
564  if (flag)
565  return ISO_STREAM_NO_CLONE; /* unknown option required */
566 
567  old_data = (_LocalFsFileSource *) old_source->data;
568  *new_source = NULL;
569  src = calloc(1, sizeof(IsoFileSource));
570  if (src == NULL)
571  goto no_mem;
572  new_name = strdup(old_data->name);
573  if (new_name == NULL)
574  goto no_mem;
575 
576  new_data = calloc(1, sizeof(_LocalFsFileSource));
577  if (new_data == NULL)
578  goto no_mem;
579  new_data->openned = 0;
580  new_data->info.fd = -1; /* the value does not matter with (openned == 0) */
581  new_data->name = new_name;
582  new_data->parent = old_data->parent;
583 
584  src->class = old_source->class;
585  src->refcount = 1;
586  src->data = new_data;
587  *new_source = src;
588 
589  iso_file_source_ref(new_data->parent);
591  return ISO_SUCCESS;
592 no_mem:;
593  if (src != NULL)
594  free((char *) src);
595  if (new_data != NULL)
596  free((char *) new_data);
597  if (new_name != NULL)
598  free(new_name);
599  return ISO_OUT_OF_MEM;
600 }
601 
602 
604 
605  2, /* version */
606  lfs_get_path,
607  lfs_get_name,
608  lfs_lstat,
609  lfs_stat,
610  lfs_access,
611  lfs_open,
612  lfs_close,
613  lfs_read,
614  lfs_readdir,
615  lfs_readlink,
617  lfs_free,
618  lfs_lseek,
621 
622 };
623 
624 
625 /**
626  *
627  * @return
628  * 1 success, < 0 error
629  */
630 static
631 int iso_file_source_new_lfs(IsoFileSource *parent, const char *name,
632  IsoFileSource **src)
633 {
634  IsoFileSource *lfs_src;
635  _LocalFsFileSource *data;
636 
637  if (src == NULL) {
638  return ISO_NULL_POINTER;
639  }
640 
641  if (lfs == NULL) {
642  /* this should never happen */
643  return ISO_ASSERT_FAILURE;
644  }
645 
646  /* allocate memory */
647  data = malloc(sizeof(_LocalFsFileSource));
648  if (data == NULL) {
649  return ISO_OUT_OF_MEM;
650  }
651  lfs_src = malloc(sizeof(IsoFileSource));
652  if (lfs_src == NULL) {
653  free(data);
654  return ISO_OUT_OF_MEM;
655  }
656 
657  /* fill struct */
658  data->name = name ? strdup(name) : NULL;
659  data->openned = 0;
660  if (parent) {
661  data->parent = parent;
662  iso_file_source_ref(parent);
663  } else {
664  data->parent = lfs_src;
665  }
666 
667  lfs_src->refcount = 1;
668  lfs_src->data = data;
669  lfs_src->class = &lfs_class;
670 
671  /* take a ref to local filesystem */
673 
674  /* return */
675  *src = lfs_src;
676  return ISO_SUCCESS;
677 }
678 
679 static
681 {
682  if (fs == NULL || root == NULL) {
683  return ISO_NULL_POINTER;
684  }
685  return iso_file_source_new_lfs(NULL, NULL, root);
686 }
687 
688 static
689 int lfs_get_by_path(IsoFilesystem *fs, const char *path, IsoFileSource **file)
690 {
691  int ret;
692  IsoFileSource *src;
693  struct stat info;
694  char *ptr, *brk_info, *component;
695 
696  if (fs == NULL || path == NULL || file == NULL) {
697  return ISO_NULL_POINTER;
698  }
699 
700  /*
701  * first of all check that it is a valid path.
702  */
703  if (lstat(path, &info) != 0) {
704  int err;
705 
706  /* error, choose an appropriate return code */
707  switch (errno) {
708  case EACCES:
710  break;
711  case ENOTDIR:
712  case ENAMETOOLONG:
713  case ELOOP:
714  err = ISO_FILE_BAD_PATH;
715  break;
716  case ENOENT:
717  err = ISO_FILE_DOESNT_EXIST;
718  break;
719  case EFAULT:
720  case ENOMEM:
721  err = ISO_OUT_OF_MEM;
722  break;
723  default:
724  err = ISO_FILE_ERROR;
725  break;
726  }
727  return err;
728  }
729 
730  /* ok, path is valid. create the file source */
731  ret = lfs_get_root(fs, &src);
732  if (ret < 0) {
733  return ret;
734  }
735  if (!strcmp(path, "/")) {
736  /* we are looking for root */
737  *file = src;
738  return ISO_SUCCESS;
739  }
740 
741  ptr = strdup(path);
742  if (ptr == NULL) {
744  return ISO_OUT_OF_MEM;
745  }
746 
747  component = strtok_r(ptr, "/", &brk_info);
748  while (component) {
749  IsoFileSource *child = NULL;
750  if (!strcmp(component, ".")) {
751  child = src;
752  } else if (!strcmp(component, "..")) {
753  child = ((_LocalFsFileSource*)src->data)->parent;
754  iso_file_source_ref(child);
756  } else {
757  ret = iso_file_source_new_lfs(src, component, &child);
759  if (ret < 0) {
760  break;
761  }
762  }
763 
764  src = child;
765  component = strtok_r(NULL, "/", &brk_info);
766  }
767 
768  free(ptr);
769  if (ret > 0) {
770  *file = src;
771  }
772  return ret;
773 }
774 
775 static
776 unsigned int lfs_get_id(IsoFilesystem *fs)
777 {
778  return ISO_LOCAL_FS_ID;
779 }
780 
781 static
783 {
784  /* open() operation is not needed */
785  return ISO_SUCCESS;
786 }
787 
788 static
790 {
791  /* close() operation is not needed */
792  return ISO_SUCCESS;
793 }
794 
795 static
797 {
798  lfs = NULL;
799 }
800 
802 {
803  if (fs == NULL) {
804  return ISO_NULL_POINTER;
805  }
806 
807  if (lfs != NULL) {
808  /* just take a new ref */
810  } else {
811 
812  lfs = malloc(sizeof(IsoFilesystem));
813  if (lfs == NULL) {
814  return ISO_OUT_OF_MEM;
815  }
816 
817  /* fill struct */
818  memcpy(lfs->type, "file", 4);
819  lfs->refcount = 1;
820  lfs->version = 0;
821  lfs->data = NULL; /* we don't need private data */
824  lfs->get_id = lfs_get_id;
825  lfs->open = lfs_fs_open;
827  lfs->free = lfs_fs_free;
828  }
829  *fs = lfs;
830  return ISO_SUCCESS;
831 }
832 
833 
835 {
836  int ret;
837 
838  ret= aaip_local_attr_support(flag & 255);
839  return ret;
840 }
841 
842 
843 int iso_local_get_acl_text(char *disk_path, char **text, int flag)
844 {
845  int ret;
846 
847  ret = aaip_get_acl_text(disk_path, text, flag & (1 | 16 | 32 | (1 << 15)));
848  return ret;
849 }
850 
851 
852 int iso_local_set_acl_text(char *disk_path, char *text, int flag)
853 {
854  int ret;
855 
856  ret = aaip_set_acl_text(disk_path, text, flag & (1 | 32));
857  if (ret < 0)
858  return ISO_AAIP_NO_SET_LOCAL;
859  return ret;
860 }
861 
862 
863 int iso_local_get_attrs(char *disk_path, size_t *num_attrs, char ***names,
864  size_t **value_lengths, char ***values, int flag)
865 {
866  int ret;
867 
868  ret = aaip_get_attr_list(disk_path,
869  num_attrs, names, value_lengths, values,
870  (flag & (1 | 4 | 8 | 32 | (1 << 15))) | 2 | 16);
871  if (ret <= 0)
872  return ISO_AAIP_NO_GET_LOCAL;
873  return 1 + (ret == 2);
874 }
875 
876 
877 int iso_local_set_attrs_errno(char *disk_path, size_t num_attrs, char **names,
878  size_t *value_lengths, char **values,
879  int *errnos, int flag)
880 {
881  int ret;
882 
883  ret = aaip_set_attr_list(disk_path, num_attrs, names, value_lengths,
884  values, errnos,
885  (flag & (8 | 32 | 64 | 128)) | !(flag & 1));
886  if (ret <= 0) {
887  if (ret == -1)
888  return ISO_OUT_OF_MEM;
889  if (ret == -2)
890  return ISO_AAIP_BAD_AASTRING;
891  if (ret >= -5)
892  return ISO_AAIP_NO_SET_LOCAL;
893  if (ret == -6 || ret == -7)
894  return ISO_AAIP_NOT_ENABLED;
895  if (ret == -8)
896  return ISO_AAIP_BAD_ATTR_NAME;
897  return ret;
898  }
899  return 1;
900 }
901 
902 
903 int iso_local_set_attrs(char *disk_path, size_t num_attrs, char **names,
904  size_t *value_lengths, char **values, int flag)
905 {
906  int ret;
907  int *errnos = NULL;
908 
909  if(num_attrs > 0) {
910  errnos= calloc(num_attrs, sizeof(int));
911  if(errnos == NULL)
912  return ISO_OUT_OF_MEM;
913  }
914  ret= iso_local_set_attrs_errno(disk_path, num_attrs, names, value_lengths,
915  values, errnos, flag);
916  if(errnos != NULL)
917  free(errnos);
918  return ret;
919 }
920 
921 
922 int iso_local_get_perms_wo_acl(char *disk_path, mode_t *st_mode, int flag)
923 {
924  struct stat stbuf;
925  int ret;
926  char *a_text = NULL;
927 
928  if (flag & 32)
929  ret = stat(disk_path, &stbuf);
930  else
931  ret = lstat(disk_path, &stbuf);
932  if (ret == -1)
933  return -1;
934  *st_mode = stbuf.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
935  ret = iso_local_get_acl_text(disk_path, &a_text, 16 | (flag & 32));
936  if (a_text != NULL) {
937  aaip_cleanout_st_mode(a_text, st_mode, 4 | 16);
938  iso_local_get_acl_text(disk_path, &a_text, 1 << 15); /* free a_text */
939  }
940  return 1;
941 }
942 
int aaip_set_attr_list(char *path, size_t num_attrs, char **names, size_t *value_lengths, char **values, int *errnos, int flag)
int aaip_get_attr_list(char *path, size_t *num_attrs, char ***names, size_t **value_lengths, char ***values, int flag)
Definition: aaip-os-dummy.c:74
int aaip_set_acl_text(char *path, char *text, int flag)
Definition: aaip-os-dummy.c:91
int aaip_get_acl_text(char *path, char **text, int flag)
Definition: aaip-os-dummy.c:64
int aaip_local_attr_support(int flag)
Definition: aaip-os-dummy.c:53
ssize_t aaip_encode(size_t num_attrs, char **names, size_t *value_lengths, char **values, size_t *result_len, unsigned char **result, int flag)
Definition: aaip_0_2.c:100
int aaip_cleanout_st_mode(char *acl_text, mode_t *in_st_mode, int flag)
Definition: aaip_0_2.c:720
static void lfs_free(IsoFileSource *src)
Definition: fs_local.c:480
static int iso_file_source_new_lfs(IsoFileSource *parent, const char *name, IsoFileSource **src)
Definition: fs_local.c:631
int iso_local_attr_support(int flag)
Definition: fs_local.c:834
int iso_local_set_attrs(char *disk_path, size_t num_attrs, char **names, size_t *value_lengths, char **values, int flag)
Definition: fs_local.c:903
IsoFileSourceIface lfs_class
Definition: fs_local.c:603
static int lfs_fs_open(IsoFilesystem *fs)
Definition: fs_local.c:782
static int lfs_lstat(IsoFileSource *src, struct stat *info)
Definition: fs_local.c:101
int iso_local_get_perms_wo_acl(char *disk_path, mode_t *st_mode, int flag)
Definition: fs_local.c:922
static int lfs_access(IsoFileSource *src)
Definition: fs_local.c:187
#define O_BINARY
Definition: fs_local.c:35
static int lfs_readdir(IsoFileSource *src, IsoFileSource **child)
Definition: fs_local.c:380
static IsoFilesystem * lfs_get_filesystem(IsoFileSource *src)
Definition: fs_local.c:474
static int lfs_get_root(IsoFilesystem *fs, IsoFileSource **root)
Definition: fs_local.c:680
static int lfs_readlink(IsoFileSource *src, char *buf, size_t bufsiz)
Definition: fs_local.c:421
static int lfs_get_aa_string(IsoFileSource *src, unsigned char **aa_string, int flag)
Definition: fs_local.c:500
int iso_local_set_attrs_errno(char *disk_path, size_t num_attrs, char **names, size_t *value_lengths, char **values, int *errnos, int flag)
Definition: fs_local.c:877
int iso_local_get_acl_text(char *disk_path, char **text, int flag)
Definition: fs_local.c:843
int iso_local_set_acl_text(char *disk_path, char *text, int flag)
Definition: fs_local.c:852
static char * lfs_get_path(IsoFileSource *src)
Definition: fs_local.c:62
static int lfs_stat(IsoFileSource *src, struct stat *info)
Definition: fs_local.c:144
static int lfs_close(IsoFileSource *src)
Definition: fs_local.c:259
static off_t lfs_lseek(IsoFileSource *src, off_t offset, int flag)
Definition: fs_local.c:334
static int lfs_read(IsoFileSource *src, void *buf, size_t count)
Definition: fs_local.c:287
IsoFilesystem * lfs
Definition: fs_local.c:45
int iso_local_filesystem_new(IsoFilesystem **fs)
Definition: fs_local.c:801
static int lfs_open(IsoFileSource *src)
Definition: fs_local.c:203
int iso_local_get_attrs(char *disk_path, size_t *num_attrs, char ***names, size_t **value_lengths, char ***values, int flag)
Definition: fs_local.c:863
static unsigned int lfs_get_id(IsoFilesystem *fs)
Definition: fs_local.c:776
static int lfs_clone_src(IsoFileSource *old_source, IsoFileSource **new_source, int flag)
Definition: fs_local.c:557
static char * lfs_get_name(IsoFileSource *src)
Definition: fs_local.c:93
static void lfs_fs_free(IsoFilesystem *fs)
Definition: fs_local.c:796
static int lfs_fs_close(IsoFilesystem *fs)
Definition: fs_local.c:789
static int lfs_get_by_path(IsoFilesystem *fs, const char *path, IsoFileSource **file)
Definition: fs_local.c:689
void iso_filesystem_ref(IsoFilesystem *fs)
Definition: fsource.c:35
void iso_file_source_unref(IsoFileSource *src)
Definition: fsource.c:27
void iso_filesystem_unref(IsoFilesystem *fs)
Definition: fsource.c:40
void iso_file_source_ref(IsoFileSource *src)
Definition: fsource.c:22
char * iso_file_source_get_path(IsoFileSource *src)
Definition: fsource.c:53
#define ISO_LOCAL_FS_ID
Definition: fsource.h:21
int iso_eaccess(const char *path)
Definition: util.c:1866
#define ISO_FILE_ACCESS_DENIED
Definition: libisofs.h:8802
#define ISO_SUCCESS
Definition: libisofs.h:8719
#define ISO_STREAM_NO_CLONE
Definition: libisofs.h:9089
#define ISO_FILE_NOT_OPENED
Definition: libisofs.h:8811
#define ISO_FILE_DOESNT_EXIST
Definition: libisofs.h:8808
#define ISO_OUT_OF_MEM
Definition: libisofs.h:8745
#define ISO_FILE_IS_NOT_DIR
Definition: libisofs.h:8823
#define ISO_RR_PATH_TOO_LONG
Definition: libisofs.h:9105
#define ISO_AAIP_NO_GET_LOCAL
Definition: libisofs.h:8942
#define ISO_FILE_READ_ERROR
Definition: libisofs.h:8820
#define ISO_AAIP_NOT_ENABLED
Definition: libisofs.h:8936
#define ISO_FILE_IS_DIR
Definition: libisofs.h:8817
#define ISO_WRONG_ARG_VALUE
Definition: libisofs.h:8751
#define ISO_AAIP_BAD_AASTRING
Definition: libisofs.h:8939
#define ISO_INTERRUPTED
Definition: libisofs.h:8748
#define ISO_NULL_POINTER
Definition: libisofs.h:8742
#define ISO_AAIP_NO_SET_LOCAL
Definition: libisofs.h:8945
#define ISO_ERROR
Definition: libisofs.h:8734
#define ISO_AAIP_BAD_ATTR_NAME
Definition: libisofs.h:9108
#define ISO_FILE_BAD_PATH
Definition: libisofs.h:8805
#define ISO_FILE_ALREADY_OPENED
Definition: libisofs.h:8796
#define ISO_FILE_ERROR
Definition: libisofs.h:8793
#define ISO_FILE_IS_NOT_SYMLINK
Definition: libisofs.h:8826
#define ISO_ASSERT_FAILURE
Definition: libisofs.h:8737
int(* close)(IsoFileSource *src)
Definition: libisofs.h:737
unsigned int openned
Definition: fs_local.c:53
union _LocalFsFileSource::@2 info
IsoFileSource * parent
Definition: fs_local.c:51
const IsoFileSourceIface * class
Definition: libisofs.h:915
unsigned int(* get_id)(IsoFilesystem *fs)
Definition: libisofs.h:593
int(* open)(IsoFilesystem *fs)
Definition: libisofs.h:605
unsigned int refcount
Definition: libisofs.h:623
int(* get_root)(IsoFilesystem *fs, IsoFileSource **root)
Definition: libisofs.h:559
int(* get_by_path)(IsoFilesystem *fs, const char *path, IsoFileSource **file)
Definition: libisofs.h:577
int(* close)(IsoFilesystem *fs)
Definition: libisofs.h:614
void * data
Definition: libisofs.h:624
void(* free)(IsoFilesystem *fs)
Definition: libisofs.h:620
char type[4]
Definition: libisofs.h:548