import HEAD into svn+ssh://svn.samba.org/home/svn/samba/trunk
[metze/old/v3-2-winbind-ndr.git] / source / utils / profiles.c
1 /* 
2    Samba Unix/Linux SMB client utility profiles.c 
3    Copyright (C) 2002 Richard Sharpe, rsharpe@richardsharpe.com
4    Copyright (C) 2003 Jelmer Vernooij (conversion to popt)
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10    
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
19  
20 /*************************************************************************
21                                                        
22  A utility to report and change SIDs in registry files 
23                                      
24  Many of the ideas in here come from other people and software. 
25  I first looked in Wine in misc/registry.c and was also influenced by
26  http://www.wednesday.demon.co.uk/dosreg.html
27
28  Which seems to contain comments from someone else. I reproduce them here
29  incase the site above disappears. It actually comes from 
30  http://home.eunet.no/~pnordahl/ntpasswd/WinReg.txt. 
31
32 The windows NT registry has 2 different blocks, where one can occure many
33 times...
34
35 the "regf"-Block
36 ================
37  
38 "regf" is obviously the abbreviation for "Registry file". "regf" is the
39 signature of the header-block which is always 4kb in size, although only
40 the first 64 bytes seem to be used and a checksum is calculated over
41 the first 0x200 bytes only!
42
43 Offset            Size      Contents
44 0x00000000      D-Word      ID: ASCII-"regf" = 0x66676572
45 0x00000004      D-Word      ???? //see struct REGF
46 0x00000008      D-Word      ???? Always the same value as at 0x00000004
47 0x0000000C      Q-Word      last modify date in WinNT date-format
48 0x00000014      D-Word      1
49 0x00000018      D-Word      3
50 0x0000001C      D-Word      0
51 0x00000020      D-Word      1
52 0x00000024      D-Word      Offset of 1st key record
53 0x00000028      D-Word      Size of the data-blocks (Filesize-4kb)
54 0x0000002C      D-Word      1
55 0x000001FC      D-Word      Sum of all D-Words from 0x00000000 to
56 0x000001FB  //XOR of all words. Nigel
57
58 I have analyzed more registry files (from multiple machines running
59 NT 4.0 german version) and could not find an explanation for the values
60 marked with ???? the rest of the first 4kb page is not important...
61
62 the "hbin"-Block
63 ================
64 I don't know what "hbin" stands for, but this block is always a multiple
65 of 4kb in size.
66
67 Inside these hbin-blocks the different records are placed. The memory-
68 management looks like a C-compiler heap management to me...
69
70 hbin-Header
71 ===========
72 Offset      Size      Contents
73 0x0000      D-Word      ID: ASCII-"hbin" = 0x6E696268
74 0x0004      D-Word      Offset from the 1st hbin-Block
75 0x0008      D-Word      Offset to the next hbin-Block
76 0x001C      D-Word      Block-size
77
78 The values in 0x0008 and 0x001C should be the same, so I don't know
79 if they are correct or swapped...
80
81 From offset 0x0020 inside a hbin-block data is stored with the following
82 format:
83
84 Offset      Size      Contents
85 0x0000      D-Word      Data-block size    //this size must be a
86 multiple of 8. Nigel
87 0x0004      ????      Data
88  
89 If the size field is negative (bit 31 set), the corresponding block
90 is free and has a size of -blocksize!
91
92 The data is stored as one record per block. Block size is a multiple
93 of 4 and the last block reaches the next hbin-block, leaving no room.
94
95 Records in the hbin-blocks
96 ==========================
97
98 nk-Record
99
100       The nk-record can be treated as a kombination of tree-record and
101       key-record of the win 95 registry.
102
103 lf-Record
104
105       The lf-record is the counterpart to the RGKN-record (the
106       hash-function)
107
108 vk-Record
109
110       The vk-record consists information to a single value.
111
112 sk-Record
113
114       sk (? Security Key ?) is the ACL of the registry.
115
116 Value-Lists
117
118       The value-lists contain information about which values are inside a
119       sub-key and don't have a header.
120
121 Datas
122
123       The datas of the registry are (like the value-list) stored without a
124       header.
125
126 All offset-values are relative to the first hbin-block and point to the
127 block-size field of the record-entry. to get the file offset, you have to add
128 the header size (4kb) and the size field (4 bytes)...
129
130 the nk-Record
131 =============
132 Offset      Size      Contents
133 0x0000      Word      ID: ASCII-"nk" = 0x6B6E
134 0x0002      Word      for the root-key: 0x2C, otherwise 0x20  //key symbolic links 0x10. Nigel
135 0x0004      Q-Word      write-date/time in windows nt notation
136 0x0010      D-Word      Offset of Owner/Parent key
137 0x0014      D-Word      number of sub-Keys
138 0x001C      D-Word      Offset of the sub-key lf-Records
139 0x0024      D-Word      number of values
140 0x0028      D-Word      Offset of the Value-List
141 0x002C      D-Word      Offset of the sk-Record
142
143 0x0030      D-Word      Offset of the Class-Name //see NK structure for the use of these fields. Nigel
144 0x0044      D-Word      Unused (data-trash)  //some kind of run time index. Does not appear to be important. Nigel
145 0x0048      Word      name-length
146 0x004A      Word      class-name length
147 0x004C      ????      key-name
148
149 the Value-List
150 ==============
151 Offset      Size      Contents
152 0x0000      D-Word      Offset 1st Value
153 0x0004      D-Word      Offset 2nd Value
154 0x????      D-Word      Offset nth Value
155
156 To determine the number of values, you have to look at the owner-nk-record!
157
158 Der vk-Record
159 =============
160 Offset      Size      Contents
161 0x0000      Word      ID: ASCII-"vk" = 0x6B76
162 0x0002      Word      name length
163 0x0004      D-Word      length of the data   //if top bit is set when offset contains data. Nigel
164 0x0008      D-Word      Offset of Data
165 0x000C      D-Word      Type of value
166 0x0010      Word      Flag
167 0x0012      Word      Unused (data-trash)
168 0x0014      ????      Name
169
170 If bit 0 of the flag-word is set, a name is present, otherwise the value has no name (=default)
171
172 If the data-size is lower 5, the data-offset value is used to store the data itself!
173
174 The data-types
175 ==============
176 Wert      Beteutung
177 0x0001      RegSZ:             character string (in UNICODE!)
178 0x0002      ExpandSZ:   string with "%var%" expanding (UNICODE!)
179 0x0003      RegBin:           raw-binary value
180 0x0004      RegDWord:   Dword
181 0x0007      RegMultiSZ:      multiple strings, separated with 0
182                   (UNICODE!)
183
184 The "lf"-record
185 ===============
186 Offset      Size      Contents
187 0x0000      Word      ID: ASCII-"lf" = 0x666C
188 0x0002      Word      number of keys
189 0x0004      ????      Hash-Records
190
191 Hash-Record
192 ===========
193 Offset      Size      Contents
194 0x0000      D-Word      Offset of corresponding "nk"-Record
195 0x0004      D-Word      ASCII: the first 4 characters of the key-name, padded with 0's. Case sensitiv!
196
197 Keep in mind, that the value at 0x0004 is used for checking the data-consistency! If you change the 
198 key-name you have to change the hash-value too!
199
200 //These hashrecords must be sorted low to high within the lf record. Nigel.
201
202 The "sk"-block
203 ==============
204 (due to the complexity of the SAM-info, not clear jet)
205
206 Offset      Size      Contents
207 0x0000      Word      ID: ASCII-"sk" = 0x6B73
208 0x0002      Word      Unused
209 0x0004      D-Word      Offset of previous "sk"-Record
210 0x0008      D-Word      Offset of next "sk"-Record
211 0x000C      D-Word      usage-counter
212 0x0010      D-Word      Size of "sk"-record in bytes
213 ????                                             //standard self
214 relative security desciptor. Nigel
215 ????  ????      Security and auditing settings...
216 ????
217
218 The usage counter counts the number of references to this
219 "sk"-record. You can use one "sk"-record for the entire registry!
220
221 Windows nt date/time format
222 ===========================
223 The time-format is a 64-bit integer which is incremented every
224 0,0000001 seconds by 1 (I don't know how accurate it realy is!)
225 It starts with 0 at the 1st of january 1601 0:00! All values are
226 stored in GMT time! The time-zone is important to get the real
227 time!
228
229 Common values for win95 and win-nt
230 ==================================
231 Offset values marking an "end of list", are either 0 or -1 (0xFFFFFFFF).
232 If a value has no name (length=0, flag(bit 0)=0), it is treated as the
233 "Default" entry...
234 If a value has no data (length=0), it is displayed as empty.
235
236 simplyfied win-3.?? registry:
237 =============================
238
239 +-----------+
240 | next rec. |---+                      +----->+------------+
241 | first sub |   |                      |      | Usage cnt. |
242 | name      |   |  +-->+------------+  |      | length     |
243 | value     |   |  |   | next rec.  |  |      | text       |------->+-------+
244 +-----------+   |  |   | name rec.  |--+      +------------+        | xxxxx |
245    +------------+  |   | value rec. |-------->+------------+        +-------+
246    v               |   +------------+         | Usage cnt. |
247 +-----------+      |                          | length     |
248 | next rec. |      |                          | text       |------->+-------+
249 | first sub |------+                          +------------+        | xxxxx |
250 | name      |                                                       +-------+
251 | value     |
252 +-----------+    
253
254 Greatly simplyfied structure of the nt-registry:
255 ================================================
256    
257 +---------------------------------------------------------------+
258 |                                                               |
259 v                                                               |
260 +---------+     +---------->+-----------+  +----->+---------+   |
261 | "nk"    |     |           | lf-rec.   |  |      | nk-rec. |   |
262 | ID      |     |           | # of keys |  |      | parent  |---+
263 | Date    |     |           | 1st key   |--+      | ....    |
264 | parent  |     |           +-----------+         +---------+
265 | suk-keys|-----+
266 | values  |--------------------->+----------+
267 | SK-rec. |---------------+      | 1. value |--> +----------+
268 | class   |--+            |      +----------+    | vk-rec.  |
269 +---------+  |            |                      | ....     |
270              v            |                      | data     |--> +-------+
271       +------------+      |                      +----------+    | xxxxx |
272       | Class name |      |                                      +-------+
273       +------------+      |
274                           v
275           +---------+    +---------+
276    +----->| next sk |--->| Next sk |--+
277    |  +---| prev sk |<---| prev sk |  |
278    |  |   | ....    |    | ...     |  |
279    |  |   +---------+    +---------+  |
280    |  |         ^          |          |
281       |         +----------+          |
282       +-------------------------------+
283
284 ---------------------------------------------------------------------------
285
286 Hope this helps....  (Although it was "fun" for me to uncover this things,
287                   it took me several sleepless nights ;)
288
289             B.D.
290
291 *************************************************************************/
292 #include "includes.h"
293 #include <stdio.h>
294 #include <errno.h>
295 #include <sys/types.h>
296 #include <sys/stat.h>
297 #include <unistd.h>
298
299 typedef unsigned int DWORD;
300 typedef unsigned short WORD;
301
302 #define REG_REGF_ID 0x66676572
303
304 typedef struct regf_block {
305   DWORD REGF_ID;     /* regf */
306   DWORD uk1;
307   DWORD uk2;
308   DWORD tim1, tim2;
309   DWORD uk3;             /* 1 */
310   DWORD uk4;             /* 3 */
311   DWORD uk5;             /* 0 */
312   DWORD uk6;             /* 1 */
313   DWORD first_key;       /* offset */
314   unsigned int dblk_size;
315   DWORD uk7[116];        /* 1 */
316   DWORD chksum;
317 } REGF_HDR;
318
319 typedef struct hbin_sub_struct {
320   DWORD dblocksize;
321   char data[1];
322 } HBIN_SUB_HDR;
323
324 #define REG_HBIN_ID 0x6E696268
325
326 typedef struct hbin_struct {
327   DWORD HBIN_ID; /* hbin */
328   DWORD next_off;
329   DWORD prev_off;
330   DWORD uk1;
331   DWORD uk2;
332   DWORD uk3;
333   DWORD uk4;
334   DWORD blk_size;
335   HBIN_SUB_HDR hbin_sub_hdr;
336 } HBIN_HDR;
337
338 #define REG_NK_ID 0x6B6E
339
340 typedef struct nk_struct {
341   WORD NK_ID;
342   WORD type;
343   DWORD t1, t2;
344   DWORD uk1;
345   DWORD own_off;
346   DWORD subk_num;
347   DWORD uk2;
348   DWORD lf_off;
349   DWORD uk3;
350   DWORD val_cnt;
351   DWORD val_off;
352   DWORD sk_off;
353   DWORD clsnam_off;
354 } NK_HDR;
355
356 #define REG_SK_ID 0x6B73
357
358 typedef struct sk_struct {
359   WORD SK_ID;
360   WORD uk1;
361   DWORD prev_off;
362   DWORD next_off;
363   DWORD ref_cnt;
364   DWORD rec_size;
365   char sec_desc[1];
366 } SK_HDR;
367
368 typedef struct sec_desc_rec {
369   WORD rev;
370   WORD type;
371   DWORD owner_off;
372   DWORD group_off;
373   DWORD sacl_off;
374   DWORD dacl_off;
375 } MY_SEC_DESC;
376
377 typedef struct ace_struct {
378     unsigned char type;
379     unsigned char flags;
380     unsigned short length;
381     unsigned int perms;
382     DOM_SID trustee;
383 } ACE;
384
385 typedef struct acl_struct {
386   WORD rev;
387   WORD size;
388   DWORD num_aces;
389   ACE *aces;   /* One or more ACEs */
390 } ACL;
391
392 #define OFF(f) (0x1000 + (f) + 4) 
393
394 static void print_sid(DOM_SID *sid);
395
396 int verbose = 1;
397 DOM_SID old_sid, new_sid;
398 int change = 0, new = 0;
399
400 /* Compare two SIDs for equality */
401 static int my_sid_equal(DOM_SID *s1, DOM_SID *s2)
402 {
403   int sa1, sa2;
404
405   if (s1->sid_rev_num != s2->sid_rev_num) return 0;
406
407   sa1 = s1->num_auths; sa2 = s2->num_auths;
408
409   if (sa1 != sa2) return 0;
410
411   return !memcmp((char *)&s1->id_auth, (char *)&s2->id_auth,
412                 6 + sa1 * 4);
413
414 }
415
416 /*
417  * Quick and dirty to read a SID in S-1-5-21-x-y-z-rid format and 
418  * construct a DOM_SID
419  */
420 static int get_sid(DOM_SID *sid, const unsigned char *sid_str)
421 {
422   int i = 0, auth;
423   const unsigned char *lstr; 
424
425   if (strncmp(sid_str, "S-1-5", 5)) {
426     fprintf(stderr, "Does not conform to S-1-5...: %s\n", sid_str);
427     return 0;
428   }
429
430   /* We only allow strings of form S-1-5... */
431
432   sid->sid_rev_num = 1;
433   sid->id_auth[5] = 5;
434
435   lstr = sid_str + 5;
436
437   while (1) {
438     if (!lstr || !lstr[0] || sscanf(lstr, "-%u", &auth) == 0) {
439       if (i < 4) {
440         fprintf(stderr, "Not of form -d-d...: %s, %u\n", lstr, i);
441         return 0;
442       }
443       sid->num_auths=i;
444       print_sid(sid);
445       return 1;
446     }
447
448     SIVAL(&sid->sub_auths[i], 0, auth);
449     i++;
450     lstr = (const unsigned char *)strchr(lstr + 1, '-'); 
451   }
452
453   return 1;
454 }
455
456 #if 0
457
458 /* 
459  * Replace SID1, component by component with SID2
460  * Assumes will never be called with unequal length SIDS
461  * so only touches 21-x-y-z-rid portion
462  * This routine does not need to deal with endianism as 
463  * long as the incoming SIDs are both in the same (LE) format.
464  */
465 static void change_sid(DOM_SID *s1, DOM_SID *s2)
466 {
467   int i;
468   
469   for (i=0; i<s1->num_auths; i++) {
470     s1->sub_auths[i] = s2->sub_auths[i];
471   }
472 }
473
474 #endif
475
476 static void print_sid(DOM_SID *sid)
477 {
478   int i, comps = sid->num_auths;
479   fprintf(stdout, "S-%u-%u", sid->sid_rev_num, sid->id_auth[5]);
480
481   for (i = 0; i < comps; i++) {
482
483     fprintf(stdout, "-%u", IVAL(&sid->sub_auths[i],0));
484
485   }
486   fprintf(stdout, "\n");
487 }
488
489 static void process_sid(DOM_SID *sid, DOM_SID *o_sid, DOM_SID *n_sid) 
490 {
491   int i;
492   if (my_sid_equal(sid, o_sid)) {
493
494     for (i=0; i<sid->num_auths; i++) {
495       sid->sub_auths[i] = n_sid->sub_auths[i];
496
497     }
498
499   }
500
501 }
502
503 static void process_acl(ACL *acl, const char *prefix)
504 {
505   int ace_cnt, i;
506   ACE *ace;
507
508   ace_cnt = IVAL(&acl->num_aces, 0);
509   ace = (ACE *)&acl->aces;
510   if (verbose) fprintf(stdout, "%sACEs: %u\n", prefix, ace_cnt);
511   for (i=0; i<ace_cnt; i++) {
512     if (verbose) fprintf(stdout, "%s  Perms: %08X, SID: ", prefix,
513                          IVAL(&ace->perms, 0));
514     if (change)
515       process_sid(&ace->trustee, &old_sid, &new_sid);
516     print_sid(&ace->trustee);
517     ace = (ACE *)((char *)ace + SVAL(&ace->length, 0));
518   }
519
520
521 int main(int argc, char *argv[])
522 {
523   int opt;
524   int fd, start = 0;
525   char *base;
526   struct stat sbuf;
527   REGF_HDR *regf_hdr;
528   HBIN_HDR *hbin_hdr;
529   NK_HDR *nk_hdr;
530   SK_HDR *sk_hdr;
531   DWORD first_sk_off, sk_off;
532   MY_SEC_DESC *sec_desc;
533   int *ptr;
534   struct poptOption long_options[] = {
535           POPT_AUTOHELP
536           { "verbose", 'v', POPT_ARG_NONE, NULL, 'v', "Sets verbose mode" },
537           { "change-sid", 'c', POPT_ARG_STRING, NULL, 'c', "Provides SID to change" },
538           { "new-sid", 'n', POPT_ARG_STRING, NULL, 'n', "Provides SID to change to" },
539           { 0, 0, 0, 0 }
540   };
541
542   poptContext pc;
543
544   pc = poptGetContext("profiles", argc, (const char **)argv, long_options, 
545                                           POPT_CONTEXT_KEEP_FIRST);
546
547   poptSetOtherOptionHelp(pc, "<profilefile>");
548
549   /*
550    * Now, process the arguments
551    */
552
553   while ((opt = poptGetNextOpt(pc)) != -1) {
554     switch (opt) {
555         case 'c':
556                 change = 1;
557                 if (!get_sid(&old_sid, poptGetOptArg(pc))) {
558                         fprintf(stderr, "Argument to -c should be a SID in form of S-1-5-...\n");
559                         poptPrintUsage(pc, stderr, 0);
560                         exit(254);
561                 }
562                 break;
563
564         case 'n':
565                 new = 1;
566                 if (!get_sid(&new_sid, poptGetOptArg(pc))) {
567                         fprintf(stderr, "Argument to -n should be a SID in form of S-1-5-...\n");
568                         poptPrintUsage(pc, stderr, 0);
569                         exit(253);
570                 }
571
572                 break;
573
574         case 'v':
575                 verbose++;
576                 break;
577         }
578   }
579
580   if (!poptPeekArg(pc)) {
581           poptPrintUsage(pc, stderr, 0);
582           exit(1);
583   }
584
585   if ((!change & new) || (change & !new)) {
586           fprintf(stderr, "You must specify both -c and -n if one or the other is set!\n");
587           poptPrintUsage(pc, stderr, 0);
588           exit(252);
589   }
590
591   poptGetArg(pc); /* To get argv[0] */
592
593   fd = open(poptPeekArg(pc), O_RDWR, 0000);
594
595   if (fd < 0) {
596     fprintf(stderr, "Could not open %s: %s\n", poptPeekArg(pc), 
597         strerror(errno));
598     exit(2);
599   }
600
601   if (fstat(fd, &sbuf) < 0) {
602     fprintf(stderr, "Could not stat file %s, %s\n", poptPeekArg(pc),
603         strerror(errno));
604     exit(3);
605   }
606
607   /*
608    * Now, mmap the file into memory, check the header and start
609    * dealing with the records. We are interested in the sk record
610    */
611   start = 0;
612
613 #ifdef HAVE_MMAP
614   base = mmap(&start, sbuf.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
615 #else
616   base = (char *)-1;
617   errno = ENOSYS;
618 #endif
619
620   if ((int)base == -1) {
621     fprintf(stderr, "Could not mmap file: %s, %s\n", poptPeekArg(pc),
622         strerror(errno));
623     exit(4);
624   }
625
626   /*
627    * In what follows, and in places above, in order to work on both LE and
628    * BE platforms, we have to use the Samba macros to extract SHORT, LONG
629    * and associated UNSIGNED quantities from the data in the mmap'd file.
630    * NOTE, however, that we do not need to do anything with memory
631    * addresses that we construct from pointers in our address space.
632    * For example, 
633    *
634    *    sec_desc = (MY_SEC_DESC *)&(sk_hdr->sec_desc[0]);
635    *
636    * is simply taking the address of a structure we already have the address
637    * of in our address space, while, the fields within it, will have to 
638    * be accessed with the macros:
639    *
640    * owner_sid = (DOM_SID *)(&sk_hdr->sec_desc[0] + 
641    *                         IVAL(&sec_desc->owner_off, 0));
642    *
643    * Which is pulling out an offset and adding it to an existing pointer.
644    *
645    */
646
647   regf_hdr = (REGF_HDR *)base;
648
649   if (verbose) fprintf(stdout, "Registry file size: %u\n", (unsigned int)sbuf.st_size);
650
651   if (IVAL(&regf_hdr->REGF_ID, 0) != REG_REGF_ID) {
652     fprintf(stderr, "Incorrect Registry file (doesn't have header ID): %s\n", poptPeekArg(pc));
653     exit(5);
654   }
655
656   if (verbose) fprintf(stdout, "First Key Off: %u, Data Block Size: %u\n",
657                        IVAL(&regf_hdr->first_key, 0), 
658                        IVAL(&regf_hdr->dblk_size, 0));
659
660   hbin_hdr = (HBIN_HDR *)(base + 0x1000); /* No need for Endian stuff */
661
662   /*
663    * This should be the hbin_hdr 
664    */
665
666   if (IVAL(&hbin_hdr->HBIN_ID, 0) != REG_HBIN_ID) {
667     fprintf(stderr, "Incorrect hbin hdr: %s\n", poptPeekArg(pc));
668     exit(6);
669   } 
670
671   if (verbose) fprintf(stdout, "Next Off: %u, Prev Off: %u\n", 
672                        IVAL(&hbin_hdr->next_off, 0), 
673                        IVAL(&hbin_hdr->prev_off, 0));
674
675   nk_hdr = (NK_HDR *)(base + 0x1000 + IVAL(&regf_hdr->first_key, 0) + 4);
676
677   if (SVAL(&nk_hdr->NK_ID, 0) != REG_NK_ID) {
678     fprintf(stderr, "Incorrect NK Header: %s\n", poptPeekArg(pc));
679     exit(7);
680   }
681
682   sk_off = first_sk_off = IVAL(&nk_hdr->sk_off, 0);
683   if (verbose) {
684     fprintf(stdout, "Type: %0x\n", SVAL(&nk_hdr->type, 0));
685     fprintf(stdout, "SK Off    : %o\n", (0x1000 + sk_off + 4));  
686   }
687
688   sk_hdr = (SK_HDR *)(base + 0x1000 + sk_off + 4);
689
690   do {
691     DOM_SID *owner_sid, *group_sid;
692     ACL *sacl, *dacl;
693     if (SVAL(&sk_hdr->SK_ID, 0) != REG_SK_ID) {
694       fprintf(stderr, "Incorrect SK Header format: %08X\n", 
695               (0x1000 + sk_off + 4));
696       exit(8);
697     }
698     ptr = (int *)sk_hdr;
699     if (verbose) fprintf(stdout, "Off: %08X, Refs: %u, Size: %u\n",
700                          sk_off, IVAL(&sk_hdr->ref_cnt, 0), 
701                          IVAL(&sk_hdr->rec_size, 0));
702
703     sec_desc = (MY_SEC_DESC *)&(sk_hdr->sec_desc[0]);
704     owner_sid = (DOM_SID *)(&sk_hdr->sec_desc[0] +
705                             IVAL(&sec_desc->owner_off, 0));
706     group_sid = (DOM_SID *)(&sk_hdr->sec_desc[0] + 
707                             IVAL(&sec_desc->group_off, 0));
708     sacl = (ACL *)(&sk_hdr->sec_desc[0] + 
709                    IVAL(&sec_desc->sacl_off, 0));
710     dacl = (ACL *)(&sk_hdr->sec_desc[0] + 
711                    IVAL(&sec_desc->dacl_off, 0));
712     if (verbose)fprintf(stdout, "  Owner SID: "); 
713     if (change) process_sid(owner_sid, &old_sid, &new_sid);
714     if (verbose) print_sid(owner_sid);
715     if (verbose) fprintf(stdout, "  Group SID: "); 
716     if (change) process_sid(group_sid, &old_sid, &new_sid);
717     if (verbose) print_sid(group_sid);
718     fprintf(stdout, "  SACL: ");
719     if (!sec_desc->sacl_off) { /* LE zero == BE zero */
720       if (verbose) fprintf(stdout, "NONE\n");
721     }
722     else 
723       process_acl(sacl, "    ");
724     if (verbose) fprintf(stdout, "  DACL: ");
725     if (!sec_desc->dacl_off) {
726       if (verbose) fprintf(stdout, "NONE\n");
727     }
728     else 
729       process_acl(dacl, "    ");
730     sk_off = IVAL(&sk_hdr->prev_off, 0);
731     sk_hdr = (SK_HDR *)(base + OFF(IVAL(&sk_hdr->prev_off, 0)));
732   } while (sk_off != first_sk_off);
733
734 #ifdef HAVE_MMAP
735   munmap(base, sbuf.st_size); 
736 #endif
737
738   poptFreeContext(pc);
739
740   close(fd);
741   return 0;
742 }