void struct_recursive_analyze(void *arg_ptr, enum struct_argtype struct_argtype, xmlTextWriterPtr writer) {
if(arg_ptr == NULL)
return;
if(nullfd == 0)
nullfd = open("/dev/random", O_WRONLY);
switch(struct_argtype) {
struct timeval timeval_s;
struct timeval *timeval_p;
struct timezone timezone_s;
struct timezone *timezone_p;
struct timex timex_s;
struct timex *timex_p;
struct tms tms_s;
struct tms *tms_p;
struct timespec timespec_s;
struct timespec *timespec_p;
struct itimerval itimerval_s;
struct itimerval *itimerval_p;
struct sigevent sigevent_s;
struct sigevent *sigevent_p;
struct itimerspec itimerspec_s;
struct itimerspec *itimerspec_p;
struct sched_param sched_param_s;
struct sched_param *sched_param_p;
struct kexec_segment kexec_segment_s;
struct kexec_segment *kexec_segment_p;
struct rusage rusage_s;
struct rusage *rusage_p;
struct siginfo siginfo_s;
struct siginfo *siginfo_p;
struct statfs statfs_s;
struct statfs *statfs_p;
struct statfs64 statfs64_s;
struct statfs64 *statfs64_p;
struct stat stat_s;
struct stat *stat_p;
struct stat64 stat64_s;
struct stat64 *stat64_p;
struct io_event io_event_s;
struct io_event *io_event_p;
struct iocb iocb_s;
struct iocb *iocb_p;
struct utimbuf utimbuf_s;
struct utimbuf *utimbuf_p;
struct iovec iovec_s;
struct iovec *iovec_p;
struct linux_dirent linux_dirent_s;
struct linux_dirent *linux_dirent_p;
struct linux_dirent64 linux_dirent64_s;
struct linux_dirent64 *linux_dirent64_p;
struct sockaddr sockaddr_s;
struct sockaddr *sockaddr_p;
struct msghdr msghdr_s;
struct msghdr *msghdr_p;
struct mmsghdr mmsghdr_s;
struct mmsghdr *mmsghdr_p;
struct pollfd pollfd_s;
struct pollfd *pollfd_p;
struct sel_arg_struct sel_arg_struct_s;
struct sel_arg_struct *sel_arg_struct_p;
struct epoll_event epoll_event_s;
struct epoll_event *epoll_event_p;
struct new_utsname new_utsname_s;
struct new_utsname *new_utsname_p;
struct rlimit rlimit_s;
struct rlimit *rlimit_p;
struct rlimit64 rlimit64_s;
struct rlimit64 *rlimit64_p;
struct msgbuf msgbuf_s;
struct msgbuf *msgbuf_p;
struct msqid_ds msqid_ds_s;
struct msqid_ds *msqid_ds_p;
struct sembuf sembuf_s;
struct sembuf *sembuf_p;
struct shmid_ds shmid_ds_s;
struct shmid_ds *shmid_ds_p;
struct mq_attr mq_attr_s;
struct mq_attr *mq_attr_p;
struct __sysctl_args __sysctl_args_s;
struct __sysctl_args *__sysctl_args_p;
struct robust_list_head robust_list_head_s;
struct robust_list_head *robust_list_head_p;
struct getcpu_cache getcpu_cache_s;
struct getcpu_cache *getcpu_cache_p;
struct perf_event_attr perf_event_attr_s;
struct perf_event_attr *perf_event_attr_p;
struct mmap_arg_struct mmap_arg_struct_s;
struct mmap_arg_struct *mmap_arg_struct_p;
struct file_handle file_handle_s;
struct file_handle *file_handle_p;
case STRUCT_ARG_timeval:
if(write(nullfd, (void *) arg_ptr, sizeof(timeval_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_timeval", "unmapped");
return;
}
timeval_p = (struct timeval *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_timeval");
xmlTextWriterWriteBase64(writer, (char *) timeval_p, 0, sizeof(timeval_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_timezone:
if(write(nullfd, (void *) arg_ptr, sizeof(timezone_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_timezone", "unmapped");
return;
}
timezone_p = (struct timezone *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_timezone");
xmlTextWriterWriteBase64(writer, (char *) timezone_p, 0, sizeof(timezone_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_timex:
if(write(nullfd, (void *) arg_ptr, sizeof(timex_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_timex", "unmapped");
return;
}
timex_p = (struct timex *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_timex");
xmlTextWriterWriteBase64(writer, (char *) timex_p, 0, sizeof(timex_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_tms:
if(write(nullfd, (void *) arg_ptr, sizeof(tms_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_tms", "unmapped");
return;
}
tms_p = (struct tms *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_tms");
xmlTextWriterWriteBase64(writer, (char *) tms_p, 0, sizeof(tms_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_timespec:
if(write(nullfd, (void *) arg_ptr, sizeof(timespec_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_timespec", "unmapped");
return;
}
timespec_p = (struct timespec *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_timespec");
xmlTextWriterWriteBase64(writer, (char *) timespec_p, 0, sizeof(timespec_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_itimerval:
if(write(nullfd, (void *) arg_ptr, sizeof(itimerval_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_itimerval", "unmapped");
return;
}
itimerval_p = (struct itimerval *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_itimerval");
xmlTextWriterWriteBase64(writer, (char *) itimerval_p, 0, sizeof(itimerval_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_sigevent:
if(write(nullfd, (void *) arg_ptr, sizeof(sigevent_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_sigevent", "unmapped");
return;
}
sigevent_p = (struct sigevent *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_sigevent");
xmlTextWriterWriteBase64(writer, (char *) sigevent_p, 0, sizeof(sigevent_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_itimerspec:
if(write(nullfd, (void *) arg_ptr, sizeof(itimerspec_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_itimerspec", "unmapped");
return;
}
itimerspec_p = (struct itimerspec *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_itimerspec");
xmlTextWriterWriteBase64(writer, (char *) itimerspec_p, 0, sizeof(itimerspec_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_sched_param:
if(write(nullfd, (void *) arg_ptr, sizeof(sched_param_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_sched_param", "unmapped");
return;
}
sched_param_p = (struct sched_param *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_sched_param");
xmlTextWriterWriteBase64(writer, (char *) sched_param_p, 0, sizeof(sched_param_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_kexec_segment:
if(write(nullfd, (void *) arg_ptr, sizeof(kexec_segment_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_kexec_segment", "unmapped");
return;
}
kexec_segment_p = (struct kexec_segment *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_kexec_segment");
xmlTextWriterWriteBase64(writer, (char *) kexec_segment_p, 0, sizeof(kexec_segment_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_rusage:
if(write(nullfd, (void *) arg_ptr, sizeof(rusage_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_rusage", "unmapped");
return;
}
rusage_p = (struct rusage *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_rusage");
xmlTextWriterWriteBase64(writer, (char *) rusage_p, 0, sizeof(rusage_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_siginfo:
if(write(nullfd, (void *) arg_ptr, sizeof(siginfo_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_siginfo", "unmapped");
return;
}
siginfo_p = (struct siginfo *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_siginfo");
xmlTextWriterWriteBase64(writer, (char *) siginfo_p, 0, sizeof(siginfo_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_statfs:
if(write(nullfd, (void *) arg_ptr, sizeof(statfs_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_statfs", "unmapped");
return;
}
statfs_p = (struct statfs *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_statfs");
xmlTextWriterWriteBase64(writer, (char *) statfs_p, 0, sizeof(statfs_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_statfs64:
if(write(nullfd, (void *) arg_ptr, sizeof(statfs64_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_statfs64", "unmapped");
return;
}
statfs64_p = (struct statfs64 *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_statfs64");
xmlTextWriterWriteBase64(writer, (char *) statfs64_p, 0, sizeof(statfs64_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_stat:
if(write(nullfd, (void *) arg_ptr, sizeof(stat_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_stat", "unmapped");
return;
}
stat_p = (struct stat *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_stat");
xmlTextWriterWriteBase64(writer, (char *) stat_p, 0, sizeof(stat_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_stat64:
if(write(nullfd, (void *) arg_ptr, sizeof(stat64_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_stat64", "unmapped");
return;
}
stat64_p = (struct stat64 *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_stat64");
xmlTextWriterWriteBase64(writer, (char *) stat64_p, 0, sizeof(stat64_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_io_event:
if(write(nullfd, (void *) arg_ptr, sizeof(io_event_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_io_event", "unmapped");
return;
}
io_event_p = (struct io_event *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_io_event");
xmlTextWriterWriteBase64(writer, (char *) io_event_p, 0, sizeof(io_event_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_iocb:
if(write(nullfd, (void *) arg_ptr, sizeof(iocb_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_iocb", "unmapped");
return;
}
iocb_p = (struct iocb *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_iocb");
xmlTextWriterWriteBase64(writer, (char *) iocb_p, 0, sizeof(iocb_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_utimbuf:
if(write(nullfd, (void *) arg_ptr, sizeof(utimbuf_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_utimbuf", "unmapped");
return;
}
utimbuf_p = (struct utimbuf *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_utimbuf");
xmlTextWriterWriteBase64(writer, (char *) utimbuf_p, 0, sizeof(utimbuf_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_iovec:
if(write(nullfd, (void *) arg_ptr, sizeof(iovec_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_iovec", "unmapped");
return;
}
iovec_p = (struct iovec *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_iovec");
xmlTextWriterWriteBase64(writer, (char *) iovec_p, 0, sizeof(iovec_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_linux_dirent:
if(write(nullfd, (void *) arg_ptr, sizeof(linux_dirent_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_linux_dirent", "unmapped");
return;
}
linux_dirent_p = (struct linux_dirent *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_linux_dirent");
xmlTextWriterWriteBase64(writer, (char *) linux_dirent_p, 0, sizeof(linux_dirent_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_linux_dirent64:
if(write(nullfd, (void *) arg_ptr, sizeof(linux_dirent64_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_linux_dirent64", "unmapped");
return;
}
linux_dirent64_p = (struct linux_dirent64 *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_linux_dirent64");
xmlTextWriterWriteBase64(writer, (char *) linux_dirent64_p, 0, sizeof(linux_dirent64_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_sockaddr:
if(write(nullfd, (void *) arg_ptr, sizeof(sockaddr_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_sockaddr", "unmapped");
return;
}
sockaddr_p = (struct sockaddr *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_sockaddr");
xmlTextWriterWriteBase64(writer, (char *) sockaddr_p, 0, sizeof(sockaddr_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_msghdr:
if(write(nullfd, (void *) arg_ptr, sizeof(msghdr_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_msghdr", "unmapped");
return;
}
msghdr_p = (struct msghdr *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_msghdr");
xmlTextWriterWriteBase64(writer, (char *) msghdr_p, 0, sizeof(msghdr_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_mmsghdr:
if(write(nullfd, (void *) arg_ptr, sizeof(mmsghdr_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_mmsghdr", "unmapped");
return;
}
mmsghdr_p = (struct mmsghdr *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_mmsghdr");
xmlTextWriterWriteBase64(writer, (char *) mmsghdr_p, 0, sizeof(mmsghdr_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_pollfd:
if(write(nullfd, (void *) arg_ptr, sizeof(pollfd_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_pollfd", "unmapped");
return;
}
pollfd_p = (struct pollfd *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_pollfd");
xmlTextWriterWriteBase64(writer, (char *) pollfd_p, 0, sizeof(pollfd_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_sel_arg_struct:
if(write(nullfd, (void *) arg_ptr, sizeof(sel_arg_struct_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_sel_arg_struct", "unmapped");
return;
}
sel_arg_struct_p = (struct sel_arg_struct *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_sel_arg_struct");
xmlTextWriterWriteBase64(writer, (char *) sel_arg_struct_p, 0, sizeof(sel_arg_struct_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_epoll_event:
if(write(nullfd, (void *) arg_ptr, sizeof(epoll_event_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_epoll_event", "unmapped");
return;
}
epoll_event_p = (struct epoll_event *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_epoll_event");
xmlTextWriterWriteBase64(writer, (char *) epoll_event_p, 0, sizeof(epoll_event_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_new_utsname:
if(write(nullfd, (void *) arg_ptr, sizeof(new_utsname_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_new_utsname", "unmapped");
return;
}
new_utsname_p = (struct new_utsname *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_new_utsname");
xmlTextWriterWriteBase64(writer, (char *) new_utsname_p, 0, sizeof(new_utsname_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_rlimit:
if(write(nullfd, (void *) arg_ptr, sizeof(rlimit_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_rlimit", "unmapped");
return;
}
rlimit_p = (struct rlimit *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_rlimit");
xmlTextWriterWriteBase64(writer, (char *) rlimit_p, 0, sizeof(rlimit_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_rlimit64:
if(write(nullfd, (void *) arg_ptr, sizeof(rlimit64_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_rlimit64", "unmapped");
return;
}
rlimit64_p = (struct rlimit64 *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_rlimit64");
xmlTextWriterWriteBase64(writer, (char *) rlimit64_p, 0, sizeof(rlimit64_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_msgbuf:
if(write(nullfd, (void *) arg_ptr, sizeof(msgbuf_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_msgbuf", "unmapped");
return;
}
msgbuf_p = (struct msgbuf *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_msgbuf");
xmlTextWriterWriteBase64(writer, (char *) msgbuf_p, 0, sizeof(msgbuf_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_msqid_ds:
if(write(nullfd, (void *) arg_ptr, sizeof(msqid_ds_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_msqid_ds", "unmapped");
return;
}
msqid_ds_p = (struct msqid_ds *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_msqid_ds");
xmlTextWriterWriteBase64(writer, (char *) msqid_ds_p, 0, sizeof(msqid_ds_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_sembuf:
if(write(nullfd, (void *) arg_ptr, sizeof(sembuf_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_sembuf", "unmapped");
return;
}
sembuf_p = (struct sembuf *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_sembuf");
xmlTextWriterWriteBase64(writer, (char *) sembuf_p, 0, sizeof(sembuf_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_shmid_ds:
if(write(nullfd, (void *) arg_ptr, sizeof(shmid_ds_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_shmid_ds", "unmapped");
return;
}
shmid_ds_p = (struct shmid_ds *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_shmid_ds");
xmlTextWriterWriteBase64(writer, (char *) shmid_ds_p, 0, sizeof(shmid_ds_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_mq_attr:
if(write(nullfd, (void *) arg_ptr, sizeof(mq_attr_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_mq_attr", "unmapped");
return;
}
mq_attr_p = (struct mq_attr *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_mq_attr");
xmlTextWriterWriteBase64(writer, (char *) mq_attr_p, 0, sizeof(mq_attr_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG___sysctl_args:
if(write(nullfd, (void *) arg_ptr, sizeof(__sysctl_args_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT___sysctl_args", "unmapped");
return;
}
__sysctl_args_p = (struct __sysctl_args *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT___sysctl_args");
xmlTextWriterWriteBase64(writer, (char *) __sysctl_args_p, 0, sizeof(__sysctl_args_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_robust_list_head:
if(write(nullfd, (void *) arg_ptr, sizeof(robust_list_head_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_robust_list_head", "unmapped");
return;
}
robust_list_head_p = (struct robust_list_head *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_robust_list_head");
xmlTextWriterWriteBase64(writer, (char *) robust_list_head_p, 0, sizeof(robust_list_head_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_getcpu_cache:
if(write(nullfd, (void *) arg_ptr, sizeof(getcpu_cache_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_getcpu_cache", "unmapped");
return;
}
getcpu_cache_p = (struct getcpu_cache *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_getcpu_cache");
xmlTextWriterWriteBase64(writer, (char *) getcpu_cache_p, 0, sizeof(getcpu_cache_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_perf_event_attr:
if(write(nullfd, (void *) arg_ptr, sizeof(perf_event_attr_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_perf_event_attr", "unmapped");
return;
}
perf_event_attr_p = (struct perf_event_attr *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_perf_event_attr");
xmlTextWriterWriteBase64(writer, (char *) perf_event_attr_p, 0, sizeof(perf_event_attr_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_mmap_arg_struct:
if(write(nullfd, (void *) arg_ptr, sizeof(mmap_arg_struct_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_mmap_arg_struct", "unmapped");
return;
}
mmap_arg_struct_p = (struct mmap_arg_struct *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_mmap_arg_struct");
xmlTextWriterWriteBase64(writer, (char *) mmap_arg_struct_p, 0, sizeof(mmap_arg_struct_s));
xmlTextWriterEndElement(writer);
break;
case STRUCT_ARG_file_handle:
if(write(nullfd, (void *) arg_ptr, sizeof(file_handle_s)) < 0) {
xmlTextWriterWriteElement(writer, "STRUCT_file_handle", "unmapped");
return;
}
file_handle_p = (struct file_handle *) arg_ptr;
xmlTextWriterStartElement(writer, "STRUCT_file_handle");
xmlTextWriterWriteBase64(writer, (char *) file_handle_p, 0, sizeof(file_handle_s));
xmlTextWriterEndElement(writer);
break;
default:
break;
}
}
static void
output_root (xmlTextWriterPtr xo, char *root)
{
char *str;
int i, r;
char buf[32];
char *canonical_root;
size_t size;
XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "operatingsystem"));
canonical_root = guestfs_canonical_device_name (g, root);
if (canonical_root == NULL)
exit (EXIT_FAILURE);
XMLERROR (-1,
xmlTextWriterWriteElement (xo, BAD_CAST "root", BAD_CAST canonical_root));
free (canonical_root);
str = guestfs_inspect_get_type (g, root);
if (!str) exit (EXIT_FAILURE);
if (STRNEQ (str, "unknown"))
XMLERROR (-1,
xmlTextWriterWriteElement (xo, BAD_CAST "name", BAD_CAST str));
free (str);
str = guestfs_inspect_get_arch (g, root);
if (!str) exit (EXIT_FAILURE);
if (STRNEQ (str, "unknown"))
XMLERROR (-1,
xmlTextWriterWriteElement (xo, BAD_CAST "arch", BAD_CAST str));
free (str);
str = guestfs_inspect_get_distro (g, root);
if (!str) exit (EXIT_FAILURE);
if (STRNEQ (str, "unknown"))
XMLERROR (-1,
xmlTextWriterWriteElement (xo, BAD_CAST "distro", BAD_CAST str));
free (str);
str = guestfs_inspect_get_product_name (g, root);
if (!str) exit (EXIT_FAILURE);
if (STRNEQ (str, "unknown"))
XMLERROR (-1,
xmlTextWriterWriteElement (xo, BAD_CAST "product_name", BAD_CAST str));
free (str);
str = guestfs_inspect_get_product_variant (g, root);
if (!str) exit (EXIT_FAILURE);
if (STRNEQ (str, "unknown"))
XMLERROR (-1,
xmlTextWriterWriteElement (xo, BAD_CAST "product_variant", BAD_CAST str));
free (str);
i = guestfs_inspect_get_major_version (g, root);
snprintf (buf, sizeof buf, "%d", i);
XMLERROR (-1,
xmlTextWriterWriteElement (xo, BAD_CAST "major_version", BAD_CAST buf));
i = guestfs_inspect_get_minor_version (g, root);
snprintf (buf, sizeof buf, "%d", i);
XMLERROR (-1,
xmlTextWriterWriteElement (xo, BAD_CAST "minor_version", BAD_CAST buf));
str = guestfs_inspect_get_package_format (g, root);
if (!str) exit (EXIT_FAILURE);
if (STRNEQ (str, "unknown"))
XMLERROR (-1,
xmlTextWriterWriteElement (xo, BAD_CAST "package_format", BAD_CAST str));
free (str);
str = guestfs_inspect_get_package_management (g, root);
if (!str) exit (EXIT_FAILURE);
if (STRNEQ (str, "unknown"))
XMLERROR (-1,
xmlTextWriterWriteElement (xo, BAD_CAST "package_management",
BAD_CAST str));
free (str);
/* inspect-get-windows-systemroot will fail with non-windows guests,
* or if the systemroot could not be determined for a windows guest.
* Disable error output around this call.
*/
guestfs_push_error_handler (g, NULL, NULL);
str = guestfs_inspect_get_windows_systemroot (g, root);
if (str)
XMLERROR (-1,
xmlTextWriterWriteElement (xo, BAD_CAST "windows_systemroot",
BAD_CAST str));
free (str);
str = guestfs_inspect_get_windows_current_control_set (g, root);
if (str)
XMLERROR (-1,
xmlTextWriterWriteElement (xo, BAD_CAST "windows_current_control_set",
BAD_CAST str));
free (str);
guestfs_pop_error_handler (g);
str = guestfs_inspect_get_hostname (g, root);
if (!str) exit (EXIT_FAILURE);
if (STRNEQ (str, "unknown"))
XMLERROR (-1,
xmlTextWriterWriteElement (xo, BAD_CAST "hostname",
BAD_CAST str));
free (str);
str = guestfs_inspect_get_format (g, root);
if (!str) exit (EXIT_FAILURE);
if (STRNEQ (str, "unknown"))
XMLERROR (-1,
xmlTextWriterWriteElement (xo, BAD_CAST "format",
BAD_CAST str));
free (str);
r = guestfs_inspect_is_live (g, root);
if (r > 0) {
XMLERROR (-1,
xmlTextWriterStartElement (xo, BAD_CAST "live"));
XMLERROR (-1, xmlTextWriterEndElement (xo));
}
r = guestfs_inspect_is_netinst (g, root);
if (r > 0) {
XMLERROR (-1,
xmlTextWriterStartElement (xo, BAD_CAST "netinst"));
XMLERROR (-1, xmlTextWriterEndElement (xo));
}
r = guestfs_inspect_is_multipart (g, root);
if (r > 0) {
XMLERROR (-1,
xmlTextWriterStartElement (xo, BAD_CAST "multipart"));
XMLERROR (-1, xmlTextWriterEndElement (xo));
}
output_mountpoints (xo, root);
output_filesystems (xo, root);
output_drive_mappings (xo, root);
/* We need to mount everything up in order to read out the list of
* applications and the icon, ie. everything below this point.
*/
inspect_mount_root (g, root);
output_applications (xo, root);
/* Don't return favicon. RHEL 7 and Fedora have crappy 16x16
* favicons in the base distro.
*/
str = guestfs_inspect_get_icon (g, root, &size,
GUESTFS_INSPECT_GET_ICON_FAVICON, 0,
-1);
if (!str) exit (EXIT_FAILURE);
if (size > 0) {
XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "icon"));
XMLERROR (-1, xmlTextWriterWriteBase64 (xo, str, 0, size));
XMLERROR (-1, xmlTextWriterEndElement (xo));
}
/* Note we must free (str) even if size == 0, because that indicates
* there was no icon.
*/
free (str);
/* Unmount (see inspect_mount_root above). */
if (guestfs_umount_all (g) == -1)
exit (EXIT_FAILURE);
XMLERROR (-1, xmlTextWriterEndElement (xo));
}
int
main(int argc, char* argv[])
{
int rc;
xmlTextWriterPtr writer;
xmlChar *tmp;
xmlDocPtr doc;
const char* file;
/* Check usage and assign out default filename. */
if (argc != 2)
{
usage(argc, argv);
}
file = argv[1];
/* Create a new XmlWrite for DOM, no compression. */
writer = xmlNewTextWriterDoc(&doc, 0);
if (writer == NULL)
{
printf("Error creating XML DOM writer.\n");
return;
}
/* Start the document with the xml default for the version,
* encoding ISO 8859-1 and the default for the standalone
* declaration. */
rc = xmlTextWriterStartDocument(writer, NULL, DEFAULT_ENCODING, NULL);
if (rc < 0)
{
printf("Error at xmlTextWriterStartDocument.\n");
return;
}
/* Start the OME element. Since this is the first element, this will
* be the root element of the document. */
rc = xmlTextWriterStartElement(writer, BAD_CAST "ome:OME");
if (rc < 0)
{
printf("Error at xmlTextWriterStartElement['ome:OME'].\n");
return;
}
/* Add attributes to the OME element. */
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "xmlns:bf",
BAD_CAST "http://www.openmicroscopy.org/Schemas/BinaryFile/2008-09");
if (rc < 0)
{
printf("Error at xmlTextWriterWriteAttribute['xmlns:bf']\n");
return;
}
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "xmlns:ome",
BAD_CAST "http://www.openmicroscopy.org/Schemas/OME/2008-09");
if (rc < 0)
{
printf("Error at xmlTextWriterWriteAttribute['xmlns:ome']\n");
return;
}
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "xmlns:xsi",
BAD_CAST "http://www.w3.org/2001/XMLSchema-instance");
if (rc < 0)
{
printf("Error at xmlTextWriterWriteAttribute['xmlns:xsi']\n");
return;
}
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "xsi:schemaLocation",
BAD_CAST "http://www.openmicroscopy.org/Schemas/OME/2008-09 http://www.openmicroscopy.org/Schemas/OME/2008-09/ome.xsd");
if (rc < 0)
{
printf("Error at xmlTextWriterWriteAttribute['xsi:schemaLocation']\n");
return;
}
/* Start the Image element. */
rc = xmlTextWriterStartElement(writer, BAD_CAST "ome:Image");
if (rc < 0)
{
printf("Error at xmlTextWriterStartElement['ome:Image'].\n");
return;
}
/* Add attributes to the Image element. */
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "ID",
BAD_CAST "Image:1");
if (rc < 0)
{
printf("Error at xmlTextWriterWriteAttribute['Image.ID']\n");
return;
}
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "Name",
BAD_CAST "Name92");
if (rc < 0)
{
printf("Error at xmlTextWriterWriteAttribute['Image.Name'\n");
return;
}
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "DefaultPixels",
BAD_CAST "Pixels:1");
if (rc < 0)
{
printf("Error at xmlTextWriterWriteAttribute['Image.DefaultPixels']\n");
return;
}
/* Write the CreationDate element with CDATA. */
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ome:CreationDate",
"%s", "2006-05-04T18:13:51.0Z");
if (rc < 0)
{
printf("Error at xmlTextWriterFormatElement['ome:CreationDate'].\n");
return;
}
/* Start the Pixels element. */
rc = xmlTextWriterStartElement(writer, BAD_CAST "ome:Pixels");
if (rc < 0)
{
printf("Error at xmlTextWriterStartElement['ome:Pixels'].\n");
return;
}
/* Add attributes to the Pixels element. */
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "ID",
BAD_CAST "Pixels:1");
if (rc < 0)
{
printf("Error at xmlTextWriterWriteAttribute['Pixels.ID'\n");
return;
}
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "DimensionOrder",
BAD_CAST "XYZCT");
if (rc < 0)
{
printf("Error at xmlTextWriterWriteAttribute['Pixels.DimensionOrder'\n");
return;
}
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "PixelType",
BAD_CAST "int8");
if (rc < 0)
{
printf("Error at xmlTextWriterWriteAttribute['Pixels.PixelType'\n");
return;
}
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "BigEndian",
BAD_CAST "false");
if (rc < 0)
{
printf("Error at xmlTextWriterWriteAttribute['Pixels.BigEndian'\n");
return;
}
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "SizeX",
BAD_CAST "2");
if (rc < 0)
{
printf("Error at xmlTextWriterWriteAttribute['Pixels.SizeX'\n");
return;
}
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "SizeY",
BAD_CAST "2");
if (rc < 0)
{
printf("Error at xmlTextWriterWriteAttribute['Pixels.SizeY'\n");
return;
}
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "SizeZ",
BAD_CAST "2");
if (rc < 0)
{
printf("Error at xmlTextWriterWriteAttribute['Pixels.SizeZ'\n");
return;
}
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "SizeC",
BAD_CAST "2");
if (rc < 0)
{
printf("Error at xmlTextWriterWriteAttribute['Pixels.SizeC'\n");
return;
}
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "SizeT",
BAD_CAST "2");
if (rc < 0)
{
printf("Error at xmlTextWriterWriteAttribute['Pixels.SizeT'\n");
return;
}
/* Start the BinData element. */
rc = xmlTextWriterStartElement(writer, BAD_CAST "bf:BinData");
if (rc < 0)
{
printf("Error at xmlTextWriterStartElement['bf:BinData']\n");
return;
}
/* Add attributes and Base64 CDATA to the BinData element. */
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "Compression",
BAD_CAST "none");
if (rc < 0)
{
printf("Error at xmlTextWriterWriteAttribute['BinData.Compression'\n");
return;
}
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "Length",
BAD_CAST "10");
if (rc < 0)
{
printf("Error at xmlTextWriterWriteAttribute['BinData.Length'\n");
return;
}
rc = xmlTextWriterWriteBase64(writer, BAD_CAST "default", 0, 7);
if (rc < 0)
{
printf("Error at xmlTextWriterWriteBase64['BinData']\n");
return;
}
/* Close the Pixels, Image and OME elements using xmlTextWriterEndDocument
* instead of calling xmlTextWriterEndElement on each to save some work. */
rc = xmlTextWriterEndDocument(writer);
if (rc < 0)
{
printf("Error at xmlTextWriterEndDocument.\n");
return;
}
xmlFreeTextWriter(writer);
xmlSaveFileEnc(file, doc, DEFAULT_ENCODING);
xmlFreeDoc(doc);
}
