Browse Source

New API function iso_node_get_acl_text

Fixes for problems with CE usage and reading of multiple AA fields
release-1.5.4.branch
Thomas Schmitt 14 years ago
parent
commit
20adf50275
  1. 25
      libisofs/libisofs.h
  2. 186
      libisofs/node.c
  3. 283
      libisofs/rockridge.c
  4. 5
      libisofs/rockridge_read.c

25
libisofs/libisofs.h

@ -4126,5 +4126,30 @@ int aaip_xinfo_func(void *data, int flag);
#endif /* Libisofs_with_aaiP */
/**
* Get an eventual ACL which is associated with the node.
* The result will be in "long" text form as of man acl resp. acl_to_text().
*
* @param node
* The node that is to be inquired.
* @param text
* Will return a pointer to the eventual ACL text or NULL if the desired
* ACL is not available. Call this funtion with flag bit15 to finally
* release the memory occupied an ACL inquiry.
* @param flag
* Bitfield for control purposes
* bit0= obtain "default" ACL rather than "access" ACL
* (Linux directories can have a "default" ACL which influences
* the permissions of newly created files.)
* bit15= free memory and return 1
* @return
* 1 on success,
* 0 if the desire ACL type is not available
* < 0 on error
*
* @since 0.6.14
*/
int iso_node_get_acl_text(IsoNode *node, char **text, int flag);
#endif /*LIBISO_LIBISOFS_H_*/

186
libisofs/node.c

@ -10,6 +10,11 @@
#include "node.h"
#include "stream.h"
#ifdef Libisofs_with_aaiP
#include "aaip_0_2.h"
#endif
#include <stdlib.h>
#include <string.h>
#include <time.h>
@ -1317,3 +1322,184 @@ int iso_node_new_special(char *name, mode_t mode, dev_t dev,
*special = new;
return ISO_SUCCESS;
}
/* ts A90116 */
/* >>> describe
@param flag bit15 = free memory
*/
int iso_node_get_attrs(IsoNode *node, size_t *num_attrs,
char ***names, size_t **value_lengths, char ***values, int flag)
{
#ifdef Libisofs_with_aaiP
void *xipt;
struct aaip_state *aaip= NULL;
unsigned char *rpt, *aa_string;
size_t len, todo, consumed;
int is_done = 0, first_round= 1, ret;
if (flag & (1 << 15))
aaip_get_decoded_attrs(&aaip, num_attrs, names,
value_lengths, values, 1 << 15);
*num_attrs = 0;
*names = NULL;
*value_lengths = NULL;
*values = NULL;
if (flag & (1 << 15))
return 1;
ret = iso_node_get_xinfo(node, aaip_xinfo_func, &xipt);
if (ret != 1)
return 1;
aa_string = rpt = (unsigned char *) xipt;
len = aaip_count_bytes(rpt, 0);
while (!is_done) {
todo = len - (rpt - aa_string);
if (todo > 2048)
todo = 2048;
if (todo == 0) {
/* >>> Out of data while still prompted to submit */;
/* >>> invent better error code */
return ISO_ERROR;
}
/* Allow 1 million bytes of memory consumption, 100,000 attributes */
ret = aaip_decode_attrs(&aaip, "AA", (size_t) 1000000, (size_t) 100000,
rpt, todo, &consumed, first_round);
rpt+= consumed;
first_round= 0;
if (ret == 1)
continue;
if (ret == 2)
break;
/* >>> "aaip_decode_attrs() reports error */;
/* >>> invent better error code */
return ISO_ERROR;
}
if(rpt - aa_string != len) {
/* >>> "aaip_decode_attrs() returns 2 but still bytes are left" */
/* >>> invent better error code */
return ISO_ERROR;
}
ret = aaip_get_decoded_attrs(&aaip, num_attrs, names,
value_lengths, values, 0);
if(ret != 1) {
/* >>> aaip_get_decoded_attrs() failed */;
return ISO_OUT_OF_MEM;
}
#else /* Libisofs_with_aaiP */
*num_attrs = 0;
*names = NULL;
*value_lengths = NULL;
*values = NULL;
#endif /* ! Libisofs_with_aaiP */
return 1;
}
/* ts A90116 */
int iso_node_get_acl_text(IsoNode *node, char **text, int flag)
{
size_t num_attrs = 0, *value_lengths = NULL, i, consumed, text_fill = 0;
size_t v_len;
char **names = NULL, **values = NULL;
unsigned char *v_data;
int ret;
if (flag & (1 << 15)) {
if (*text != NULL)
free(*text);
*text = NULL;
return 1;
}
#ifdef Libisofs_with_aaiP
*text = NULL;
ret = iso_node_get_attrs(node, &num_attrs, &names,
&value_lengths, &values, 0);
if (ret < 0)
return ret;
for(i = 0; i < num_attrs; i++) {
if (names[i][0]) /* searching the empty name */
continue;
v_data = (unsigned char *) values[i];
v_len = value_lengths[i];
if (flag & 1) {
/* Skip "access" ACL and address "default" ACL instead */
ret = aaip_decode_acl(v_data, v_len,
&consumed, NULL, (size_t) 0, &text_fill, 1);
if (ret <= 0)
goto bad_decode;
if (ret != 2) {
ret = 0;
goto ex;
}
v_data += consumed;
v_len -= consumed;
}
ret = aaip_decode_acl(v_data, v_len,
&consumed, NULL, (size_t) 0, &text_fill, 1);
if (ret <= 0)
goto bad_decode;
if (text_fill == 0) {
ret = 0;
goto ex;
}
*text = calloc(text_fill, 1);
if (*text == NULL) {
ret = ISO_OUT_OF_MEM;
goto ex;
}
ret = aaip_decode_acl(v_data, v_len,
&consumed, *text, text_fill, &text_fill, 0);
if (ret <= 0)
goto bad_decode;
break;
}
ret = (*text != NULL);
ex:;
iso_node_get_attrs(node, &num_attrs, &names,
&value_lengths, &values, 1 << 15); /* free memory */
return ret;
bad_decode:;
/* >>> something is wrong with the attribute value */;
/* >>> invent better error code */
ret = ISO_ERROR;
goto ex;
#else /* Libisofs_with_aaiP */
*text = NULL;
return 0;
#endif /* ! Libisofs_with_aaiP */
}

283
libisofs/rockridge.c

@ -7,6 +7,8 @@
* published by the Free Software Foundation. See COPYING file for details.
*/
#define Libisofs_new_nm_sl_cE yes
/* ts A90116 : libisofs.h eventually defines Libisofs_with_aaiP */
#include "libisofs.h"
@ -16,7 +18,10 @@
#include "writer.h"
#include "messages.h"
#include "image.h"
#ifdef Libisofs_with_aaiP
#include "aaip_0_2.h"
#endif
#include <string.h>
@ -700,6 +705,212 @@ int aaip_xinfo_func(void *data, int flag)
#endif /* Libisofs_with_aaiP */
/* ts A90117 */
/**
* Compute SUA lentgth and eventual Continuation Area length of field NM and
* eventually fields SL and AA. Because CA usage makes necessary the use of
* a CE entry of 28 bytes in SUA, this computation fails if not the 28 bytes
* are taken into account at start. In this case the caller should retry with
* bit0 set.
*
* @param flag bit0= assume CA usage (else return 0 on SUA overflow)
* @return 1= ok, computation of *su_size and *ce is valid
* 0= not ok, CA usage is necessary but bit0 was not set
* (*su_size and *ce stay unaltered in this case)
* <0= error:
* -1= not enough SUA space for 28 bytes of CE entry
*/
static
int susp_calc_nm_sl_aa(Ecma119Image *t, Ecma119Node *n, size_t space,
size_t *su_size, size_t *ce, int flag)
{
char *name;
size_t namelen, su_mem, ce_mem;
#ifdef Libisofs_with_aaiP
/* ts A90112 */
void *xipt;
size_t num_aapt = 0, sua_free = 0;
int ret;
#endif
su_mem = *su_size;
ce_mem = *ce;
if (*ce > 0 && !(flag & 1))
goto unannounced_ca;
name = get_rr_fname(t, n->node->name);
namelen = strlen(name);
free(name);
if (flag & 1) {
/* Account for 28 bytes of CE field */
if (*su_size + 28 > space)
return -1;
*su_size += 28;
}
/* NM entry */
if (*su_size + 5 + namelen <= space) {
/* ok, it fits in System Use Area */
*su_size += 5 + namelen;
} else {
/* the NM will be divided in a CA */
if (!(flag & 1))
goto unannounced_ca;
namelen = namelen - (space - *su_size - 5);
*ce = 5 + namelen;
*su_size = space;
}
if (n->type == ECMA119_SYMLINK) {
/*
* for symlinks, we also need to write the SL
*/
char *dest, *cur, *prev;
size_t sl_len = 5;
int cew = (*ce != 0); /* are we writing to CA ? */
dest = get_rr_fname(t, ((IsoSymlink*)n->node)->dest);
prev = dest;
cur = strchr(prev, '/');
while (1) {
size_t clen;
if (cur) {
clen = cur - prev;
} else {
/* last component */
clen = strlen(prev);
}
if (clen == 1 && prev[0] == '.') {
clen = 0;
} else if (clen == 2 && prev[0] == '.' && prev[1] == '.') {
clen = 0;
}
/* flags and len for each component record (RRIP, 4.1.3.1) */
clen += 2;
if (!cew) {
/* we are still writing to the SUA */
if (*su_size + sl_len + clen > space) {
/*
* ok, we need a Continuation Area anyway
* TODO this can be handled better, but for now SL
* will be completelly moved into the CA
*/
if (!(flag & 1))
goto unannounced_ca;
cew = 1;
} else {
sl_len += clen;
}
}
if (cew) {
if (sl_len + clen > 255) {
/* we need an additional SL entry */
if (clen > 250) {
/*
* case 1, component too large to fit in a
* single SL entry. Thus, the component need
* to be divided anyway.
* Note than clen can be up to 255 + 2 = 257.
*
* First, we check how many bytes fit in current
* SL field
*/
int fit = 255 - sl_len - 2;
if (clen - 250 <= fit) {
/*
* the component can be divided between this
* and another SL entry
*/
*ce += 255; /* this SL, full */
sl_len = 5 + (clen - fit);
} else {
/*
* the component will need a 2rd SL entry in
* any case, so we prefer to don't write
* anything in this SL
*/
*ce += sl_len + 255;
sl_len = 5 + (clen - 250) + 2;
}
} else {
/* case 2, create a new SL entry */
*ce += sl_len;
sl_len = 5 + clen;
}
} else {
sl_len += clen;
}
}
if (!cur || cur[1] == '\0') {
/* cur[1] can be \0 if dest ends with '/' */
break;
}
prev = cur + 1;
cur = strchr(prev, '/');
}
free(dest);
/* and finally write the pending SL field */
if (!cew) {
/* the whole SL fits into the SUA */
*su_size += sl_len;
} else {
*ce += sl_len;
}
}
#ifdef Libisofs_with_aaiP
/* ts A90112 */
xipt = NULL;
#ifdef Libisofs_with_aaip_dummY
num_aapt = 28;
aaip_xinfo_func(NULL, 0); /* to avoid compiler warning */
#else /* Libisofs_with_aaip_dummY */
/* obtain num_aapt from node */
num_aapt = 0;
/* >>> if AAIP is enabled */
if (1) {
ret = iso_node_get_xinfo(n->node, aaip_xinfo_func, &xipt);
if (ret == 1) {
num_aapt = aaip_count_bytes((unsigned char *) xipt, 0);
}
}
#endif /* ! Libisofs_with_aaip_dummY */
/* let the expert decide where to add num_aapt */
if (num_aapt > 0) {
sua_free = space - *su_size;
aaip_add_AA(NULL, NULL, NULL, num_aapt, &sua_free, ce, 1);
*su_size = space - sua_free;
if (*ce > 0 && !(flag & 1))
goto unannounced_ca;
}
#endif /* Libisofs_with_aaiP */
return 1;
unannounced_ca:;
*su_size = su_mem;
*ce = ce_mem;
return 0;
}
/**
* Compute the length needed for write all RR and SUSP entries for a given
* node.
@ -721,10 +932,16 @@ size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type, size_t space,
#ifdef Libisofs_with_aaiP
/* ts A90112 */
#ifndef Libisofs_new_nm_sl_cE
void *xipt;
size_t num_aapt = 0, sua_free = 0;
#endif /* Libisofs_new_nm_sl_cE */
int ret;
#else /* Libisofs_with_aaiP */
#ifdef Libisofs_new_nm_sl_cE
int ret;
#endif
#endif /* ! Libisofs_with_aaiP */
/* space min is 255 - 33 - 37 = 185
* At the same time, it is always an odd number, but we need to pad it
@ -763,6 +980,16 @@ size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type, size_t space,
}
if (type == 0) {
#ifdef Libisofs_new_nm_sl_cE
/* Try without CE */
ret = susp_calc_nm_sl_aa(t, n, space, &su_size, ce, 0);
if (ret == 0) /* Retry with CE */
susp_calc_nm_sl_aa(t, n, space, &su_size, ce, 1);
#else /* Libisofs_new_nm_sl_cE */
char *name = get_rr_fname(t, n->node->name);
size_t namelen = strlen(name);
free(name);
@ -921,6 +1148,8 @@ size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type, size_t space,
#endif /* Libisofs_with_aaiP */
#endif /* ! Libisofs_new_nm_sl_cE */
} else {
/* "." or ".." entry */
@ -1017,6 +1246,11 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
#endif
size_t aaip_er_len= 0;
#ifdef Libisofs_new_nm_sl_cE
size_t su_size_pd, ce_len_pd; /* predicted sizes of SUA and CA */
int ce_is_predicted = 0;
#endif
if (t == NULL || n == NULL || info == NULL) {
return ISO_NULL_POINTER;
}
@ -1110,6 +1344,20 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
sua_free = space - info->suf_len;
#ifdef Libisofs_new_nm_sl_cE
/* ts A90117 */
/* Try whether NM, SL, AA will fit into SUA */
su_size_pd = info->suf_len;
ce_len_pd = ce_len;
ret = susp_calc_nm_sl_aa(t, n, space, &su_size_pd, &ce_len_pd, 0);
if (ret == 0) { /* Have to use CA. 28 bytes of CE are necessary */
susp_calc_nm_sl_aa(t, n, space, &su_size_pd, &ce_len_pd, 1);
sua_free -= 28;
ce_is_predicted = 1;
}
#endif /* ! Libisofs_new_nm_sl_cE */
/* NM entry */
if (5 + namelen <= sua_free) {
/* ok, it fits in System Use Area */
@ -1118,7 +1366,13 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
} else {
/* the NM will be divided in a CE */
nm_type = 1;
#ifdef Libisofs_new_nm_sl_cE
namelen = namelen - (sua_free - 5);
#else
namelen = namelen - (sua_free - 5 - 28);
#endif
ce_len = 5 + namelen;
sua_free = 0;
}
@ -1166,6 +1420,15 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
* TODO this can be handled better, but for now SL
* will be completelly moved into the CA
*/
#ifdef Libisofs_new_nm_sl_cE
/* ts A90117 */
/* sua_free, ce_len, nm_type already account for CE */
cew = 1;
#else /* Libisofs_new_nm_sl_cE */
if (28 <= sua_free) {
/* the CE entry fills without reducing NM */
sua_free -= 28;
@ -1177,6 +1440,9 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
sua_free = 0;
cew = 1;
}
#endif /* ! Libisofs_new_nm_sl_cE */
} else {
/* add the component */
ret = rrip_SL_append_comp(&n_comp, &comps, prev,
@ -1293,16 +1559,33 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
* Write the NM part that fits in SUA... Note that CE
* entry and NM in the continuation area is added below
*/
#ifdef Libisofs_new_nm_sl_cE
namelen = space - info->suf_len - 28 * (!!ce_is_predicted) - 5;
#else
namelen = space - info->suf_len - 28 - 5;
#endif
ret = rrip_add_NM(t, info, name, namelen, 1, 0);
if (ret < 0) {
goto add_susp_cleanup;
}
}
#ifdef Libisofs_new_nm_sl_cE
if (ce_is_predicted) {
/* Add the CE entry */
ret = susp_add_CE(t, ce_len_pd, info);
#else /* Libisofs_new_nm_sl_cE */
if (ce_len > 0) {
/* Add the CE entry */
ret = susp_add_CE(t, ce_len, info);
#endif /* ! Libisofs_new_nm_sl_cE */
if (ret < 0) {
goto add_susp_cleanup;
}

5
libisofs/rockridge_read.c

@ -433,7 +433,7 @@ int read_aaip_AA(struct susp_sys_user_entry *sue, char aa[2],
}
/* Eventually create or grow storage */
if (*aa_size == 0 || *aa_string == 0) {
if (*aa_size == 0 || *aa_string == NULL) {
*aa_size = *aa_len + sue->len_sue[0];
*aa_string = calloc(*aa_size, 1);
*aa_len = 0;
@ -461,7 +461,8 @@ int read_aaip_AA(struct susp_sys_user_entry *sue, char aa[2],
/* Append sue payload */
memcpy(aapt + 5, sue->data.AA.comps, sue->len_sue[0]);
*is_done = sue->data.AA.flags[0] & 1;
*aa_len += sue->len_sue[0];
*is_done = !(sue->data.AA.flags[0] & 1);
return ISO_SUCCESS;
}

Loading…
Cancel
Save