2 * Copyright (C) 1997-2007 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
);
206 ret
= send_buffer(fd
, (char *)result
.data
);
209 send_va_buffer(fd
, "%s\n", para_strerror(-ret
));
211 send_va_buffer(fd
, "no matches\n");
215 static int com_setatt_callback(const struct osl_object
*query
,
216 __a_unused
struct osl_object
*result
)
219 uint64_t add_mask
= 0, del_mask
= 0;
222 struct osl_object obj
;
225 for (p
= query
->data
; p
< (char *)query
->data
+ query
->size
; p
+= len
+ 1) {
230 return -E_ATTR_SYNTAX
;
232 if (c
!= '+' && c
!= '-')
237 ret
= osl_get_row(attribute_table
, ATTCOL_NAME
, &obj
, &row
);
240 ret
= osl_get_object(attribute_table
, row
, ATTCOL_BITNUM
,
245 add_mask
|= (1UL << *(unsigned char *)obj
.data
);
247 del_mask
|= (1UL << *(unsigned char *)obj
.data
);
249 if (!add_mask
&& !del_mask
)
250 return -E_ATTR_SYNTAX
;
251 PARA_DEBUG_LOG("masks: %llx:%llx\n",(long long unsigned)add_mask
,
252 (long long unsigned)del_mask
);
253 for (; p
< (char *)query
->data
+ query
->size
; p
+= len
+ 1) { /* TODO: fnmatch */
254 struct afs_info old_afsi
, new_afsi
;
255 struct afsi_change_event_data aced
= {.old_afsi
= &old_afsi
};
258 ret
= aft_get_row_of_path(p
, &aced
.aft_row
);
261 ret
= get_afsi_object_of_row(aced
.aft_row
, &obj
);
264 ret
= load_afsi(&old_afsi
, &obj
);
268 new_afsi
.attributes
|= add_mask
;
269 new_afsi
.attributes
&= ~del_mask
;
270 save_afsi(&new_afsi
, &obj
); /* in-place update */
271 afs_event(AFSI_CHANGE
, NULL
, &aced
);
276 int com_setatt(__a_unused
int fd
, int argc
, char * const * const argv
)
279 return -E_ATTR_SYNTAX
;
280 return send_standard_callback_request(argc
- 1, argv
+ 1, com_setatt_callback
,
284 struct addatt_event_data
{
286 unsigned char bitnum
;
290 static int com_addatt_callback(const struct osl_object
*query
,
291 struct osl_object
*result
)
293 char *p
= query
->data
;
295 struct para_buffer pb
= {.size
= 0};
298 for (p
= query
->data
; p
< (char *)query
->data
+ query
->size
; p
+= len
+ 1) {
299 struct osl_object objs
[NUM_ATT_COLUMNS
];
301 unsigned char bitnum
;
303 struct addatt_event_data aed
;
305 if (!len
|| p
[len
- 1] == '-' || p
[len
- 1] == '+') {
306 para_printf(&pb
, "invalid attribute name: %s\n", p
);
309 ret
= get_attribute_bitnum_by_name(p
, &bitnum
);
311 para_printf(&pb
, "attribute \"%s\" already exists\n", p
);
314 if (ret
!= -E_RB_KEY_NOT_FOUND
) /* error */
316 objs
[ATTCOL_BITNUM
].size
= 1;
317 /* find smallest unused attribute */
318 for (bitnum
= 0; bitnum
< 64; bitnum
++) {
319 objs
[ATTCOL_BITNUM
].data
= &bitnum
;
320 ret
= osl_get_row(attribute_table
, ATTCOL_BITNUM
,
321 &objs
[ATTCOL_BITNUM
], &row
);
322 if (ret
== -E_RB_KEY_NOT_FOUND
)
323 break; /* this bitnum is unused, use it */
324 if (ret
< 0) /* error */
326 /* this bit is already in use, try next bit */
329 ret
= -E_ATT_TABLE_FULL
;
332 objs
[ATTCOL_NAME
].data
= p
;
333 objs
[ATTCOL_NAME
].size
= len
+ 1;
334 ret
= osl_add_row(attribute_table
, objs
);
339 afs_event(ATTRIBUTE_ADD
, &pb
, &aed
);
340 greatest_att_bitnum
= PARA_MAX(greatest_att_bitnum
, bitnum
);
344 para_printf(&pb
, "%s: %s\n", p
, para_strerror(-ret
));
345 result
->data
= pb
.buf
;
346 result
->size
= pb
.size
;
347 return result
->data
? 0 : 1;
350 int com_addatt(int fd
, int argc
, char * const * const argv
)
352 struct osl_object result
;
356 return -E_ATTR_SYNTAX
;
357 ret
= send_standard_callback_request(argc
- 1, argv
+ 1, com_addatt_callback
,
363 if (!result
.data
|| !result
.size
)
365 ret
= send_va_buffer(fd
, "%s", (char *) result
.data
);
370 static int com_mvatt_callback(const struct osl_object
*query
,
371 struct osl_object
*result
)
373 char *old
= query
->data
;
374 size_t size
= strlen(old
) + 1;
375 char *new = old
+ size
;
376 struct osl_object obj
= {.data
= old
, .size
= size
};
378 struct para_buffer pb
= {.size
= 0};
381 ret
= osl_get_row(attribute_table
, ATTCOL_NAME
, &obj
, &row
);
385 obj
.size
= strlen(new) + 1;
386 ret
= osl_update_object(attribute_table
, row
, ATTCOL_NAME
, &obj
);
389 para_printf(&pb
, "%s\n", para_strerror(-ret
));
391 afs_event(ATTRIBUTE_RENAME
, &pb
, NULL
);
394 result
->data
= pb
.buf
;
395 result
->size
= pb
.size
;
399 int com_mvatt(int fd
, int argc
, char * const * const argv
)
401 struct osl_object result
;
405 return -E_ATTR_SYNTAX
;
406 ret
= send_standard_callback_request(argc
- 1, argv
+ 1, com_mvatt_callback
,
412 if (!result
.data
|| !result
.size
)
414 ret
= send_va_buffer(fd
, "%s", (char *) result
.data
);
419 /** Data passed to the action handler of com_rmatt(). */
420 struct remove_attribute_action_data
{
421 /** Message buffer. */
422 struct para_buffer pb
;
423 /** Numver of attributes removed. */
425 /** Bitwise "or" of the removed attributes. */
426 uint64_t mask_of_removed_atts
;
429 static int remove_attribute(struct osl_table
*table
, struct osl_row
*row
,
430 const char *name
, void *data
)
432 struct remove_attribute_action_data
*raad
= data
;
434 struct rmatt_event_data red
= {.name
= name
};
436 ret
= get_attribute_bitnum_by_name(name
, &red
.bitnum
);
438 para_printf(&raad
->pb
, "%s: %s\n", name
, para_strerror(-ret
));
441 ret
= osl_del_row(table
, row
);
443 para_printf(&raad
->pb
, "%s: %s\n", name
, para_strerror(-ret
));
446 para_printf(&raad
->pb
, "removed attribute %s\n", name
);
448 raad
->mask_of_removed_atts
|= (1 << red
.bitnum
);
449 afs_event(ATTRIBUTE_REMOVE
, &raad
->pb
, &red
);
453 static int com_rmatt_callback(const struct osl_object
*query
,
454 struct osl_object
*result
)
456 struct remove_attribute_action_data raad
= {.num_removed
= 0};
458 struct pattern_match_data pmd
= {
459 .table
= attribute_table
,
461 .loop_col_num
= ATTCOL_BITNUM
,
462 .match_col_num
= ATTCOL_NAME
,
464 .action
= remove_attribute
466 ret
= for_each_matching_row(&pmd
);
468 para_printf(&raad
.pb
, "%s\n", para_strerror(-ret
));
469 if (!raad
.num_removed
)
470 para_printf(&raad
.pb
, "no match -- nothing removed\n");
471 result
->data
= raad
.pb
.buf
;
472 result
->size
= raad
.pb
.size
;
476 int com_rmatt(int fd
, int argc
, char * const * const argv
)
479 struct osl_object result
;
482 return -E_ATTR_SYNTAX
;
483 ret
= send_standard_callback_request(argc
- 1, argv
+ 1, com_rmatt_callback
,
486 send_buffer(fd
, (char *)result
.data
);
489 send_va_buffer(fd
, "%s\n", para_strerror(-ret
));
494 * Return a binary representation of the given attribute value.
496 * \param atts Pointer to the attribute value.
499 * This function prints a string of at most 64 characters plus the terminating
500 * \p NULL character into \a buf which must be provided by the caller and at
501 * least 65 bytes long. The "x" character is used for set attributes and "-" is
502 * used for unset attributes.
504 * In practice, not all 64 attributes are defined. In this case, the function
505 * only prints \a N + 1 charaters where \a N is the greatest id of a defined
508 void get_attribute_bitmap(const uint64_t *atts
, char *buf
)
511 const uint64_t one
= 1;
513 for (i
= 0; i
<= greatest_att_bitnum
; i
++)
514 buf
[greatest_att_bitnum
- i
] = (*atts
& (one
<< i
))? 'x' : '-';
519 * Get a string containing the set attributes in text form.
521 * \param atts The attribute bitmap.
522 * \param delim The delimiter to separate matching attribute names.
523 * \param text Result pointer.
525 * \return Positive on success, negative on errors. If no attributes have
526 * been defined, \a *text is NULL.
528 int get_attribute_text(uint64_t *atts
, const char *delim
, char **text
)
531 const uint64_t one
= 1;
534 if (greatest_att_bitnum
< 0) { /* no attributes available */
535 *text
= para_strdup("(no attributes available)");
538 for (i
= 0; i
<= greatest_att_bitnum
; i
++) {
539 unsigned char bn
= i
;
540 struct osl_object obj
= {.data
= &bn
, .size
= 1};
543 if (!(*atts
& (one
<< i
)))
545 ret
= osl_get_row(attribute_table
, ATTCOL_BITNUM
, &obj
, &row
);
548 ret
= osl_get_object(attribute_table
, row
, ATTCOL_NAME
, &obj
);
552 char *tmp
= make_message("%s%s%s", *text
, delim
, (char *)obj
.data
);
556 *text
= para_strdup(obj
.data
);
558 if (!*text
) /* no attributes set */
559 *text
= para_strdup("");
567 * Close the attribute table.
569 * \sa osl_close_table().
571 void attribute_close(void)
573 osl_close_table(attribute_table
, OSL_MARK_CLEAN
);
574 attribute_table
= NULL
;
578 * Open the attribute table.
580 * \param ti Gets initialized by this function.
581 * \param db The database directory.
583 * \return Positive on success, negative on errors.
585 * \sa osl_open_table().
587 static int attribute_open(const char *dir
)
591 attribute_table_desc
.dir
= dir
;
592 ret
= osl_open_table(&attribute_table_desc
, &attribute_table
);
593 greatest_att_bitnum
= -1; /* no atts available */
595 find_greatest_att_bitnum();
598 attribute_table
= NULL
;
599 if (ret
>= 0 || is_errno(-ret
, ENOENT
))
604 static int attribute_create(const char *dir
)
606 attribute_table_desc
.dir
= dir
;
607 return osl_create_table(&attribute_table_desc
);
611 void attribute_init(struct afs_table
*t
)
613 t
->name
= attribute_table_desc
.name
;
614 t
->open
= attribute_open
;
615 t
->close
= attribute_close
;
616 t
->create
= attribute_create
;