int
main (int argc, char *argv[])
{
anidb_session_t *session;
anidb_result_t *res;
char *key;
if (argc < 4) {
printf("Usage: %s <username> <password> <path>\n", argv[0]);
exit(0);
}
session = anidb_session_new("anidbfs", "1");
ANIDBFS_DEBUG("Connecting to AniDB");
res = anidb_session_authenticate(session, argv[1], argv[2]);
dump_result(res);
if (anidb_result_get_code(res) == ANIDB_LOGIN_ACCEPTED) {
if (anidb_result_get_str(res, &key)) {
anidb_session_set_key(session, key);
}
anidbfs_hash_dir(session, argv[3]);
ANIDBFS_DEBUG("Logging out");
anidb_session_logout(session);
}
anidb_result_unref(res);
anidb_session_unref(session);
return 1;
}
void verify_result (const void *src, const void *dst, size_t len,
const void *cdr, size_t clen)
{
if (memcmp (src, dst, len)) {
printf (" -- failed - dumping data -- \r\n");
dump_result ("dump", src, dst, len, cdr, clen);
exit (1);
}
}
/*
* This function does the initialization common for
* - parse_cmd (commands)
* - parse_open (file names for OPEN and DIRECTORY)
* Afterwards the appropriate function is called.
*
* Note that some functionality relies on that the resulting name pointer is
* within the cmd_t command buffer! So the result has to be taken from "in place"
* of what has been given
*
* To distinguish numeric drive numbers from unassigned (undefined) drives like "ftp:",
* the provider name must not end with a digit.
*/
void parse_filename(cmd_t *in, nameinfo_t *result, uint8_t parsehint) {
int8_t len = in->command_length; // includes the zero-byte
result->access = 0;
result->type = 0;
// copy over command to the end of the buffer, so we can
// construct it from the parts at the beginning after parsing it
// (because we may need to insert bytes at some places, which would
// be difficult)
// Note that assembling takes place in assemble_filename_packet below.
uint8_t diff = CONFIG_COMMAND_BUFFER_SIZE - len;
memmove(in->command_buffer + diff, in->command_buffer, len);
// adjust so we exclude final null byte
len--;
// runtime vars (uint e.g. to avoid sign extension on REL file record len)
uint8_t *p = in->command_buffer + diff;
// init output
memset(result, 0, sizeof(*result));
result->drive = NAMEINFO_UNUSED_DRIVE;
for (uint8_t i=0; i < MAX_NAMEINFO_FILES ; ++i) {
result->file[i].drive = NAMEINFO_UNUSED_DRIVE;
}
result->cmd = CMD_NONE; // no command
if (parsehint & PARSEHINT_COMMAND) {
parse_cmd(p, len, result);
} else {
result->name = p; // full name
result->namelen = len; // default
parse_open(p, parsehint & PARSEHINT_LOAD, len, result);
}
dump_result(result);
}
int
main(int argc, char *argv[])
{
int c;
int sts;
char *rawfile = NULL;
int i;
int ctxid;
int first = 1;
int dflag = 0;
int iflag = 0;
int Lflag = 0;
int lflag = 0;
int Mflag = 0;
int mflag = 0;
int tflag = 0;
int vflag = 0;
int mode = PM_MODE_FORW;
__pmContext *ctxp;
pmResult *raw_result;
pmResult *skel_result = NULL;
pmResult *result;
struct timeval done;
while ((c = pmGetOptions(argc, argv, &opts)) != EOF) {
switch (c) {
case 'a': /* dump everything */
dflag = iflag = lflag = mflag = sflag = tflag = 1;
break;
case 'd': /* dump pmDesc structures */
dflag = 1;
break;
case 'i': /* dump instance domains */
iflag = 1;
break;
case 'L': /* dump label, verbose */
Lflag = 1;
lflag = 1;
break;
case 'l': /* dump label */
lflag = 1;
break;
case 'm': /* dump metrics in log */
mflag = 1;
break;
case 'M': /* report <mark> records */
Mflag = 1;
break;
case 'r': /* read log in reverse chornological order */
mode = PM_MODE_BACK;
break;
case 's': /* report data size in log */
sflag = 1;
break;
case 't': /* dump temporal index */
tflag = 1;
break;
case 'v': /* verbose, dump in raw format */
vflag = 1;
rawfile = opts.optarg;
break;
case 'x': /* report Ddd Mmm DD <timestamp> YYYY */
/* -xx reports numeric timeval also */
xflag++;
break;
}
}
if (opts.errors ||
(vflag && opts.optind != argc) ||
(!vflag && opts.optind > argc - 1 && !opts.narchives)) {
pmUsageMessage(&opts);
exit(1);
}
if (vflag) {
FILE *f;
if ((f = fopen(rawfile, "r")) == NULL) {
fprintf(stderr, "%s: Cannot open \"%s\": %s\n", pmProgname, rawfile, osstrerror());
exit(1);
}
printf("Raw dump of physical archive file \"%s\" ...\n", rawfile);
rawdump(f);
exit(0);
}
if (dflag + iflag + lflag + mflag + tflag == 0)
mflag = 1; /* default */
/* delay option end processing until now that we have the archive name */
if (opts.narchives == 0)
__pmAddOptArchive(&opts, argv[opts.optind++]);
opts.flags &= ~PM_OPTFLAG_DONE;
__pmEndOptions(&opts);
if ((sts = ctxid = pmNewContext(PM_CONTEXT_ARCHIVE, opts.archives[0])) < 0) {
fprintf(stderr, "%s: Cannot open archive \"%s\": %s\n",
pmProgname, opts.archives[0], pmErrStr(sts));
exit(1);
}
/* complete TZ and time window option (origin) setup */
if (pmGetContextOptions(ctxid, &opts)) {
pmflush();
exit(1);
}
numpmid = argc - opts.optind;
if (numpmid) {
numpmid = 0;
pmid = NULL;
for (i = 0; opts.optind < argc; i++, opts.optind++) {
numpmid++;
pmid = (pmID *)realloc(pmid, numpmid * sizeof(pmID));
if ((sts = pmLookupName(1, &argv[opts.optind], &pmid[numpmid-1])) < 0) {
if (sts == PM_ERR_NONLEAF) {
numpmid--;
if ((sts = pmTraversePMNS(argv[opts.optind], dometric)) < 0)
fprintf(stderr, "%s: pmTraversePMNS(%s): %s\n",
pmProgname, argv[opts.optind], pmErrStr(sts));
}
else
fprintf(stderr, "%s: pmLookupName(%s): %s\n",
pmProgname, argv[opts.optind], pmErrStr(sts));
if (sts < 0)
numpmid--;
}
}
if (numpmid == 0) {
fprintf(stderr, "No metric names can be translated, dump abandoned\n");
exit(1);
}
}
if ((sts = pmGetArchiveLabel(&label)) < 0) {
fprintf(stderr, "%s: Cannot get archive label record: %s\n",
pmProgname, pmErrStr(sts));
exit(1);
}
if (numpmid > 0) {
/*
* setup dummy pmResult
*/
skel_result = (pmResult *)malloc(sizeof(pmResult)+(numpmid-1)*sizeof(pmValueSet *));
if (skel_result == NULL) {
fprintf(stderr, "%s: malloc(skel_result): %s\n", pmProgname, osstrerror());
exit(1);
}
}
/*
* Note: ctxp->c_lock remains locked throughout ... __pmHandleToPtr()
* is only called once, and a single context is used throughout
* ... so there is no PM_UNLOCK(ctxp->c_lock) anywhere in the
* pmdumplog code.
* This works because ctxp->c_lock is a recursive lock and
* pmdumplog is single-threaded.
*/
if ((ctxp = __pmHandleToPtr(ctxid)) == NULL) {
fprintf(stderr, "%s: botch: __pmHandleToPtr(%d) returns NULL!\n",
pmProgname, ctxid);
exit(1);
}
pmSetMode(mode, &opts.start, 0);
if (lflag)
dumpLabel(Lflag);
if (dflag)
dumpDesc(ctxp);
if (iflag)
dumpInDom(ctxp);
if (tflag)
dumpTI(ctxp);
if (mflag) {
if (mode == PM_MODE_FORW) {
if (opts.start_optarg != NULL || opts.finish_optarg != NULL) {
/* -S or -T */
sts = pmSetMode(mode, &opts.start, 0);
done = opts.finish;
}
else {
/* read the whole archive */
done.tv_sec = 0;
done.tv_usec = 0;
sts = pmSetMode(mode, &done, 0);
done.tv_sec = INT_MAX;
}
}
else {
if (opts.start_optarg != NULL || opts.finish_optarg != NULL) {
/* -S or -T */
done.tv_sec = INT_MAX;
done.tv_usec = 0;
sts = pmSetMode(mode, &done, 0);
done = opts.start;
}
else {
/* read the whole archive backwards */
done.tv_sec = INT_MAX;
done.tv_usec = 0;
sts = pmSetMode(mode, &done, 0);
done.tv_sec = 0;
}
}
if (sts < 0) {
fprintf(stderr, "%s: pmSetMode: %s\n", pmProgname, pmErrStr(sts));
exit(1);
}
sts = 0;
for ( ; ; ) {
sts = __pmLogFetch(ctxp, 0, NULL, &raw_result);
if (sts < 0)
break;
if (numpmid == 0 || (raw_result->numpmid == 0 && Mflag)) {
/*
* want 'em all or <mark> record ...
*/
result = raw_result;
}
else if (numpmid > 0) {
/*
* cherry pick from raw_result if pmid matches one
* of interest
*/
int picked = 0;
int j;
skel_result->timestamp = raw_result->timestamp;
for (j = 0; j < numpmid; j++)
skel_result->vset[j] = NULL;
for (i = 0; i < raw_result->numpmid; i++) {
for (j = 0; j < numpmid; j++) {
if (pmid[j] == raw_result->vset[i]->pmid) {
skel_result->vset[j] = raw_result->vset[i];
picked++;
break;
}
}
}
if (picked == 0) {
/* no metrics of interest, skip this record */
pmFreeResult(raw_result);
continue;
}
skel_result->numpmid = picked;
if (picked != numpmid) {
/* did not find 'em all ... shuffle time */
int j;
i = 0;
for (j = 0; j < numpmid; j++) {
if (skel_result->vset[j] != NULL)
skel_result->vset[i++] = skel_result->vset[j];
}
}
result = skel_result;
}
else {
/* not interesting */
pmFreeResult(raw_result);
continue;
}
if (first && mode == PM_MODE_BACK) {
first = 0;
printf("\nLog finished at %24.24s - dump in reverse order\n",
pmCtime(&result->timestamp.tv_sec, timebuf));
}
if ((mode == PM_MODE_FORW && tvcmp(result->timestamp, done) > 0) ||
(mode == PM_MODE_BACK && tvcmp(result->timestamp, done) < 0)) {
sts = PM_ERR_EOL;
break;
}
putchar('\n');
dump_result(result);
pmFreeResult(raw_result);
}
if (sts != PM_ERR_EOL) {
fprintf(stderr, "%s: pmFetch: %s\n", pmProgname, pmErrStr(sts));
exit(1);
}
}
exit(0);
}
static int process_result(int in, int out, int ref)
{
dump_result(in,out);
return CHECK(out,ref);
}
