ipc.c :
[kai/samba.git] / source3 / smbd / pipes.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 1.9.
4    Pipe SMB reply routines
5    Copyright (C) Andrew Tridgell 1992-1997,
6    Copyright (C) Luke Kenneth Casson Leighton 1996-1997.
7    Copyright (C) Paul Ashton  1997.
8    
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 2 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23 /*
24    This file handles reply_ calls on named pipes that the server
25    makes to handle specific protocols
26 */
27
28
29 #include "includes.h"
30 #include "trans2.h"
31 #include "nterr.h"
32
33 #define PIPE            "\\PIPE\\"
34 #define PIPELEN         strlen(PIPE)
35
36 #define REALLOC(ptr,size) Realloc(ptr,MAX((size),4*1024))
37
38 /* look in server.c for some explanation of these variables */
39 extern int Protocol;
40 extern int DEBUGLEVEL;
41 extern int chain_fnum;
42 extern char magic_char;
43 extern connection_struct Connections[];
44 extern files_struct Files[];
45 extern BOOL case_sensitive;
46 extern pstring sesssetup_user;
47 extern int Client;
48 extern fstring myworkgroup;
49
50 /* this macro should always be used to extract an fnum (smb_fid) from
51 a packet to ensure chaining works correctly */
52 #define GETFNUM(buf,where) (chain_fnum!= -1?chain_fnum:SVAL(buf,where))
53
54 char * known_pipes [] =
55 {
56   "lsarpc",
57 #if NTDOMAIN
58   "NETLOGON",
59 #endif
60   NULL
61 };
62
63 /****************************************************************************
64   reply to an open and X on a named pipe
65
66   In fact what we do is to open a regular file with the same name in
67   /tmp. This can then be closed as normal. Reading and writing won't
68   make much sense, but will do *something*. The real reason for this
69   support is to be able to do transactions on them (well, on lsarpc
70   for domain login purposes...).
71
72   This code is basically stolen from reply_open_and_X with some
73   wrinkles to handle pipes.
74 ****************************************************************************/
75 int reply_open_pipe_and_X(char *inbuf,char *outbuf,int length,int bufsize)
76 {
77   pstring fname;
78   int cnum = SVAL(inbuf,smb_tid);
79   int fnum = -1;
80   int smb_mode = SVAL(inbuf,smb_vwv3);
81   int smb_attr = SVAL(inbuf,smb_vwv5);
82 #if 0
83   int open_flags = SVAL(inbuf,smb_vwv2);
84   int smb_sattr = SVAL(inbuf,smb_vwv4); 
85   uint32 smb_time = make_unix_date3(inbuf+smb_vwv6);
86 #endif
87   int smb_ofun = SVAL(inbuf,smb_vwv8);
88   int unixmode;
89   int size=0,fmode=0,mtime=0,rmode=0;
90   struct stat sbuf;
91   int smb_action = 0;
92   int i;
93   BOOL bad_path = False;
94
95   /* XXXX we need to handle passed times, sattr and flags */
96   pstrcpy(fname,smb_buf(inbuf));
97
98   /* If the name doesn't start \PIPE\ then this is directed */
99   /* at a mailslot or something we really, really don't understand, */
100   /* not just something we really don't understand. */
101   if ( strncmp(fname,PIPE,PIPELEN) != 0 )
102     return(ERROR(ERRSRV,ERRaccess));
103
104   DEBUG(4,("Opening pipe %s.\n", fname));
105
106   /* Strip \PIPE\ off the name. */
107   pstrcpy(fname,smb_buf(inbuf) + PIPELEN);
108
109   /* See if it is one we want to handle. */
110   for( i = 0; known_pipes[i] ; i++ )
111     if( strcmp(fname,known_pipes[i]) == 0 )
112       break;
113
114   if ( known_pipes[i] == NULL )
115     return(ERROR(ERRSRV,ERRaccess));
116
117   /* Known pipes arrive with DIR attribs. Remove it so a regular file */
118   /* can be opened and add it in after the open. */
119   DEBUG(3,("Known pipe %s opening.\n",fname));
120   smb_attr &= ~aDIR;
121   Connections[cnum].read_only = 0;
122   smb_ofun |= 0x10;             /* Add Create it not exists flag */
123
124   unix_convert(fname,cnum,0,&bad_path);
125     
126   fnum = find_free_file();
127   if (fnum < 0)
128     return(ERROR(ERRSRV,ERRnofids));
129
130   if (!check_name(fname,cnum))
131     return(UNIXERROR(ERRDOS,ERRnoaccess));
132
133   unixmode = unix_mode(cnum,smb_attr);
134       
135   open_file_shared(fnum,cnum,fname,smb_mode,smb_ofun,unixmode,
136                    0, &rmode,&smb_action);
137       
138   if (!Files[fnum].open)
139   {
140     /* Change the error code if bad_path was set. */
141     if((errno == ENOENT) && bad_path)
142     {
143       unix_ERR_class = ERRDOS;
144       unix_ERR_code = ERRbadpath;
145     }
146     return(UNIXERROR(ERRDOS,ERRnoaccess));
147   }
148
149   if (fstat(Files[fnum].fd_ptr->fd,&sbuf) != 0) {
150     close_file(fnum);
151     return(ERROR(ERRDOS,ERRnoaccess));
152   }
153
154   size = sbuf.st_size;
155   fmode = dos_mode(cnum,fname,&sbuf);
156   mtime = sbuf.st_mtime;
157   if (fmode & aDIR) {
158     close_file(fnum);
159     return(ERROR(ERRDOS,ERRnoaccess));
160   }
161
162   /* Prepare the reply */
163   set_message(outbuf,15,0,True);
164
165   /* Put things back the way they were. */
166   Connections[cnum].read_only = 1;
167
168   /* Mark the opened file as an existing named pipe in message mode. */
169   SSVAL(outbuf,smb_vwv9,2);
170   SSVAL(outbuf,smb_vwv10,0xc700);
171   if (rmode == 2)
172   {
173     DEBUG(4,("Resetting open result to open from create.\n"));
174     rmode = 1;
175   }
176
177   SSVAL(outbuf,smb_vwv2,fnum);
178   SSVAL(outbuf,smb_vwv3,fmode);
179   put_dos_date3(outbuf,smb_vwv4,mtime);
180   SIVAL(outbuf,smb_vwv6,size);
181   SSVAL(outbuf,smb_vwv8,rmode);
182   SSVAL(outbuf,smb_vwv11,smb_action);
183
184   chain_fnum = fnum;
185
186   DEBUG(4,("Opened pipe %s with handle %d, saved name %s.\n",
187            fname, fnum, Files[fnum].name));
188   
189   return chain_reply(inbuf,outbuf,length,bufsize);
190 }
191
192
193 /****************************************************************************
194  api_LsarpcSNPHS
195
196  SetNamedPipeHandleState on \PIPE\lsarpc. We can't really do much here,
197  so just blithely return True. This is really only for NT domain stuff,
198  we we're only handling that - don't assume Samba now does complete
199  named pipe handling.
200 ****************************************************************************/
201 BOOL api_LsarpcSNPHS(int cnum,int uid, char *param,char *data,
202                      int mdrcnt,int mprcnt,
203                      char **rdata,char **rparam,
204                      int *rdata_len,int *rparam_len)
205 {
206   uint16 id;
207
208   id = param[0] + (param[1] << 8);
209   DEBUG(4,("lsarpc SetNamedPipeHandleState to code %x\n",id));
210   return(True);
211 }
212
213
214 /****************************************************************************
215  api_LsarpcTNP
216
217  TransactNamedPipe on \PIPE\lsarpc.
218 ****************************************************************************/
219 static void LsarpcTNP1(char *data,char **rdata, int *rdata_len)
220 {
221   uint32 dword1, dword2;
222   char pname[] = "\\PIPE\\lsass";
223
224   /* All kinds of mysterious numbers here */
225   *rdata_len = 68;
226   *rdata = REALLOC(*rdata,*rdata_len);
227
228   dword1 = IVAL(data,0xC);
229   dword2 = IVAL(data,0x10);
230
231   SIVAL(*rdata,0,0xc0005);
232   SIVAL(*rdata,4,0x10);
233   SIVAL(*rdata,8,0x44);
234   SIVAL(*rdata,0xC,dword1);
235   
236   SIVAL(*rdata,0x10,dword2);
237   SIVAL(*rdata,0x14,0x15);
238   SSVAL(*rdata,0x18,sizeof(pname));
239   strcpy(*rdata + 0x1a,pname);
240   SIVAL(*rdata,0x28,1);
241   memcpy(*rdata + 0x30, data + 0x34, 0x14);
242 }
243
244 static void LsarpcTNP2(char *data,char **rdata, int *rdata_len)
245 {
246   uint32 dword1;
247
248   /* All kinds of mysterious numbers here */
249   *rdata_len = 48;
250   *rdata = REALLOC(*rdata,*rdata_len);
251
252   dword1 = IVAL(data,0xC);
253
254   SIVAL(*rdata,0,0x03020005);
255   SIVAL(*rdata,4,0x10);
256   SIVAL(*rdata,8,0x30);
257   SIVAL(*rdata,0xC,dword1);
258   SIVAL(*rdata,0x10,0x18);
259   SIVAL(*rdata,0x1c,0x44332211);
260   SIVAL(*rdata,0x20,0x88776655);
261   SIVAL(*rdata,0x24,0xCCBBAA99);
262   SIVAL(*rdata,0x28,0x11FFEEDD);
263 }
264
265 static void LsarpcTNP3(char *data,char **rdata, int *rdata_len)
266 {
267   uint32 dword1;
268   uint16 word1;
269   char * workgroup = myworkgroup;
270   int wglen = strlen(workgroup);
271   int i;
272
273   /* All kinds of mysterious numbers here */
274   *rdata_len = 90 + 2 * wglen;
275   *rdata = REALLOC(*rdata,*rdata_len);
276
277   dword1 = IVAL(data,0xC);
278   word1 = SVAL(data,0x2C);
279
280   SIVAL(*rdata,0,0x03020005);
281   SIVAL(*rdata,4,0x10);
282   SIVAL(*rdata,8,0x60);
283   SIVAL(*rdata,0xC,dword1);
284   SIVAL(*rdata,0x10,0x48);
285   SSVAL(*rdata,0x18,0x5988);    /* This changes */
286   SSVAL(*rdata,0x1A,0x15);
287   SSVAL(*rdata,0x1C,word1);
288   SSVAL(*rdata,0x20,6);
289   SSVAL(*rdata,0x22,8);
290   SSVAL(*rdata,0x24,0x8E8);     /* So does this */
291   SSVAL(*rdata,0x26,0x15);
292   SSVAL(*rdata,0x28,0x4D48);    /* And this */
293   SSVAL(*rdata,0x2A,0x15);
294   SIVAL(*rdata,0x2C,4);
295   SIVAL(*rdata,0x34,wglen);
296   for ( i = 0 ; i < wglen ; i++ )
297     (*rdata)[0x38 + i * 2] = workgroup[i];
298    
299   /* Now fill in the rest */
300   i = 0x38 + wglen * 2;
301   SSVAL(*rdata,i,0x648);
302   SIVAL(*rdata,i+2,4);
303   SIVAL(*rdata,i+6,0x401);
304   SSVAL(*rdata,i+0xC,0x500);
305   SIVAL(*rdata,i+0xE,0x15);
306   SIVAL(*rdata,i+0x12,0x2372FE1);
307   SIVAL(*rdata,i+0x16,0x7E831BEF);
308   SIVAL(*rdata,i+0x1A,0x4B454B2);
309 }
310
311 static void LsarpcTNP4(char *data,char **rdata, int *rdata_len)
312 {
313   uint32 dword1;
314
315   /* All kinds of mysterious numbers here */
316   *rdata_len = 48;
317   *rdata = REALLOC(*rdata,*rdata_len);
318
319   dword1 = IVAL(data,0xC);
320
321   SIVAL(*rdata,0,0x03020005);
322   SIVAL(*rdata,4,0x10);
323   SIVAL(*rdata,8,0x30);
324   SIVAL(*rdata,0xC,dword1);
325   SIVAL(*rdata,0x10,0x18);
326 }
327
328
329 BOOL api_LsarpcTNP(int cnum,int uid, char *param,char *data,
330                      int mdrcnt,int mprcnt,
331                      char **rdata,char **rparam,
332                      int *rdata_len,int *rparam_len)
333 {
334   uint32 id,id2;
335
336   id = IVAL(data,0);
337
338   DEBUG(4,("lsarpc TransactNamedPipe id %lx\n",id));
339   switch (id)
340   {
341     case 0xb0005:
342       LsarpcTNP1(data,rdata,rdata_len);
343       break;
344
345     case 0x03000005:
346       id2 = IVAL(data,8);
347       DEBUG(4,("\t- Suboperation %lx\n",id2));
348       switch (id2 & 0xF)
349       {
350         case 8:
351           LsarpcTNP2(data,rdata,rdata_len);
352           break;
353
354         case 0xC:
355           LsarpcTNP4(data,rdata,rdata_len);
356           break;
357
358         case 0xE:
359           LsarpcTNP3(data,rdata,rdata_len);
360           break;
361       }
362       break;
363   }
364   return(True);
365 }
366
367
368 #ifdef NTDOMAIN
369 /*
370    PAXX: Someone fix above.
371    The above API is indexing RPC calls based on RPC flags and 
372    fragment length. I've decided to do it based on operation number :-)
373 */
374
375 /* this function is due to be replaced */
376 static void initrpcreply(char *inbuf, char *q)
377 {
378         uint32 callid;
379
380         SCVAL(q, 0, 5); q++; /* RPC version 5 */
381         SCVAL(q, 0, 0); q++; /* minor version 0 */
382         SCVAL(q, 0, 2); q++; /* RPC response packet */
383         SCVAL(q, 0, 3); q++; /* first frag + last frag */
384         RSIVAL(q, 0, 0x10000000); q += 4; /* packed data representation */
385         RSSVAL(q, 0, 0); q += 2; /* fragment length, fill in later */
386         SSVAL(q, 0, 0); q += 2; /* authentication length */
387         callid = RIVAL(inbuf, 12);
388         RSIVAL(q, 0, callid); q += 4; /* call identifier - match incoming RPC */
389         SIVAL(q, 0, 0x18); q += 4; /* allocation hint (no idea) */
390         SSVAL(q, 0, 0); q += 2; /* presentation context identifier */
391         SCVAL(q, 0, 0); q++; /* cancel count */
392         SCVAL(q, 0, 0); q++; /* reserved */
393 }
394
395 /* this function is due to be replaced */
396 static void endrpcreply(char *inbuf, char *q, int datalen, int rtnval, int *rlen)
397 {
398         SSVAL(q, 8, datalen + 4);
399         SIVAL(q,0x10,datalen+4-0x18); /* allocation hint */
400         SIVAL(q, datalen, rtnval);
401         *rlen = datalen + 4;
402         { int fd; fd = open("/tmp/rpc", O_RDWR); write(fd, q, datalen + 4); }
403 }
404
405 /* RID username mapping function.  just for fun, it maps to the unix uid */
406 static uint32 name_to_rid(char *user_name)
407 {
408     struct passwd *pw = Get_Pwnam(user_name, False);
409     if (!pw)
410         {
411       DEBUG(1,("Username %s is invalid on this system\n", user_name));
412       return (uint32)(-1);
413     }
414
415     return (uint32)(pw->pw_uid);
416 }
417
418
419 /* BIG NOTE: this function only does SIDS where the identauth is not >= 2^32 */
420 char *dom_sid_to_string(DOM_SID *sid)
421 {
422   static pstring sidstr;
423   char subauth[16];
424   int i;
425   uint32 ia = (sid->id_auth[0]) +
426               (sid->id_auth[1] << 8 ) +
427               (sid->id_auth[2] << 16) +
428               (sid->id_auth[3] << 24);
429
430   sprintf(sidstr, "S-%d-%d", sid->sid_no, ia);
431
432   for (i = 0; i < sid->num_auths; i++)
433   {
434     sprintf(subauth, "-%d", sid->sub_auths[i]);
435     strcat(sidstr, subauth);
436   }
437
438   DEBUG(5,("dom_sid_to_string returning %s\n", sidstr));
439   return sidstr;
440 }
441
442 /* BIG NOTE: this function only does SIDS where the identauth is not >= 2^32 */
443 /* identauth >= 2^32 can be detected because it will be specified in hex */
444 static void make_dom_sid(DOM_SID *sid, char *domsid)
445 {
446         int identauth;
447         char *p;
448
449         DEBUG(4,("netlogon domain SID: %s\n", domsid));
450
451         /* assume, but should check, that domsid starts "S-" */
452         p = strtok(domsid+2,"-");
453         sid->sid_no = atoi(p);
454
455         /* identauth in decimal should be <  2^32 */
456         /* identauth in hex     should be >= 2^32 */
457         identauth = atoi(strtok(0,"-"));
458
459         DEBUG(4,("netlogon rev %d\n", sid->sid_no));
460         DEBUG(4,("netlogon %s ia %d\n", p, identauth));
461
462         sid->id_auth[0] = 0;
463         sid->id_auth[1] = 0;
464         sid->id_auth[2] = (identauth & 0xff000000) >> 24;
465         sid->id_auth[3] = (identauth & 0x00ff0000) >> 16;
466         sid->id_auth[4] = (identauth & 0x0000ff00) >> 8;
467         sid->id_auth[5] = (identauth & 0x000000ff);
468
469         sid->num_auths = 0;
470
471         while ((p = strtok(0, "-")) != NULL)
472         {
473                 sid->sub_auths[sid->num_auths++] = atoi(p);
474         }
475 }
476
477 static void create_rpc_reply(RPC_HDR *hdr, uint32 call_id, int data_len)
478 {
479         if (hdr == NULL) return;
480
481         hdr->major        = 5;               /* RPC version 5 */
482         hdr->minor        = 0;               /* minor version 0 */
483         hdr->pkt_type     = 2;               /* RPC response packet */
484         hdr->frag         = 3;               /* first frag + last frag */
485         hdr->pack_type    = 1;               /* packed data representation */
486         hdr->frag_len     = data_len;        /* fragment length, fill in later */
487         hdr->auth_len     = 0;               /* authentication length */
488         hdr->call_id      = call_id;         /* call identifier - match incoming RPC */
489         hdr->alloc_hint   = data_len - 0x18; /* allocation hint (no idea) */
490         hdr->context_id   = 0;               /* presentation context identifier */
491         hdr->cancel_count = 0;               /* cancel count */
492         hdr->reserved     = 0;               /* reserved */
493 }
494
495 static int make_rpc_reply(char *inbuf, char *q, int data_len)
496 {
497         uint32 callid = RIVAL(inbuf, 12);
498         RPC_HDR hdr;
499
500         create_rpc_reply(&hdr, callid, data_len);
501         return smb_io_rpc_hdr(False, &hdr, q, q, 4) - q;
502 }
503
504 static int lsa_reply_open_policy(char *q, char *base)
505 {
506         char *start = q;
507         LSA_R_OPEN_POL r_o;
508
509         /* set up the LSA QUERY INFO response */
510         bzero(&(r_o.pol.data), POL_HND_SIZE);
511         r_o.status = 0x0;
512
513         /* store the response in the SMB stream */
514         q = lsa_io_r_open_pol(False, &r_o, q, base, 4);
515
516         /* return length of SMB data stored */
517         return q - start; 
518 }
519
520 static void make_uni_hdr(UNIHDR *hdr, int max_len, int len, uint16 terminate)
521 {
522         hdr->uni_max_len = max_len;
523         hdr->uni_str_len = len;
524         hdr->undoc       = terminate;
525 }
526
527 static void make_uni_hdr2(UNIHDR2 *hdr, int max_len, int len, uint16 terminate)
528 {
529         make_uni_hdr(&(hdr->unihdr), max_len, len, terminate);
530         hdr->undoc_buffer = len > 0 ? 1 : 0;
531 }
532
533 static void make_unistr(UNISTR *str, char *buf)
534 {
535         /* store the string (null-terminated copy) */
536         PutUniCode((char *)(str->buffer), buf);
537 }
538
539 static void make_unistr2(UNISTR2 *str, char *buf, int len, char terminate)
540 {
541         /* set up string lengths. add one if string is not null-terminated */
542         str->uni_max_len = len + (terminate != 0 ? 1 : 0);
543         str->undoc       = 0;
544         str->uni_str_len = len;
545
546         /* store the string (null-terminated copy) */
547         PutUniCode((char *)str->buffer, buf);
548
549         /* overwrite the last character: some strings are terminated with 4 not 0 */
550         str->buffer[len] = (uint16)terminate;
551 }
552
553 static void make_dom_rid2(DOM_RID2 *rid2, uint32 rid)
554 {
555         rid2->type    = 0x5;
556         rid2->undoc   = 0x5;
557         rid2->rid     = rid;
558         rid2->rid_idx = 0;
559 }
560
561 static void make_dom_sid2(DOM_SID2 *sid2, char *sid_str)
562 {
563         int len_sid_str = strlen(sid_str);
564
565         sid2->type = 0x5;
566         sid2->undoc = 0;
567         make_uni_hdr2(&(sid2->hdr), len_sid_str, len_sid_str, 0);
568         make_unistr  (&(sid2->str), sid_str);
569 }
570
571 static void make_dom_query(DOM_QUERY *d_q, char *dom_name, char *dom_sid)
572 {
573         int domlen = strlen(dom_name);
574
575         d_q->uni_dom_max_len = domlen * 2;
576         d_q->padding = 0;
577         d_q->uni_dom_str_len = domlen * 2;
578
579         d_q->buffer_dom_name = 0; /* domain buffer pointer */
580         d_q->buffer_dom_sid  = 0; /* domain sid pointer */
581
582         /* NOT null-terminated: 4-terminated instead! */
583         make_unistr2(&(d_q->uni_domain_name), dom_name, domlen, 4);
584
585         make_dom_sid(&(d_q->dom_sid), dom_sid);
586 }
587
588 static int lsa_reply_query_info(LSA_Q_QUERY_INFO *q_q, char *q, char *base,
589                                 char *dom_name, char *dom_sid)
590 {
591         char *start = q;
592         LSA_R_QUERY_INFO r_q;
593
594         /* set up the LSA QUERY INFO response */
595
596         r_q.undoc_buffer = 1; /* not null */
597         r_q.info_class = q_q->info_class;
598
599         make_dom_query(&r_q.dom.id5, dom_name, dom_sid);
600
601         r_q.status = 0x0;
602
603         /* store the response in the SMB stream */
604         q = lsa_io_r_query(False, &r_q, q, base, 4);
605
606         /* return length of SMB data stored */
607         return q - start; 
608 }
609
610 /* pretty much hard-coded choice of "other" sids, unfortunately... */
611 static void make_dom_ref(DOM_R_REF *ref,
612                                 char *dom_name, char *dom_sid,
613                                 char *other_sid1, char *other_sid2, char *other_sid3)
614 {
615         int len_dom_name   = strlen(dom_name);
616         int len_other_sid1 = strlen(other_sid1);
617         int len_other_sid2 = strlen(other_sid2);
618         int len_other_sid3 = strlen(other_sid3);
619
620         ref->undoc_buffer = 1;
621         ref->num_ref_doms_1 = 4;
622         ref->buffer_dom_name = 1;
623         ref->max_entries = 32;
624         ref->num_ref_doms_2 = 4;
625
626         make_uni_hdr2(&(ref->hdr_dom_name  ), len_dom_name  , len_dom_name  , 0);
627         make_uni_hdr2(&(ref->hdr_ref_dom[0]), len_other_sid1, len_other_sid1, 0);
628         make_uni_hdr2(&(ref->hdr_ref_dom[1]), len_other_sid2, len_other_sid2, 0);
629         make_uni_hdr2(&(ref->hdr_ref_dom[2]), len_other_sid3, len_other_sid3, 0);
630
631         if (dom_name != NULL)
632         {
633                 make_unistr(&(ref->uni_dom_name), dom_name);
634         }
635
636         make_dom_sid(&(ref->ref_dom[0]), dom_sid   );
637         make_dom_sid(&(ref->ref_dom[1]), other_sid1);
638         make_dom_sid(&(ref->ref_dom[2]), other_sid2);
639         make_dom_sid(&(ref->ref_dom[3]), other_sid3);
640 }
641
642 static void make_reply_lookup_rids(LSA_R_LOOKUP_RIDS *r_l,
643                                 int num_entries, uint32 dom_rids[MAX_LOOKUP_SIDS],
644                                 char *dom_name, char *dom_sid,
645                                 char *other_sid1, char *other_sid2, char *other_sid3)
646 {
647         int i;
648
649         make_dom_ref(&(r_l->dom_ref), dom_name, dom_sid,
650                      other_sid1, other_sid2, other_sid3);
651
652         r_l->num_entries = num_entries;
653         r_l->undoc_buffer = 1;
654         r_l->num_entries2 = num_entries;
655
656         for (i = 0; i < num_entries; i++)
657         {
658                 make_dom_rid2(&(r_l->dom_rid[i]), dom_rids[i]);
659         }
660
661         r_l->num_entries3 = num_entries;
662 }
663
664 static void make_reply_lookup_sids(LSA_R_LOOKUP_SIDS *r_l,
665                                 int num_entries, fstring dom_sids[MAX_LOOKUP_SIDS],
666                                 char *dom_name, char *dom_sid,
667                                 char *other_sid1, char *other_sid2, char *other_sid3)
668 {
669         int i;
670
671         make_dom_ref(&(r_l->dom_ref), dom_name, dom_sid,
672                      other_sid1, other_sid2, other_sid3);
673
674         r_l->num_entries = num_entries;
675         r_l->undoc_buffer = 1;
676         r_l->num_entries2 = num_entries;
677
678         for (i = 0; i < num_entries; i++)
679         {
680                 make_dom_sid2(&(r_l->dom_sid[i]), dom_sids[i]);
681         }
682
683         r_l->num_entries3 = num_entries;
684 }
685
686 static int lsa_reply_lookup_sids(char *q, char *base,
687                                 int num_entries, fstring dom_sids[MAX_LOOKUP_SIDS],
688                                 char *dom_name, char *dom_sid,
689                                 char *other_sid1, char *other_sid2, char *other_sid3)
690 {
691         char *start = q;
692         LSA_R_LOOKUP_SIDS r_l;
693
694         /* set up the LSA Lookup SIDs response */
695         make_reply_lookup_sids(&r_l, num_entries, dom_sids,
696                                 dom_name, dom_sid, other_sid1, other_sid2, other_sid3);
697         r_l.status = 0x0;
698
699         /* store the response in the SMB stream */
700         q = lsa_io_r_lookup_sids(False, &r_l, q, base, 4);
701
702         /* return length of SMB data stored */
703         return q - start; 
704 }
705
706 static int lsa_reply_lookup_rids(char *q, char *base,
707                                 int num_entries, uint32 dom_rids[MAX_LOOKUP_SIDS],
708                                 char *dom_name, char *dom_sid,
709                                 char *other_sid1, char *other_sid2, char *other_sid3)
710 {
711         char *start = q;
712         LSA_R_LOOKUP_RIDS r_l;
713
714         /* set up the LSA Lookup RIDs response */
715         make_reply_lookup_rids(&r_l, num_entries, dom_rids,
716                                 dom_name, dom_sid, other_sid1, other_sid2, other_sid3);
717         r_l.status = 0x0;
718
719         /* store the response in the SMB stream */
720         q = lsa_io_r_lookup_rids(False, &r_l, q, base, 4);
721
722         /* return length of SMB data stored */
723         return q - start; 
724 }
725
726 static void make_lsa_r_req_chal(LSA_R_REQ_CHAL *r_c,
727                                 DOM_CHAL *srv_chal, int status)
728 {
729         memcpy(r_c->srv_chal.data, srv_chal->data, sizeof(r_c->srv_chal.data));
730         r_c->status = status;
731 }
732
733 static int lsa_reply_req_chal(LSA_Q_REQ_CHAL *q_c, char *q, char *base,
734                                         DOM_CHAL *srv_chal)
735 {
736         char *start = q;
737         LSA_R_REQ_CHAL r_c;
738
739         /* set up the LSA REQUEST CHALLENGE response */
740
741         make_lsa_r_req_chal(&r_c, srv_chal, 0);
742
743         /* store the response in the SMB stream */
744         q = lsa_io_r_req_chal(False, &r_c, q, base, 4);
745
746         /* return length of SMB data stored */
747         return q - start; 
748 }
749
750 static void make_lsa_chal(DOM_CHAL *cred, char resp_cred[8])
751 {
752         memcpy(cred->data, resp_cred, sizeof(cred->data));
753 }
754
755 static void make_lsa_r_auth_2(LSA_R_AUTH_2 *r_a,
756                               DOM_CHAL *resp_cred, NEG_FLAGS *flgs, int status)
757 {
758         memcpy(  r_a->srv_chal.data, resp_cred->data, sizeof(resp_cred->data));
759         memcpy(&(r_a->srv_flgs)    , flgs           , sizeof(r_a->srv_flgs));
760         r_a->status = status;
761 }
762
763 static int lsa_reply_auth_2(LSA_Q_AUTH_2 *q_a, char *q, char *base,
764                                 DOM_CHAL *resp_cred, int status)
765 {
766         char *start = q;
767         LSA_R_AUTH_2 r_a;
768
769         /* set up the LSA AUTH 2 response */
770
771         make_lsa_r_auth_2(&r_a, resp_cred, &(q_a->clnt_flgs), status);
772
773         /* store the response in the SMB stream */
774         q = lsa_io_r_auth_2(False, &r_a, q, base, 4);
775
776         /* return length of SMB data stored */
777         return q - start; 
778 }
779
780 static void make_lsa_dom_chal(DOM_CRED *cred, char srv_chal[8], UTIME srv_time)
781 {
782         make_lsa_chal(&(cred->challenge), srv_chal);
783         cred->timestamp = srv_time;
784 }
785         
786
787 static void make_lsa_r_srv_pwset(LSA_R_SRV_PWSET *r_a,
788                               char srv_chal[8], UTIME srv_time, int status)
789 {
790         make_lsa_dom_chal(&(r_a->srv_cred), srv_chal, srv_time);
791         r_a->status = status;
792 }
793
794 static int lsa_reply_srv_pwset(LSA_Q_SRV_PWSET *q_s, char *q, char *base,
795                                 char srv_cred[8], UTIME srv_time,
796                                 int status)
797 {
798         char *start = q;
799         LSA_R_SRV_PWSET r_s;
800
801         /* set up the LSA Server Password Set response */
802         make_lsa_r_srv_pwset(&r_s, srv_cred, srv_time, status);
803
804         /* store the response in the SMB stream */
805         q = lsa_io_r_srv_pwset(False, &r_s, q, base, 4);
806
807         /* return length of SMB data stored */
808         return q - start; 
809 }
810
811 static void make_lsa_user_info(LSA_USER_INFO *usr,
812
813         NTTIME *logon_time,
814         NTTIME *logoff_time,
815         NTTIME *kickoff_time,
816         NTTIME *pass_last_set_time,
817         NTTIME *pass_can_change_time,
818         NTTIME *pass_must_change_time,
819
820         char *user_name,
821         char *full_name,
822         char *logon_script,
823         char *profile_path,
824         char *home_dir,
825         char *dir_drive,
826
827         uint16 logon_count,
828         uint16 bad_pw_count,
829
830         uint32 user_id,
831         uint32 group_id,
832         uint32 num_groups,
833         DOM_GID *gids,
834         uint32 user_flgs,
835
836         char sess_key[16],
837
838         char *logon_srv,
839         char *logon_dom,
840
841         char *dom_sid,
842         char *other_sids) /* space-delimited set of SIDs */ 
843 {
844         /* only cope with one "other" sid, right now. */
845         /* need to count the number of space-delimited sids */
846         int i;
847         int num_other_sids = other_sids != NULL ? 1 : 0;
848
849         int len_user_name    = strlen(user_name   );
850         int len_full_name    = strlen(full_name   );
851         int len_logon_script = strlen(logon_script);
852         int len_profile_path = strlen(profile_path);
853         int len_home_dir     = strlen(home_dir    );
854         int len_dir_drive    = strlen(dir_drive   );
855
856         int len_logon_srv    = strlen(logon_srv);
857         int len_logon_dom    = strlen(logon_dom);
858
859         usr->undoc_buffer = 1; /* yes, we're bothering to put USER_INFO data here */
860
861         usr->logon_time            = *logon_time;
862         usr->logoff_time           = *logoff_time;
863         usr->kickoff_time          = *kickoff_time;
864         usr->pass_last_set_time    = *pass_last_set_time;
865         usr->pass_can_change_time  = *pass_can_change_time;
866         usr->pass_must_change_time = *pass_must_change_time;
867
868         make_uni_hdr(&(usr->hdr_user_name   ), len_user_name   , len_user_name   , 4);
869         make_uni_hdr(&(usr->hdr_full_name   ), len_full_name   , len_full_name   , 4);
870         make_uni_hdr(&(usr->hdr_logon_script), len_logon_script, len_logon_script, 4);
871         make_uni_hdr(&(usr->hdr_profile_path), len_profile_path, len_profile_path, 4);
872         make_uni_hdr(&(usr->hdr_home_dir    ), len_home_dir    , len_home_dir    , 4);
873         make_uni_hdr(&(usr->hdr_dir_drive   ), len_dir_drive   , len_dir_drive   , 4);
874
875         usr->logon_count = logon_count;
876         usr->bad_pw_count = bad_pw_count;
877
878         usr->user_id = user_id;
879         usr->group_id = group_id;
880         usr->num_groups = num_groups;
881         usr->buffer_groups = num_groups ? 1 : 0; /* yes, we're bothering to put group info in */
882         usr->user_flgs = user_flgs;
883
884         if (sess_key != NULL)
885         {
886                 memcpy(usr->sess_key, sess_key, sizeof(usr->sess_key));
887         }
888         else
889         {
890                 bzero(usr->sess_key, sizeof(usr->sess_key));
891         }
892
893         make_uni_hdr(&(usr->hdr_logon_srv), len_logon_srv, len_logon_srv, 4);
894         make_uni_hdr(&(usr->hdr_logon_dom), len_logon_dom, len_logon_dom, 4);
895
896         usr->buffer_dom_id = dom_sid ? 1 : 0; /* yes, we're bothering to put a domain SID in */
897
898         bzero(usr->padding, sizeof(usr->padding));
899
900         usr->num_other_sids = num_other_sids;
901         usr->buffer_other_sids = num_other_sids != 0 ? 1 : 0; 
902         
903         make_unistr2(&(usr->uni_user_name   ), user_name   , len_user_name   , 0);
904         make_unistr2(&(usr->uni_full_name   ), full_name   , len_full_name   , 0);
905         make_unistr2(&(usr->uni_logon_script), logon_script, len_logon_script, 0);
906         make_unistr2(&(usr->uni_profile_path), profile_path, len_profile_path, 0);
907         make_unistr2(&(usr->uni_home_dir    ), home_dir    , len_home_dir    , 0);
908         make_unistr2(&(usr->uni_dir_drive   ), dir_drive   , len_dir_drive   , 0);
909
910         usr->num_groups2 = num_groups;
911         for (i = 0; i < num_groups; i++)
912         {
913                 usr->gids[i] = gids[i];
914         }
915
916         make_unistr2(&(usr->uni_logon_srv), logon_srv, len_logon_srv, 0);
917         make_unistr2(&(usr->uni_logon_dom), logon_dom, len_logon_dom, 0);
918
919         make_dom_sid(&(usr->dom_sid), dom_sid);
920         make_dom_sid(&(usr->other_sids[0]), other_sids);
921 }
922
923
924 static int lsa_reply_sam_logon(LSA_Q_SAM_LOGON *q_s, char *q, char *base,
925                                 char srv_cred[8], UTIME srv_time,
926                                 LSA_USER_INFO *user_info)
927 {
928         char *start = q;
929         LSA_R_SAM_LOGON r_s;
930
931         /* XXXX maybe we want to say 'no', reject the client's credentials */
932         r_s.buffer_creds = 1; /* yes, we have valid server credentials */
933         make_lsa_dom_chal(&(r_s.srv_creds), srv_cred, srv_time);
934
935         /* store the user information, if there is any. */
936         r_s.user = user_info;
937         r_s.buffer_user = user_info != NULL ? 1 : 0;
938         r_s.status = user_info != NULL ? 0 : (0xC000000|NT_STATUS_NO_SUCH_USER);
939
940         /* store the response in the SMB stream */
941         q = lsa_io_r_sam_logon(False, &r_s, q, base, 4);
942
943         /* return length of SMB data stored */
944         return q - start; 
945 }
946
947
948 static int lsa_reply_sam_logoff(LSA_Q_SAM_LOGOFF *q_s, char *q, char *base,
949                                 char srv_cred[8], UTIME srv_time,
950                                 uint32 status)
951 {
952         char *start = q;
953         LSA_R_SAM_LOGOFF r_s;
954
955         /* XXXX maybe we want to say 'no', reject the client's credentials */
956         r_s.buffer_creds = 1; /* yes, we have valid server credentials */
957         make_lsa_dom_chal(&(r_s.srv_creds), srv_cred, srv_time);
958
959         r_s.status = status;
960
961         /* store the response in the SMB stream */
962         q = lsa_io_r_sam_logoff(False, &r_s, q, base, 4);
963
964         /* return length of SMB data stored */
965         return q - start; 
966 }
967
968
969 static void api_lsa_open_policy( char *param, char *data,
970                              char **rdata, int *rdata_len )
971 {
972         int reply_len;
973
974         /* we might actually want to decode the query, but it's not necessary */
975         /* lsa_io_q_open_policy(...); */
976
977         /* return a 20 byte policy handle */
978         reply_len = lsa_reply_open_policy(*rdata + 0x18, *rdata + 0x18);
979
980         /* construct header, now that we know the reply length */
981         make_rpc_reply(data, *rdata, reply_len);
982         *rdata_len = reply_len + 0x18;
983 }
984
985 static void api_lsa_query_info( char *param, char *data,
986                                 char **rdata, int *rdata_len )
987 {
988         int reply_len;
989
990         LSA_Q_QUERY_INFO q_i;
991         pstring dom_name;
992         pstring dom_sid;
993
994         /* grab the info class and policy handle */
995         lsa_io_q_query(True, &q_i, data + 0x18, data + 0x18, 4);
996
997         pstrcpy(dom_name, lp_workgroup());
998         pstrcpy(dom_sid , lp_domainsid());
999
1000         /* construct reply.  return status is always 0x0 */
1001         reply_len = lsa_reply_query_info(&q_i, *rdata + 0x18, *rdata + 0x18, 
1002                                                                          dom_name, dom_sid);
1003
1004         /* construct header, now that we know the reply length */
1005         make_rpc_reply(data, *rdata, reply_len);
1006         *rdata_len = reply_len + 0x18;
1007 }
1008
1009 static void api_lsa_lookup_sids( char *param, char *data,
1010                                  char **rdata, int *rdata_len )
1011 {
1012         int reply_len;
1013
1014         int i;
1015         LSA_Q_LOOKUP_SIDS q_l;
1016         pstring dom_name;
1017         pstring dom_sid;
1018         fstring dom_sids[MAX_LOOKUP_SIDS];
1019
1020         /* grab the info class and policy handle */
1021         lsa_io_q_lookup_sids(True, &q_l, data + 0x18, data + 0x18, 4);
1022
1023         pstrcpy(dom_name, lp_workgroup());
1024         pstrcpy(dom_sid , lp_domainsid());
1025
1026         /* convert received SIDs to strings, so we can do them. */
1027         for (i = 0; i < q_l.num_entries; i++)
1028         {
1029                 fstrcpy(dom_sids[i], dom_sid_to_string(&(q_l.dom_sids[i])));
1030         }
1031
1032         /* construct reply.  return status is always 0x0 */
1033         reply_len = lsa_reply_lookup_sids(*rdata + 0x18, *rdata + 0x18,
1034                     q_l.num_entries, dom_sids, /* text-converted SIDs */
1035                                 dom_name, dom_sid, /* domain name, domain SID */
1036                                 "S-1-1", "S-1-3", "S-1-5"); /* the three other SIDs */
1037
1038         /* construct header, now that we know the reply length */
1039         make_rpc_reply(data, *rdata, reply_len);
1040         *rdata_len = reply_len + 0x18;
1041 }
1042
1043 static void api_lsa_lookup_names( char *param, char *data,
1044                                   char **rdata, int *rdata_len )
1045 {
1046         int reply_len;
1047
1048         int i;
1049         LSA_Q_LOOKUP_RIDS q_l;
1050         pstring dom_name;
1051         pstring dom_sid;
1052         uint32 dom_rids[MAX_LOOKUP_SIDS];
1053
1054         /* grab the info class and policy handle */
1055         lsa_io_q_lookup_rids(True, &q_l, data + 0x18, data + 0x18, 4);
1056
1057         pstrcpy(dom_name, lp_workgroup());
1058         pstrcpy(dom_sid , lp_domainsid());
1059
1060         /* convert received RIDs to strings, so we can do them. */
1061         for (i = 0; i < q_l.num_entries; i++)
1062         {
1063                 char *user_name = unistr2(q_l.lookup_name[i].str.buffer);
1064                 dom_rids[i] = name_to_rid(user_name);
1065         }
1066
1067         /* construct reply.  return status is always 0x0 */
1068         reply_len = lsa_reply_lookup_rids(*rdata + 0x18, *rdata + 0x18,
1069                     q_l.num_entries, dom_rids, /* text-converted SIDs */
1070                                 dom_name, dom_sid, /* domain name, domain SID */
1071                                 "S-1-1", "S-1-3", "S-1-5"); /* the three other SIDs */
1072
1073         /* construct header, now that we know the reply length */
1074         make_rpc_reply(data, *rdata, reply_len);
1075         *rdata_len = reply_len + 0x18;
1076 }
1077
1078 BOOL api_ntLsarpcTNP(int cnum,int uid, char *param,char *data,
1079                      int mdrcnt,int mprcnt,
1080                      char **rdata,char **rparam,
1081                      int *rdata_len,int *rparam_len)
1082 {
1083         uint16 opnum = SVAL(data,22);
1084
1085         int pkttype = CVAL(data, 2);
1086         if (pkttype == 0x0b) /* RPC BIND */
1087         {
1088                 DEBUG(4,("netlogon rpc bind %x\n",pkttype));
1089                 LsarpcTNP1(data,rdata,rdata_len);
1090                 return True;
1091         }
1092
1093         DEBUG(4,("ntlsa TransactNamedPipe op %x\n",opnum));
1094         switch (opnum)
1095         {
1096                 case LSA_OPENPOLICY:
1097                 {
1098                         DEBUG(3,("LSA_OPENPOLICY\n"));
1099                         api_lsa_open_policy(param, data, rdata, rdata_len);
1100                         break;
1101                 }
1102
1103                 case LSA_QUERYINFOPOLICY:
1104                 {
1105                         DEBUG(3,("LSA_QUERYINFOPOLICY\n"));
1106
1107                         api_lsa_query_info(param, data, rdata, rdata_len);
1108                         break;
1109                 }
1110
1111                 case LSA_ENUMTRUSTDOM:
1112                 {
1113                         char *q = *rdata + 0x18;
1114
1115                         DEBUG(3,("LSA_ENUMTRUSTDOM\n"));
1116
1117                         initrpcreply(data, *rdata);
1118
1119                         SIVAL(q, 0, 0); /* enumeration context */
1120                         SIVAL(q, 0, 4); /* entries read */
1121                         SIVAL(q, 0, 8); /* trust information */
1122
1123                         endrpcreply(data, *rdata, q-*rdata, 0x8000001a, rdata_len);
1124
1125                         break;
1126                 }
1127
1128                 case LSA_CLOSE:
1129                 {
1130                         char *q = *rdata + 0x18;
1131
1132                         DEBUG(3,("LSA_CLOSE\n"));
1133
1134                         initrpcreply(data, *rdata);
1135
1136                         SIVAL(q, 0, 0);
1137                         SIVAL(q, 0, 4);
1138                         SIVAL(q, 0, 8);
1139                         SIVAL(q, 0, 12);
1140                         SIVAL(q, 0, 16);
1141
1142                         endrpcreply(data, *rdata, q-*rdata, 0, rdata_len);
1143
1144                         break;
1145                 }
1146
1147                 case LSA_OPENSECRET:
1148                 {
1149                         char *q = *rdata + 0x18;
1150                         DEBUG(3,("LSA_OPENSECRET\n"));
1151
1152                         initrpcreply(data, *rdata);
1153
1154                         SIVAL(q, 0, 0);
1155                         SIVAL(q, 0, 4);
1156                         SIVAL(q, 0, 8);
1157                         SIVAL(q, 0, 12);
1158                         SIVAL(q, 0, 16);
1159
1160                         endrpcreply(data, *rdata, q-*rdata, 0xc000034, rdata_len);
1161
1162                         break;
1163                 }
1164
1165                 case LSA_LOOKUPSIDS:
1166                 {
1167                         DEBUG(3,("LSA_OPENSECRET\n"));
1168                         api_lsa_lookup_sids(param, data, rdata, rdata_len);
1169                         break;
1170                 }
1171
1172                 case LSA_LOOKUPNAMES:
1173                 {
1174                         DEBUG(3,("LSA_LOOKUPNAMES\n"));
1175                         api_lsa_lookup_names(param, data, rdata, rdata_len);
1176                         break;
1177                 }
1178
1179                 default:
1180                 {
1181                         DEBUG(4, ("NTLSARPC, unknown code: %lx\n", opnum));
1182                         break;
1183                 }
1184         }
1185         return True;
1186 }
1187
1188 static BOOL update_dcinfo(struct dcinfo *dc, DOM_CHAL *clnt_chal, char *mach_acct)
1189 {
1190     struct smb_passwd *smb_pass = get_smbpwnam(mach_acct);
1191         int i;
1192
1193         if (smb_pass != NULL)
1194         {
1195                 memcpy(dc->md4pw, smb_pass->smb_nt_passwd, sizeof(dc->md4pw));
1196         }
1197         else
1198         {
1199                 /* No such machine account. Should error out here, but we'll
1200                    print and carry on */
1201                 DEBUG(1,("No account in domain for %s\n", mach_acct));
1202                 return False;
1203         }
1204
1205         {
1206                 char foo[16];
1207                 for (i = 0; i < 16; i++) sprintf(foo+i*2,"%02x ", dc->md4pw[i]);
1208                 DEBUG(4,("pass %s %s\n", mach_acct, foo));
1209         }
1210
1211         /* from client / server challenges and md4 password, generate sess key */
1212         cred_session_key(&(dc->clnt_chal), &(dc->srv_chal),
1213                            dc->md4pw, dc->sess_key);
1214
1215         /* copy the client credentials for later use */
1216         memcpy(dc->srv_chal.data, clnt_chal->data, sizeof(clnt_chal->data));
1217         memcpy(dc->srv_cred.data, clnt_chal->data, sizeof(clnt_chal->data));
1218
1219         /* create a server challenge for the client */
1220         /* PAXX: set these to random values. */
1221         /* lkcl: paul, you mentioned that it doesn't really matter much */
1222         for (i = 0; i < 8; i++)
1223         {
1224                 dc->srv_chal.data[i] = 0xA5;
1225         }
1226
1227         return True;
1228 }
1229
1230 static void api_lsa_req_chal( user_struct *vuser,
1231                               char *param, char *data,
1232                               char **rdata, int *rdata_len )
1233 {
1234         int reply_len;
1235
1236         LSA_Q_REQ_CHAL q_r;
1237
1238         fstring mach_acct;
1239
1240         /* grab the challenge... */
1241         lsa_io_q_req_chal(True, &q_r, data + 0x18, data + 0x18, 4);
1242
1243         fstrcpy(mach_acct, unistr2(q_r.uni_logon_clnt.buffer));
1244
1245         strcat(mach_acct, "$");
1246
1247         update_dcinfo(&(vuser->dc), &(q_r.clnt_chal), mach_acct);
1248
1249         /* construct reply.  return status is always 0x0 */
1250         reply_len = lsa_reply_req_chal(&q_r, *rdata + 0x18, *rdata + 0x18,
1251                                         &(vuser->dc.srv_chal));
1252
1253         /* construct header, now that we know the reply length */
1254         reply_len += make_rpc_reply(data, *rdata, reply_len);
1255
1256         *rdata_len = reply_len;
1257 }
1258
1259 static void api_lsa_auth_2( user_struct *vuser,
1260                             char *param, char *data,
1261                             char **rdata, int *rdata_len )
1262 {
1263         int reply_len;
1264         LSA_Q_AUTH_2 q_a;
1265
1266         DOM_CHAL srv_chal;
1267         UTIME srv_time;
1268
1269         srv_time.time = 0;
1270
1271         /* grab the challenge... */
1272         lsa_io_q_auth_2(True, &q_a, data + 0x18, data + 0x18, 4);
1273
1274         /* check that the client credentials are valid */
1275         cred_assert(&(q_a.clnt_chal), vuser->dc.sess_key,
1276                 &(vuser->dc.srv_cred), srv_time);
1277
1278         /* create server credentials for inclusion in the reply */
1279         cred_create(vuser->dc.sess_key, &(vuser->dc.srv_cred), srv_time, &srv_chal);
1280
1281         /* construct reply.  return status is always 0x0 */
1282         reply_len = lsa_reply_auth_2(&q_a, *rdata + 0x18, *rdata + 0x18,
1283                                         &srv_chal, 0x0);
1284
1285         /* construct header, now that we know the reply length */
1286         reply_len += make_rpc_reply(data, *rdata, reply_len);
1287
1288         *rdata_len = reply_len;
1289 }
1290
1291
1292 BOOL api_netlogrpcTNP(int cnum,int uid, char *param,char *data,
1293                      int mdrcnt,int mprcnt,
1294                      char **rdata,char **rparam,
1295                      int *rdata_len,int *rparam_len)
1296 {
1297         uint16 opnum = SVAL(data,22);
1298         int pkttype  = CVAL(data, 2);
1299
1300         user_struct *vuser = get_valid_user_struct(uid);
1301
1302         if (pkttype == 0x0b) /* RPC BIND */
1303         {
1304                 DEBUG(4,("netlogon rpc bind %x\n",pkttype));
1305                 LsarpcTNP1(data,rdata,rdata_len);
1306                 return True;
1307         }
1308
1309         DEBUG(4,("netlogon TransactNamedPipe op %x\n",opnum));
1310
1311         if (vuser == NULL) return False;
1312
1313         DEBUG(3,("Username of UID %d is %s\n", vuser->uid, vuser->name));
1314 #if defined(NETGROUP) && defined(AUTOMOUNT)
1315         DEBUG(3,("HOMESHR for %s is %s\n", vuser->name, vuser->home_share));
1316 #endif
1317
1318         switch (opnum)
1319         {
1320                 case LSA_REQCHAL:
1321                 {
1322                         DEBUG(3,("LSA_REQCHAL\n"));
1323                         api_lsa_req_chal(vuser, param, data, rdata, rdata_len);
1324                         break;
1325                 }
1326
1327                 case LSA_AUTH2:
1328                 {
1329                         DEBUG(3,("LSA_AUTH2\n"));
1330                         api_lsa_auth_2(vuser, param, data, rdata, rdata_len);
1331                         break;
1332                 }
1333
1334                 default:
1335                 {
1336                         DEBUG(4, ("**** netlogon, unknown code: %lx\n", opnum));
1337                         break;
1338                 }
1339         }
1340
1341         return True;
1342 }
1343
1344
1345 #if 0
1346
1347 case LSASVRPWSET:
1348         DEBUG(1,("LSASVRPWSET\n"));
1349         q = data + 0x18;
1350         dump_data(1,q,128);
1351         logonsrv = q + 16;
1352         q = skip_unicode_string(logonsrv,1)+12;
1353         q = align4(q, data);
1354         accountname = q;
1355         q = skip_unicode_string(accountname,1);
1356         secchanneltype = qSVAL;
1357         q += 12;
1358         q = align4(q, data);
1359         unicomp = q;
1360         q = skip_unicode_string(unicomp,1);
1361         rcvcred[0] = qIVAL;
1362         rcvcred[1] = qIVAL;
1363         clnttime = qIVAL;
1364
1365         DEBUG(1,("PWSET logonsrv=%s accountname=%s unicomp=%s\n",
1366                  unistr(logonsrv), unistr(accountname), unistr(unicomp)));
1367
1368         checkcred(cnum, rcvcred[0], rcvcred[1], clnttime);
1369         DEBUG(3,("PWSET %lx %lx %lx %lx\n", rcvcred[0], rcvcred[1], clnttime, negflags));
1370         newpass = q;
1371
1372         DEBUG(1,("PWSET logonsrv=%s accountname=%s unicomp=%s newpass=%s\n",
1373                  unistr(logonsrv), unistr(accountname), unistr(unicomp), newpass));
1374
1375         /* PAXX: For the moment we'll reject these */
1376         /* TODO Need to set newpass in smbpasswd file for accountname */
1377         q = *rdata + 0x18;
1378         makecred(cnum, clnttime+1, q);
1379         q += 8;
1380         qSIVAL(0); /* timestamp. Seems to be ignored */
1381         
1382         dcauth[cnum].svrcred[0] = dcauth[cnum].cred[0] = dcauth[cnum].cred[0] + clnttime + 1;
1383
1384         endrpcreply(data, *rdata, q-*rdata, 0xc000006a, rdata_len);
1385         break;
1386
1387 case LSASAMLOGON:
1388         DEBUG(1,("LSASAMLOGON\n"));
1389         dump_data(1,data,128);
1390         q = data + 0x18;
1391         logonsrv = q + 16;
1392         DEBUG(1,("SMLOG %d\n", __LINE__));
1393         q = skip_unicode_string(logonsrv,1)+16;
1394         q = align4(q, data);
1395         unicomp = q;
1396         q = skip_unicode_string(unicomp,1)+4;
1397         DEBUG(1,("SMLOG %d  logonsrv=%s unicomp=%s\n", 
1398                  __LINE__, unistr(logonsrv), unistr(unicomp)));
1399         q = align4(q, data);
1400         rcvcred[0] = qIVAL;
1401         DEBUG(1,("SMLOG %d\n", __LINE__));
1402         rcvcred[1] = qIVAL;
1403         DEBUG(1,("SMLOG %d\n", __LINE__));
1404         clnttime = qIVAL;
1405         checkcred(cnum, rcvcred[0], rcvcred[1], clnttime);
1406         q += 2;
1407         rtncred[0] = qIVAL; /* all these are ignored */
1408         DEBUG(1,("SMLOG %d\n", __LINE__));
1409         rtncred[1] = qIVAL;
1410         rtntime = qIVAL;
1411         logonlevel = qSVAL;
1412         DEBUG(1,("SMLOG %d\n", __LINE__));
1413         switchval = qSVAL;
1414         switch (switchval)
1415                 {
1416                 case 1:
1417                         
1418                         q += 6;
1419                         domlen = qSVAL;
1420                         dommaxlen = qSVAL; q += 4;
1421                         paramcontrol = qIVAL;
1422                         logonid[0] = qIVAL; /* low part */
1423                         logonid[1] = qIVAL; /* high part */
1424                         
1425                         usernamelen = qSVAL;
1426                         
1427                         DEBUG(1,("SMLOG %d\n", __LINE__));
1428                         usernamemaxlen = qSVAL; q += 4;
1429                         
1430                         DEBUG(1,("usernamelen=%d maxlen=%d dommaxlen=%d\n", 
1431                                  usernamelen, usernamemaxlen, dommaxlen));
1432                         
1433                         dump_data(1,q,128);
1434                         
1435                         wslen = qSVAL;
1436                         wsmaxlen = qSVAL; q += 4;
1437                         rc4lmowfpass = q; q += 16;
1438                         rc4ntowfpass = q; q += 16;
1439                         
1440                         q += 12; domain = q; q += dommaxlen + 12;
1441                         q = align4(q, data);
1442                         username = q; q += usernamemaxlen + 12; 
1443                         q = align4(q, data);
1444                         ws = q;
1445                         DEBUG(1,("domain=%s username=%s ws=%s\n",
1446                                  unistr(domain), unistr(username),
1447                                  unistr(ws)));
1448                         break;
1449                 default: 
1450                         DEBUG(0,("unknown switch in SAMLOGON %d\n",
1451                                  switchval));
1452                 }
1453         for(i=0;i<16;i++) sprintf(foo+i*2,"%02x",username[i]);
1454         DEBUG(1,("userNAME %s  [%s]\n", foo, username));
1455         DEBUG(1,("SMLOG %d\n", __LINE__));
1456         q = *rdata + 0x18;
1457         qSIVAL(0x16a4b4); /* magic buffer pointer ? */
1458         makecred(cnum, clnttime+1, q);
1459         dcauth[cnum].svrcred[0] = dcauth[cnum].cred[0] = dcauth[cnum].cred[0] + clnttime + 1;
1460         q += 8;
1461         qSIVAL(0); /* timestamp. client doesn't care */
1462         qSSVAL(3); /* switch value 3. May be others? */
1463         qSSVAL(0); /* undocumented */
1464         DEBUG(1,("SMLOG %d\n", __LINE__));
1465         
1466         memset(rc4key, 0, sizeof rc4key);
1467         SIVAL(rc4key, 0, dcauth[cnum].sesskey[0]);
1468         SIVAL(rc4key, 4, dcauth[cnum].sesskey[1]);
1469         for(i=0;i<16;i++) sprintf(foo+i*2,"%02x",rc4ntowfpass[i]);
1470         DEBUG(1,("rc4ntowf %s\n", foo));
1471         arcfour_init(&c, rc4key, sizeof rc4key);
1472         arcfour_encrypt(&c, ntowfpass, rc4ntowfpass, sizeof ntowfpass);
1473         for(i=0;i<16;i++) sprintf(foo+i*2,"%02x",ntowfpass[i]);
1474         DEBUG(1,("ntowf %s\n", foo));
1475         
1476         if(!(userinfo = getuserinfo(username, usernamelen, ntowfpass))) {
1477                 qSIVAL(0); /* no buffer */
1478                 qSCVAL(1); /* Authoratitive. Change if passthrough? */
1479                 qSCVAL(0); /* pad for above boolean */
1480                 qSSVAL(0); /* pad for above boolean */
1481                 
1482                 endrpcreply(data, *rdata, q-*rdata, 0xc0000064, rdata_len);
1483                 break;
1484         }
1485
1486         qSIVAL(2); /* another magic bufptr? */
1487   DEBUG(1,("SMLOG %d %lx\n", __LINE__, userinfo));
1488   qSIVAL(userinfo->logontime[0]); qSIVAL(userinfo->logontime[1]);
1489   qSIVAL(userinfo->logofftime[0]); qSIVAL(userinfo->logofftime[1]);
1490   DEBUG(1,("SMLOG %d %lx\n", __LINE__, userinfo->passlastsettime[1]));
1491   qSIVAL(userinfo->kickofftime[0]); qSIVAL(userinfo->kickofftime[1]);
1492   qSIVAL(userinfo->passlastsettime[0]); qSIVAL(userinfo->passlastsettime[1]);
1493   qSIVAL(userinfo->passcanchgtime[0]); qSIVAL(userinfo->passcanchgtime[1]);
1494   qSIVAL(userinfo->passmustchgtime[0]); qSIVAL(userinfo->passmustchgtime[1]);
1495   DEBUG(1,("SMLOG %d %s\n", __LINE__, userinfo->effectivename));
1496   qunihdr(userinfo->effectivename);
1497   qunihdr(userinfo->fullname);
1498   DEBUG(1,("SMLOG %d\n", __LINE__));
1499   qunihdr(userinfo->logonscript);
1500   qunihdr(userinfo->profilepath);
1501   qunihdr(userinfo->homedirectory);
1502   qunihdr(userinfo->homedirectorydrive);
1503   DEBUG(1,("SMLOG %d\n", __LINE__));
1504   qSSVAL(userinfo->logoncount);
1505   qSSVAL(userinfo->badpwcount);
1506   qSIVAL(userinfo->uid);
1507   qSIVAL(userinfo->gid);
1508   DEBUG(1,("SMLOG %d\n", __LINE__));
1509   qSIVAL(userinfo->ngroups);
1510   qSIVAL(8); /* ptr to groups */
1511   qSIVAL(userinfo->userflags);
1512   DEBUG(1,("SMLOG %d\n", __LINE__));
1513   qSIVAL(0); qSIVAL(0); qSIVAL(0); qSIVAL(0); /* unused user session key */
1514   qunihdr(userinfo->logonserver);
1515   qunihdr(userinfo->logondomain);
1516   DEBUG(1,("SMLOG %d\n", __LINE__));
1517   qSIVAL(2); /* logon domain id ptr */
1518   DEBUG(1,("SMLOG %d\n", __LINE__));
1519   memset(q,0,40); q += 40; /* expansion room */
1520   DEBUG(1,("SMLOG %d\n", __LINE__));
1521   qSIVAL(userinfo->nsids);
1522   DEBUG(1,("SMLOG %d\n", __LINE__));
1523   qSIVAL(0); /* ptr to sids and values */
1524   DEBUG(1,("SMLOG %d\n", __LINE__));
1525   qunistr(userinfo->effectivename);
1526   DEBUG(1,("SMLOG %d\n", __LINE__));
1527   qunistr(userinfo->fullname);
1528   DEBUG(1,("SMLOG %d\n", __LINE__));
1529   qunistr(userinfo->logonscript);
1530   DEBUG(1,("SMLOG %d\n", __LINE__));
1531   qunistr(userinfo->profilepath);
1532   qunistr(userinfo->homedirectory);
1533   qunistr(userinfo->homedirectorydrive);
1534   DEBUG(1,("SMLOG %d\n", __LINE__));
1535   qSIVAL(userinfo->ngroups);
1536   for (i = 0; i < userinfo->ngroups; i++)
1537   {
1538         qSIVAL(userinfo->groups[i].gid);
1539         qSIVAL(userinfo->groups[i].attr);
1540   }
1541   qunistr(userinfo->logonserver);
1542   qunistr(userinfo->logondomain);
1543   for (i = 0; i < userinfo->nsids; i++)
1544   {
1545         /* put the extra sids: PAXX: TODO */
1546   }
1547   /* Assumption. This is the only domain, sending our SID */
1548   /* PAXX: may want to do passthrough later */
1549   strcpy(domsid,lp_domainsid());
1550 DEBUG(4,("netlogon LINE %d %lx %s\n",__LINE__, q, domsid));
1551   /* assume, but should check, that domsid starts "S-" */
1552   p = strtok(domsid+2,"-");
1553   revision = atoi(p);
1554 DEBUG(4,("netlogon LINE %d %lx %s rev %d\n",__LINE__, q, p, revision));
1555   identauth = atoi(strtok(0,"-"));
1556 DEBUG(4,("netlogon LINE %d %lx %s ia %d\n",__LINE__, q, p, identauth));
1557   numsubauths = 0;
1558   while (p = strtok(0, "-"))
1559         subauths[numsubauths++] = atoi(p);
1560   qSIVAL(numsubauths);
1561   qSCVAL(revision);
1562   qSCVAL(numsubauths);
1563   qRSSVAL(0); /* PAXX: FIX. first 2 bytes identifier authority */
1564   qRSIVAL(identauth); /* next 4 bytes */
1565   DEBUG(1,("SMLOG %d\n", __LINE__));
1566   for (i = 0; i < numsubauths; i++)
1567   {
1568         qSIVAL(subauths[i]);
1569   }
1570   qSCVAL(1); /* Authoratitive. Change if passthrough? */
1571   qSCVAL(0); /* pad for above boolean */
1572   qSSVAL(0); /* pad for above boolean */
1573
1574   endrpcreply(data, *rdata, q-*rdata, 0, rdata_len);
1575   break;
1576
1577 case LSASAMLOGOFF:
1578         DEBUG(1,("LSASAMLOGOFF\n"));
1579   q = data + 0x18;
1580   logonsrv = q + 16;
1581   DEBUG(1,("SAMLOGOFF %d\n", __LINE__));
1582   unicomp = skip_unicode_string(logonsrv,1)+16;
1583   if (strlen(unistr(logonsrv)) % 2 == 0)
1584 q += 2;
1585   DEBUG(1,("SMLOG %d\n", __LINE__));
1586   q = skip_unicode_string(unicomp,1)+4;
1587   if (strlen(unistr(unicomp)) % 2 == 0)
1588 q += 2;
1589   DEBUG(1,("SMLOG %d\n", __LINE__));
1590   rcvcred[0] = qIVAL;
1591   DEBUG(1,("SMLOG %d\n", __LINE__));
1592   rcvcred[1] = qIVAL;
1593   DEBUG(1,("SMLOG %d\n", __LINE__));
1594   clnttime = qIVAL;
1595   checkcred(cnum, rcvcred[0], rcvcred[1], clnttime);
1596   q += 4;
1597   rtncred[0] = qIVAL; /* all these are ignored */
1598   DEBUG(1,("SMLOG %d\n", __LINE__));
1599   rtncred[1] = qIVAL;
1600   rtntime = qIVAL;
1601   logonlevel = qSVAL;
1602   DEBUG(1,("SMLOG %d\n", __LINE__));
1603   switchval = qSVAL;
1604   switch (switchval)
1605   {
1606         case 1:
1607   q += 4;
1608   domlen = qSVAL;
1609   dommaxlen = qSVAL; q += 4;
1610   paramcontrol = qIVAL;
1611   logonid[0] = qIVAL; /* low part */
1612   logonid[1] = qIVAL; /* high part */
1613   usernamelen = qSVAL;
1614   DEBUG(1,("SMLOG %d\n", __LINE__));
1615   usernamemaxlen = qSVAL; q += 4;
1616   wslen = qSVAL;
1617   wsmaxlen = qSVAL; q += 4;
1618   rc4lmowfpass = q; q += 16;
1619   rc4ntowfpass = q; q += 16;
1620   q += 12; domain = q; q += dommaxlen + 12;
1621   if ((domlen/2) % 2 != 0) q += 2;
1622   username = q; q += usernamemaxlen + 12; /* PAXX: HACK */
1623   if ((usernamelen/2) % 2 != 0) q += 2;
1624   ws = q;
1625   break;
1626 default: DEBUG(0, ("unknown switch in SAMLOGON %d\n",switchval));
1627   }
1628   DEBUG(1,("SAMLOGOFF %s\n", unistr(username)));
1629 default:
1630   DEBUG(4, ("**** netlogon, unknown code: %lx\n", opnum));
1631
1632 #endif /* 0 */
1633
1634 void no_fn(uint uid)
1635 {
1636 }
1637
1638 #endif /* NTDOMAIN */
1639
1640 #ifdef UNDEFINED_NTDOMAIN
1641 /*
1642    PAXX: Someone fix above.
1643    The above API is indexing RPC calls based on RPC flags and 
1644    fragment length. I've decided to do it based on operation number :-)
1645 */
1646
1647 #endif /* NTDOMAIN */