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  */
24 
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
58 
59 #include <linux/intermezzo_lib.h>
60 #include <linux/intermezzo_idl.h>
61 #include <linux/intermezzo_fs.h>
62 
kml_unpack_version(struct presto_version ** ver,char ** buf,char * end)63 int kml_unpack_version(struct presto_version **ver, char **buf, char *end)
64 {
65 	char *ptr = *buf;
66         struct presto_version *pv;
67 
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);
73 
74 	*buf = ptr;
75 
76         return 0;
77 }
78 
79 
kml_unpack_noop(struct kml_rec * rec,char ** buf,char * end)80 static int kml_unpack_noop(struct kml_rec *rec, char **buf, char *end)
81 {
82 	return 0;
83 }
84 
85 
kml_unpack_get_fileid(struct kml_rec * rec,char ** buf,char * end)86 static int kml_unpack_get_fileid(struct kml_rec *rec, char **buf, char *end)
87 {
88 	char *ptr = *buf;
89 
90 	LUNLOGV(rec->pathlen, __u32, ptr, end);
91 	UNLOGL(rec->path, char, rec->pathlen, ptr, end);
92 
93 	*buf = ptr;
94 	return 0;
95 }
96 
kml_unpack_create(struct kml_rec * rec,char ** buf,char * end)97 static int kml_unpack_create(struct kml_rec *rec, char **buf, char *end)
98 {
99 	char *ptr = *buf;
100 
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);
109 
110 	*buf = ptr;
111 
112 	return 0;
113 }
114 
115 
kml_unpack_mkdir(struct kml_rec * rec,char ** buf,char * end)116 static int kml_unpack_mkdir(struct kml_rec *rec, char **buf, char *end)
117 {
118 	char *ptr = *buf;
119 
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);
128 
129 	*buf = ptr;
130 
131 	return 0;
132 }
133 
134 
kml_unpack_unlink(struct kml_rec * rec,char ** buf,char * end)135 static int kml_unpack_unlink(struct kml_rec *rec, char **buf, char *end)
136 {
137 	char *ptr = *buf;
138 
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);
152 
153 	*buf = ptr;
154 
155 	return 0;
156 }
157 
158 
kml_unpack_rmdir(struct kml_rec * rec,char ** buf,char * end)159 static int kml_unpack_rmdir(struct kml_rec *rec, char **buf, char *end)
160 {
161 	char *ptr = *buf;
162 
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);
174 
175 	*buf = ptr;
176 
177 	return 0;
178 }
179 
180 
kml_unpack_close(struct kml_rec * rec,char ** buf,char * end)181 static int kml_unpack_close(struct kml_rec *rec, char **buf, char *end)
182 {
183 	char *ptr = *buf;
184 
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);
194 
195 	*buf = ptr;
196 
197 	return 0;
198 }
199 
200 
kml_unpack_symlink(struct kml_rec * rec,char ** buf,char * end)201 static int kml_unpack_symlink(struct kml_rec *rec, char **buf, char *end)
202 {
203 	char *ptr = *buf;
204 
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);
214 
215 	*buf = ptr;
216 
217 	return 0;
218 }
219 
220 
kml_unpack_rename(struct kml_rec * rec,char ** buf,char * end)221 static int kml_unpack_rename(struct kml_rec *rec, char **buf, char *end)
222 {
223 	char *ptr = *buf;
224 
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);
233 
234 	*buf = ptr;
235 
236 	return 0;
237 }
238 
239 
kml_unpack_setattr(struct kml_rec * rec,char ** buf,char * end)240 static int kml_unpack_setattr(struct kml_rec *rec, char **buf, char *end)
241 {
242 	char *ptr = *buf;
243 
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);
259 
260 	*buf = ptr;
261 
262 	return 0;
263 }
264 
265 
kml_unpack_link(struct kml_rec * rec,char ** buf,char * end)266 static int kml_unpack_link(struct kml_rec *rec, char **buf, char *end)
267 {
268 	char *ptr = *buf;
269 
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);
277 
278 	*buf = ptr;
279 
280 	return 0;
281 }
282 
kml_unpack_mknod(struct kml_rec * rec,char ** buf,char * end)283 static int kml_unpack_mknod(struct kml_rec *rec, char **buf, char *end)
284 {
285 	char *ptr = *buf;
286 
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);
297 
298 	*buf = ptr;
299 
300 	return 0;
301 }
302 
303 
kml_unpack_write(struct kml_rec * rec,char ** buf,char * end)304 static int kml_unpack_write(struct kml_rec *rec, char **buf, char *end)
305 {
306 	printf("NOT IMPLEMENTED");
307 	return 0;
308 }
309 
310 
kml_unpack_release(struct kml_rec * rec,char ** buf,char * end)311 static int kml_unpack_release(struct kml_rec *rec, char **buf, char *end)
312 {
313 	printf("NOT IMPLEMENTED");
314 	return 0;
315 }
316 
317 
kml_unpack_trunc(struct kml_rec * rec,char ** buf,char * end)318 static int kml_unpack_trunc(struct kml_rec *rec, char **buf, char *end)
319 {
320 	printf("NOT IMPLEMENTED");
321 	return 0;
322 }
323 
324 
kml_unpack_setextattr(struct kml_rec * rec,char ** buf,char * end)325 static int kml_unpack_setextattr(struct kml_rec *rec, char **buf, char *end)
326 {
327 	char *ptr = *buf;
328 
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);
339 
340 	*buf = ptr;
341 
342 	return 0;
343 }
344 
345 
kml_unpack_delextattr(struct kml_rec * rec,char ** buf,char * end)346 static int kml_unpack_delextattr(struct kml_rec *rec, char **buf, char *end)
347 {
348 	char *ptr = *buf;
349 
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);
359 
360 	*buf = ptr;
361 
362 	return 0;
363 }
364 
kml_unpack_open(struct kml_rec * rec,char ** buf,char * end)365 static int kml_unpack_open(struct kml_rec *rec, char **buf, char *end)
366 {
367 	printf("NOT IMPLEMENTED");
368 	return 0;
369 }
370 
kml_unpack_kml_trunc(struct kml_rec * rec,char ** buf,char * end)371 static int kml_unpack_kml_trunc(struct kml_rec *rec, char **buf, char *end)
372 {
373 
374 	printf("NOT IMPLEMENTED");
375 	return 0;
376 }
377 
378 
379 typedef int (*unpacker)(struct kml_rec *rec, char **buf, char *end);
380 
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 };
403 
kml_unpack_prefix(struct kml_rec * rec,char ** buf,char * end)404 int kml_unpack_prefix(struct kml_rec *rec, char **buf, char *end)
405 {
406 	char *ptr = *buf;
407         int n;
408 
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);
418 
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         }
423 
424 	*buf = ptr;
425 
426         return 0;
427 }
428 
kml_unpack_suffix(struct kml_rec * rec,char ** buf,char * end)429 int kml_unpack_suffix(struct kml_rec *rec, char **buf, char *end)
430 {
431 	char *ptr = *buf;
432 
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);
438 
439 	*buf = ptr;
440 
441         return 0;
442 }
443 
kml_unpack(struct kml_rec * rec,char ** buf,char * end)444 int kml_unpack(struct kml_rec *rec, char **buf, char *end)
445 {
446 	char *ptr = *buf;
447 	int err;
448 
449         if (((unsigned long)ptr % 4) != 0) {
450                 printf("InterMezzo: %s: record misaligned.\n", __FUNCTION__);
451                 return -EINVAL;
452         }
453 
454         while (ptr < end) {
455                 __u32 *i = (__u32 *)ptr;
456                 if (*i)
457                         break;
458                 ptr += sizeof(*i);
459         }
460 	*buf = ptr;
461 
462 	memset(rec, 0, sizeof(*rec));
463 
464         err = kml_unpack_prefix(rec, &ptr, end);
465 	if (err) {
466                 printf("InterMezzo: %s: unpack_prefix failed: %d\n",
467                        __FUNCTION__, err);
468 		return err;
469         }
470 
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: %d\n",
480                        __FUNCTION__, err);
481 		return err;
482         }
483 
484         err = kml_unpack_suffix(rec, &ptr, end);
485 	if (err) {
486                 printf("InterMezzo: %s: unpack_suffix failed: %d\n",
487                        __FUNCTION__, err);
488 		return err;
489         }
490 
491 
492 	if (rec->prefix.hdr->len != rec->suffix->len) {
493                 printf("InterMezzo: %s: lengths don't match\n",
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 error\n",
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 }
516 
517 
518 #ifndef __KERNEL__
519 #define STR(ptr) ((ptr))? (ptr) : ""
520 
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
544 
print_opname(int op)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 }
551 
552 
print_time(__u64 i)553 static char *print_time(__u64 i)
554 {
555 	char buf[128];
556 
557 	memset(buf, 0, 128);
558 
559 #ifndef __KERNEL__
560 	strftime(buf, 128, "%Y/%m/%d %H:%M:%S", gmtime((time_t *)&i));
561 #else
562 	sprintf(buf, "%Ld\n", i);
563 #endif
564 
565 	return strdup(buf);
566 }
567 
print_version(struct presto_version * ver)568 static char *print_version(struct presto_version *ver)
569 {
570 	char ver_buf[128];
571 	char *mtime;
572 	char *ctime;
573 
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 }
585 
586 
kml_print_rec(struct kml_rec * rec,int brief)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;
592 
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 	}
602 
603 	rectime = print_time(rec->suffix->time);
604 	mtime = print_time(rec->mtime);
605 	ctime = print_time(rec->ctime);
606 
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);
613 
614 	str = g_strdup_printf("\n -- Record:\n"
615 		"    Recno     %d\n"
616 		"    KML off   %lld\n"
617 		"    Version   %d\n"
618 		"    Len       %d\n"
619 		"    Suf len   %d\n"
620 		"    Time      %s\n"
621 		"    Opcode    %d\n"
622 		"    Op        %s\n"
623 		"    Pid       %d\n"
624 		"    AUid      %d\n"
625 		"    Fsuid     %d\n"
626 		"    Fsgid     %d\n"
627 		"    Prevrec   %d\n"
628 		"    Ngroups   %d\n"
629 		//"    Groups    @{$self->{groups}}\n"
630 		" -- Path:\n"
631 		"    Inode     %d\n"
632 		"    Gen num   %u\n"
633                 "    Old mode  %o\n"
634                 "    Old rdev  %x\n"
635                 "    Old uid   %llu\n"
636                 "    Old gid   %llu\n"
637 		"    Path      %*s\n"
638 		//"    Open_mode %o\n",
639 		"    Pathlen   %d\n"
640 		"    Tgt       %*s\n"
641 		"    Tgtlen    %d\n"
642 		"    Old Tgt   %*s\n"
643 		"    Old Tgtln %d\n"
644 		" -- Attr:\n"
645 		"    Valid     %x\n"
646 		"    mode %o, uid %d, gid %d, size %lld, mtime %s, ctime %s rdev %x (%d:%d)\n"
647 		" -- Versions:\n"
648 		"    New object %s\n"
649 		"    Old object %s\n"
650 		"    New target %s\n"
651 		"    Old target %s\n"
652 		"    New parent %s\n"
653 		"    Old parent %s\n",
654 
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,
684 
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);
694 
695 	free(nov);
696 	free(oov);
697 	free(ntv);
698 	free(otv);
699 	free(npv);
700 	free(opv);
701 
702 	free(rectime);
703 	free(ctime);
704 	free(mtime);
705 
706 	return str;
707 }
708 #endif
709