static void
print_group(struct gfarm_group_info *gi)
{
printf("groupname=%s", gi->groupname);
if (!opt_verbose)
return;
if (gi->nusers > 0)
print_stringlist("usernames", gi->usernames);
}
static void
print_host(struct gfarm_host_info *hi)
{
printf("hostname=%s", hi->hostname);
if (!opt_verbose)
return;
printf(";port=%d;architecture=%s;ncpu=%d;flags=0x%x",
hi->port, hi->architecture, hi->ncpu, hi->flags);
if (hi->nhostaliases > 0)
print_stringlist("aliases", hi->hostaliases);
}
static void
print_obj(enum journal_operation ope, void *obj)
{
switch (ope) {
case GFM_JOURNAL_BEGIN:
case GFM_JOURNAL_END:
break;
case GFM_JOURNAL_HOST_ADD:
print_host(obj);
break;
case GFM_JOURNAL_HOST_MODIFY: {
struct db_host_modify_arg *m = obj;
print_host(&m->hi);
if (opt_verbose) {
print_modflags(m->modflags, host_modflag_info);
if (m->add_count > 0)
print_stringlist("add_aliases",
m->add_aliases);
if (m->del_count > 0)
print_stringlist("del_aliases",
m->del_aliases);
}
break;
}
case GFM_JOURNAL_USER_ADD:
print_user(obj);
break;
case GFM_JOURNAL_USER_MODIFY: {
struct db_user_modify_arg *m = obj;
print_user(&m->ui);
if (opt_verbose)
print_modflags(m->modflags, user_modflag_info);
break;
}
case GFM_JOURNAL_GROUP_ADD:
print_group(obj);
break;
case GFM_JOURNAL_GROUP_MODIFY: {
struct db_group_modify_arg *m = obj;
print_group(&m->gi);
if (opt_verbose) {
print_modflags(m->modflags, NULL);
if (m->add_count > 0)
print_stringlist("add_users",
m->add_users);
if (m->del_count > 0)
print_stringlist("del_users",
m->del_users);
}
break;
}
case GFM_JOURNAL_HOST_REMOVE:
case GFM_JOURNAL_USER_REMOVE:
case GFM_JOURNAL_GROUP_REMOVE:
case GFM_JOURNAL_MDHOST_REMOVE:
printf("name=%s", (const char *)obj);
break;
case GFM_JOURNAL_INODE_ADD:
case GFM_JOURNAL_INODE_MODIFY:
print_stat(obj);
break;
case GFM_JOURNAL_INODE_GEN_MODIFY:
case GFM_JOURNAL_INODE_NLINK_MODIFY:
case GFM_JOURNAL_INODE_SIZE_MODIFY: {
struct db_inode_uint64_modify_arg *m = obj;
printf("ino=%" GFARM_PRId64, m->inum);
if (opt_verbose)
printf(";uint64=%" GFARM_PRId64 "", m->uint64);
break;
}
case GFM_JOURNAL_INODE_MODE_MODIFY: {
struct db_inode_uint32_modify_arg *m = obj;
printf("ino=%" GFARM_PRId64, m->inum);
if (opt_verbose)
printf(";uint32=%d", m->uint32);
break;
}
case GFM_JOURNAL_INODE_USER_MODIFY:
case GFM_JOURNAL_INODE_GROUP_MODIFY: {
struct db_inode_string_modify_arg *m = obj;
printf("ino=%" GFARM_PRId64, m->inum);
if (opt_verbose)
printf(";string=%s", m->string);
break;
}
case GFM_JOURNAL_INODE_ATIME_MODIFY:
case GFM_JOURNAL_INODE_MTIME_MODIFY:
case GFM_JOURNAL_INODE_CTIME_MODIFY: {
struct db_inode_timespec_modify_arg *m = obj;
printf("ino=%" GFARM_PRId64, m->inum);
if (opt_verbose)
print_timespec("time", &m->time);
break;
}
case GFM_JOURNAL_INODE_CKSUM_ADD:
case GFM_JOURNAL_INODE_CKSUM_MODIFY: {
struct db_inode_cksum_arg *m = obj;
printf("ino=%" GFARM_PRId64, m->inum);
if (opt_verbose)
printf(";type=%s;len=%lu", m->type,
(unsigned long)m->len);
break;
}
case GFM_JOURNAL_INODE_CKSUM_REMOVE:
case GFM_JOURNAL_SYMLINK_REMOVE: {
struct db_inode_inum_arg *m = obj;
printf("ino=%" GFARM_PRId64, m->inum);
break;
}
case GFM_JOURNAL_FILECOPY_ADD:
case GFM_JOURNAL_FILECOPY_REMOVE: {
struct db_filecopy_arg *m = obj;
printf("ino=%" GFARM_PRId64, m->inum);
if (opt_verbose)
printf(";hostname=%s", m->hostname);
break;
}
case GFM_JOURNAL_DEADFILECOPY_ADD:
case GFM_JOURNAL_DEADFILECOPY_REMOVE: {
struct db_deadfilecopy_arg *m = obj;
printf("ino=%" GFARM_PRId64, m->inum);
if (opt_verbose)
printf(";igen=%" GFARM_PRId64 ";hostname=%s",
m->igen, m->hostname);
break;
}
case GFM_JOURNAL_DIRENTRY_ADD:
case GFM_JOURNAL_DIRENTRY_REMOVE: {
struct db_direntry_arg *m = obj;
printf("ino=%" GFARM_PRId64, m->dir_inum);
if (opt_verbose)
printf(";entry_ino=%" GFARM_PRId64
";entry_name=%s;entry_len=%d",
m->entry_inum, m->entry_name, m->entry_len);
break;
}
case GFM_JOURNAL_SYMLINK_ADD: {
struct db_symlink_arg *m = obj;
printf("ino=%" GFARM_PRId64, m->inum);
if (opt_verbose)
printf(";source_path=%s", m->source_path);
break;
}
case GFM_JOURNAL_XATTR_ADD:
case GFM_JOURNAL_XATTR_MODIFY:
case GFM_JOURNAL_XATTR_REMOVE:
case GFM_JOURNAL_XATTR_REMOVEALL: {
struct db_xattr_arg *m = obj;
printf("ino=%" GFARM_PRId64, m->inum);
if (opt_verbose) {
printf(";xml_mode=%d;attrname=%s;size=%lu",
m->xmlMode, m->attrname, (unsigned long)m->size);
print_bin_value("value", m->value, m->size);
}
break;
}
case GFM_JOURNAL_QUOTA_ADD:
case GFM_JOURNAL_QUOTA_MODIFY: {
struct db_quota_arg *m = obj;
printf("name=%s;is_group=%d", m->name, m->is_group);
if (opt_verbose)
print_quota(&m->quota);
break;
}
case GFM_JOURNAL_QUOTA_REMOVE: {
struct db_quota_remove_arg *m = obj;
printf("name=%s;is_group=%d", m->name, m->is_group);
break;
}
case GFM_JOURNAL_MDHOST_ADD:
print_mdhost(obj);
break;
case GFM_JOURNAL_MDHOST_MODIFY: {
struct db_mdhost_modify_arg *m = obj;
print_mdhost(&m->ms);
break;
}
case GFM_JOURNAL_FSNGROUP_MODIFY: {
struct db_fsngroup_modify_arg *m = obj;
print_fsngroup_modify(m->hostname, m->fsngroupname);
break;
}
default:
break;
}
}
static void dump2(bytecode_input_t *d, int bc_len)
{
int i;
int version, requires;
if (!d) return;
i = bc_header_parse(d, &version, &requires);
if (i < 0) {
printf("not a bytecode file [magic number test failed]\n");
return;
}
printf("Bytecode version: %d\n", version);
if (version >= 0x11) {
printf("Require:");
if (requires & BFE_VARIABLES) printf(" Variables");
printf("\n");
}
printf("\n");
while (i < bc_len) {
commandlist_t cmd;
printf("%04d: ", i);
i = bc_action_parse(d, i, version, &cmd);
switch (cmd.type) {
case B_STOP:
printf("STOP");
break;
case B_KEEP_ORIG:
case B_KEEP_COPY:
case B_KEEP:
printf("KEEP");
if (cmd.type >= B_KEEP_COPY) {
print_stringlist(" FLAGS", cmd.u.k.flags);
}
break;
case B_DISCARD:
printf("DISCARD");
break;
case B_EREJECT:
printf("E");
GCC_FALLTHROUGH
case B_REJECT:
print_string("REJECT ", cmd.u.str);
break;
case B_ERROR:
print_string("ERROR ", cmd.u.str);
break;
case B_FILEINTO_ORIG:
case B_FILEINTO_COPY:
case B_FILEINTO_FLAGS:
case B_FILEINTO_CREATE:
case B_FILEINTO_SPECIALUSE:
case B_FILEINTO:
printf("FILEINTO");
if (cmd.type >= B_FILEINTO_COPY) {
printf(" COPY(%d)", cmd.u.f.copy);
if (cmd.type >= B_FILEINTO_FLAGS) {
print_stringlist(" FLAGS", cmd.u.f.flags);
if (cmd.type >= B_FILEINTO_CREATE) {
printf("\n\tCREATE(%d)", cmd.u.f.create);
if (cmd.type >= B_FILEINTO_SPECIALUSE) {
print_string(" SPECIALUSE", cmd.u.f.specialuse);
if (cmd.type >= B_FILEINTO) {
print_string(" MAILBOXID", cmd.u.f.mailboxid);
}
}
}
}
}
print_string(" FOLDER", cmd.u.f.folder);
break;
case B_REDIRECT_ORIG:
case B_REDIRECT_COPY:
case B_REDIRECT_LIST:
case B_REDIRECT:
printf("REDIRECT");
if (cmd.type >= B_REDIRECT_COPY) {
printf(" COPY(%d)", cmd.u.r.copy);
if (cmd.type >= B_REDIRECT_LIST) {
printf( "LIST(%d)", cmd.u.r.list);
if (cmd.type >= B_REDIRECT) {
print_string(" BYTIME", cmd.u.r.bytime);
print_string(" BYMODE", cmd.u.r.bymode);
printf(" BYTRACE(%d)", cmd.u.r.bytrace);
print_string("\n\tDSN-NOTIFY", cmd.u.r.dsn_notify);
print_string(" DSN-RET", cmd.u.r.dsn_ret);
}
}
}
print_string(" ADDRESS", cmd.u.r.address);
break;
case B_IF:
printf("IF (ends at %d) ", cmd.u.i.testend);
i = dump2_test(d, i, version);
break;
case B_MARK:
printf("MARK");
break;
case B_UNMARK:
printf("UNMARK");
break;
case B_ADDFLAG_ORIG:
case B_ADDFLAG:
printf("ADDFLAG");
if (cmd.type >= B_ADDFLAG)
print_string(" VARIABLE", cmd.u.fl.variable);
print_stringlist(" FLAGS", cmd.u.fl.flags);
break;
case B_SETFLAG_ORIG:
case B_SETFLAG:
printf("SETFLAG");
if (cmd.type >= B_SETFLAG)
print_string(" VARIABLE", cmd.u.fl.variable);
print_stringlist(" FLAGS", cmd.u.fl.flags);
break;
case B_REMOVEFLAG_ORIG:
case B_REMOVEFLAG:
printf("REMOVEFLAG");
if (cmd.type >= B_REMOVEFLAG)
print_string(" VARIABLE", cmd.u.fl.variable);
print_stringlist(" FLAGS", cmd.u.fl.flags);
break;
case B_DENOTIFY:
printf("DENOTIFY PRIORITY(%d)", cmd.u.d.priority);
if (cmd.u.d.pattern) {
print_comparator(&cmd.u.d.comp);
print_string("\n\tPATTERN", cmd.u.d.pattern);
}
break;
case B_ENOTIFY:
printf("E");
GCC_FALLTHROUGH
case B_NOTIFY:
printf("NOTIFY ");
print_string(" METHOD", cmd.u.n.method);
if (cmd.type == B_ENOTIFY) {
printf(" IMPORTANCE(%d)", cmd.u.n.priority);
print_string(" FROM", cmd.u.n.from);
}
else {
printf(" PRIORITY(%d)", cmd.u.n.priority);
print_string(" ID", cmd.u.n.id);
}
print_stringlist(" OPTIONS", cmd.u.n.options);
print_string("\n\tMESSAGE", cmd.u.n.message);
break;
case B_VACATION_ORIG:
case B_VACATION_SEC:
case B_VACATION_FCC:
case B_VACATION:
printf("VACATION");
print_stringlist(" ADDR", cmd.u.v.addresses);
print_string("\n\tSUBJ", cmd.u.v.subject);
print_string("\n\tMESG", cmd.u.v.message);
printf("\n\tSECONDS(%d) MIME(%d)",
cmd.u.v.seconds * (cmd.type == B_VACATION_ORIG ? DAY2SEC : 1),
cmd.u.v.mime);
if (version >= 0x05) {
print_string(" FROM", cmd.u.v.from);
print_string(" HANDLE", cmd.u.v.handle);
if (cmd.type >= B_VACATION_FCC) {
print_string("\n\tFCC", cmd.u.v.fcc.folder);
if (cmd.u.v.fcc.folder) {
printf(" CREATE(%d)", cmd.u.v.fcc.create);
print_stringlist(" FLAGS", cmd.u.v.fcc.flags);
if (cmd.type >= B_VACATION) {
print_string("\n\tSPECIALUSE",
cmd.u.v.fcc.specialuse);
}
}
}
}
break;
case B_NULL:
printf("NULL");
break;
case B_JUMP:
printf("JUMP %d", cmd.u.jump);
break;
case B_INCLUDE:
printf("INCLUDE LOCATION(%s) ONCE(%d) OPTIONAL(%d)",
(cmd.u.inc.location = B_PERSONAL) ? "Personal" : "Global",
cmd.u.inc.once, cmd.u.inc.optional);
print_string("\n\tSCRIPT", cmd.u.inc.script);
break;
case B_SET:
printf("SET LOWER(%d) UPPER(%d)",
cmd.u.s.mod40 & BFV_LOWER, cmd.u.s.mod40 & BFV_UPPER);
printf(" LOWERFIRST(%d) UPPERFIRST(%d)",
cmd.u.s.mod30 & BFV_LOWERFIRST,
cmd.u.s.mod30 & BFV_UPPERFIRST);
printf("\n\tQUOTEWILDCARD(%d) QUOTEREGEX(%d)",
cmd.u.s.mod20 & BFV_QUOTEWILDCARD,
cmd.u.s.mod20 & BFV_QUOTEREGEX);
printf(" ENCODEURL(%d) LENGTH(%d)",
cmd.u.s.mod15 & BFV_ENCODEURL, cmd.u.s.mod10 & BFV_LENGTH);
print_string("\n\tVARIABLE", cmd.u.s.variable);
print_string(" VALUE", cmd.u.s.value);
break;
case B_ADDHEADER:
printf("ADDHEADER INDEX(%d)", cmd.u.ah.index);
print_string(" NAME", cmd.u.ah.name);
print_string(" VALUE", cmd.u.ah.value);
break;
case B_DELETEHEADER:
printf("DELETEHEADER INDEX(%d)", cmd.u.dh.comp.index);
print_comparator(&cmd.u.dh.comp);
print_string("\n\tNAME", cmd.u.dh.name);
print_stringlist(" VALUES", cmd.u.dh.values);
break;
case B_RETURN:
printf("RETURN");
break;
default:
printf("%d (NOT AN OP)\n", cmd.type);
exit(1);
}
printf("\n");
}
printf("full len is: %d\n", bc_len);
}
static void print_test(test_t *test)
{
switch (test->type) {
case BC_FALSE:
printf("FALSE");
break;
case BC_TRUE:
printf("TRUE");
break;
case BC_EXISTS:
print_stringlist("EXISTS", test->u.sl);
break;
case BC_SIZE:
printf("SIZE %s %d",
(test->u.sz.t == B_OVER) ? "over" : "under", test->u.sz.n);
break;
case BC_ADDRESS:
printf("ADDRESS");
printf(" ADDRPART(%s)", addrpart_to_string(test->u.ae.addrpart));
if (test->u.ae.comp.index) {
printf(" INDEX(%d %s)", abs(test->u.ae.comp.index),
(test->u.ae.comp.index < 0) ? "[LAST]" : "");
}
print_comparator(&test->u.ae.comp);
print_stringlist("\n\tHEADERS", test->u.ae.sl);
print_stringlist(" PATTERNS", test->u.ae.pl);
break;
case BC_ENVELOPE:
printf("ENVELOPE");
printf(" ADDRPART(%s)", addrpart_to_string(test->u.ae.addrpart));
print_comparator(&test->u.ae.comp);
print_stringlist("\n\tHEADERS", test->u.ae.sl);
print_stringlist(" PATTERNS", test->u.ae.pl);
break;
case BC_HEADER:
printf("HEADER");
if (test->u.hhs.comp.index) {
printf(" INDEX(%d %s)", abs(test->u.hhs.comp.index),
(test->u.hhs.comp.index < 0) ? "[LAST]" : "");
}
print_comparator(&test->u.hhs.comp);
print_stringlist("\n\tHEADERS", test->u.hhs.sl);
print_stringlist(" PATTERNS", test->u.hhs.pl);
break;
case BC_BODY:
printf("BODY");
print_comparator(&test->u.b.comp);
printf("\n\tTRANSFORM(%s)", transform_to_string(test->u.b.transform));
printf(" OFFSET(%d)", test->u.b.offset);
print_stringlist(" CONTENT-TYPES", test->u.b.content_types);
print_stringlist(" PATTERNS", test->u.b.pl);
break;
case BC_DATE:
printf("DATE");
if (test->u.dt.comp.index) {
printf(" INDEX(%d %s)", abs(test->u.dt.comp.index),
(test->u.dt.comp.index < 0) ? "[LAST]" : "");
}
if (test->u.dt.zonetag == B_TIMEZONE)
printf(" ZONE(%+dmin)", test->u.dt.zone);
else
printf(" ZONE(ORIGINAL)");
print_comparator(&test->u.dt.comp);
printf("\n\tDATEPART(%s)", datepart_to_string(test->u.dt.date_part));
print_string(" HEADER", test->u.dt.header_name);
print_stringlist(" KEYS", test->u.dt.kl);
break;
case BC_CURRENTDATE:
printf("CURRENTDATE");
if (test->u.dt.zonetag == B_TIMEZONE)
printf(" ZONE(%+dmin)", test->u.dt.zone);
else
printf(" ZONE(ORIGINAL)");
print_comparator(&test->u.dt.comp);
printf("\n\tDATEPART(%s)", datepart_to_string(test->u.dt.date_part));
print_stringlist(" KEYS", test->u.dt.kl);
break;
case BC_HASFLAG:
printf("HASFLAG");
print_comparator(&test->u.hhs.comp);
print_stringlist("\n\tVARIABLES", test->u.hhs.sl);
print_stringlist(" PATTERNS", test->u.hhs.pl);
break;
case BC_MAILBOXEXISTS:
print_stringlist("MAILBOXEXISTS", test->u.mm.keylist);
break;
case BC_MAILBOXIDEXISTS:
print_stringlist("MAILBOXIDEXISTS", test->u.mm.keylist);
break;
case BC_METADATA:
printf("METADATA");
print_comparator(&test->u.mm.comp);
print_string("\n\tMAILBOX", test->u.mm.extname);
print_string(" ANNOTATION", test->u.mm.keyname);
print_stringlist(" PATTERNS", test->u.mm.keylist);
break;
case BC_METADATAEXISTS:
printf("METAEXISTS");
print_string("MAILBOX", test->u.mm.extname);
print_stringlist(" ANNOTATIONS", test->u.mm.keylist);
break;
case BC_SERVERMETADATA:
printf("SERVERMETADATA");
print_comparator(&test->u.mm.comp);
print_string("\n\tANNOTATION", test->u.mm.keyname);
print_stringlist(" PATTERNS", test->u.mm.keylist);
break;
case BC_SERVERMETADATAEXISTS:
print_stringlist("SERVERMETADATAEXISTS", test->u.mm.keylist);
break;
case BC_STRING:
printf("STRING");
print_comparator(&test->u.hhs.comp);
print_stringlist("\n\tVARIABLES", test->u.hhs.sl);
print_stringlist(" PATTERNS", test->u.hhs.pl);
break;
case BC_VALIDEXTLIST:
print_stringlist("VALIDEXTLIST", test->u.sl);
break;
case BC_VALIDNOTIFYMETHOD:
print_stringlist("VALIDNOTIFYMETHOD", test->u.sl);
break;
case BC_NOTIFYMETHODCAPABILITY:
printf("NOTIFYMETHODCAPABILITY");
print_comparator(&test->u.mm.comp);
print_string("\n\tURI", test->u.mm.extname);
print_string(" CAPABILITY", test->u.mm.keyname);
print_stringlist(" KEYS", test->u.mm.keylist);
break;
case BC_DUPLICATE:
printf("DUPLICATE");
print_string((test->u.dup.idtype == B_UNIQUEID) ?
" UNIQUEID" : " HDRNAME", test->u.dup.idval);
print_string(" HANDLE", test->u.dup.handle);
printf("\n\tSECONDS(%d) LAST(%d)",
test->u.dup.seconds, test->u.dup.last);
break;
case BC_IHAVE:
print_stringlist("IHAVE", test->u.sl);
break;
case BC_SPECIALUSEEXISTS:
printf("SPECIALUSEEXISTS");
print_string("MAILBOX", test->u.mm.extname);
print_stringlist(" FLAGS", test->u.mm.keylist);
break;
case BC_ENVIRONMENT:
printf("ENVIRONMENT");
print_comparator(&test->u.mm.comp);
print_string("\n\tITEM", test->u.mm.keyname);
print_stringlist(" KEYS", test->u.mm.keylist);
break;
}
printf("\n");
}
