Makefile: added lsaparse.c and smbparse.c
[kai/samba.git] / source3 / lsaparse.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 1.9.
4    Samba utility functions
5    Copyright (C) Luke Leighton 1996 - 1997  Paul Ashton 1997
6    
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11    
12    This program 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 this program; if not, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 #include "includes.h"
23
24 extern int DEBUGLEVEL;
25
26
27 /*******************************************************************
28 reads or writes an LSA_Q_QUERY_INFO structure.
29 ********************************************************************/
30 char* lsa_io_q_query(BOOL io, LSA_Q_QUERY_INFO *q_q, char *q, char *base, int align)
31 {
32         if (q_q == NULL) return NULL;
33
34         RW_SVAL(io, q, q_q->info_class, 0); q += 2;
35
36         return q;
37 }
38
39 /*******************************************************************
40 reads or writes an LSA_Q_QUERY_INFO structure.
41 ********************************************************************/
42 char* lsa_io_r_query(BOOL io, LSA_R_QUERY_INFO *r_q, char *q, char *base, int align)
43 {
44         if (r_q == NULL) return NULL;
45
46         RW_IVAL(io, q, r_q->undoc_buffer, 0); q += 4;
47
48         if (r_q->undoc_buffer != 0)
49         {
50                 RW_SVAL(io, q, r_q->info_class, 0); q += 2;
51
52                 switch (r_q->info_class)
53                 {
54                         case 3:
55                         {
56                                 q = smb_io_dom_query_3(io, &(r_q->dom.id3), q, base, align);
57                                 break;
58                         }
59                         case 5:
60                         {
61                                 q = smb_io_dom_query_5(io, &(r_q->dom.id3), q, base, align);
62                                 break;
63                         }
64                         default:
65                         {
66                                 /* PANIC! */
67                                 break;
68                         }
69                 }
70         }
71         return q;
72 }
73
74 /*******************************************************************
75 reads or writes a structure.
76 ********************************************************************/
77 char* lsa_io_q_lookup_sids(BOOL io, LSA_Q_LOOKUP_SIDS *q_s, char *q, char *base, int align)
78 {
79         int i;
80
81         if (q_s == NULL) return NULL;
82
83         q = align_offset(q, base, align);
84         
85     q = smb_io_pol_hnd(io, &(q_s->pol_hnd), q, base, align); /* policy handle */
86
87         RW_IVAL(io, q, q_s->num_entries, 0); q += 4;
88         RW_IVAL(io, q, q_s->buffer_dom_sid, 0); q += 4; /* undocumented domain SID buffer pointer */
89         RW_IVAL(io, q, q_s->buffer_dom_name, 0); q += 4; /* undocumented domain name buffer pointer */
90
91         for (i = 0; i < q_s->num_entries; i++)
92         {
93                 RW_IVAL(io, q, q_s->buffer_lookup_sids[i], 0); q += 4; /* undocumented domain SID pointers to be looked up. */
94         }
95
96         for (i = 0; i < q_s->num_entries; i++)
97         {
98                 q = smb_io_dom_sid(io, &(q_s->dom_sids[i]), q, base, align); /* domain SIDs to be looked up. */
99         }
100
101         RW_PCVAL(io, q, q_s->undoc, 16); q += 16; /* completely undocumented 16 bytes */
102
103         return q;
104 }
105
106 /*******************************************************************
107 reads or writes a structure.
108 ********************************************************************/
109 char* lsa_io_r_lookup_sids(BOOL io, LSA_R_LOOKUP_SIDS *r_s, char *q, char *base, int align)
110 {
111         int i;
112
113         if (r_s == NULL) return NULL;
114
115         q = align_offset(q, base, align);
116         
117         q = smb_io_dom_r_ref(io, &(r_s->dom_ref), q, base, align); /* domain reference info */
118
119         RW_IVAL(io, q, r_s->num_entries, 0); q += 4;
120         RW_IVAL(io, q, r_s->undoc_buffer, 0); q += 4;
121         RW_IVAL(io, q, r_s->num_entries2, 0); q += 4;
122
123         for (i = 0; i < r_s->num_entries2; i++)
124         {
125                 q = smb_io_dom_sid2(io, &(r_s->dom_sid[i]), q, base, align); /* domain SIDs being looked up */
126         }
127
128         RW_IVAL(io, q, r_s->num_entries3, 0); q += 4;
129
130         return q;
131 }
132
133 /*******************************************************************
134 reads or writes a structure.
135 ********************************************************************/
136 char* lsa_io_q_lookup_rids(BOOL io, LSA_Q_LOOKUP_RIDS *q_r, char *q, char *base, int align)
137 {
138         int i;
139
140         if (q_r == NULL) return NULL;
141
142         q = align_offset(q, base, align);
143         
144     q = smb_io_pol_hnd(io, &(q_r->pol_hnd), q, base, align); /* policy handle */
145
146         RW_IVAL(io, q, q_r->num_entries, 0); q += 4;
147         RW_IVAL(io, q, q_r->num_entries2, 0); q += 4;
148         RW_IVAL(io, q, q_r->buffer_dom_sid, 0); q += 4; /* undocumented domain SID buffer pointer */
149         RW_IVAL(io, q, q_r->buffer_dom_name, 0); q += 4; /* undocumented domain name buffer pointer */
150
151         for (i = 0; i < q_r->num_entries; i++)
152         {
153                 q = smb_io_dom_name(io, &(q_r->lookup_name[i]), q, base, 0); /* names to be looked up */
154         }
155
156         RW_PCVAL(io, q, q_r->undoc, UNKNOWN_LEN); q += UNKNOWN_LEN; /* completely undocumented bytes of unknown length */
157
158         return q;
159 }
160
161 /*******************************************************************
162 reads or writes a structure.
163 ********************************************************************/
164 char* lsa_io_r_lookup_rids(BOOL io, LSA_R_LOOKUP_RIDS *r_r, char *q, char *base, int align)
165 {
166         int i;
167
168         if (r_r == NULL) return NULL;
169
170         q = align_offset(q, base, align);
171         
172         q = smb_io_dom_r_ref(io, &(r_r->dom_ref), q, base, align); /* domain reference info */
173
174         RW_IVAL(io, q, r_r->num_entries, 0); q += 4;
175         RW_IVAL(io, q, r_r->undoc_buffer, 0); q += 4;
176         RW_IVAL(io, q, r_r->num_entries2, 0); q += 4;
177
178         for (i = 0; i < r_r->num_entries2; i++)
179         {
180                 q = smb_io_dom_rid2(io, &(r_r->dom_rid[i]), q, base, align); /* domain RIDs being looked up */
181         }
182
183         RW_IVAL(io, q, r_r->num_entries3, 0); q += 4;
184
185         return q;
186 }
187
188 /*******************************************************************
189 reads or writes a structure.
190 ********************************************************************/
191 char* lsa_io_q_req_chal(BOOL io, LSA_Q_REQ_CHAL *q_c, char *q, char *base, int align)
192 {
193         if (q_c == NULL) return NULL;
194
195         q = align_offset(q, base, align);
196     
197         q = smb_io_unistr2(io, &(q_c->uni_logon_srv), q, base, align); /* logon server unicode string */
198         q = smb_io_unistr2(io, &(q_c->uni_logon_clnt), q, base, align); /* logon client unicode string */
199         q = smb_io_chal(io, &(q_c->clnt_chal), q, base, align); /* client challenge */
200
201         return q;
202 }
203
204 /*******************************************************************
205 reads or writes a structure.
206 ********************************************************************/
207 char* lsa_io_r_req_chal(BOOL io, LSA_R_REQ_CHAL *r_c, char *q, char *base, int align)
208 {
209         if (r_c == NULL) return NULL;
210
211         q = align_offset(q, base, align);
212     
213         q = smb_io_chal(io, &(r_c->srv_chal), q, base, align); /* server challenge */
214
215         return q;
216 }
217
218
219 /*******************************************************************
220 reads or writes a structure.
221 ********************************************************************/
222 char* lsa_io_q_auth2(BOOL io, LSA_Q_AUTH_2 *q_a, char *q, char *base, int align)
223 {
224         if (q_a == NULL) return NULL;
225
226         q = align_offset(q, base, align);
227     
228         q = smb_io_log_info (io, &(q_a->clnt_id), q, base, align); /* client identification info */
229         q = smb_io_chal     (io, &(q_a->clnt_chal), q, base, align); /* client-calculated credentials */
230         q = smb_io_neg_flags(io, &(q_a->clnt_flgs), q, base, align);
231
232         return q;
233 }
234
235 /*******************************************************************
236 reads or writes a structure.
237 ********************************************************************/
238 char* lsa_io_r_auth_2(BOOL io, LSA_R_AUTH_2 *r_a, char *q, char *base, int align)
239 {
240         if (r_a == NULL) return NULL;
241
242         q = align_offset(q, base, align);
243     
244         q = smb_io_chal     (io, &(r_a->srv_chal), q, base, align); /* server challenge */
245         q = smb_io_neg_flags(io, &(r_a->srv_flgs), q, base, align);
246
247         return q;
248 }
249
250
251 /*******************************************************************
252 reads or writes a structure.
253 ********************************************************************/
254 char* lsa_io_q_srv_pwset(BOOL io, LSA_Q_SRV_PWSET *q_s, char *q, char *base, int align)
255 {
256         if (q_s == NULL) return NULL;
257
258         q = align_offset(q, base, align);
259     
260         q = smb_io_clnt_info(io, &(q_s->clnt_id), q, base, align); /* client identification/authentication info */
261         RW_PCVAL(io, q, q_s->pwd, 16); q += 16; /* new password - undocumented */
262
263         return q;
264 }
265
266 /*******************************************************************
267 reads or writes a structure.
268 ********************************************************************/
269 char* lsa_io_r_srv_pwset(BOOL io, LSA_R_SRV_PWSET *r_s, char *q, char *base, int align)
270 {
271         if (r_s == NULL) return NULL;
272
273         q = align_offset(q, base, align);
274     
275         q = smb_io_chal(io, &(r_s->srv_chal), q, base, align); /* server challenge */
276
277         return q;
278 }
279
280 /* LSA_USER_INFO */
281
282 /*******************************************************************
283 reads or writes a structure.
284 ********************************************************************/
285 char* lsa_io_user_info(BOOL io, LSA_USER_INFO *usr, char *q, char *base, int align)
286 {
287         int i;
288
289         if (usr == NULL) return NULL;
290
291         q = align_offset(q, base, align);
292         
293         RW_IVAL(io, q, usr->undoc_buffer, 0); q += 4;
294
295         q = smb_io_time(io, &(usr->logon_time)           , q, base, align); /* logon time */
296         q = smb_io_time(io, &(usr->logoff_time)          , q, base, align); /* logoff time */
297         q = smb_io_time(io, &(usr->kickoff_time)         , q, base, align); /* kickoff time */
298         q = smb_io_time(io, &(usr->pass_last_set_time)   , q, base, align); /* password last set time */
299         q = smb_io_time(io, &(usr->pass_can_change_time) , q, base, align); /* password can change time */
300         q = smb_io_time(io, &(usr->pass_must_change_time), q, base, align); /* password must change time */
301
302         q = smb_io_unihdr(io, &(usr->hdr_user_name)   , q, base, align); /* username unicode string header */
303         q = smb_io_unihdr(io, &(usr->hdr_full_name)   , q, base, align); /* user's full name unicode string header */
304         q = smb_io_unihdr(io, &(usr->hdr_logon_script), q, base, align); /* logon script unicode string header */
305         q = smb_io_unihdr(io, &(usr->hdr_profile_path), q, base, align); /* profile path unicode string header */
306         q = smb_io_unihdr(io, &(usr->hdr_home_dir)    , q, base, align); /* home directory unicode string header */
307         q = smb_io_unihdr(io, &(usr->hdr_dir_drive)   , q, base, align); /* home directory drive unicode string header */
308
309         RW_SVAL(io, q, usr->logon_count , 0); q += 2;  /* logon count */
310         RW_SVAL(io, q, usr->bad_pw_count, 0); q += 2; /* bad password count */
311
312         RW_IVAL(io, q, usr->user_id      , 0); q += 4;       /* User ID */
313         RW_IVAL(io, q, usr->group_id     , 0); q += 4;      /* Group ID */
314         RW_IVAL(io, q, usr->num_groups   , 0); q += 4;    /* num groups */
315         RW_IVAL(io, q, usr->buffer_groups, 0); q += 4; /* undocumented buffer pointer to groups. */
316         RW_IVAL(io, q, usr->user_flgs    , 0); q += 4;     /* user flags */
317
318         RW_PCVAL(io, q, usr->sess_key, 16); q += 16; /* unused user session key */
319
320         q = smb_io_unihdr(io, &(usr->hdr_logon_srv), q, base, align); /* logon server unicode string header */
321         q = smb_io_unihdr(io, &(usr->hdr_logon_dom), q, base, align); /* logon domain unicode string header */
322
323         RW_IVAL(io, q, usr->buffer_dom_id, 0); q += 4; /* undocumented logon domain id pointer */
324         RW_PCVAL(io, q, usr->padding, 40); q += 40; /* unused padding bytes? */
325
326         RW_IVAL(io, q, usr->num_sids, 0); q += 4; /* 0 - num_sids */
327         RW_IVAL(io, q, usr->buffer_sids, 0); q += 4; /* NULL - undocumented pointer to SIDs. */
328         
329         q = smb_io_unistr2(io, &(usr->uni_user_name)   , q, base, align); /* username unicode string */
330         q = smb_io_unistr2(io, &(usr->uni_full_name)   , q, base, align); /* user's full name unicode string */
331         q = smb_io_unistr2(io, &(usr->uni_logon_script), q, base, align); /* logon script unicode string */
332         q = smb_io_unistr2(io, &(usr->uni_profile_path), q, base, align); /* profile path unicode string */
333         q = smb_io_unistr2(io, &(usr->uni_home_dir)    , q, base, align); /* home directory unicode string */
334         q = smb_io_unistr2(io, &(usr->uni_dir_drive)   , q, base, align); /* home directory drive unicode string */
335
336         RW_IVAL(io, q, usr->num_groups2, 0); q += 4;        /* num groups */
337         for (i = 0; i < usr->num_groups2; i++)
338         {
339                 q = smb_io_gid(io, &(usr->gids[i]), q, base, align); /* group info */
340         }
341
342         q = smb_io_unistr2(io, &( usr->uni_logon_srv), q, base, align); /* logon server unicode string */
343         q = smb_io_unistr2(io, &( usr->uni_logon_dom), q, base, align); /* logon domain unicode string */
344
345         q = smb_io_dom_sid(io, &(usr->undoc_dom_sids[0]), q, base, align); /* undocumented - domain SIDs */
346         q = smb_io_dom_sid(io, &(usr->undoc_dom_sids[1]), q, base, align); /* undocumented - domain SIDs */
347         q = smb_io_dom_sid(io, &(usr->dom_sid), q, base, align);           /* domain SID */
348
349         return q;
350 }
351
352
353 #if 0
354 /*******************************************************************
355 reads or writes a structure.
356 ********************************************************************/
357  char* lsa_io_(BOOL io, *, char *q, char *base, int align)
358 {
359         if (== NULL) return NULL;
360
361         q = align_offset(q, base, align);
362         
363         RW_IVAL(io, q, , 0); q += 4;
364
365         return q;
366 }
367 #endif
368
369
370 #if 0 /* to be done... */
371
372
373 #define LSA_MAX_GROUPS 32
374
375 /* LSA_USER_INFO */
376 typedef struct lsa_q_user_info
377 {
378         uint32 undoc_buffer;
379
380         NTTIME logon_time;            /* logon time */
381         NTTIME logoff_time;           /* logoff time */
382         NTTIME kickoff_time;          /* kickoff time */
383         NTTIME pass_last_set_time;    /* password last set time */
384         NTTIME pass_can_change_time;  /* password can change time */
385         NTTIME pass_must_change_time; /* password must change time */
386
387         UNIHDR hdr_user_name;    /* username unicode string header */
388         UNIHDR hdr_full_name;    /* user's full name unicode string header */
389         UNIHDR hdr_logon_script; /* logon script unicode string header */
390         UNIHDR hdr_profile_path; /* profile path unicode string header */
391         UNIHDR hdr_home_dir;     /* home directory unicode string header */
392         UNIHDR hdr_dir_drive;    /* home directory drive unicode string header */
393
394         uint16 logon_count;  /* logon count */
395         uint16 bad_pw_count; /* bad password count */
396
397         uint32 user_id;       /* User ID */
398         uint32 group_id;      /* Group ID */
399         uint32 num_groups;    /* num groups */
400         uint32 buffer_groups; /* undocumented buffer pointer to groups. */
401         uint32 user_flgs;     /* user flags */
402
403         char sess_key[16]; /* unused user session key */
404
405         UNIHDR hdr_logon_srv; /* logon server unicode string header */
406         UNIHDR hdr_logon_dom; /* logon domain unicode string header */
407
408         uint32 buffer_dom_id; /* undocumented logon domain id pointer */
409         char padding[40];    /* unused padding bytes? */
410
411         uint32 num_sids; /* 0 - num_sids */
412         uint32 buffer_sids; /* NULL - undocumented pointer to SIDs. */
413         
414         UNISTR2 uni_user_name;    /* username unicode string */
415         UNISTR2 uni_full_name;    /* user's full name unicode string */
416         UNISTR2 uni_logon_script; /* logon script unicode string */
417         UNISTR2 uni_profile_path; /* profile path unicode string */
418         UNISTR2 uni_home_dir;     /* home directory unicode string */
419         UNISTR2 uni_dir_drive;    /* home directory drive unicode string */
420
421         uint32 num_groups2;        /* num groups */
422         DOM_GID gids[LSA_MAX_GROUPS]; /* group info */
423
424         UNISTR2 uni_logon_srv; /* logon server unicode string */
425         UNISTR2 uni_logon_dom; /* logon domain unicode string */
426
427         DOM_SID undoc_dom_sids[2]; /* undocumented - domain SIDs */
428         DOM_SID dom_sid;           /* domain SID */
429
430 } LSA_USER_INFO;
431
432
433 /* LSA_Q_SAM_LOGON */
434 typedef struct lsa_q_sam_logon_info
435 {
436     DOM_SAM_INFO sam_id;
437
438 } LSA_Q_SAM_LOGON;
439
440 /* LSA_R_SAM_LOGON */
441 typedef struct lsa_r_sam_logon_info
442 {
443     uint32 buffer_creds; /* undocumented buffer pointer */
444     DOM_CRED srv_creds; /* server credentials.  server time stamp appears to be ignored. */
445     
446     uint32 buffer_user;
447     LSA_USER_INFO user;
448
449     uint32 auth_resp; /* 1 - Authoritative response; 0 - Non-Auth? */
450
451 } LSA_R_SAM_LOGON;
452
453
454 /* LSA_Q_SAM_LOGOFF */
455 typedef struct lsa_q_sam_logoff_info
456 {
457     DOM_SAM_INFO sam_id;
458
459 } LSA_Q_SAM_LOGOFF;
460
461 /* LSA_R_SAM_LOGOFF */
462 typedef struct lsa_r_sam_logoff_info
463 {
464     uint32 buffer_creds; /* undocumented buffer pointer */
465     DOM_CRED srv_creds; /* server credentials.  server time stamp appears to be ignored. */
466     
467 } LSA_R_SAM_LOGOFF;
468
469 #endif
470
471
472 #if 0
473 /*******************************************************************
474 reads or writes a structure.
475 ********************************************************************/
476  char* lsa_io_(BOOL io, *, char *q, char *base, int align)
477 {
478         if (== NULL) return NULL;
479
480         q = align_offset(q, base, align);
481         
482         RW_IVAL(io, q, , 0); q += 4;
483
484         return q;
485 }
486 #endif