2 * Copyright (C) 1997-2008 Andre Noll <maan@systemlinux.org>
4 * Licensed under the GPL v2. For licencing details see COPYING.
7 /** \file attribute.c Attribute handling functions. */
15 static struct osl_table
*attribute_table
;
16 static int greatest_att_bitnum
;
18 /** The columns of the attribute table. */
19 enum attribute_table_columns
{
20 /** The bit number (0-63). */
22 /** The name of the attribute. */
24 /** Number of columns in this table. */
28 static int char_compare(const struct osl_object
*obj1
, const struct osl_object
*obj2
)
30 const unsigned char *c1
= (const unsigned char*)obj1
->data
;
31 const unsigned char *c2
= (const unsigned char*)obj2
->data
;
39 static struct osl_column_description att_cols
[] = {
41 .storage_type
= OSL_MAPPED_STORAGE
,
42 .storage_flags
= OSL_RBTREE
| OSL_FIXED_SIZE
| OSL_UNIQUE
,
44 .compare_function
= char_compare
,
48 .storage_type
= OSL_MAPPED_STORAGE
,
49 .storage_flags
= OSL_RBTREE
| OSL_UNIQUE
,
51 .compare_function
= string_compare
,
55 static struct osl_table_description attribute_table_desc
= {
57 .num_columns
= NUM_ATT_COLUMNS
,
59 .column_descriptions
= att_cols
62 static void find_greatest_att_bitnum(void)
67 struct osl_object obj
= {.data
= &c
, .size
= 1};
68 if (osl_get_row(attribute_table
, ATTCOL_BITNUM
, &obj
,
70 greatest_att_bitnum
= c
;
74 PARA_INFO_LOG("no attributes\n");
75 greatest_att_bitnum
= -E_NO_ATTRIBUTES
;
79 * Retrieve the identifier (number) of an attribute.
81 * \param att_name The name of the attribute.
82 * \param bitnum Result pointer.
84 * \return Positive on success, negative on errors.
86 int get_attribute_bitnum_by_name(const char *att_name
, unsigned char *bitnum
)
88 struct osl_object obj
= {.data
= (char *)att_name
,
89 .size
= strlen(att_name
) + 1};
91 int ret
= osl_get_row(attribute_table
, ATTCOL_NAME
, &obj
, &row
);
95 ret
= osl_get_object(attribute_table
, row
, ATTCOL_BITNUM
, &obj
);
98 *bitnum
= *(unsigned char *)obj
.data
;
103 * Flags used by the lsatt command.
105 * \param \sa com_lsatt().
108 /** Whether "-a" was given for the lsatt command. */
109 LSATT_FLAG_SORT_BY_ID
= 1,
110 /** Whether "-l" was given for the lsatt command. */
112 /** Reverse sort order. */
113 LSATT_FLAG_REVERSE
= 4
116 /** Data passed to the action function of lsatt */
117 struct lsatt_action_data
{
118 /** The result buffer. */
119 struct para_buffer pb
;
120 /** The given flags for the lsatt command. */
124 static int print_attribute(struct osl_table
*table
, struct osl_row
*row
,
125 const char *name
, void *data
)
127 struct lsatt_action_data
*laad
= data
;
128 struct osl_object bitnum_obj
;
131 if (!(laad
->flags
& LSATT_FLAG_LONG
)) {
132 para_printf(&laad
->pb
, "%s\n", name
);
135 ret
= osl_get_object(table
, row
, ATTCOL_BITNUM
, &bitnum_obj
);
137 para_printf(&laad
->pb
, "%s: %s\n", name
, para_strerror(-ret
));
140 para_printf(&laad
->pb
, "%u\t%s\n", *(unsigned char*)bitnum_obj
.data
,
145 static int com_lsatt_callback(const struct osl_object
*query
,
146 struct osl_object
*result
)
148 struct lsatt_action_data laad
= {.flags
= *(unsigned *) query
->data
};
149 struct pattern_match_data pmd
= {
150 .table
= attribute_table
,
151 .loop_col_num
= ATTCOL_BITNUM
,
152 .match_col_num
= ATTCOL_NAME
,
153 .patterns
= {.data
= (char *)query
->data
+ sizeof(laad
.flags
),
154 .size
= query
->size
- sizeof(laad
.flags
)},
155 .pm_flags
= PM_NO_PATTERN_MATCHES_EVERYTHING
,
157 .action
= print_attribute
161 if (laad
.flags
& LSATT_FLAG_SORT_BY_ID
)
162 pmd
.loop_col_num
= ATTCOL_NAME
;
163 if (laad
.flags
& LSATT_FLAG_REVERSE
)
164 pmd
.pm_flags
|= PM_REVERSE_LOOP
;
165 ret
= for_each_matching_row(&pmd
);
167 para_printf(&laad
.pb
, "%s\n", para_strerror(-ret
));
170 result
->data
= laad
.pb
.buf
;
171 result
->size
= laad
.pb
.size
;
175 int com_lsatt(int fd
, int argc
, char * const * const argv
)
178 struct osl_object options
= {.data
= &flags
, .size
= sizeof(flags
)},
182 for (i
= 1; i
< argc
; i
++) {
183 const char *arg
= argv
[i
];
186 if (!strcmp(arg
, "--")) {
190 if (!strcmp(arg
, "-i")) {
191 flags
|= LSATT_FLAG_SORT_BY_ID
;
194 if (!strcmp(arg
, "-l")) {
195 flags
|= LSATT_FLAG_LONG
;
198 if (!strcmp(arg
, "-r")) {
199 flags
|= LSATT_FLAG_REVERSE
;
203 ret
= send_option_arg_callback_request(&options
, argc
- i
, argv
+ i
,
204 com_lsatt_callback
, &result
);
207 ret
= send_va_buffer(fd
, "no matches\n");
211 send_va_buffer(fd
, "%s\n", para_strerror(-ret
));
214 ret
= send_buffer(fd
, (char *)result
.data
);
219 static int com_setatt_callback(const struct osl_object
*query
,
220 __a_unused
struct osl_object
*result
)
223 uint64_t add_mask
= 0, del_mask
= 0;
226 struct osl_object obj
;
229 for (p
= query
->data
; p
< (char *)query
->data
+ query
->size
; p
+= len
+ 1) {
234 return -E_ATTR_SYNTAX
;
236 if (c
!= '+' && c
!= '-')
241 ret
= osl_get_row(attribute_table
, ATTCOL_NAME
, &obj
, &row
);
244 ret
= osl_get_object(attribute_table
, row
, ATTCOL_BITNUM
,
249 add_mask
|= (1UL << *(unsigned char *)obj
.data
);
251 del_mask
|= (1UL << *(unsigned char *)obj
.data
);
253 if (!add_mask
&& !del_mask
)
254 return -E_ATTR_SYNTAX
;
255 PARA_DEBUG_LOG("masks: %llx:%llx\n",(long long unsigned)add_mask
,
256 (long long unsigned)del_mask
);
257 for (; p
< (char *)query
->data
+ query
->size
; p
+= len
+ 1) { /* TODO: fnmatch */
258 struct afs_info old_afsi
, new_afsi
;
259 struct afsi_change_event_data aced
= {.old_afsi
= &old_afsi
};
262 ret
= aft_get_row_of_path(p
, &aced
.aft_row
);
265 ret
= get_afsi_object_of_row(aced
.aft_row
, &obj
);
268 ret
= load_afsi(&old_afsi
, &obj
);
272 new_afsi
.attributes
|= add_mask
;
273 new_afsi
.attributes
&= ~del_mask
;
274 save_afsi(&new_afsi
, &obj
); /* in-place update */
275 afs_event(AFSI_CHANGE
, NULL
, &aced
);
280 int com_setatt(__a_unused
int fd
, int argc
, char * const * const argv
)
283 return -E_ATTR_SYNTAX
;
284 return send_standard_callback_request(argc
- 1, argv
+ 1, com_setatt_callback
,
288 struct addatt_event_data
{
290 unsigned char bitnum
;
294 static int com_addatt_callback(const struct osl_object
*query
,
295 struct osl_object
*result
)
297 char *p
= query
->data
;
299 struct para_buffer pb
= {.size
= 0};
302 for (p
= query
->data
; p
< (char *)query
->data
+ query
->size
; p
+= len
+ 1) {
303 struct osl_object objs
[NUM_ATT_COLUMNS
];
305 unsigned char bitnum
;
307 struct addatt_event_data aed
;
309 if (!len
|| p
[len
- 1] == '-' || p
[len
- 1] == '+') {
310 para_printf(&pb
, "invalid attribute name: %s\n", p
);
313 ret
= get_attribute_bitnum_by_name(p
, &bitnum
);
315 para_printf(&pb
, "attribute \"%s\" already exists\n", p
);
318 if (ret
!= -E_RB_KEY_NOT_FOUND
) /* error */
320 objs
[ATTCOL_BITNUM
].size
= 1;
321 /* find smallest unused attribute */
322 for (bitnum
= 0; bitnum
< 64; bitnum
++) {
323 objs
[ATTCOL_BITNUM
].data
= &bitnum
;
324 ret
= osl_get_row(attribute_table
, ATTCOL_BITNUM
,
325 &objs
[ATTCOL_BITNUM
], &row
);
326 if (ret
== -E_RB_KEY_NOT_FOUND
)
327 break; /* this bitnum is unused, use it */
328 if (ret
< 0) /* error */
330 /* this bit is already in use, try next bit */
333 ret
= -E_ATT_TABLE_FULL
;
336 objs
[ATTCOL_NAME
].data
= p
;
337 objs
[ATTCOL_NAME
].size
= len
+ 1;
338 ret
= osl_add_row(attribute_table
, objs
);
343 afs_event(ATTRIBUTE_ADD
, &pb
, &aed
);
344 greatest_att_bitnum
= PARA_MAX(greatest_att_bitnum
, bitnum
);
348 para_printf(&pb
, "%s: %s\n", p
, para_strerror(-ret
));
349 result
->data
= pb
.buf
;
350 result
->size
= pb
.size
;
351 return result
->data
? 0 : 1;
354 int com_addatt(int fd
, int argc
, char * const * const argv
)
356 struct osl_object result
;
360 return -E_ATTR_SYNTAX
;
361 ret
= send_standard_callback_request(argc
- 1, argv
+ 1, com_addatt_callback
,
367 if (!result
.data
|| !result
.size
)
369 ret
= send_va_buffer(fd
, "%s", (char *) result
.data
);
374 static int com_mvatt_callback(const struct osl_object
*query
,
375 struct osl_object
*result
)
377 char *old
= query
->data
;
378 size_t size
= strlen(old
) + 1;
379 char *new = old
+ size
;
380 struct osl_object obj
= {.data
= old
, .size
= size
};
382 struct para_buffer pb
= {.size
= 0};
385 ret
= osl_get_row(attribute_table
, ATTCOL_NAME
, &obj
, &row
);
389 obj
.size
= strlen(new) + 1;
390 ret
= osl_update_object(attribute_table
, row
, ATTCOL_NAME
, &obj
);
393 para_printf(&pb
, "%s\n", para_strerror(-ret
));
395 afs_event(ATTRIBUTE_RENAME
, &pb
, NULL
);
398 result
->data
= pb
.buf
;
399 result
->size
= pb
.size
;
403 int com_mvatt(int fd
, int argc
, char * const * const argv
)
405 struct osl_object result
;
409 return -E_ATTR_SYNTAX
;
410 ret
= send_standard_callback_request(argc
- 1, argv
+ 1, com_mvatt_callback
,
416 if (!result
.data
|| !result
.size
)
418 ret
= send_va_buffer(fd
, "%s", (char *) result
.data
);
423 /** Data passed to the action handler of com_rmatt(). */
424 struct remove_attribute_action_data
{
425 /** Message buffer. */
426 struct para_buffer pb
;
427 /** Numver of attributes removed. */
429 /** Bitwise "or" of the removed attributes. */
430 uint64_t mask_of_removed_atts
;
433 static int remove_attribute(struct osl_table
*table
, struct osl_row
*row
,
434 const char *name
, void *data
)
436 struct remove_attribute_action_data
*raad
= data
;
438 struct rmatt_event_data red
= {.name
= name
};
440 ret
= get_attribute_bitnum_by_name(name
, &red
.bitnum
);
442 para_printf(&raad
->pb
, "%s: %s\n", name
, para_strerror(-ret
));
445 ret
= osl_del_row(table
, row
);
447 para_printf(&raad
->pb
, "%s: %s\n", name
, para_strerror(-ret
));
450 para_printf(&raad
->pb
, "removed attribute %s\n", name
);
452 raad
->mask_of_removed_atts
|= (1 << red
.bitnum
);
453 afs_event(ATTRIBUTE_REMOVE
, &raad
->pb
, &red
);
457 static int com_rmatt_callback(const struct osl_object
*query
,
458 struct osl_object
*result
)
460 struct remove_attribute_action_data raad
= {.num_removed
= 0};
462 struct pattern_match_data pmd
= {
463 .table
= attribute_table
,
465 .loop_col_num
= ATTCOL_BITNUM
,
466 .match_col_num
= ATTCOL_NAME
,
468 .action
= remove_attribute
470 ret
= for_each_matching_row(&pmd
);
472 para_printf(&raad
.pb
, "%s\n", para_strerror(-ret
));
473 if (!raad
.num_removed
)
474 para_printf(&raad
.pb
, "no match -- nothing removed\n");
475 result
->data
= raad
.pb
.buf
;
476 result
->size
= raad
.pb
.size
;
480 int com_rmatt(int fd
, int argc
, char * const * const argv
)
483 struct osl_object result
;
486 return -E_ATTR_SYNTAX
;
487 ret
= send_standard_callback_request(argc
- 1, argv
+ 1, com_rmatt_callback
,
492 send_va_buffer(fd
, "%s\n", para_strerror(-ret
));
495 ret
= send_buffer(fd
, (char *)result
.data
);
501 * Return a binary representation of the given attribute value.
503 * \param atts Pointer to the attribute value.
506 * This function prints a string of at most 64 characters plus the terminating
507 * \p NULL character into \a buf which must be provided by the caller and at
508 * least 65 bytes long. The "x" character is used for set attributes and "-" is
509 * used for unset attributes.
511 * In practice, not all 64 attributes are defined. In this case, the function
512 * only prints \a N + 1 charaters where \a N is the greatest id of a defined
515 void get_attribute_bitmap(const uint64_t *atts
, char *buf
)
518 const uint64_t one
= 1;
520 for (i
= 0; i
<= greatest_att_bitnum
; i
++)
521 buf
[greatest_att_bitnum
- i
] = (*atts
& (one
<< i
))? 'x' : '-';
526 * Get a string containing the set attributes in text form.
528 * \param atts The attribute bitmap.
529 * \param delim The delimiter to separate matching attribute names.
530 * \param text Result pointer.
532 * \return Positive on success, negative on errors. If no attributes have
533 * been defined, \a *text is NULL.
535 int get_attribute_text(uint64_t *atts
, const char *delim
, char **text
)
538 const uint64_t one
= 1;
541 if (greatest_att_bitnum
< 0) { /* no attributes available */
542 *text
= para_strdup("(no attributes available)");
545 for (i
= 0; i
<= greatest_att_bitnum
; i
++) {
546 unsigned char bn
= i
;
547 struct osl_object obj
= {.data
= &bn
, .size
= 1};
550 if (!(*atts
& (one
<< i
)))
552 ret
= osl_get_row(attribute_table
, ATTCOL_BITNUM
, &obj
, &row
);
555 ret
= osl_get_object(attribute_table
, row
, ATTCOL_NAME
, &obj
);
559 char *tmp
= make_message("%s%s%s", *text
, delim
, (char *)obj
.data
);
563 *text
= para_strdup(obj
.data
);
565 if (!*text
) /* no attributes set */
566 *text
= para_strdup("");
574 * Close the attribute table.
576 * \sa osl_close_table().
578 void attribute_close(void)
580 osl_close_table(attribute_table
, OSL_MARK_CLEAN
);
581 attribute_table
= NULL
;
585 * Open the attribute table.
587 * \param ti Gets initialized by this function.
588 * \param db The database directory.
590 * \return Positive on success, negative on errors.
592 * \sa osl_open_table().
594 static int attribute_open(const char *dir
)
598 attribute_table_desc
.dir
= dir
;
599 ret
= osl_open_table(&attribute_table_desc
, &attribute_table
);
600 greatest_att_bitnum
= -1; /* no atts available */
602 find_greatest_att_bitnum();
605 attribute_table
= NULL
;
606 if (ret
>= 0 || is_errno(-ret
, ENOENT
))
611 static int attribute_create(const char *dir
)
613 attribute_table_desc
.dir
= dir
;
614 return osl_create_table(&attribute_table_desc
);
618 void attribute_init(struct afs_table
*t
)
620 t
->name
= attribute_table_desc
.name
;
621 t
->open
= attribute_open
;
622 t
->close
= attribute_close
;
623 t
->create
= attribute_create
;