开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
kml_unpack.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：18k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

kml_unpack.c：源码内容
  1. /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
  2.  * vim:expandtab:shiftwidth=8:tabstop=8:
  3.  *
  4.  *  Copyright (C) 2001 Cluster File Systems, Inc. <braam@clusterfs.com>
  5.  *
  6.  *   This file is part of InterMezzo, http://www.inter-mezzo.org.
  7.  *
  8.  *   InterMezzo is free software; you can redistribute it and/or
  9.  *   modify it under the terms of version 2 of the GNU General Public
  10.  *   License as published by the Free Software Foundation.
  11.  *
  12.  *   InterMezzo is distributed in the hope that it will be useful,
  13.  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.  *   GNU General Public License for more details.
  16.  *
  17.  *   You should have received a copy of the GNU General Public License
  18.  *   along with InterMezzo; if not, write to the Free Software
  19.  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  *
  21.  * Unpacking of KML records
  22.  *
  23.  */
  25. #ifdef __KERNEL__
  26. #  include <linux/module.h>
  27. #  include <linux/errno.h>
  28. #  include <linux/kernel.h>
  29. #  include <linux/major.h>
  30. #  include <linux/sched.h>
  31. #  include <linux/lp.h>
  32. #  include <linux/slab.h>
  33. #  include <linux/ioport.h>
  34. #  include <linux/fcntl.h>
  35. #  include <linux/delay.h>
  36. #  include <linux/skbuff.h>
  37. #  include <linux/proc_fs.h>
  38. #  include <linux/vmalloc.h>
  39. #  include <linux/fs.h>
  40. #  include <linux/poll.h>
  41. #  include <linux/init.h>
  42. #  include <linux/list.h>
  43. #  include <linux/stat.h>
  44. #  include <asm/io.h>
  45. #  include <asm/segment.h>
  46. #  include <asm/system.h>
  47. #  include <asm/poll.h>
  48. #  include <asm/uaccess.h>
  49. #else
  50. #  include <time.h>
  51. #  include <stdio.h>
  52. #  include <string.h>
  53. #  include <stdlib.h>
  54. #  include <errno.h>
  55. #  include <sys/stat.h>
  56. #  include <glib.h>
  57. #endif
  59. #include <linux/intermezzo_lib.h>
  60. #include <linux/intermezzo_idl.h>
  61. #include <linux/intermezzo_fs.h>
  63. int kml_unpack_version(struct presto_version **ver, char **buf, char *end) 
  64. {
  65. char *ptr = *buf;
  66.         struct presto_version *pv;
  68. UNLOGP(*ver, struct presto_version, ptr, end);
  69.         pv = *ver;
  70.         pv->pv_mtime   = NTOH__u64(pv->pv_mtime);
  71.         pv->pv_ctime   = NTOH__u64(pv->pv_ctime);
  72.         pv->pv_size    = NTOH__u64(pv->pv_size);
  74. *buf = ptr;
  76.         return 0;
  77. }
  80. static int kml_unpack_noop(struct kml_rec *rec, char **buf, char *end)
  81. {
  82. return 0;
  83. }
  85.  
  86. static int kml_unpack_get_fileid(struct kml_rec *rec, char **buf, char *end)
  87. {
  88. char *ptr = *buf;
  90. LUNLOGV(rec->pathlen, __u32, ptr, end);
  91. UNLOGL(rec->path, char, rec->pathlen, ptr, end);
  93. *buf = ptr;
  94. return 0;
  95. }
  97. static int kml_unpack_create(struct kml_rec *rec, char **buf, char *end)
  98. {
  99. char *ptr = *buf;
  101. kml_unpack_version(&rec->old_parentv, &ptr, end);
  102. kml_unpack_version(&rec->new_parentv, &ptr, end);
  103. kml_unpack_version(&rec->new_objectv, &ptr, end);
  104. LUNLOGV(rec->mode, __u32, ptr, end);
  105. LUNLOGV(rec->uid, __u32, ptr, end);
  106. LUNLOGV(rec->gid, __u32, ptr, end);
  107. LUNLOGV(rec->pathlen, __u32, ptr, end);
  108. UNLOGL(rec->path, char, rec->pathlen, ptr, end);
  110. *buf = ptr;
  112. return 0;
  113. }
  115.  
  116. static int kml_unpack_mkdir(struct kml_rec *rec, char **buf, char *end)
  117. {
  118. char *ptr = *buf;
  120. kml_unpack_version(&rec->old_parentv, &ptr, end);
  121. kml_unpack_version(&rec->new_parentv, &ptr, end);
  122. kml_unpack_version(&rec->new_objectv, &ptr, end);
  123. LUNLOGV(rec->mode, __u32, ptr, end);
  124. LUNLOGV(rec->uid, __u32, ptr, end);
  125. LUNLOGV(rec->gid, __u32, ptr, end);
  126. LUNLOGV(rec->pathlen, __u32, ptr, end);
  127. UNLOGL(rec->path, char, rec->pathlen, ptr, end);
  129. *buf = ptr;
  131. return 0;
  132. }
  135. static int kml_unpack_unlink(struct kml_rec *rec, char **buf, char *end)
  136. {
  137. char *ptr = *buf;
  139. kml_unpack_version(&rec->old_parentv, &ptr, end);
  140. kml_unpack_version(&rec->new_parentv, &ptr, end);
  141. kml_unpack_version(&rec->old_objectv, &ptr, end);
  142.         LUNLOGV(rec->old_mode, __u32, ptr, end);
  143.         LUNLOGV(rec->old_rdev, __u32, ptr, end);
  144.         LUNLOGV(rec->old_uid, __u64, ptr, end);
  145.         LUNLOGV(rec->old_gid, __u64, ptr, end);
  146. LUNLOGV(rec->pathlen, __u32, ptr, end);
  147. LUNLOGV(rec->targetlen, __u32, ptr, end);
  148.         LUNLOGV(rec->old_targetlen, __u32, ptr, end);
  149. UNLOGL(rec->path, char, rec->pathlen, ptr, end);
  150. UNLOGL(rec->target, char, rec->targetlen, ptr, end);
  151.         UNLOGL(rec->old_target, char, rec->old_targetlen, ptr, end);
  153. *buf = ptr;
  155. return 0;
  156. }
  159. static int kml_unpack_rmdir(struct kml_rec *rec, char **buf, char *end)
  160. {
  161. char *ptr = *buf;
  163. kml_unpack_version(&rec->old_parentv, &ptr, end);
  164. kml_unpack_version(&rec->new_parentv, &ptr, end);
  165. kml_unpack_version(&rec->old_objectv, &ptr, end);
  166.         LUNLOGV(rec->old_mode, __u32, ptr, end);
  167.         LUNLOGV(rec->old_rdev, __u32, ptr, end);
  168.         LUNLOGV(rec->old_uid, __u64, ptr, end);
  169.         LUNLOGV(rec->old_gid, __u64, ptr, end);
  170. LUNLOGV(rec->pathlen, __u32, ptr, end);
  171. LUNLOGV(rec->targetlen, __u32, ptr, end);
  172. UNLOGL(rec->path, char, rec->pathlen, ptr, end);
  173. UNLOGL(rec->target, char, rec->targetlen, ptr, end);
  175. *buf = ptr;
  177. return 0;
  178. }
  181. static int kml_unpack_close(struct kml_rec *rec, char **buf, char *end)
  182. {
  183. char *ptr = *buf;
  185. LUNLOGV(rec->mode, __u32, ptr, end);  // used for open_mode
  186. LUNLOGV(rec->uid, __u32, ptr, end);   // used for open_uid
  187. LUNLOGV(rec->gid, __u32, ptr, end);   // used for open_gid
  188. kml_unpack_version(&rec->old_objectv, &ptr, end);
  189. kml_unpack_version(&rec->new_objectv, &ptr, end);
  190. LUNLOGV(rec->ino, __u64, ptr, end);
  191. LUNLOGV(rec->generation, __u32, ptr, end);
  192. LUNLOGV(rec->pathlen, __u32, ptr, end);
  193. UNLOGL(rec->path, char, rec->pathlen, ptr, end);
  195. *buf = ptr;
  197. return 0;
  198. }
  201. static int kml_unpack_symlink(struct kml_rec *rec, char **buf, char *end)
  202. {
  203. char *ptr = *buf;
  205. kml_unpack_version(&rec->old_parentv, &ptr, end);
  206. kml_unpack_version(&rec->new_parentv, &ptr, end);
  207. kml_unpack_version(&rec->new_objectv, &ptr, end);
  208. LUNLOGV(rec->uid, __u32, ptr, end);
  209. LUNLOGV(rec->gid, __u32, ptr, end);
  210. LUNLOGV(rec->pathlen, __u32, ptr, end);
  211. LUNLOGV(rec->targetlen, __u32, ptr, end);
  212. UNLOGL(rec->path, char, rec->pathlen, ptr, end);
  213. UNLOGL(rec->target, char, rec->targetlen, ptr, end);
  215. *buf = ptr;
  217. return 0;
  218. }
  221. static int kml_unpack_rename(struct kml_rec *rec, char **buf, char *end)
  222. {
  223. char *ptr = *buf;
  225. kml_unpack_version(&rec->old_objectv, &ptr, end);
  226. kml_unpack_version(&rec->new_objectv, &ptr, end);
  227. kml_unpack_version(&rec->old_parentv, &ptr, end);
  228. kml_unpack_version(&rec->new_parentv, &ptr, end);
  229. LUNLOGV(rec->pathlen, __u32, ptr, end);
  230. LUNLOGV(rec->targetlen, __u32, ptr, end);
  231. UNLOGL(rec->path, char, rec->pathlen, ptr, end);
  232. UNLOGL(rec->target, char, rec->targetlen, ptr, end);
  234. *buf = ptr;
  236. return 0;
  237. }
  240. static int kml_unpack_setattr(struct kml_rec *rec, char **buf, char *end)
  241. {
  242. char *ptr = *buf;
  244. kml_unpack_version(&rec->old_objectv, &ptr, end);
  245. LUNLOGV(rec->valid, __u32, ptr, end);
  246. LUNLOGV(rec->mode, __u32, ptr, end);
  247. LUNLOGV(rec->uid, __u32, ptr, end);
  248. LUNLOGV(rec->gid, __u32, ptr, end);
  249. LUNLOGV(rec->size, __u64, ptr, end);
  250. LUNLOGV(rec->mtime, __u64, ptr, end);
  251. LUNLOGV(rec->ctime, __u64, ptr, end);
  252. LUNLOGV(rec->flags, __u32, ptr, end);
  253.         LUNLOGV(rec->old_mode, __u32, ptr, end);
  254.         LUNLOGV(rec->old_rdev, __u32, ptr, end);
  255.         LUNLOGV(rec->old_uid, __u64, ptr, end);
  256.         LUNLOGV(rec->old_gid, __u64, ptr, end);
  257. LUNLOGV(rec->pathlen, __u32, ptr, end);
  258. UNLOGL(rec->path, char, rec->pathlen, ptr, end);
  260. *buf = ptr;
  262. return 0;
  263. }
  266. static int kml_unpack_link(struct kml_rec *rec, char **buf, char *end)
  267. {
  268. char *ptr = *buf;
  270. kml_unpack_version(&rec->old_parentv, &ptr, end);
  271. kml_unpack_version(&rec->new_parentv, &ptr, end);
  272. kml_unpack_version(&rec->new_objectv, &ptr, end);
  273. LUNLOGV(rec->pathlen, __u32, ptr, end);
  274. LUNLOGV(rec->targetlen, __u32, ptr, end);
  275. UNLOGL(rec->path, char, rec->pathlen, ptr, end);
  276. UNLOGL(rec->target, char, rec->targetlen, ptr, end);
  278. *buf = ptr;
  280. return 0;
  281. }
  283. static int kml_unpack_mknod(struct kml_rec *rec, char **buf, char *end)
  284. {
  285. char *ptr = *buf;
  287. kml_unpack_version(&rec->old_parentv, &ptr, end);
  288. kml_unpack_version(&rec->new_parentv, &ptr, end);
  289. kml_unpack_version(&rec->new_objectv, &ptr, end);
  290. LUNLOGV(rec->mode, __u32, ptr, end);
  291. LUNLOGV(rec->uid, __u32, ptr, end);
  292. LUNLOGV(rec->gid, __u32, ptr, end);
  293. LUNLOGV(rec->major, __u32, ptr, end);
  294. LUNLOGV(rec->minor, __u32, ptr, end);
  295. LUNLOGV(rec->pathlen, __u32, ptr, end);
  296. UNLOGL(rec->path, char, rec->pathlen, ptr, end);
  298. *buf = ptr;
  300. return 0;
  301. }
  304. static int kml_unpack_write(struct kml_rec *rec, char **buf, char *end)
  305. {
  306. printf("NOT IMPLEMENTED");
  307. return 0;
  308. }
  311. static int kml_unpack_release(struct kml_rec *rec, char **buf, char *end)
  312. {
  313. printf("NOT IMPLEMENTED");
  314. return 0;
  315. }
  318. static int kml_unpack_trunc(struct kml_rec *rec, char **buf, char *end)
  319. {
  320. printf("NOT IMPLEMENTED");
  321. return 0;
  322. }
  325. static int kml_unpack_setextattr(struct kml_rec *rec, char **buf, char *end)
  326. {
  327. char *ptr = *buf;
  329. kml_unpack_version(&rec->old_objectv, &ptr, end);
  330. kml_unpack_version(&rec->new_objectv, &ptr, end);
  331. LUNLOGV(rec->flags, __u32, ptr, end);
  332. LUNLOGV(rec->mode, __u32, ptr, end);
  333. LUNLOGV(rec->pathlen, __u32, ptr, end);
  334. LUNLOGV(rec->namelen, __u32, ptr, end);
  335. LUNLOGV(rec->targetlen, __u32, ptr, end);
  336.         UNLOGL(rec->path, char, rec->pathlen, ptr, end);
  337. UNLOGL(rec->name, char, rec->namelen, ptr, end);
  338. UNLOGL(rec->target, char, rec->targetlen, ptr, end);
  340. *buf = ptr;
  342. return 0;
  343. }
  346. static int kml_unpack_delextattr(struct kml_rec *rec, char **buf, char *end)
  347. {
  348. char *ptr = *buf;
  350. kml_unpack_version(&rec->old_objectv, &ptr, end);
  351. kml_unpack_version(&rec->new_objectv, &ptr, end);
  352. LUNLOGV(rec->flags, __u32, ptr, end);
  353. LUNLOGV(rec->mode, __u32, ptr, end);
  354. LUNLOGV(rec->pathlen, __u32, ptr, end);
  355. LUNLOGV(rec->namelen, __u32, ptr, end);
  356. LUNLOGV(rec->targetlen, __u32, ptr, end);
  357. UNLOGL(rec->path, char, rec->pathlen, ptr, end);
  358. UNLOGL(rec->name, char, rec->namelen, ptr, end);
  360. *buf = ptr;
  362. return 0;
  363. }
  365. static int kml_unpack_open(struct kml_rec *rec, char **buf, char *end)
  366. {
  367. printf("NOT IMPLEMENTED");
  368. return 0;
  369. }
  371. static int kml_unpack_kml_trunc(struct kml_rec *rec, char **buf, char *end)
  372. {
  374. printf("NOT IMPLEMENTED");
  375. return 0;
  376. }
  379. typedef int (*unpacker)(struct kml_rec *rec, char **buf, char *end);
  381. static unpacker unpackers[KML_OPCODE_NUM] = 
  382. {
  383. [KML_OPCODE_NOOP] = kml_unpack_noop,
  384. [KML_OPCODE_CREATE] = kml_unpack_create, 
  385. [KML_OPCODE_MKDIR] = kml_unpack_mkdir,
  386. [KML_OPCODE_UNLINK] = kml_unpack_unlink,
  387. [KML_OPCODE_RMDIR] = kml_unpack_rmdir,
  388. [KML_OPCODE_CLOSE] = kml_unpack_close,
  389. [KML_OPCODE_SYMLINK] = kml_unpack_symlink,
  390. [KML_OPCODE_RENAME] = kml_unpack_rename,
  391. [KML_OPCODE_SETATTR] = kml_unpack_setattr,
  392. [KML_OPCODE_LINK] = kml_unpack_link,
  393. [KML_OPCODE_OPEN] = kml_unpack_open,
  394. [KML_OPCODE_MKNOD] = kml_unpack_mknod,
  395. [KML_OPCODE_WRITE] = kml_unpack_write,
  396. [KML_OPCODE_RELEASE] = kml_unpack_release,
  397. [KML_OPCODE_TRUNC] = kml_unpack_trunc,
  398. [KML_OPCODE_SETEXTATTR] = kml_unpack_setextattr,
  399. [KML_OPCODE_DELEXTATTR] = kml_unpack_delextattr,
  400. [KML_OPCODE_KML_TRUNC] = kml_unpack_kml_trunc,
  401. [KML_OPCODE_GET_FILEID] = kml_unpack_get_fileid
  402. };
  404. int kml_unpack_prefix(struct kml_rec *rec, char **buf, char *end) 
  405. {
  406. char *ptr = *buf;
  407.         int n;
  409.         UNLOGP(rec->prefix.hdr, struct kml_prefix_hdr, ptr, end);
  410.         rec->prefix.hdr->len     = NTOH__u32(rec->prefix.hdr->len);
  411.         rec->prefix.hdr->version = NTOH__u32(rec->prefix.hdr->version);
  412.         rec->prefix.hdr->pid     = NTOH__u32(rec->prefix.hdr->pid);
  413.         rec->prefix.hdr->auid    = NTOH__u32(rec->prefix.hdr->auid);
  414.         rec->prefix.hdr->fsuid   = NTOH__u32(rec->prefix.hdr->fsuid);
  415.         rec->prefix.hdr->fsgid   = NTOH__u32(rec->prefix.hdr->fsgid);
  416.         rec->prefix.hdr->opcode  = NTOH__u32(rec->prefix.hdr->opcode);
  417.         rec->prefix.hdr->ngroups = NTOH__u32(rec->prefix.hdr->ngroups);
  419. UNLOGL(rec->prefix.groups, __u32, rec->prefix.hdr->ngroups, ptr, end);
  420.         for (n = 0; n < rec->prefix.hdr->ngroups; n++) {
  421.                 rec->prefix.groups[n] = NTOH__u32(rec->prefix.groups[n]);
  422.         }
  424. *buf = ptr;
  426.         return 0;
  427. }
  429. int kml_unpack_suffix(struct kml_rec *rec, char **buf, char *end) 
  430. {
  431. char *ptr = *buf;
  433. UNLOGP(rec->suffix, struct kml_suffix, ptr, end);
  434.         rec->suffix->prevrec   = NTOH__u32(rec->suffix->prevrec);
  435.         rec->suffix->recno    = NTOH__u32(rec->suffix->recno);
  436.         rec->suffix->time     = NTOH__u32(rec->suffix->time);
  437.         rec->suffix->len      = NTOH__u32(rec->suffix->len);
  439. *buf = ptr;
  441.         return 0;
  442. }
  444. int kml_unpack(struct kml_rec *rec, char **buf, char *end)
  445. {
  446. char *ptr = *buf;
  447. int err; 
  449.         if (((unsigned long)ptr % 4) != 0) {
  450.                 printf("InterMezzo: %s: record misaligned.n", __FUNCTION__);
  451.                 return -EINVAL;
  452.         }
  454.         while (ptr < end) { 
  455.                 __u32 *i = (__u32 *)ptr;
  456.                 if (*i)
  457.                         break;
  458.                 ptr += sizeof(*i);
  459.         }
  460. *buf = ptr;
  462. memset(rec, 0, sizeof(*rec));
  464.         err = kml_unpack_prefix(rec, &ptr, end);
  465. if (err) {
  466.                 printf("InterMezzo: %s: unpack_prefix failed: %dn",
  467.                        __FUNCTION__, err);
  468. return err;
  469.         }
  471.         if (rec->prefix.hdr->opcode < 0  ||
  472.             rec->prefix.hdr->opcode >= KML_OPCODE_NUM) {
  473.                 printf("InterMezzo: %s: invalid opcode (%d)n",
  474.                        __FUNCTION__, rec->prefix.hdr->opcode);
  475. return -EINVAL;
  476.         }
  477. err = unpackers[rec->prefix.hdr->opcode](rec, &ptr, end);
  478. if (err) {
  479.                 printf("InterMezzo: %s: unpacker failed: %dn",
  480.                        __FUNCTION__, err);
  481. return err;
  482.         }
  484.         err = kml_unpack_suffix(rec, &ptr, end);
  485. if (err) {
  486.                 printf("InterMezzo: %s: unpack_suffix failed: %dn",
  487.                        __FUNCTION__, err);
  488. return err;
  489.         }
  492. if (rec->prefix.hdr->len != rec->suffix->len) {
  493.                 printf("InterMezzo: %s: lengths don't matchn",
  494.                        __FUNCTION__);
  495. return -EINVAL;
  496.         }
  497.         if ((rec->prefix.hdr->len % 4) != 0) {
  498.                 printf("InterMezzo: %s: record length not a "
  499.                        "multiple of 4.n", __FUNCTION__);
  500.                 return -EINVAL;
  501.         }
  502.         if (ptr - *buf != rec->prefix.hdr->len) {
  503.                 printf("InterMezzo: %s: unpacking errorn",
  504.                        __FUNCTION__);
  505.                 return -EINVAL;
  506.         }
  507.         while (ptr < end) { 
  508.                 __u32 *i = (__u32 *)ptr;
  509.                 if (*i)
  510.                         break;
  511.                 ptr += sizeof(*i);
  512.         }
  513. *buf = ptr;
  514. return 0;
  515. }
  518. #ifndef __KERNEL__
  519. #define STR(ptr) ((ptr))? (ptr) : ""
  521. #define OPNAME(n) [KML_OPCODE_##n] = #n
  522. static char *opnames[KML_OPCODE_NUM] = {
  523. OPNAME(NOOP),
  524. OPNAME(CREATE),
  525. OPNAME(MKDIR), 
  526. OPNAME(UNLINK),
  527. OPNAME(RMDIR),
  528. OPNAME(CLOSE),
  529. OPNAME(SYMLINK),
  530. OPNAME(RENAME),
  531. OPNAME(SETATTR),
  532. OPNAME(LINK),
  533. OPNAME(OPEN),
  534. OPNAME(MKNOD),
  535. OPNAME(WRITE),
  536. OPNAME(RELEASE),
  537. OPNAME(TRUNC),
  538. OPNAME(SETEXTATTR),
  539. OPNAME(DELEXTATTR),
  540. OPNAME(KML_TRUNC),
  541. OPNAME(GET_FILEID)
  542. };
  543. #undef OPNAME
  545. static char *print_opname(int op)
  546. {
  547. if (op < 0 || op >= sizeof (opnames) / sizeof (*opnames))
  548. return NULL;
  549. return opnames[op];
  550. }
  553. static char *print_time(__u64 i)
  554. {
  555. char buf[128];
  557. memset(buf, 0, 128);
  559. #ifndef __KERNEL__
  560. strftime(buf, 128, "%Y/%m/%d %H:%M:%S", gmtime((time_t *)&i));
  561. #else
  562. sprintf(buf, "%Ldn", i);
  563. #endif
  565. return strdup(buf);
  566. }
  568. static char *print_version(struct presto_version *ver)
  569. {
  570. char ver_buf[128];
  571. char *mtime;
  572. char *ctime;
  574. if (!ver || ver->pv_ctime == 0) {
  575. return strdup("");
  576. } 
  577. mtime = print_time(ver->pv_mtime);
  578. ctime = print_time(ver->pv_ctime);
  579. sprintf(ver_buf, "mtime %s, ctime %s, len %lld", 
  580. mtime, ctime, ver->pv_size);
  581. free(mtime);
  582. free(ctime);
  583. return strdup(ver_buf);
  584. }
  587. char *kml_print_rec(struct kml_rec *rec, int brief)
  588. {
  589. char *str;
  590. char *nov, *oov, *ntv, *otv, *npv, *opv;
  591. char *rectime, *mtime, *ctime;
  593.         if (brief) {
  594. str = g_strdup_printf(" %08d %7s %*s %*s", 
  595.                                       rec->suffix->recno,
  596.                                       print_opname (rec->prefix.hdr->opcode),
  597.                                       rec->pathlen, STR(rec->path),
  598.                                       rec->targetlen, STR(rec->target));
  599.                 
  600. return str;
  601. }
  603. rectime = print_time(rec->suffix->time);
  604. mtime = print_time(rec->mtime);
  605. ctime = print_time(rec->ctime);
  607. nov = print_version(rec->new_objectv);
  608. oov = print_version(rec->old_objectv);
  609. ntv = print_version(rec->new_targetv);
  610. otv = print_version(rec->old_targetv);
  611. npv = print_version(rec->new_parentv);
  612. opv = print_version(rec->old_parentv);
  614. str = g_strdup_printf("n -- Record:n"
  615. "    Recno     %dn"
  616. "    KML off   %lldn" 
  617. "    Version   %dn" 
  618. "    Len       %dn"
  619. "    Suf len   %dn"
  620. "    Time      %sn"
  621. "    Opcode    %dn"
  622. "    Op        %sn"
  623. "    Pid       %dn"
  624. "    AUid      %dn"
  625. "    Fsuid     %dn" 
  626. "    Fsgid     %dn"
  627. "    Prevrec   %dn" 
  628. "    Ngroups   %dn"
  629. //"    Groups    @{$self->{groups}}n" 
  630. " -- Path:n"
  631. "    Inode     %dn"
  632. "    Gen num   %un"
  633.                 "    Old mode  %on"
  634.                 "    Old rdev  %xn"
  635.                 "    Old uid   %llun"
  636.                 "    Old gid   %llun"
  637. "    Path      %*sn"
  638. //"    Open_mode %on",
  639. "    Pathlen   %dn"
  640. "    Tgt       %*sn"
  641. "    Tgtlen    %dn" 
  642. "    Old Tgt   %*sn"
  643. "    Old Tgtln %dn" 
  644. " -- Attr:n"
  645. "    Valid     %xn"
  646. "    mode %o, uid %d, gid %d, size %lld, mtime %s, ctime %s rdev %x (%d:%d)n"
  647. " -- Versions:n"
  648. "    New object %sn"
  649. "    Old object %sn"
  650. "    New target %sn"
  651. "    Old target %sn"
  652. "    New parent %sn"
  653. "    Old parent %sn", 
  655. rec->suffix->recno, 
  656. rec->offset, 
  657. rec->prefix.hdr->version, 
  658. rec->prefix.hdr->len, 
  659. rec->suffix->len, 
  660. rectime,
  661. rec->prefix.hdr->opcode, 
  662. print_opname (rec->prefix.hdr->opcode),
  663. rec->prefix.hdr->pid,
  664. rec->prefix.hdr->auid,
  665. rec->prefix.hdr->fsuid,
  666. rec->prefix.hdr->fsgid,
  667. rec->suffix->prevrec,
  668. rec->prefix.hdr->ngroups,
  669. rec->ino,
  670. rec->generation,
  671.                 rec->old_mode,
  672.                 rec->old_rdev,
  673.                 rec->old_uid,
  674.                 rec->old_gid,
  675. rec->pathlen,
  676. STR(rec->path),
  677. rec->pathlen,
  678. rec->targetlen,
  679. STR(rec->target),
  680. rec->targetlen,
  681. rec->old_targetlen,
  682. STR(rec->old_target),
  683. rec->old_targetlen,
  685. rec->valid, 
  686. rec->mode,
  687. rec->uid,
  688. rec->gid,
  689. rec->size,
  690. mtime,
  691. ctime,
  692. rec->rdev, rec->major, rec->minor,
  693. nov, oov, ntv, otv, npv, opv);
  695. free(nov);
  696. free(oov);
  697. free(ntv);
  698. free(otv);
  699. free(npv);
  700. free(opv);
  702. free(rectime); 
  703. free(ctime);
  704. free(mtime);
  706. return str;
  707. }
  708. #endif