* Copyright 2010, Alexander Shagarov, alexander.shagarov@gmail.com.
* Copyright 2005, Stephan Aßmus, superstippi@yellowbites.com.
* Copyright 2004-2010, Axel Dörfler, axeld@pinc-software.de.
* Copyright 2002, Sebastian Nozzi.
*
* Distributed under the terms of the MIT license.
*/
#include <ctype.h>
#include <errno.h>
#include <getopt.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fs_attr.h>
#include <Mime.h>
#include <String.h>
#include <TypeConstants.h>
static void
putCharOrDot(uchar c)
{
putchar(isgraph(c) ? c : '.');
}
raw data. This view is used for the type B_RAW_DATA_TYPE,
for custom types and for any type that is not directly
supported by the utility "addattr"
*/
static void
dumpRawData(const char *buffer, size_t size)
{
const uint32 kChunkSize = 16;
uint32 dumpPosition = 0;
while (dumpPosition < size) {
printf("0x%06" B_PRIx32 ": ", dumpPosition);
for (uint32 i = 0; i < kChunkSize; i++) {
if (dumpPosition + i < size) {
printf("%02x ", (uint8)buffer[dumpPosition + i]);
} else
printf(" ");
}
printf(" '");
for (uint32 i = 0; i < kChunkSize; i++) {
if (dumpPosition < size)
putCharOrDot(buffer[dumpPosition]);
else
putchar(' ');
dumpPosition++;
}
printf("'\n");
}
}
static const char*
type_to_string(uint32 type)
{
static char buffer[32];
int32 missed = 0, shift = 24;
uint8 value[4];
for (int32 i = 0; i < 4; i++, shift -= 8) {
value[i] = uint8(type >> shift);
if (value[i] < ' ' || value[i] > 127) {
value[i] = '.';
missed++;
}
}
if (missed < 2) {
sprintf(buffer, "'%c%c%c%c'", value[0], value[1], value[2],
value[3]);
} else
sprintf(buffer, "0x%08" B_PRIx32, type);
return buffer;
}
static BString
type_name(uint32 type)
{
switch (type) {
case B_INT8_TYPE:
return "int8";
case B_UINT8_TYPE:
return "uint8";
case B_INT16_TYPE:
return "int16";
case B_UINT16_TYPE:
return "uint16";
case B_INT32_TYPE:
return "int32";
case B_UINT32_TYPE:
return "uint32";
case B_INT64_TYPE:
return "int64";
case B_UINT64_TYPE:
return "uint64";
case B_FLOAT_TYPE:
return "float";
case B_DOUBLE_TYPE:
return "double";
case B_BOOL_TYPE:
return "bool";
case B_STRING_TYPE:
return "string";
case B_MESSAGE_TYPE:
return "message";
case B_RAW_TYPE:
return "raw_data";
default:
return type_to_string(type);
}
}
static status_t
catAttr(const char *attribute, const char *fileName, bool keepRaw,
bool dataOnly, bool resolveLinks)
{
int fd = open(fileName, O_RDONLY | (resolveLinks ? 0 : O_NOTRAVERSE));
if (fd < 0)
return errno;
attr_info info;
if (fs_stat_attr(fd, attribute, &info) < 0) {
close(fd);
return errno;
}
off_t size = info.size;
bool cut = false;
if (size > 64 * 1024) {
size = 64 * 1024;
cut = true;
}
char* buffer = (char*)malloc(size);
if (!buffer) {
fprintf(stderr, "Could not allocate read buffer!\n");
close(fd);
return B_NO_MEMORY;
}
ssize_t bytesRead = fs_read_attr(fd, attribute, info.type, 0, buffer, size);
if (bytesRead < 0) {
free(buffer);
close(fd);
return errno;
}
if (bytesRead != size) {
fprintf(stderr, "Could only read %ld bytes from attribute!\n",
bytesRead);
free(buffer);
close(fd);
return B_ERROR;
}
if (keepRaw) {
off_t pos = 0;
ssize_t written = 0;
while (pos < info.size) {
written = write(STDOUT_FILENO, buffer, bytesRead);
if (written < bytesRead) {
if (written >= 0) {
fprintf(stderr, "Could only write %ld bytes to stream!\n",
written);
written = B_ERROR;
} else {
fprintf(stderr, "Failed to write to stream: %s\n",
strerror(written));
}
break;
}
pos += bytesRead;
bytesRead = fs_read_attr(fd, attribute, info.type, pos, buffer,
size);
if (bytesRead < size && pos + bytesRead < info.size) {
if (bytesRead >= 0) {
fprintf(stderr, "Could only read %ld bytes from "
"attribute!\n", bytesRead);
} else {
fprintf(stderr, "Failed to read from attribute: %s\n",
strerror(bytesRead));
}
written = B_ERROR;
break;
}
}
free(buffer);
if (written > 0)
written = B_OK;
close(fd);
return written;
}
if (!dataOnly)
printf("%s : %s : ", fileName, type_name(info.type).String());
switch (info.type) {
case B_INT8_TYPE:
printf("%" B_PRId8 "\n", *((int8*)buffer));
break;
case B_UINT8_TYPE:
printf("%" B_PRIu8 "\n", *((uint8*)buffer));
break;
case B_INT16_TYPE:
printf("%" B_PRId16 "\n", *((int16*)buffer));
break;
case B_UINT16_TYPE:
printf("%" B_PRIu16 "\n", *((uint16*)buffer));
break;
case B_INT32_TYPE:
printf("%" B_PRId32 "\n", *((int32*)buffer));
break;
case B_UINT32_TYPE:
printf("%" B_PRIu32 "\n", *((uint32*)buffer));
break;
case B_INT64_TYPE:
printf("%" B_PRId64 "\n", *((int64*)buffer));
break;
case B_UINT64_TYPE:
printf("%" B_PRIu64 "\n", *((uint64*)buffer));
break;
case B_FLOAT_TYPE:
printf("%f\n", *((float*)buffer));
break;
case B_DOUBLE_TYPE:
printf("%f\n", *((double*)buffer));
break;
case B_BOOL_TYPE:
printf("%d\n", *((unsigned char*)buffer));
break;
case B_STRING_TYPE:
case B_MIME_STRING_TYPE:
case 'MSIG':
case 'MSDC':
case 'MPTH':
printf("%s\n", buffer);
break;
case B_MESSAGE_TYPE:
{
BMessage message;
if (!cut && message.Unflatten(buffer) == B_OK) {
message.PrintToStream();
break;
}
}
default:
dumpRawData(buffer, size);
break;
}
free(buffer);
close(fd);
return B_OK;
}
static int
usage(const char* program, int returnCode)
{
fprintf(returnCode == EXIT_SUCCESS ? stdout : stderr,
"usage: %s [-P] [--raw|-r] <attribute-name> <file1> [<file2>...]\n"
" -P\t\tDon't resolve links\n"
" --raw,-r\tGet the raw data of attributes\n"
" --data,-d\tShow the attribute data only\n", program);
return returnCode;
}
int
main(int argc, char *argv[])
{
char *program = strrchr(argv[0], '/');
if (program == NULL)
program = argv[0];
else
program++;
const struct option kLongOptions[] = {
{"raw", no_argument, NULL, 'r'},
{"data", no_argument, NULL, 'd'},
{"help", no_argument, NULL, 'h'},
{NULL, 0, NULL, 0}
};
bool keepRaw = false;
bool resolveLinks = true;
bool dataOnly = false;
int option;
while ((option = getopt_long(argc, argv, "rdPh", kLongOptions, NULL))
!= -1) {
switch (option) {
case 'r':
keepRaw = true;
break;
case 'P':
resolveLinks = false;
break;
case 'd':
dataOnly = true;
break;
case 'h':
return usage(program, EXIT_SUCCESS);
default:
return usage(program, EXIT_FAILURE);
}
}
if (optind + 2 > argc)
return usage(program, EXIT_FAILURE);
int succeeded = 0;
const char* attrName = argv[optind++];
while (optind < argc) {
const char* fileName = argv[optind++];
status_t status = catAttr(attrName, fileName, keepRaw, dataOnly,
resolveLinks);
if (status != B_OK) {
fprintf(stderr, "%s: \"%s\", attribute \"%s\": %s\n",
program, fileName, attrName, strerror(status));
} else
succeeded++;
}
return succeeded != 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
