};
/** Data passed to the action function of lsatt */
-struct lsatt_action_data {
- /** The result buffer. */
- struct para_buffer pb;
- /** The given flags for the lsatt command. */
- unsigned flags;
-};
-
static int print_attribute(struct osl_table *table, struct osl_row *row,
const char *name, void *data)
{
- struct lsatt_action_data *laad = data;
+ struct afs_callback_arg *aca = data;
+ unsigned flags = *(unsigned *)aca->query.data;
struct osl_object bitnum_obj;
int ret;
- if (!(laad->flags & LSATT_FLAG_LONG)) {
- para_printf(&laad->pb, "%s\n", name);
+ if (!(flags & LSATT_FLAG_LONG)) {
+ para_printf(&aca->pbout, "%s\n", name);
return 1;
}
ret = osl(osl_get_object(table, row, ATTCOL_BITNUM, &bitnum_obj));
if (ret < 0) {
- para_printf(&laad->pb, "%s: %s\n", name, para_strerror(-ret));
+ para_printf(&aca->pbout, "%s: %s\n", name, para_strerror(-ret));
return ret;
}
- para_printf(&laad->pb, "%u\t%s\n", *(unsigned char*)bitnum_obj.data,
+ para_printf(&aca->pbout, "%u\t%s\n", *(unsigned char*)bitnum_obj.data,
name);
return 1;
}
-static int com_lsatt_callback(int fd, const struct osl_object *query)
+static int com_lsatt_callback(struct afs_callback_arg *aca)
{
+ unsigned flags = *(unsigned *)aca->query.data;
int ret;
- struct lsatt_action_data laad = {
- .flags = *(unsigned *) query->data,
- .pb = {
- .max_size = shm_get_shmmax(),
- .private_data = &(struct afs_max_size_handler_data) {
- .fd = fd,
- .band = SBD_OUTPUT
- },
- .max_size_handler = afs_max_size_handler
- }
-
- };
struct pattern_match_data pmd = {
.table = attribute_table,
- .loop_col_num = ATTCOL_BITNUM,
+ .loop_col_num = ATTCOL_NAME,
.match_col_num = ATTCOL_NAME,
- .patterns = {.data = (char *)query->data + sizeof(laad.flags),
- .size = query->size - sizeof(laad.flags)},
+ .patterns = {.data = (char *)aca->query.data + sizeof(flags),
+ .size = aca->query.size - sizeof(flags)},
.pm_flags = PM_NO_PATTERN_MATCHES_EVERYTHING,
- .data = &laad,
+ .data = aca,
.action = print_attribute
};
- if (laad.flags & LSATT_FLAG_SORT_BY_ID)
- pmd.loop_col_num = ATTCOL_NAME;
- if (laad.flags & LSATT_FLAG_REVERSE)
+ if (flags & LSATT_FLAG_SORT_BY_ID)
+ pmd.loop_col_num = ATTCOL_BITNUM;
+ if (flags & LSATT_FLAG_REVERSE)
pmd.pm_flags |= PM_REVERSE_LOOP;
ret = for_each_matching_row(&pmd);
if (ret < 0)
if (pmd.num_matches == 0)
ret = -E_NO_MATCH;
out:
- flush_and_free_pb(&laad.pb);
return ret;
}
};
-static int com_addatt_callback(int fd, const struct osl_object *query)
+static int com_addatt_callback(struct afs_callback_arg *aca)
{
char *p;
int ret = 1;
- struct para_buffer pb = {
- .max_size = shm_get_shmmax(),
- .private_data = &(struct afs_max_size_handler_data) {
- .fd = fd,
- .band = SBD_OUTPUT
- },
- .max_size_handler = afs_max_size_handler
- };
size_t len;
- for (p = query->data; p < (char *)query->data + query->size; p += len + 1) {
+ for (
+ p = aca->query.data;
+ p < (char *)aca->query.data + aca->query.size;
+ p += len + 1
+ ) {
struct osl_object objs[NUM_ATT_COLUMNS];
struct osl_row *row;
unsigned char bitnum;
len = strlen(p);
if (!len || p[len - 1] == '-' || p[len - 1] == '+') {
- para_printf(&pb, "invalid attribute name: %s\n", p);
+ para_printf(&aca->pbout, "invalid attribute name: %s\n", p);
continue;
}
ret = get_attribute_bitnum_by_name(p, &bitnum);
if (ret >= 0) {
- para_printf(&pb, "attribute \"%s\" already exists\n", p);
+ para_printf(&aca->pbout, "attribute \"%s\" already exists\n", p);
continue;
}
if (ret != -OSL_ERRNO_TO_PARA_ERROR(E_OSL_RB_KEY_NOT_FOUND)) /* error */
goto out;
aed.name = p;
aed.bitnum = bitnum;
- ret = afs_event(ATTRIBUTE_ADD, &pb, &aed);
+ ret = afs_event(ATTRIBUTE_ADD, &aca->pbout, &aed);
if (ret < 0)
goto out;
greatest_att_bitnum = PARA_MAX(greatest_att_bitnum, (int)bitnum);
}
out:
if (ret < 0)
- para_printf(&pb, "%s: %s\n", p, para_strerror(-ret));
- flush_and_free_pb(&pb);
- return 0;
+ para_printf(&aca->pbout, "%s: %s\n", p, para_strerror(-ret));
+ return ret;
}
int com_addatt(struct command_context *cc)
return ret;
}
-static int com_mvatt_callback(int fd, const struct osl_object *query)
+static int com_mvatt_callback(struct afs_callback_arg *aca)
{
- char *old = query->data;
+ char *old = aca->query.data;
size_t size = strlen(old) + 1;
char *new = old + size;
struct osl_object obj = {.data = old, .size = size};
struct osl_row *row;
- struct para_buffer pb = {
- .max_size = shm_get_shmmax(),
- .private_data = &(struct afs_max_size_handler_data) {
- .fd = fd,
- .band = SBD_OUTPUT
- },
- .max_size_handler = afs_max_size_handler,
- };
int ret;
ret = osl(osl_get_row(attribute_table, ATTCOL_NAME, &obj, &row));
ret = osl(osl_update_object(attribute_table, row, ATTCOL_NAME, &obj));
out:
if (ret < 0)
- para_printf(&pb, "cannot rename %s to %s\n", old, new);
+ para_printf(&aca->pbout, "cannot rename %s to %s\n", old, new);
else
- ret = afs_event(ATTRIBUTE_RENAME, &pb, NULL);
- flush_and_free_pb(&pb);
+ ret = afs_event(ATTRIBUTE_RENAME, &aca->pbout, NULL);
return ret;
}
static int remove_attribute(struct osl_table *table, struct osl_row *row,
const char *name, void *data)
{
- struct para_buffer *pb = data;
+ struct afs_callback_arg *aca = data;
int ret;
struct rmatt_event_data red = {.name = name};
ret = get_attribute_bitnum_by_name(name, &red.bitnum);
if (ret < 0) {
- para_printf(pb, "cannot remove %s\n", name);
+ para_printf(&aca->pbout, "cannot remove %s\n", name);
return ret;
}
- para_printf(pb, "removing attribute %s\n", name);
+ para_printf(&aca->pbout, "removing attribute %s\n", name);
ret = osl(osl_del_row(table, row));
if (ret < 0) {
- para_printf(pb, "cannot remove %s\n", name);
+ para_printf(&aca->pbout, "cannot remove %s\n", name);
return ret;
}
- return afs_event(ATTRIBUTE_REMOVE, pb, &red);
+ return afs_event(ATTRIBUTE_REMOVE, &aca->pbout, &red);
}
-static int com_rmatt_callback(int fd, const struct osl_object *query)
+static int com_rmatt_callback(struct afs_callback_arg *aca)
{
- struct para_buffer pb = {
- .max_size = shm_get_shmmax(),
- .private_data = &(struct afs_max_size_handler_data) {
- .fd = fd,
- .band = SBD_OUTPUT
- },
- .max_size_handler = afs_max_size_handler,
- };
int ret;
struct pattern_match_data pmd = {
.table = attribute_table,
- .patterns = *query,
+ .patterns = aca->query,
.loop_col_num = ATTCOL_BITNUM,
.match_col_num = ATTCOL_NAME,
- .data = &pb,
+ .data = aca,
.action = remove_attribute
};
ret = for_each_matching_row(&pmd);
if (pmd.num_matches == 0)
ret = -E_NO_MATCH;
out:
- flush_and_free_pb(&pb);
return ret;
}
static int att_logical_or(struct osl_row *row, void *data)
{
- uint64_t *att_mask = data;
+ uint64_t *att_mask = data, one = 1;
struct osl_object bitnum_obj;
int ret = osl_get_object(attribute_table, row, ATTCOL_BITNUM, &bitnum_obj);
if (ret < 0)
return ret;
- *att_mask |= 1 << *(unsigned char *)bitnum_obj.data;
+ *att_mask |= one << *(unsigned char *)bitnum_obj.data;
return 0;
}
/**
* Compute the attribute bit mask and check each afs info bitmap.
*
- * \param fd Needed for the para buffer.
- * \param query Unused.
+ * \param aca The query field of \a aca is ignored.
*
* This iterates over all attributes in the attribute table and computes the
* logical or of 1 << b where b is the bit number of the attribute. The
*
* \sa \ref aft_check_attributes().
*/
-int attribute_check_callback(int fd, __a_unused const struct osl_object *query)
+int attribute_check_callback(struct afs_callback_arg *aca)
{
int ret;
uint64_t att_mask = 0; /* bits corresponding to a attributes */
- struct para_buffer pb = {
- .max_size = shm_get_shmmax(),
- .private_data = &(struct afs_max_size_handler_data) {
- .fd = fd,
- .band = SBD_OUTPUT
- },
- .max_size_handler = afs_max_size_handler,
- };
ret = osl_rbtree_loop(attribute_table, ATTCOL_BITNUM, &att_mask,
att_logical_or);
para_strerror(-ret));
return ret;
}
- ret = aft_check_attributes(att_mask, &pb);
- flush_and_free_pb(&pb);
- return ret;
+ return aft_check_attributes(att_mask, &aca->pbout);
}
/**
return ret;
}
attribute_table = NULL;
- if (ret >= 0 || ret == -OSL_ERRNO_TO_PARA_ERROR(E_OSL_NOENT))
+ if (ret == -OSL_ERRNO_TO_PARA_ERROR(E_OSL_NOENT))
return 1;
return ret;
}
projects / paraslash.git / blobdiff