?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r6303: Setting up for 3.0.15pre1
[Samba.git] / source / smbd / lanman.c
blob127480f0b3deef73943514b104d812d859dc224d
1 /*
2 Unix SMB/CIFS implementation.
3 Inter-process communication and named pipe handling
4 Copyright (C) Andrew Tridgell 1992-1998
5
6 SMB Version handling
7 Copyright (C) John H Terpstra 1995-1998
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 the named pipe and mailslot calls
25 in the SMBtrans protocol
26 */
27
28 #include "includes.h"
29
30 extern struct current_user current_user;
31 extern userdom_struct current_user_info;
32
33 #ifdef CHECK_TYPES
34 #undef CHECK_TYPES
35 #endif
36 #define CHECK_TYPES 0
37
38 #define NERR_Success 0
39 #define NERR_badpass 86
40 #define NERR_notsupported 50
41
42 #define NERR_BASE (2100)
43 #define NERR_BufTooSmall (NERR_BASE+23)
44 #define NERR_JobNotFound (NERR_BASE+51)
45 #define NERR_DestNotFound (NERR_BASE+52)
46
47 #define ACCESS_READ 0x01
48 #define ACCESS_WRITE 0x02
49 #define ACCESS_CREATE 0x04
50
51 #define SHPWLEN 8 /* share password length */
52
53 static BOOL api_Unsupported(connection_struct *conn,uint16 vuid, char *param,char *data,
54 int mdrcnt,int mprcnt,
55 char **rdata,char **rparam,
56 int *rdata_len,int *rparam_len);
57 static BOOL api_TooSmall(connection_struct *conn,uint16 vuid, char *param,char *data,
58 int mdrcnt,int mprcnt,
59 char **rdata,char **rparam,
60 int *rdata_len,int *rparam_len);
61
62
63 static int CopyExpanded(connection_struct *conn,
64 int snum, char** dst, char* src, int* n)
65 {
66 pstring buf;
67 int l;
68
69 if (!src || !dst || !n || !(*dst)) return(0);
70
71 StrnCpy(buf,src,sizeof(buf)/2);
72 pstring_sub(buf,"%S",lp_servicename(snum));
73 standard_sub_conn(conn,buf,sizeof(buf));
74 l = push_ascii(*dst,buf,*n, STR_TERMINATE);
75 (*dst) += l;
76 (*n) -= l;
77 return l;
78 }
79
80 static int CopyAndAdvance(char** dst, char* src, int* n)
81 {
82 int l;
83 if (!src || !dst || !n || !(*dst)) return(0);
84 l = push_ascii(*dst,src,*n, STR_TERMINATE);
85 (*dst) += l;
86 (*n) -= l;
87 return l;
88 }
89
90 static int StrlenExpanded(connection_struct *conn, int snum, char* s)
91 {
92 pstring buf;
93 if (!s) return(0);
94 StrnCpy(buf,s,sizeof(buf)/2);
95 pstring_sub(buf,"%S",lp_servicename(snum));
96 standard_sub_conn(conn,buf,sizeof(buf));
97 return strlen(buf) + 1;
98 }
99
100 static char* Expand(connection_struct *conn, int snum, char* s)
101 {
102 static pstring buf;
103 if (!s) return(NULL);
104 StrnCpy(buf,s,sizeof(buf)/2);
105 pstring_sub(buf,"%S",lp_servicename(snum));
106 standard_sub_conn(conn,buf,sizeof(buf));
107 return &buf[0];
108 }
109
110 /*******************************************************************
111 check a API string for validity when we only need to check the prefix
112 ******************************************************************/
113 static BOOL prefix_ok(const char *str, const char *prefix)
114 {
115 return(strncmp(str,prefix,strlen(prefix)) == 0);
116 }
117
118 struct pack_desc {
119 const char* format; /* formatstring for structure */
120 const char* subformat; /* subformat for structure */
121 char* base; /* baseaddress of buffer */
122 int buflen; /* remaining size for fixed part; on init: length of base */
123 int subcount; /* count of substructures */
124 char* structbuf; /* pointer into buffer for remaining fixed part */
125 int stringlen; /* remaining size for variable part */
126 char* stringbuf; /* pointer into buffer for remaining variable part */
127 int neededlen; /* total needed size */
128 int usedlen; /* total used size (usedlen <= neededlen and usedlen <= buflen) */
129 const char* curpos; /* current position; pointer into format or subformat */
130 int errcode;
131 };
132
133 static int get_counter(const char** p)
134 {
135 int i, n;
136 if (!p || !(*p)) return(1);
137 if (!isdigit((int)**p)) return 1;
138 for (n = 0;;) {
139 i = **p;
140 if (isdigit(i))
141 n = 10 * n + (i - '0');
142 else
143 return n;
144 (*p)++;
145 }
146 }
147
148 static int getlen(const char* p)
149 {
150 int n = 0;
151 if (!p) return(0);
152 while (*p) {
153 switch( *p++ ) {
154 case 'W': /* word (2 byte) */
155 n += 2;
156 break;
157 case 'K': /* status word? (2 byte) */
158 n += 2;
159 break;
160 case 'N': /* count of substructures (word) at end */
161 n += 2;
162 break;
163 case 'D': /* double word (4 byte) */
164 case 'z': /* offset to zero terminated string (4 byte) */
165 case 'l': /* offset to user data (4 byte) */
166 n += 4;
167 break;
168 case 'b': /* offset to data (with counter) (4 byte) */
169 n += 4;
170 get_counter(&p);
171 break;
172 case 'B': /* byte (with optional counter) */
173 n += get_counter(&p);
174 break;
175 }
176 }
177 return n;
178 }
179
180 static BOOL init_package(struct pack_desc* p, int count, int subcount)
181 {
182 int n = p->buflen;
183 int i;
184
185 if (!p->format || !p->base) return(False);
186
187 i = count * getlen(p->format);
188 if (p->subformat) i += subcount * getlen(p->subformat);
189 p->structbuf = p->base;
190 p->neededlen = 0;
191 p->usedlen = 0;
192 p->subcount = 0;
193 p->curpos = p->format;
194 if (i > n) {
195 p->neededlen = i;
196 i = n = 0;
197 #if 0
198 /*
199 * This is the old error code we used. Aparently
200 * WinNT/2k systems return ERRbuftoosmall (2123) and
201 * OS/2 needs this. I'm leaving this here so we can revert
202 * if needed. JRA.
203 */
204 p->errcode = ERRmoredata;
205 #else
206 p->errcode = ERRbuftoosmall;
207 #endif
208 }
209 else
210 p->errcode = NERR_Success;
211 p->buflen = i;
212 n -= i;
213 p->stringbuf = p->base + i;
214 p->stringlen = n;
215 return(p->errcode == NERR_Success);
216 }
217
218 static int package(struct pack_desc* p, ...)
219 {
220 va_list args;
221 int needed=0, stringneeded;
222 const char* str=NULL;
223 int is_string=0, stringused;
224 int32 temp;
225
226 va_start(args,p);
227
228 if (!*p->curpos) {
229 if (!p->subcount)
230 p->curpos = p->format;
231 else {
232 p->curpos = p->subformat;
233 p->subcount--;
234 }
235 }
236 #if CHECK_TYPES
237 str = va_arg(args,char*);
238 SMB_ASSERT(strncmp(str,p->curpos,strlen(str)) == 0);
239 #endif
240 stringneeded = -1;
241
242 if (!p->curpos) {
243 va_end(args);
244 return(0);
245 }
246
247 switch( *p->curpos++ ) {
248 case 'W': /* word (2 byte) */
249 needed = 2;
250 temp = va_arg(args,int);
251 if (p->buflen >= needed) SSVAL(p->structbuf,0,temp);
252 break;
253 case 'K': /* status word? (2 byte) */
254 needed = 2;
255 temp = va_arg(args,int);
256 if (p->buflen >= needed) SSVAL(p->structbuf,0,temp);
257 break;
258 case 'N': /* count of substructures (word) at end */
259 needed = 2;
260 p->subcount = va_arg(args,int);
261 if (p->buflen >= needed) SSVAL(p->structbuf,0,p->subcount);
262 break;
263 case 'D': /* double word (4 byte) */
264 needed = 4;
265 temp = va_arg(args,int);
266 if (p->buflen >= needed) SIVAL(p->structbuf,0,temp);
267 break;
268 case 'B': /* byte (with optional counter) */
269 needed = get_counter(&p->curpos);
270 {
271 char *s = va_arg(args,char*);
272 if (p->buflen >= needed) StrnCpy(p->structbuf,s?s:"",needed-1);
273 }
274 break;
275 case 'z': /* offset to zero terminated string (4 byte) */
276 str = va_arg(args,char*);
277 stringneeded = (str ? strlen(str)+1 : 0);
278 is_string = 1;
279 break;
280 case 'l': /* offset to user data (4 byte) */
281 str = va_arg(args,char*);
282 stringneeded = va_arg(args,int);
283 is_string = 0;
284 break;
285 case 'b': /* offset to data (with counter) (4 byte) */
286 str = va_arg(args,char*);
287 stringneeded = get_counter(&p->curpos);
288 is_string = 0;
289 break;
290 }
291 va_end(args);
292 if (stringneeded >= 0) {
293 needed = 4;
294 if (p->buflen >= needed) {
295 stringused = stringneeded;
296 if (stringused > p->stringlen) {
297 stringused = (is_string ? p->stringlen : 0);
298 if (p->errcode == NERR_Success) p->errcode = ERRmoredata;
299 }
300 if (!stringused)
301 SIVAL(p->structbuf,0,0);
302 else {
303 SIVAL(p->structbuf,0,PTR_DIFF(p->stringbuf,p->base));
304 memcpy(p->stringbuf,str?str:"",stringused);
305 if (is_string) p->stringbuf[stringused-1] = '\0';
306 p->stringbuf += stringused;
307 p->stringlen -= stringused;
308 p->usedlen += stringused;
309 }
310 }
311 p->neededlen += stringneeded;
312 }
313 p->neededlen += needed;
314 if (p->buflen >= needed) {
315 p->structbuf += needed;
316 p->buflen -= needed;
317 p->usedlen += needed;
318 }
319 else {
320 if (p->errcode == NERR_Success) p->errcode = ERRmoredata;
321 }
322 return 1;
323 }
324
325 #if CHECK_TYPES
326 #define PACK(desc,t,v) package(desc,t,v,0,0,0,0)
327 #define PACKl(desc,t,v,l) package(desc,t,v,l,0,0,0,0)
328 #else
329 #define PACK(desc,t,v) package(desc,v)
330 #define PACKl(desc,t,v,l) package(desc,v,l)
331 #endif
332
333 static void PACKI(struct pack_desc* desc, const char *t,int v)
334 {
335 PACK(desc,t,v);
336 }
337
338 static void PACKS(struct pack_desc* desc,const char *t,const char *v)
339 {
340 PACK(desc,t,v);
341 }
342
343
344 /****************************************************************************
345 get a print queue
346 ****************************************************************************/
347 static void PackDriverData(struct pack_desc* desc)
348 {
349 char drivdata[4+4+32];
350 SIVAL(drivdata,0,sizeof drivdata); /* cb */
351 SIVAL(drivdata,4,1000); /* lVersion */
352 memset(drivdata+8,0,32); /* szDeviceName */
353 push_ascii(drivdata+8,"NULL",-1, STR_TERMINATE);
354 PACKl(desc,"l",drivdata,sizeof drivdata); /* pDriverData */
355 }
356
357 static int check_printq_info(struct pack_desc* desc,
358 int uLevel, char *id1, char *id2)
359 {
360 desc->subformat = NULL;
361 switch( uLevel ) {
362 case 0:
363 desc->format = "B13";
364 break;
365 case 1:
366 desc->format = "B13BWWWzzzzzWW";
367 break;
368 case 2:
369 desc->format = "B13BWWWzzzzzWN";
370 desc->subformat = "WB21BB16B10zWWzDDz";
371 break;
372 case 3:
373 desc->format = "zWWWWzzzzWWzzl";
374 break;
375 case 4:
376 desc->format = "zWWWWzzzzWNzzl";
377 desc->subformat = "WWzWWDDzz";
378 break;
379 case 5:
380 desc->format = "z";
381 break;
382 case 51:
383 desc->format = "K";
384 break;
385 case 52:
386 desc->format = "WzzzzzzzzN";
387 desc->subformat = "z";
388 break;
389 default: return False;
390 }
391 if (strcmp(desc->format,id1) != 0) return False;
392 if (desc->subformat && strcmp(desc->subformat,id2) != 0) return False;
393 return True;
394 }
395
396
397 #define RAP_JOB_STATUS_QUEUED 0
398 #define RAP_JOB_STATUS_PAUSED 1
399 #define RAP_JOB_STATUS_SPOOLING 2
400 #define RAP_JOB_STATUS_PRINTING 3
401 #define RAP_JOB_STATUS_PRINTED 4
402
403 #define RAP_QUEUE_STATUS_PAUSED 1
404 #define RAP_QUEUE_STATUS_ERROR 2
405
406 /* turn a print job status into a on the wire status
407 */
408 static int printj_status(int v)
409 {
410 switch (v) {
411 case LPQ_QUEUED:
412 return RAP_JOB_STATUS_QUEUED;
413 case LPQ_PAUSED:
414 return RAP_JOB_STATUS_PAUSED;
415 case LPQ_SPOOLING:
416 return RAP_JOB_STATUS_SPOOLING;
417 case LPQ_PRINTING:
418 return RAP_JOB_STATUS_PRINTING;
419 }
420 return 0;
421 }
422
423 /* turn a print queue status into a on the wire status
424 */
425 static int printq_status(int v)
426 {
427 switch (v) {
428 case LPQ_QUEUED:
429 return 0;
430 case LPQ_PAUSED:
431 return RAP_QUEUE_STATUS_PAUSED;
432 }
433 return RAP_QUEUE_STATUS_ERROR;
434 }
435
436 static void fill_printjob_info(connection_struct *conn, int snum, int uLevel,
437 struct pack_desc* desc,
438 print_queue_struct* queue, int n)
439 {
440 time_t t = queue->time;
441
442 /* the client expects localtime */
443 t -= TimeDiff(t);
444
445 PACKI(desc,"W",pjobid_to_rap(lp_const_servicename(snum),queue->job)); /* uJobId */
446 if (uLevel == 1) {
447 PACKS(desc,"B21",queue->fs_user); /* szUserName */
448 PACKS(desc,"B",""); /* pad */
449 PACKS(desc,"B16",""); /* szNotifyName */
450 PACKS(desc,"B10","PM_Q_RAW"); /* szDataType */
451 PACKS(desc,"z",""); /* pszParms */
452 PACKI(desc,"W",n+1); /* uPosition */
453 PACKI(desc,"W",printj_status(queue->status)); /* fsStatus */
454 PACKS(desc,"z",""); /* pszStatus */
455 PACKI(desc,"D",t); /* ulSubmitted */
456 PACKI(desc,"D",queue->size); /* ulSize */
457 PACKS(desc,"z",queue->fs_file); /* pszComment */
458 }
459 if (uLevel == 2 || uLevel == 3 || uLevel == 4) {
460 PACKI(desc,"W",queue->priority); /* uPriority */
461 PACKS(desc,"z",queue->fs_user); /* pszUserName */
462 PACKI(desc,"W",n+1); /* uPosition */
463 PACKI(desc,"W",printj_status(queue->status)); /* fsStatus */
464 PACKI(desc,"D",t); /* ulSubmitted */
465 PACKI(desc,"D",queue->size); /* ulSize */
466 PACKS(desc,"z","Samba"); /* pszComment */
467 PACKS(desc,"z",queue->fs_file); /* pszDocument */
468 if (uLevel == 3) {
469 PACKS(desc,"z",""); /* pszNotifyName */
470 PACKS(desc,"z","PM_Q_RAW"); /* pszDataType */
471 PACKS(desc,"z",""); /* pszParms */
472 PACKS(desc,"z",""); /* pszStatus */
473 PACKS(desc,"z",SERVICE(snum)); /* pszQueue */
474 PACKS(desc,"z","lpd"); /* pszQProcName */
475 PACKS(desc,"z",""); /* pszQProcParms */
476 PACKS(desc,"z","NULL"); /* pszDriverName */
477 PackDriverData(desc); /* pDriverData */
478 PACKS(desc,"z",""); /* pszPrinterName */
479 } else if (uLevel == 4) { /* OS2 */
480 PACKS(desc,"z",""); /* pszSpoolFileName */
481 PACKS(desc,"z",""); /* pszPortName */
482 PACKS(desc,"z",""); /* pszStatus */
483 PACKI(desc,"D",0); /* ulPagesSpooled */
484 PACKI(desc,"D",0); /* ulPagesSent */
485 PACKI(desc,"D",0); /* ulPagesPrinted */
486 PACKI(desc,"D",0); /* ulTimePrinted */
487 PACKI(desc,"D",0); /* ulExtendJobStatus */
488 PACKI(desc,"D",0); /* ulStartPage */
489 PACKI(desc,"D",0); /* ulEndPage */
490 }
491 }
492 }
493
494 /********************************************************************
495 Return a driver name given an snum.
496 Returns True if from tdb, False otherwise.
497 ********************************************************************/
498
499 static BOOL get_driver_name(int snum, pstring drivername)
500 {
501 NT_PRINTER_INFO_LEVEL *info = NULL;
502 BOOL in_tdb = False;
503
504 get_a_printer (NULL, &info, 2, lp_servicename(snum));
505 if (info != NULL) {
506 pstrcpy( drivername, info->info_2->drivername);
507 in_tdb = True;
508 free_a_printer(&info, 2);
509 }
510
511 return in_tdb;
512 }
513
514 /********************************************************************
515 Respond to the DosPrintQInfo command with a level of 52
516 This is used to get printer driver information for Win9x clients
517 ********************************************************************/
518 static void fill_printq_info_52(connection_struct *conn, int snum,
519 struct pack_desc* desc, int count )
520 {
521 int i;
522 fstring location;
523 NT_PRINTER_DRIVER_INFO_LEVEL driver;
524 NT_PRINTER_INFO_LEVEL *printer = NULL;
525
526 ZERO_STRUCT(driver);
527
528 if ( !W_ERROR_IS_OK(get_a_printer( NULL, &printer, 2, lp_servicename(snum))) ) {
529 DEBUG(3,("fill_printq_info_52: Failed to lookup printer [%s]\n",
530 lp_servicename(snum)));
531 goto err;
532 }
533
534 if ( !W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername,
535 "Windows 4.0", 0)) )
536 {
537 DEBUG(3,("fill_printq_info_52: Failed to lookup driver [%s]\n",
538 printer->info_2->drivername));
539 goto err;
540 }
541
542 trim_string(driver.info_3->driverpath, "\\print$\\WIN40\\0\\", 0);
543 trim_string(driver.info_3->datafile, "\\print$\\WIN40\\0\\", 0);
544 trim_string(driver.info_3->helpfile, "\\print$\\WIN40\\0\\", 0);
545
546 PACKI(desc, "W", 0x0400); /* don't know */
547 PACKS(desc, "z", driver.info_3->name); /* long printer name */
548 PACKS(desc, "z", driver.info_3->driverpath); /* Driverfile Name */
549 PACKS(desc, "z", driver.info_3->datafile); /* Datafile name */
550 PACKS(desc, "z", driver.info_3->monitorname); /* language monitor */
551
552 fstrcpy(location, "\\\\%L\\print$\\WIN40\\0");
553 standard_sub_basic( "", location, sizeof(location)-1 );
554 PACKS(desc,"z", location); /* share to retrieve files */
555
556 PACKS(desc,"z", driver.info_3->defaultdatatype); /* default data type */
557 PACKS(desc,"z", driver.info_3->helpfile); /* helpfile name */
558 PACKS(desc,"z", driver.info_3->driverpath); /* driver name */
559
560 DEBUG(3,("Printer Driver Name: %s:\n",driver.info_3->name));
561 DEBUG(3,("Driver: %s:\n",driver.info_3->driverpath));
562 DEBUG(3,("Data File: %s:\n",driver.info_3->datafile));
563 DEBUG(3,("Language Monitor: %s:\n",driver.info_3->monitorname));
564 DEBUG(3,("Driver Location: %s:\n",location));
565 DEBUG(3,("Data Type: %s:\n",driver.info_3->defaultdatatype));
566 DEBUG(3,("Help File: %s:\n",driver.info_3->helpfile));
567 PACKI(desc,"N",count); /* number of files to copy */
568
569 for ( i=0; i<count && driver.info_3->dependentfiles && *driver.info_3->dependentfiles[i]; i++)
570 {
571 trim_string(driver.info_3->dependentfiles[i], "\\print$\\WIN40\\0\\", 0);
572 PACKS(desc,"z",driver.info_3->dependentfiles[i]); /* driver files to copy */
573 DEBUG(3,("Dependent File: %s:\n",driver.info_3->dependentfiles[i]));
574 }
575
576 /* sanity check */
577 if ( i != count )
578 DEBUG(3,("fill_printq_info_52: file count specified by client [%d] != number of dependent files [%i]\n",
579 count, i));
580
581 DEBUG(3,("fill_printq_info on <%s> gave %d entries\n", SERVICE(snum),i));
582
583 desc->errcode=NERR_Success;
584 goto done;
585
586 err:
587 DEBUG(3,("fill_printq_info: Can't supply driver files\n"));
588 desc->errcode=NERR_notsupported;
589
590 done:
591 if ( printer )
592 free_a_printer( &printer, 2 );
593
594 if ( driver.info_3 )
595 free_a_printer_driver( driver, 3 );
596 }
597
598
599 static void fill_printq_info(connection_struct *conn, int snum, int uLevel,
600 struct pack_desc* desc,
601 int count, print_queue_struct* queue,
602 print_status_struct* status)
603 {
604 switch (uLevel) {
605 case 1:
606 case 2:
607 PACKS(desc,"B13",SERVICE(snum));
608 break;
609 case 3:
610 case 4:
611 case 5:
612 PACKS(desc,"z",Expand(conn,snum,SERVICE(snum)));
613 break;
614 case 51:
615 PACKI(desc,"K",printq_status(status->status));
616 break;
617 }
618
619 if (uLevel == 1 || uLevel == 2) {
620 PACKS(desc,"B",""); /* alignment */
621 PACKI(desc,"W",5); /* priority */
622 PACKI(desc,"W",0); /* start time */
623 PACKI(desc,"W",0); /* until time */
624 PACKS(desc,"z",""); /* pSepFile */
625 PACKS(desc,"z","lpd"); /* pPrProc */
626 PACKS(desc,"z",SERVICE(snum)); /* pDestinations */
627 PACKS(desc,"z",""); /* pParms */
628 if (snum < 0) {
629 PACKS(desc,"z","UNKNOWN PRINTER");
630 PACKI(desc,"W",LPSTAT_ERROR);
631 }
632 else if (!status || !status->message[0]) {
633 PACKS(desc,"z",Expand(conn,snum,lp_comment(snum)));
634 PACKI(desc,"W",LPSTAT_OK); /* status */
635 } else {
636 PACKS(desc,"z",status->message);
637 PACKI(desc,"W",printq_status(status->status)); /* status */
638 }
639 PACKI(desc,(uLevel == 1 ? "W" : "N"),count);
640 }
641
642 if (uLevel == 3 || uLevel == 4) {
643 pstring drivername;
644
645 PACKI(desc,"W",5); /* uPriority */
646 PACKI(desc,"W",0); /* uStarttime */
647 PACKI(desc,"W",0); /* uUntiltime */
648 PACKI(desc,"W",5); /* pad1 */
649 PACKS(desc,"z",""); /* pszSepFile */
650 PACKS(desc,"z","WinPrint"); /* pszPrProc */
651 PACKS(desc,"z",NULL); /* pszParms */
652 PACKS(desc,"z",NULL); /* pszComment - don't ask.... JRA */
653 /* "don't ask" that it's done this way to fix corrupted
654 Win9X/ME printer comments. */
655 if (!status) {
656 PACKI(desc,"W",LPSTAT_OK); /* fsStatus */
657 } else {
658 PACKI(desc,"W",printq_status(status->status)); /* fsStatus */
659 }
660 PACKI(desc,(uLevel == 3 ? "W" : "N"),count); /* cJobs */
661 PACKS(desc,"z",SERVICE(snum)); /* pszPrinters */
662 get_driver_name(snum,drivername);
663 PACKS(desc,"z",drivername); /* pszDriverName */
664 PackDriverData(desc); /* pDriverData */
665 }
666
667 if (uLevel == 2 || uLevel == 4) {
668 int i;
669 for (i=0;i<count;i++)
670 fill_printjob_info(conn,snum,uLevel == 2 ? 1 : 2,desc,&queue[i],i);
671 }
672
673 if (uLevel==52)
674 fill_printq_info_52( conn, snum, desc, count );
675 }
676
677 /* This function returns the number of files for a given driver */
678 static int get_printerdrivernumber(int snum)
679 {
680 int result = 0;
681 NT_PRINTER_DRIVER_INFO_LEVEL driver;
682 NT_PRINTER_INFO_LEVEL *printer = NULL;
683
684 ZERO_STRUCT(driver);
685
686 if ( !W_ERROR_IS_OK(get_a_printer( NULL, &printer, 2, lp_servicename(snum))) ) {
687 DEBUG(3,("get_printerdrivernumber: Failed to lookup printer [%s]\n",
688 lp_servicename(snum)));
689 goto done;
690 }
691
692 if ( !W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername,
693 "Windows 4.0", 0)) )
694 {
695 DEBUG(3,("get_printerdrivernumber: Failed to lookup driver [%s]\n",
696 printer->info_2->drivername));
697 goto done;
698 }
699
700 /* count the number of files */
701 while ( driver.info_3->dependentfiles && *driver.info_3->dependentfiles[result] )
702 result++;
703 \
704 done:
705 if ( printer )
706 free_a_printer( &printer, 2 );
707
708 if ( driver.info_3 )
709 free_a_printer_driver( driver, 3 );
710
711 return result;
712 }
713
714 static BOOL api_DosPrintQGetInfo(connection_struct *conn,
715 uint16 vuid, char *param,char *data,
716 int mdrcnt,int mprcnt,
717 char **rdata,char **rparam,
718 int *rdata_len,int *rparam_len)
719 {
720 char *str1 = param+2;
721 char *str2 = skip_string(str1,1);
722 char *p = skip_string(str2,1);
723 char *QueueName = p;
724 int uLevel;
725 int count=0;
726 int snum;
727 char* str3;
728 struct pack_desc desc;
729 print_queue_struct *queue=NULL;
730 print_status_struct status;
731 char* tmpdata=NULL;
732
733 memset((char *)&status,'\0',sizeof(status));
734 memset((char *)&desc,'\0',sizeof(desc));
735
736 p = skip_string(p,1);
737 uLevel = SVAL(p,0);
738 str3 = p + 4;
739
740 /* remove any trailing username */
741 if ((p = strchr_m(QueueName,'%')))
742 *p = 0;
743
744 DEBUG(3,("api_DosPrintQGetInfo uLevel=%d name=%s\n",uLevel,QueueName));
745
746 /* check it's a supported varient */
747 if (!prefix_ok(str1,"zWrLh"))
748 return False;
749 if (!check_printq_info(&desc,uLevel,str2,str3)) {
750 /*
751 * Patch from Scott Moomaw <scott@bridgewater.edu>
752 * to return the 'invalid info level' error if an
753 * unknown level was requested.
754 */
755 *rdata_len = 0;
756 *rparam_len = 6;
757 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
758 SSVALS(*rparam,0,ERRunknownlevel);
759 SSVAL(*rparam,2,0);
760 SSVAL(*rparam,4,0);
761 return(True);
762 }
763
764 snum = find_service(QueueName);
765 if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) )
766 return False;
767
768 if (uLevel==52) {
769 count = get_printerdrivernumber(snum);
770 DEBUG(3,("api_DosPrintQGetInfo: Driver files count: %d\n",count));
771 } else {
772 count = print_queue_status(snum, &queue,&status);
773 }
774
775 if (mdrcnt > 0) {
776 *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
777 desc.base = *rdata;
778 desc.buflen = mdrcnt;
779 } else {
780 /*
781 * Don't return data but need to get correct length
782 * init_package will return wrong size if buflen=0
783 */
784 desc.buflen = getlen(desc.format);
785 desc.base = tmpdata = (char *) SMB_MALLOC (desc.buflen);
786 }
787
788 if (init_package(&desc,1,count)) {
789 desc.subcount = count;
790 fill_printq_info(conn,snum,uLevel,&desc,count,queue,&status);
791 }
792
793 *rdata_len = desc.usedlen;
794
795 /*
796 * We must set the return code to ERRbuftoosmall
797 * in order to support lanman style printing with Win NT/2k
798 * clients --jerry
799 */
800 if (!mdrcnt && lp_disable_spoolss())
801 desc.errcode = ERRbuftoosmall;
802
803 *rdata_len = desc.usedlen;
804 *rparam_len = 6;
805 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
806 SSVALS(*rparam,0,desc.errcode);
807 SSVAL(*rparam,2,0);
808 SSVAL(*rparam,4,desc.neededlen);
809
810 DEBUG(4,("printqgetinfo: errorcode %d\n",desc.errcode));
811
812 SAFE_FREE(queue);
813 SAFE_FREE(tmpdata);
814
815 return(True);
816 }
817
818 /****************************************************************************
819 View list of all print jobs on all queues.
820 ****************************************************************************/
821
822 static BOOL api_DosPrintQEnum(connection_struct *conn, uint16 vuid, char* param, char* data,
823 int mdrcnt, int mprcnt,
824 char **rdata, char** rparam,
825 int *rdata_len, int *rparam_len)
826 {
827 char *param_format = param+2;
828 char *output_format1 = skip_string(param_format,1);
829 char *p = skip_string(output_format1,1);
830 int uLevel = SVAL(p,0);
831 char *output_format2 = p + 4;
832 int services = lp_numservices();
833 int i, n;
834 struct pack_desc desc;
835 print_queue_struct **queue = NULL;
836 print_status_struct *status = NULL;
837 int* subcntarr = NULL;
838 int queuecnt, subcnt=0, succnt=0;
839
840 memset((char *)&desc,'\0',sizeof(desc));
841
842 DEBUG(3,("DosPrintQEnum uLevel=%d\n",uLevel));
843
844 if (!prefix_ok(param_format,"WrLeh")) return False;
845 if (!check_printq_info(&desc,uLevel,output_format1,output_format2)) {
846 /*
847 * Patch from Scott Moomaw <scott@bridgewater.edu>
848 * to return the 'invalid info level' error if an
849 * unknown level was requested.
850 */
851 *rdata_len = 0;
852 *rparam_len = 6;
853 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
854 SSVALS(*rparam,0,ERRunknownlevel);
855 SSVAL(*rparam,2,0);
856 SSVAL(*rparam,4,0);
857 return(True);
858 }
859
860 queuecnt = 0;
861 for (i = 0; i < services; i++)
862 if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i))
863 queuecnt++;
864 if (uLevel > 0) {
865 if((queue = SMB_MALLOC_ARRAY(print_queue_struct*, queuecnt)) == NULL) {
866 DEBUG(0,("api_DosPrintQEnum: malloc fail !\n"));
867 return False;
868 }
869 memset(queue,0,queuecnt*sizeof(print_queue_struct*));
870 if((status = SMB_MALLOC_ARRAY(print_status_struct,queuecnt)) == NULL) {
871 DEBUG(0,("api_DosPrintQEnum: malloc fail !\n"));
872 return False;
873 }
874 memset(status,0,queuecnt*sizeof(print_status_struct));
875 if((subcntarr = SMB_MALLOC_ARRAY(int,queuecnt)) == NULL) {
876 DEBUG(0,("api_DosPrintQEnum: malloc fail !\n"));
877 return False;
878 }
879 subcnt = 0;
880 n = 0;
881 for (i = 0; i < services; i++)
882 if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
883 subcntarr[n] = print_queue_status(i, &queue[n],&status[n]);
884 subcnt += subcntarr[n];
885 n++;
886 }
887 }
888 if (mdrcnt > 0) *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
889 desc.base = *rdata;
890 desc.buflen = mdrcnt;
891
892 if (init_package(&desc,queuecnt,subcnt)) {
893 n = 0;
894 succnt = 0;
895 for (i = 0; i < services; i++)
896 if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
897 fill_printq_info(conn,i,uLevel,&desc,subcntarr[n],queue[n],&status[n]);
898 n++;
899 if (desc.errcode == NERR_Success) succnt = n;
900 }
901 }
902
903 SAFE_FREE(subcntarr);
904
905 *rdata_len = desc.usedlen;
906 *rparam_len = 8;
907 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
908 SSVALS(*rparam,0,desc.errcode);
909 SSVAL(*rparam,2,0);
910 SSVAL(*rparam,4,succnt);
911 SSVAL(*rparam,6,queuecnt);
912
913 for (i = 0; i < queuecnt; i++) {
914 if (queue) SAFE_FREE(queue[i]);
915 }
916
917 SAFE_FREE(queue);
918 SAFE_FREE(status);
919
920 return True;
921 }
922
923 /****************************************************************************
924 get info level for a server list query
925 ****************************************************************************/
926 static BOOL check_server_info(int uLevel, char* id)
927 {
928 switch( uLevel ) {
929 case 0:
930 if (strcmp(id,"B16") != 0) return False;
931 break;
932 case 1:
933 if (strcmp(id,"B16BBDz") != 0) return False;
934 break;
935 default:
936 return False;
937 }
938 return True;
939 }
940
941 struct srv_info_struct
942 {
943 fstring name;
944 uint32 type;
945 fstring comment;
946 fstring domain;
947 BOOL server_added;
948 };
949
950
951 /*******************************************************************
952 get server info lists from the files saved by nmbd. Return the
953 number of entries
954 ******************************************************************/
955 static int get_server_info(uint32 servertype,
956 struct srv_info_struct **servers,
957 const char *domain)
958 {
959 int count=0;
960 int alloced=0;
961 char **lines;
962 BOOL local_list_only;
963 int i;
964
965 lines = file_lines_load(lock_path(SERVER_LIST), NULL);
966 if (!lines) {
967 DEBUG(4,("Can't open %s - %s\n",lock_path(SERVER_LIST),strerror(errno)));
968 return(0);
969 }
970
971 /* request for everything is code for request all servers */
972 if (servertype == SV_TYPE_ALL)
973 servertype &= ~(SV_TYPE_DOMAIN_ENUM|SV_TYPE_LOCAL_LIST_ONLY);
974
975 local_list_only = (servertype & SV_TYPE_LOCAL_LIST_ONLY);
976
977 DEBUG(4,("Servertype search: %8x\n",servertype));
978
979 for (i=0;lines[i];i++) {
980 fstring stype;
981 struct srv_info_struct *s;
982 const char *ptr = lines[i];
983 BOOL ok = True;
984
985 if (!*ptr) continue;
986
987 if (count == alloced) {
988 struct srv_info_struct *ts;
989
990 alloced += 10;
991 ts = SMB_REALLOC_ARRAY(*servers,struct srv_info_struct, alloced);
992 if (!ts) {
993 DEBUG(0,("get_server_info: failed to enlarge servers info struct!\n"));
994 return(0);
995 }
996 else *servers = ts;
997 memset((char *)((*servers)+count),'\0',sizeof(**servers)*(alloced-count));
998 }
999 s = &(*servers)[count];
1000
1001 if (!next_token(&ptr,s->name , NULL, sizeof(s->name))) continue;
1002 if (!next_token(&ptr,stype , NULL, sizeof(stype))) continue;
1003 if (!next_token(&ptr,s->comment, NULL, sizeof(s->comment))) continue;
1004 if (!next_token(&ptr,s->domain , NULL, sizeof(s->domain))) {
1005 /* this allows us to cope with an old nmbd */
1006 fstrcpy(s->domain,lp_workgroup());
1007 }
1008
1009 if (sscanf(stype,"%X",&s->type) != 1) {
1010 DEBUG(4,("r:host file "));
1011 ok = False;
1012 }
1013
1014 /* Filter the servers/domains we return based on what was asked for. */
1015
1016 /* Check to see if we are being asked for a local list only. */
1017 if(local_list_only && ((s->type & SV_TYPE_LOCAL_LIST_ONLY) == 0)) {
1018 DEBUG(4,("r: local list only"));
1019 ok = False;
1020 }
1021
1022 /* doesn't match up: don't want it */
1023 if (!(servertype & s->type)) {
1024 DEBUG(4,("r:serv type "));
1025 ok = False;
1026 }
1027
1028 if ((servertype & SV_TYPE_DOMAIN_ENUM) !=
1029 (s->type & SV_TYPE_DOMAIN_ENUM))
1030 {
1031 DEBUG(4,("s: dom mismatch "));
1032 ok = False;
1033 }
1034
1035 if (!strequal(domain, s->domain) && !(servertype & SV_TYPE_DOMAIN_ENUM))
1036 {
1037 ok = False;
1038 }
1039
1040 /* We should never return a server type with a SV_TYPE_LOCAL_LIST_ONLY set. */
1041 s->type &= ~SV_TYPE_LOCAL_LIST_ONLY;
1042
1043 if (ok)
1044 {
1045 DEBUG(4,("**SV** %20s %8x %25s %15s\n",
1046 s->name, s->type, s->comment, s->domain));
1047
1048 s->server_added = True;
1049 count++;
1050 }
1051 else
1052 {
1053 DEBUG(4,("%20s %8x %25s %15s\n",
1054 s->name, s->type, s->comment, s->domain));
1055 }
1056 }
1057
1058 file_lines_free(lines);
1059 return(count);
1060 }
1061
1062
1063 /*******************************************************************
1064 fill in a server info structure
1065 ******************************************************************/
1066 static int fill_srv_info(struct srv_info_struct *service,
1067 int uLevel, char **buf, int *buflen,
1068 char **stringbuf, int *stringspace, char *baseaddr)
1069 {
1070 int struct_len;
1071 char* p;
1072 char* p2;
1073 int l2;
1074 int len;
1075
1076 switch (uLevel) {
1077 case 0: struct_len = 16; break;
1078 case 1: struct_len = 26; break;
1079 default: return -1;
1080 }
1081
1082 if (!buf)
1083 {
1084 len = 0;
1085 switch (uLevel)
1086 {
1087 case 1:
1088 len = strlen(service->comment)+1;
1089 break;
1090 }
1091
1092 if (buflen) *buflen = struct_len;
1093 if (stringspace) *stringspace = len;
1094 return struct_len + len;
1095 }
1096
1097 len = struct_len;
1098 p = *buf;
1099 if (*buflen < struct_len) return -1;
1100 if (stringbuf)
1101 {
1102 p2 = *stringbuf;
1103 l2 = *stringspace;
1104 }
1105 else
1106 {
1107 p2 = p + struct_len;
1108 l2 = *buflen - struct_len;
1109 }
1110 if (!baseaddr) baseaddr = p;
1111
1112 switch (uLevel)
1113 {
1114 case 0:
1115 push_ascii(p,service->name, MAX_NETBIOSNAME_LEN, STR_TERMINATE);
1116 break;
1117
1118 case 1:
1119 push_ascii(p,service->name,MAX_NETBIOSNAME_LEN, STR_TERMINATE);
1120 SIVAL(p,18,service->type);
1121 SIVAL(p,22,PTR_DIFF(p2,baseaddr));
1122 len += CopyAndAdvance(&p2,service->comment,&l2);
1123 break;
1124 }
1125
1126 if (stringbuf)
1127 {
1128 *buf = p + struct_len;
1129 *buflen -= struct_len;
1130 *stringbuf = p2;
1131 *stringspace = l2;
1132 }
1133 else
1134 {
1135 *buf = p2;
1136 *buflen -= len;
1137 }
1138 return len;
1139 }
1140
1141
1142 static BOOL srv_comp(struct srv_info_struct *s1,struct srv_info_struct *s2)
1143 {
1144 return(strcmp(s1->name,s2->name));
1145 }
1146
1147 /****************************************************************************
1148 view list of servers available (or possibly domains). The info is
1149 extracted from lists saved by nmbd on the local host
1150 ****************************************************************************/
1151 static BOOL api_RNetServerEnum(connection_struct *conn, uint16 vuid, char *param, char *data,
1152 int mdrcnt, int mprcnt, char **rdata,
1153 char **rparam, int *rdata_len, int *rparam_len)
1154 {
1155 char *str1 = param+2;
1156 char *str2 = skip_string(str1,1);
1157 char *p = skip_string(str2,1);
1158 int uLevel = SVAL(p,0);
1159 int buf_len = SVAL(p,2);
1160 uint32 servertype = IVAL(p,4);
1161 char *p2;
1162 int data_len, fixed_len, string_len;
1163 int f_len = 0, s_len = 0;
1164 struct srv_info_struct *servers=NULL;
1165 int counted=0,total=0;
1166 int i,missed;
1167 fstring domain;
1168 BOOL domain_request;
1169 BOOL local_request;
1170
1171 /* If someone sets all the bits they don't really mean to set
1172 DOMAIN_ENUM and LOCAL_LIST_ONLY, they just want all the
1173 known servers. */
1174
1175 if (servertype == SV_TYPE_ALL)
1176 servertype &= ~(SV_TYPE_DOMAIN_ENUM|SV_TYPE_LOCAL_LIST_ONLY);
1177
1178 /* If someone sets SV_TYPE_LOCAL_LIST_ONLY but hasn't set
1179 any other bit (they may just set this bit on it's own) they
1180 want all the locally seen servers. However this bit can be
1181 set on its own so set the requested servers to be
1182 ALL - DOMAIN_ENUM. */
1183
1184 if ((servertype & SV_TYPE_LOCAL_LIST_ONLY) && !(servertype & SV_TYPE_DOMAIN_ENUM))
1185 servertype = SV_TYPE_ALL & ~(SV_TYPE_DOMAIN_ENUM);
1186
1187 domain_request = ((servertype & SV_TYPE_DOMAIN_ENUM) != 0);
1188 local_request = ((servertype & SV_TYPE_LOCAL_LIST_ONLY) != 0);
1189
1190 p += 8;
1191
1192 if (!prefix_ok(str1,"WrLehD")) return False;
1193 if (!check_server_info(uLevel,str2)) return False;
1194
1195 DEBUG(4, ("server request level: %s %8x ", str2, servertype));
1196 DEBUG(4, ("domains_req:%s ", BOOLSTR(domain_request)));
1197 DEBUG(4, ("local_only:%s\n", BOOLSTR(local_request)));
1198
1199 if (strcmp(str1, "WrLehDz") == 0) {
1200 pull_ascii_fstring(domain, p);
1201 } else {
1202 fstrcpy(domain, lp_workgroup());
1203 }
1204
1205 if (lp_browse_list())
1206 total = get_server_info(servertype,&servers,domain);
1207
1208 data_len = fixed_len = string_len = 0;
1209 missed = 0;
1210
1211 if (total > 0)
1212 qsort(servers,total,sizeof(servers[0]),QSORT_CAST srv_comp);
1213
1214 {
1215 char *lastname=NULL;
1216
1217 for (i=0;i<total;i++)
1218 {
1219 struct srv_info_struct *s = &servers[i];
1220 if (lastname && strequal(lastname,s->name)) continue;
1221 lastname = s->name;
1222 data_len += fill_srv_info(s,uLevel,0,&f_len,0,&s_len,0);
1223 DEBUG(4,("fill_srv_info %20s %8x %25s %15s\n",
1224 s->name, s->type, s->comment, s->domain));
1225
1226 if (data_len <= buf_len) {
1227 counted++;
1228 fixed_len += f_len;
1229 string_len += s_len;
1230 } else {
1231 missed++;
1232 }
1233 }
1234 }
1235
1236 *rdata_len = fixed_len + string_len;
1237 *rdata = SMB_REALLOC_LIMIT(*rdata,*rdata_len);
1238 memset(*rdata,'\0',*rdata_len);
1239
1240 p2 = (*rdata) + fixed_len; /* auxilliary data (strings) will go here */
1241 p = *rdata;
1242 f_len = fixed_len;
1243 s_len = string_len;
1244
1245 {
1246 char *lastname=NULL;
1247 int count2 = counted;
1248 for (i = 0; i < total && count2;i++)
1249 {
1250 struct srv_info_struct *s = &servers[i];
1251 if (lastname && strequal(lastname,s->name)) continue;
1252 lastname = s->name;
1253 fill_srv_info(s,uLevel,&p,&f_len,&p2,&s_len,*rdata);
1254 DEBUG(4,("fill_srv_info %20s %8x %25s %15s\n",
1255 s->name, s->type, s->comment, s->domain));
1256 count2--;
1257 }
1258 }
1259
1260 *rparam_len = 8;
1261 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
1262 SSVAL(*rparam,0,(missed == 0 ? NERR_Success : ERRmoredata));
1263 SSVAL(*rparam,2,0);
1264 SSVAL(*rparam,4,counted);
1265 SSVAL(*rparam,6,counted+missed);
1266
1267 SAFE_FREE(servers);
1268
1269 DEBUG(3,("NetServerEnum domain = %s uLevel=%d counted=%d total=%d\n",
1270 domain,uLevel,counted,counted+missed));
1271
1272 return(True);
1273 }
1274
1275 /****************************************************************************
1276 command 0x34 - suspected of being a "Lookup Names" stub api
1277 ****************************************************************************/
1278 static BOOL api_RNetGroupGetUsers(connection_struct *conn, uint16 vuid, char *param, char *data,
1279 int mdrcnt, int mprcnt, char **rdata,
1280 char **rparam, int *rdata_len, int *rparam_len)
1281 {
1282 char *str1 = param+2;
1283 char *str2 = skip_string(str1,1);
1284 char *p = skip_string(str2,1);
1285 int uLevel = SVAL(p,0);
1286 int buf_len = SVAL(p,2);
1287 int counted=0;
1288 int missed=0;
1289
1290 DEBUG(5,("RNetGroupGetUsers: %s %s %s %d %d\n",
1291 str1, str2, p, uLevel, buf_len));
1292
1293 if (!prefix_ok(str1,"zWrLeh")) return False;
1294
1295 *rdata_len = 0;
1296
1297 *rparam_len = 8;
1298 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
1299
1300 SSVAL(*rparam,0,0x08AC); /* informational warning message */
1301 SSVAL(*rparam,2,0);
1302 SSVAL(*rparam,4,counted);
1303 SSVAL(*rparam,6,counted+missed);
1304
1305 return(True);
1306 }
1307
1308 /****************************************************************************
1309 get info about a share
1310 ****************************************************************************/
1311 static BOOL check_share_info(int uLevel, char* id)
1312 {
1313 switch( uLevel ) {
1314 case 0:
1315 if (strcmp(id,"B13") != 0) return False;
1316 break;
1317 case 1:
1318 if (strcmp(id,"B13BWz") != 0) return False;
1319 break;
1320 case 2:
1321 if (strcmp(id,"B13BWzWWWzB9B") != 0) return False;
1322 break;
1323 case 91:
1324 if (strcmp(id,"B13BWzWWWzB9BB9BWzWWzWW") != 0) return False;
1325 break;
1326 default: return False;
1327 }
1328 return True;
1329 }
1330
1331 static int fill_share_info(connection_struct *conn, int snum, int uLevel,
1332 char** buf, int* buflen,
1333 char** stringbuf, int* stringspace, char* baseaddr)
1334 {
1335 int struct_len;
1336 char* p;
1337 char* p2;
1338 int l2;
1339 int len;
1340
1341 switch( uLevel ) {
1342 case 0: struct_len = 13; break;
1343 case 1: struct_len = 20; break;
1344 case 2: struct_len = 40; break;
1345 case 91: struct_len = 68; break;
1346 default: return -1;
1347 }
1348
1349
1350 if (!buf)
1351 {
1352 len = 0;
1353 if (uLevel > 0) len += StrlenExpanded(conn,snum,lp_comment(snum));
1354 if (uLevel > 1) len += strlen(lp_pathname(snum)) + 1;
1355 if (buflen) *buflen = struct_len;
1356 if (stringspace) *stringspace = len;
1357 return struct_len + len;
1358 }
1359
1360 len = struct_len;
1361 p = *buf;
1362 if ((*buflen) < struct_len) return -1;
1363 if (stringbuf)
1364 {
1365 p2 = *stringbuf;
1366 l2 = *stringspace;
1367 }
1368 else
1369 {
1370 p2 = p + struct_len;
1371 l2 = (*buflen) - struct_len;
1372 }
1373 if (!baseaddr) baseaddr = p;
1374
1375 push_ascii(p,lp_servicename(snum),13, STR_TERMINATE);
1376
1377 if (uLevel > 0)
1378 {
1379 int type;
1380 SCVAL(p,13,0);
1381 type = STYPE_DISKTREE;
1382 if (lp_print_ok(snum)) type = STYPE_PRINTQ;
1383 if (strequal("IPC",lp_fstype(snum))) type = STYPE_IPC;
1384 SSVAL(p,14,type); /* device type */
1385 SIVAL(p,16,PTR_DIFF(p2,baseaddr));
1386 len += CopyExpanded(conn,snum,&p2,lp_comment(snum),&l2);
1387 }
1388
1389 if (uLevel > 1)
1390 {
1391 SSVAL(p,20,ACCESS_READ|ACCESS_WRITE|ACCESS_CREATE); /* permissions */
1392 SSVALS(p,22,-1); /* max uses */
1393 SSVAL(p,24,1); /* current uses */
1394 SIVAL(p,26,PTR_DIFF(p2,baseaddr)); /* local pathname */
1395 len += CopyAndAdvance(&p2,lp_pathname(snum),&l2);
1396 memset(p+30,0,SHPWLEN+2); /* passwd (reserved), pad field */
1397 }
1398
1399 if (uLevel > 2)
1400 {
1401 memset(p+40,0,SHPWLEN+2);
1402 SSVAL(p,50,0);
1403 SIVAL(p,52,0);
1404 SSVAL(p,56,0);
1405 SSVAL(p,58,0);
1406 SIVAL(p,60,0);
1407 SSVAL(p,64,0);
1408 SSVAL(p,66,0);
1409 }
1410
1411 if (stringbuf)
1412 {
1413 (*buf) = p + struct_len;
1414 (*buflen) -= struct_len;
1415 (*stringbuf) = p2;
1416 (*stringspace) = l2;
1417 }
1418 else
1419 {
1420 (*buf) = p2;
1421 (*buflen) -= len;
1422 }
1423 return len;
1424 }
1425
1426 static BOOL api_RNetShareGetInfo(connection_struct *conn,uint16 vuid, char *param,char *data,
1427 int mdrcnt,int mprcnt,
1428 char **rdata,char **rparam,
1429 int *rdata_len,int *rparam_len)
1430 {
1431 char *str1 = param+2;
1432 char *str2 = skip_string(str1,1);
1433 char *netname = skip_string(str2,1);
1434 char *p = skip_string(netname,1);
1435 int uLevel = SVAL(p,0);
1436 int snum = find_service(netname);
1437
1438 if (snum < 0) return False;
1439
1440 /* check it's a supported varient */
1441 if (!prefix_ok(str1,"zWrLh")) return False;
1442 if (!check_share_info(uLevel,str2)) return False;
1443
1444 *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
1445 p = *rdata;
1446 *rdata_len = fill_share_info(conn,snum,uLevel,&p,&mdrcnt,0,0,0);
1447 if (*rdata_len < 0) return False;
1448
1449 *rparam_len = 6;
1450 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
1451 SSVAL(*rparam,0,NERR_Success);
1452 SSVAL(*rparam,2,0); /* converter word */
1453 SSVAL(*rparam,4,*rdata_len);
1454
1455 return(True);
1456 }
1457
1458 /****************************************************************************
1459 View the list of available shares.
1460
1461 This function is the server side of the NetShareEnum() RAP call.
1462 It fills the return buffer with share names and share comments.
1463 Note that the return buffer normally (in all known cases) allows only
1464 twelve byte strings for share names (plus one for a nul terminator).
1465 Share names longer than 12 bytes must be skipped.
1466 ****************************************************************************/
1467 static BOOL api_RNetShareEnum( connection_struct *conn,
1468 uint16 vuid,
1469 char *param,
1470 char *data,
1471 int mdrcnt,
1472 int mprcnt,
1473 char **rdata,
1474 char **rparam,
1475 int *rdata_len,
1476 int *rparam_len )
1477 {
1478 char *str1 = param+2;
1479 char *str2 = skip_string(str1,1);
1480 char *p = skip_string(str2,1);
1481 int uLevel = SVAL(p,0);
1482 int buf_len = SVAL(p,2);
1483 char *p2;
1484 int count=lp_numservices();
1485 int total=0,counted=0;
1486 BOOL missed = False;
1487 int i;
1488 int data_len, fixed_len, string_len;
1489 int f_len = 0, s_len = 0;
1490
1491 if (!prefix_ok(str1,"WrLeh")) return False;
1492 if (!check_share_info(uLevel,str2)) return False;
1493
1494 data_len = fixed_len = string_len = 0;
1495 for (i=0;i<count;i++) {
1496 fstring servicename_dos;
1497 if (!(lp_browseable(i) && lp_snum_ok(i)))
1498 continue;
1499 push_ascii_fstring(servicename_dos, lp_servicename(i));
1500 if( lp_browseable( i )
1501 && lp_snum_ok( i )
1502 && (strlen(servicename_dos) < 13) ) /* Maximum name length. */
1503 {
1504 total++;
1505 data_len += fill_share_info(conn,i,uLevel,0,&f_len,0,&s_len,0);
1506 if (data_len <= buf_len)
1507 {
1508 counted++;
1509 fixed_len += f_len;
1510 string_len += s_len;
1511 }
1512 else
1513 missed = True;
1514 }
1515 }
1516 *rdata_len = fixed_len + string_len;
1517 *rdata = SMB_REALLOC_LIMIT(*rdata,*rdata_len);
1518 memset(*rdata,0,*rdata_len);
1519
1520 p2 = (*rdata) + fixed_len; /* auxiliary data (strings) will go here */
1521 p = *rdata;
1522 f_len = fixed_len;
1523 s_len = string_len;
1524 for( i = 0; i < count; i++ )
1525 {
1526 fstring servicename_dos;
1527 if (!(lp_browseable(i) && lp_snum_ok(i)))
1528 continue;
1529 push_ascii_fstring(servicename_dos, lp_servicename(i));
1530 if( lp_browseable( i )
1531 && lp_snum_ok( i )
1532 && (strlen(servicename_dos) < 13) )
1533 {
1534 if( fill_share_info( conn,i,uLevel,&p,&f_len,&p2,&s_len,*rdata ) < 0 )
1535 break;
1536 }
1537 }
1538
1539 *rparam_len = 8;
1540 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
1541 SSVAL(*rparam,0,missed ? ERRmoredata : NERR_Success);
1542 SSVAL(*rparam,2,0);
1543 SSVAL(*rparam,4,counted);
1544 SSVAL(*rparam,6,total);
1545
1546 DEBUG(3,("RNetShareEnum gave %d entries of %d (%d %d %d %d)\n",
1547 counted,total,uLevel,
1548 buf_len,*rdata_len,mdrcnt));
1549 return(True);
1550 } /* api_RNetShareEnum */
1551
1552 /****************************************************************************
1553 Add a share
1554 ****************************************************************************/
1555 static BOOL api_RNetShareAdd(connection_struct *conn,uint16 vuid, char *param,char *data,
1556 int mdrcnt,int mprcnt,
1557 char **rdata,char **rparam,
1558 int *rdata_len,int *rparam_len)
1559 {
1560 char *str1 = param+2;
1561 char *str2 = skip_string(str1,1);
1562 char *p = skip_string(str2,1);
1563 int uLevel = SVAL(p,0);
1564 fstring sharename;
1565 fstring comment;
1566 pstring pathname;
1567 char *command, *cmdname;
1568 unsigned int offset;
1569 int snum;
1570 int res = ERRunsup;
1571
1572 /* check it's a supported varient */
1573 if (!prefix_ok(str1,RAP_WShareAdd_REQ)) return False;
1574 if (!check_share_info(uLevel,str2)) return False;
1575 if (uLevel != 2) return False;
1576
1577 pull_ascii_fstring(sharename,data);
1578 snum = find_service(sharename);
1579 if (snum >= 0) { /* already exists */
1580 res = ERRfilexists;
1581 goto error_exit;
1582 }
1583
1584 /* only support disk share adds */
1585 if (SVAL(data,14)!=STYPE_DISKTREE) return False;
1586
1587 offset = IVAL(data, 16);
1588 if (offset >= mdrcnt) {
1589 res = ERRinvalidparam;
1590 goto error_exit;
1591 }
1592 pull_ascii_fstring(comment, offset? (data+offset) : "");
1593
1594 offset = IVAL(data, 26);
1595 if (offset >= mdrcnt) {
1596 res = ERRinvalidparam;
1597 goto error_exit;
1598 }
1599 pull_ascii_pstring(pathname, offset? (data+offset) : "");
1600
1601 string_replace(sharename, '"', ' ');
1602 string_replace(pathname, '"', ' ');
1603 string_replace(comment, '"', ' ');
1604
1605 cmdname = lp_add_share_cmd();
1606
1607 if (!cmdname || *cmdname == '\0') return False;
1608
1609 asprintf(&command, "%s \"%s\" \"%s\" \"%s\" \"%s\"",
1610 lp_add_share_cmd(), dyn_CONFIGFILE, sharename, pathname, comment);
1611
1612 if (command) {
1613 DEBUG(10,("api_RNetShareAdd: Running [%s]\n", command ));
1614 if ((res = smbrun(command, NULL)) != 0) {
1615 DEBUG(1,("api_RNetShareAdd: Running [%s] returned (%d)\n", command, res ));
1616 SAFE_FREE(command);
1617 res = ERRnoaccess;
1618 goto error_exit;
1619 } else {
1620 SAFE_FREE(command);
1621 message_send_all(conn_tdb_ctx(), MSG_SMB_CONF_UPDATED, NULL, 0, False, NULL);
1622 }
1623 } else return False;
1624
1625 *rparam_len = 6;
1626 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
1627 SSVAL(*rparam,0,NERR_Success);
1628 SSVAL(*rparam,2,0); /* converter word */
1629 SSVAL(*rparam,4,*rdata_len);
1630 *rdata_len = 0;
1631
1632 return True;
1633
1634 error_exit:
1635 *rparam_len = 4;
1636 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
1637 *rdata_len = 0;
1638 SSVAL(*rparam,0,res);
1639 SSVAL(*rparam,2,0);
1640 return True;
1641
1642 }
1643
1644 /****************************************************************************
1645 view list of groups available
1646 ****************************************************************************/
1647 static BOOL api_RNetGroupEnum(connection_struct *conn,uint16 vuid, char *param,char *data,
1648 int mdrcnt,int mprcnt,
1649 char **rdata,char **rparam,
1650 int *rdata_len,int *rparam_len)
1651 {
1652 int i;
1653 int errflags=0;
1654 int resume_context, cli_buf_size;
1655 char *str1 = param+2;
1656 char *str2 = skip_string(str1,1);
1657 char *p = skip_string(str2,1);
1658
1659 struct pdb_search *search;
1660 struct samr_displayentry *entries;
1661
1662 int num_entries;
1663
1664 if (strcmp(str1,"WrLeh") != 0)
1665 return False;
1666
1667 /* parameters
1668 * W-> resume context (number of users to skip)
1669 * r -> return parameter pointer to receive buffer
1670 * L -> length of receive buffer
1671 * e -> return parameter number of entries
1672 * h -> return parameter total number of users
1673 */
1674 if (strcmp("B21",str2) != 0)
1675 return False;
1676
1677 /* get list of domain groups SID_DOMAIN_GRP=2 */
1678 become_root();
1679 search = pdb_search_groups();
1680 unbecome_root();
1681
1682 if (search == NULL) {
1683 DEBUG(3,("api_RNetGroupEnum:failed to get group list"));
1684 return False;
1685 }
1686
1687 resume_context = SVAL(p,0);
1688 cli_buf_size=SVAL(p+2,0);
1689 DEBUG(10,("api_RNetGroupEnum:resume context: %d, client buffer size: "
1690 "%d\n", resume_context, cli_buf_size));
1691
1692 become_root();
1693 num_entries = pdb_search_entries(search, resume_context, 0xffffffff,
1694 &entries);
1695 unbecome_root();
1696
1697 *rdata_len = cli_buf_size;
1698 *rdata = SMB_REALLOC_LIMIT(*rdata,*rdata_len);
1699
1700 p = *rdata;
1701
1702 for(i=0; i<num_entries; i++) {
1703 fstring name;
1704 fstrcpy(name, entries[i].account_name);
1705 if( ((PTR_DIFF(p,*rdata)+21) <= *rdata_len) ) {
1706 /* truncate the name at 21 chars. */
1707 memcpy(p, name, 21);
1708 DEBUG(10,("adding entry %d group %s\n", i, p));
1709 p += 21;
1710 p += 5; /* Both NT4 and W2k3SP1 do padding here.
1711 No idea why... */
1712 } else {
1713 /* set overflow error */
1714 DEBUG(3,("overflow on entry %d group %s\n", i, name));
1715 errflags=234;
1716 break;
1717 }
1718 }
1719
1720 pdb_search_destroy(search);
1721
1722 *rdata_len = PTR_DIFF(p,*rdata);
1723
1724 *rparam_len = 8;
1725 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
1726
1727 SSVAL(*rparam, 0, errflags);
1728 SSVAL(*rparam, 2, 0); /* converter word */
1729 SSVAL(*rparam, 4, i); /* is this right?? */
1730 SSVAL(*rparam, 6, resume_context+num_entries); /* is this right?? */
1731
1732 return(True);
1733 }
1734
1735 /*******************************************************************
1736 get groups that a user is a member of
1737 ******************************************************************/
1738 static BOOL api_NetUserGetGroups(connection_struct *conn,uint16 vuid, char *param,char *data,
1739 int mdrcnt,int mprcnt,
1740 char **rdata,char **rparam,
1741 int *rdata_len,int *rparam_len)
1742 {
1743 char *str1 = param+2;
1744 char *str2 = skip_string(str1,1);
1745 char *UserName = skip_string(str2,1);
1746 char *p = skip_string(UserName,1);
1747 int uLevel = SVAL(p,0);
1748 const char *level_string;
1749 int count=0;
1750 SAM_ACCOUNT *sampw = NULL;
1751 BOOL ret = False;
1752 DOM_SID *sids;
1753 gid_t *gids;
1754 int num_groups;
1755 int i;
1756 fstring grp_domain;
1757 fstring grp_name;
1758 enum SID_NAME_USE grp_type;
1759 struct passwd *passwd;
1760 NTSTATUS result;
1761
1762 *rparam_len = 8;
1763 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
1764
1765 /* check it's a supported varient */
1766
1767 if ( strcmp(str1,"zWrLeh") != 0 )
1768 return False;
1769
1770 switch( uLevel ) {
1771 case 0:
1772 level_string = "B21";
1773 break;
1774 default:
1775 return False;
1776 }
1777
1778 if (strcmp(level_string,str2) != 0)
1779 return False;
1780
1781 *rdata_len = mdrcnt + 1024;
1782 *rdata = SMB_REALLOC_LIMIT(*rdata,*rdata_len);
1783
1784 SSVAL(*rparam,0,NERR_Success);
1785 SSVAL(*rparam,2,0); /* converter word */
1786
1787 p = *rdata;
1788
1789 /* Lookup the user information; This should only be one of
1790 our accounts (not remote domains) */
1791
1792 passwd = getpwnam_alloc(UserName);
1793
1794 if (passwd == NULL)
1795 return False;
1796
1797 pdb_init_sam( &sampw );
1798
1799 become_root(); /* ROOT BLOCK */
1800
1801 if ( !pdb_getsampwnam(sampw, UserName) )
1802 goto out;
1803
1804 sids = NULL;
1805 num_groups = 0;
1806
1807 result = pdb_enum_group_memberships(pdb_get_username(sampw),
1808 passwd->pw_gid,
1809 &sids, &gids, &num_groups);
1810
1811 if (!NT_STATUS_IS_OK(result))
1812 goto out;
1813
1814 for (i=0; i<num_groups; i++) {
1815
1816 if ( lookup_sid(&sids[i], grp_domain, grp_name, &grp_type) ) {
1817 pstrcpy(p, grp_name);
1818 p += 21;
1819 count++;
1820 }
1821 }
1822
1823 SAFE_FREE(sids);
1824
1825 *rdata_len = PTR_DIFF(p,*rdata);
1826
1827 SSVAL(*rparam,4,count); /* is this right?? */
1828 SSVAL(*rparam,6,count); /* is this right?? */
1829
1830 ret = True;
1831
1832 out:
1833 unbecome_root(); /* END ROOT BLOCK */
1834
1835 pdb_free_sam( &sampw );
1836 passwd_free(&passwd);
1837
1838 return ret;
1839 }
1840
1841 /*******************************************************************
1842 get all users
1843 ******************************************************************/
1844 static BOOL api_RNetUserEnum(connection_struct *conn,uint16 vuid, char *param,char *data,
1845 int mdrcnt,int mprcnt,
1846 char **rdata,char **rparam,
1847 int *rdata_len,int *rparam_len)
1848 {
1849 int count_sent=0;
1850 int num_users=0;
1851 int errflags=0;
1852 int i, resume_context, cli_buf_size;
1853 struct pdb_search *search;
1854 struct samr_displayentry *users;
1855
1856 char *str1 = param+2;
1857 char *str2 = skip_string(str1,1);
1858 char *p = skip_string(str2,1);
1859
1860 if (strcmp(str1,"WrLeh") != 0)
1861 return False;
1862 /* parameters
1863 * W-> resume context (number of users to skip)
1864 * r -> return parameter pointer to receive buffer
1865 * L -> length of receive buffer
1866 * e -> return parameter number of entries
1867 * h -> return parameter total number of users
1868 */
1869
1870 resume_context = SVAL(p,0);
1871 cli_buf_size=SVAL(p+2,0);
1872 DEBUG(10,("api_RNetUserEnum:resume context: %d, client buffer size: %d\n", resume_context, cli_buf_size));
1873
1874 *rparam_len = 8;
1875 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
1876
1877 /* check it's a supported varient */
1878 if (strcmp("B21",str2) != 0)
1879 return False;
1880
1881 *rdata_len = cli_buf_size;
1882 *rdata = SMB_REALLOC_LIMIT(*rdata,*rdata_len);
1883
1884 p = *rdata;
1885
1886 become_root();
1887 search = pdb_search_users(ACB_NORMAL);
1888 unbecome_root();
1889 if (search == NULL) {
1890 DEBUG(0, ("api_RNetUserEnum:unable to open sam database.\n"));
1891 return False;
1892 }
1893
1894 become_root();
1895 num_users = pdb_search_entries(search, resume_context, 0xffffffff,
1896 &users);
1897 unbecome_root();
1898
1899 errflags=NERR_Success;
1900
1901 for (i=0; i<num_users; i++) {
1902 const char *name = users[i].account_name;
1903
1904 if(((PTR_DIFF(p,*rdata)+21)<=*rdata_len)&&(strlen(name)<=21)) {
1905 pstrcpy(p,name);
1906 DEBUG(10,("api_RNetUserEnum:adding entry %d username "
1907 "%s\n",count_sent,p));
1908 p += 21;
1909 count_sent++;
1910 } else {
1911 /* set overflow error */
1912 DEBUG(10,("api_RNetUserEnum:overflow on entry %d "
1913 "username %s\n",count_sent,name));
1914 errflags=234;
1915 break;
1916 }
1917 }
1918
1919 pdb_search_destroy(search);
1920
1921 *rdata_len = PTR_DIFF(p,*rdata);
1922
1923 SSVAL(*rparam,0,errflags);
1924 SSVAL(*rparam,2,0); /* converter word */
1925 SSVAL(*rparam,4,count_sent); /* is this right?? */
1926 SSVAL(*rparam,6,num_users); /* is this right?? */
1927
1928 return True;
1929 }
1930
1931
1932
1933 /****************************************************************************
1934 get the time of day info
1935 ****************************************************************************/
1936 static BOOL api_NetRemoteTOD(connection_struct *conn,uint16 vuid, char *param,char *data,
1937 int mdrcnt,int mprcnt,
1938 char **rdata,char **rparam,
1939 int *rdata_len,int *rparam_len)
1940 {
1941 char *p;
1942 *rparam_len = 4;
1943 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
1944
1945 *rdata_len = 21;
1946 *rdata = SMB_REALLOC_LIMIT(*rdata,*rdata_len);
1947
1948 SSVAL(*rparam,0,NERR_Success);
1949 SSVAL(*rparam,2,0); /* converter word */
1950
1951 p = *rdata;
1952
1953 {
1954 struct tm *t;
1955 time_t unixdate = time(NULL);
1956
1957 put_dos_date3(p,0,unixdate); /* this is the time that is looked at
1958 by NT in a "net time" operation,
1959 it seems to ignore the one below */
1960
1961 /* the client expects to get localtime, not GMT, in this bit
1962 (I think, this needs testing) */
1963 t = LocalTime(&unixdate);
1964
1965 SIVAL(p,4,0); /* msecs ? */
1966 SCVAL(p,8,t->tm_hour);
1967 SCVAL(p,9,t->tm_min);
1968 SCVAL(p,10,t->tm_sec);
1969 SCVAL(p,11,0); /* hundredths of seconds */
1970 SSVALS(p,12,TimeDiff(unixdate)/60); /* timezone in minutes from GMT */
1971 SSVAL(p,14,10000); /* timer interval in 0.0001 of sec */
1972 SCVAL(p,16,t->tm_mday);
1973 SCVAL(p,17,t->tm_mon + 1);
1974 SSVAL(p,18,1900+t->tm_year);
1975 SCVAL(p,20,t->tm_wday);
1976 }
1977
1978
1979 return(True);
1980 }
1981
1982 /****************************************************************************
1983 Set the user password.
1984 *****************************************************************************/
1985
1986 static BOOL api_SetUserPassword(connection_struct *conn,uint16 vuid, char *param,char *data,
1987 int mdrcnt,int mprcnt,
1988 char **rdata,char **rparam,
1989 int *rdata_len,int *rparam_len)
1990 {
1991 char *p = skip_string(param+2,2);
1992 fstring user;
1993 fstring pass1,pass2;
1994
1995 pull_ascii_fstring(user,p);
1996
1997 p = skip_string(p,1);
1998
1999 memset(pass1,'\0',sizeof(pass1));
2000 memset(pass2,'\0',sizeof(pass2));
2001 memcpy(pass1,p,16);
2002 memcpy(pass2,p+16,16);
2003
2004 *rparam_len = 4;
2005 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
2006
2007 *rdata_len = 0;
2008
2009 SSVAL(*rparam,0,NERR_badpass);
2010 SSVAL(*rparam,2,0); /* converter word */
2011
2012 DEBUG(3,("Set password for <%s>\n",user));
2013
2014 /*
2015 * Attempt to verify the old password against smbpasswd entries
2016 * Win98 clients send old and new password in plaintext for this call.
2017 */
2018
2019 {
2020 auth_serversupplied_info *server_info = NULL;
2021 DATA_BLOB password = data_blob(pass1, strlen(pass1)+1);
2022
2023 if (NT_STATUS_IS_OK(check_plaintext_password(user,password,&server_info))) {
2024
2025 become_root();
2026 if (NT_STATUS_IS_OK(change_oem_password(server_info->sam_account, pass1, pass2, False))) {
2027 SSVAL(*rparam,0,NERR_Success);
2028 }
2029 unbecome_root();
2030
2031 free_server_info(&server_info);
2032 }
2033 data_blob_clear_free(&password);
2034 }
2035
2036 /*
2037 * If the plaintext change failed, attempt
2038 * the old encrypted method. NT will generate this
2039 * after trying the samr method. Note that this
2040 * method is done as a last resort as this
2041 * password change method loses the NT password hash
2042 * and cannot change the UNIX password as no plaintext
2043 * is received.
2044 */
2045
2046 if(SVAL(*rparam,0) != NERR_Success) {
2047 SAM_ACCOUNT *hnd = NULL;
2048
2049 if (check_lanman_password(user,(unsigned char *)pass1,(unsigned char *)pass2, &hnd)) {
2050 become_root();
2051 if (change_lanman_password(hnd,(uchar *)pass2)) {
2052 SSVAL(*rparam,0,NERR_Success);
2053 }
2054 unbecome_root();
2055 pdb_free_sam(&hnd);
2056 }
2057 }
2058
2059 memset((char *)pass1,'\0',sizeof(fstring));
2060 memset((char *)pass2,'\0',sizeof(fstring));
2061
2062 return(True);
2063 }
2064
2065 /****************************************************************************
2066 Set the user password (SamOEM version - gets plaintext).
2067 ****************************************************************************/
2068
2069 static BOOL api_SamOEMChangePassword(connection_struct *conn,uint16 vuid, char *param,char *data,
2070 int mdrcnt,int mprcnt,
2071 char **rdata,char **rparam,
2072 int *rdata_len,int *rparam_len)
2073 {
2074 fstring user;
2075 char *p = param + 2;
2076 *rparam_len = 2;
2077 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
2078
2079 *rdata_len = 0;
2080
2081 SSVAL(*rparam,0,NERR_badpass);
2082
2083 /*
2084 * Check the parameter definition is correct.
2085 */
2086
2087 if(!strequal(param + 2, "zsT")) {
2088 DEBUG(0,("api_SamOEMChangePassword: Invalid parameter string %s\n", param + 2));
2089 return False;
2090 }
2091 p = skip_string(p, 1);
2092
2093 if(!strequal(p, "B516B16")) {
2094 DEBUG(0,("api_SamOEMChangePassword: Invalid data parameter string %s\n", p));
2095 return False;
2096 }
2097 p = skip_string(p,1);
2098 p += pull_ascii_fstring(user,p);
2099
2100 DEBUG(3,("api_SamOEMChangePassword: Change password for <%s>\n",user));
2101
2102 /*
2103 * Pass the user through the NT -> unix user mapping
2104 * function.
2105 */
2106
2107 (void)map_username(user);
2108
2109 if (NT_STATUS_IS_OK(pass_oem_change(user, (uchar*) data, (uchar *)&data[516], NULL, NULL))) {
2110 SSVAL(*rparam,0,NERR_Success);
2111 }
2112
2113 return(True);
2114 }
2115
2116 /****************************************************************************
2117 delete a print job
2118 Form: <W> <>
2119 ****************************************************************************/
2120 static BOOL api_RDosPrintJobDel(connection_struct *conn,uint16 vuid, char *param,char *data,
2121 int mdrcnt,int mprcnt,
2122 char **rdata,char **rparam,
2123 int *rdata_len,int *rparam_len)
2124 {
2125 int function = SVAL(param,0);
2126 char *str1 = param+2;
2127 char *str2 = skip_string(str1,1);
2128 char *p = skip_string(str2,1);
2129 uint32 jobid;
2130 int snum;
2131 fstring sharename;
2132 int errcode;
2133 WERROR werr = WERR_OK;
2134
2135 if(!rap_to_pjobid(SVAL(p,0), sharename, &jobid))
2136 return False;
2137
2138 /* check it's a supported varient */
2139 if (!(strcsequal(str1,"W") && strcsequal(str2,"")))
2140 return(False);
2141
2142 *rparam_len = 4;
2143 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
2144 *rdata_len = 0;
2145
2146 if (!print_job_exists(sharename, jobid)) {
2147 errcode = NERR_JobNotFound;
2148 goto out;
2149 }
2150
2151 snum = lp_servicenumber( sharename);
2152 if (snum == -1) {
2153 errcode = NERR_DestNotFound;
2154 goto out;
2155 }
2156
2157 errcode = NERR_notsupported;
2158
2159 switch (function) {
2160 case 81: /* delete */
2161 if (print_job_delete(&current_user, snum, jobid, &werr))
2162 errcode = NERR_Success;
2163 break;
2164 case 82: /* pause */
2165 if (print_job_pause(&current_user, snum, jobid, &werr))
2166 errcode = NERR_Success;
2167 break;
2168 case 83: /* resume */
2169 if (print_job_resume(&current_user, snum, jobid, &werr))
2170 errcode = NERR_Success;
2171 break;
2172 }
2173
2174 if (!W_ERROR_IS_OK(werr))
2175 errcode = W_ERROR_V(werr);
2176
2177 out:
2178 SSVAL(*rparam,0,errcode);
2179 SSVAL(*rparam,2,0); /* converter word */
2180
2181 return(True);
2182 }
2183
2184 /****************************************************************************
2185 Purge a print queue - or pause or resume it.
2186 ****************************************************************************/
2187 static BOOL api_WPrintQueueCtrl(connection_struct *conn,uint16 vuid, char *param,char *data,
2188 int mdrcnt,int mprcnt,
2189 char **rdata,char **rparam,
2190 int *rdata_len,int *rparam_len)
2191 {
2192 int function = SVAL(param,0);
2193 char *str1 = param+2;
2194 char *str2 = skip_string(str1,1);
2195 char *QueueName = skip_string(str2,1);
2196 int errcode = NERR_notsupported;
2197 int snum;
2198 WERROR werr = WERR_OK;
2199
2200 /* check it's a supported varient */
2201 if (!(strcsequal(str1,"z") && strcsequal(str2,"")))
2202 return(False);
2203
2204 *rparam_len = 4;
2205 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
2206 *rdata_len = 0;
2207
2208 snum = print_queue_snum(QueueName);
2209
2210 if (snum == -1) {
2211 errcode = NERR_JobNotFound;
2212 goto out;
2213 }
2214
2215 switch (function) {
2216 case 74: /* Pause queue */
2217 if (print_queue_pause(&current_user, snum, &werr)) errcode = NERR_Success;
2218 break;
2219 case 75: /* Resume queue */
2220 if (print_queue_resume(&current_user, snum, &werr)) errcode = NERR_Success;
2221 break;
2222 case 103: /* Purge */
2223 if (print_queue_purge(&current_user, snum, &werr)) errcode = NERR_Success;
2224 break;
2225 }
2226
2227 if (!W_ERROR_IS_OK(werr)) errcode = W_ERROR_V(werr);
2228
2229 out:
2230 SSVAL(*rparam,0,errcode);
2231 SSVAL(*rparam,2,0); /* converter word */
2232
2233 return(True);
2234 }
2235
2236
2237 /****************************************************************************
2238 set the property of a print job (undocumented?)
2239 ? function = 0xb -> set name of print job
2240 ? function = 0x6 -> move print job up/down
2241 Form: <WWsTP> <WWzWWDDzzzzzzzzzzlz>
2242 or <WWsTP> <WB21BB16B10zWWzDDz>
2243 ****************************************************************************/
2244 static int check_printjob_info(struct pack_desc* desc,
2245 int uLevel, char* id)
2246 {
2247 desc->subformat = NULL;
2248 switch( uLevel ) {
2249 case 0: desc->format = "W"; break;
2250 case 1: desc->format = "WB21BB16B10zWWzDDz"; break;
2251 case 2: desc->format = "WWzWWDDzz"; break;
2252 case 3: desc->format = "WWzWWDDzzzzzzzzzzlz"; break;
2253 case 4: desc->format = "WWzWWDDzzzzzDDDDDDD"; break;
2254 default: return False;
2255 }
2256 if (strcmp(desc->format,id) != 0) return False;
2257 return True;
2258 }
2259
2260 static BOOL api_PrintJobInfo(connection_struct *conn,uint16 vuid,char *param,char *data,
2261 int mdrcnt,int mprcnt,
2262 char **rdata,char **rparam,
2263 int *rdata_len,int *rparam_len)
2264 {
2265 struct pack_desc desc;
2266 char *str1 = param+2;
2267 char *str2 = skip_string(str1,1);
2268 char *p = skip_string(str2,1);
2269 uint32 jobid;
2270 int snum;
2271 fstring sharename;
2272 int uLevel = SVAL(p,2);
2273 int function = SVAL(p,4);
2274 int place, errcode;
2275
2276 if(!rap_to_pjobid(SVAL(p,0), sharename, &jobid))
2277 return False;
2278 *rparam_len = 4;
2279 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
2280
2281 if ( (snum = lp_servicenumber(sharename)) == -1 ) {
2282 DEBUG(0,("api_PrintJobInfo: unable to get service number from sharename [%s]\n",
2283 sharename));
2284 return False;
2285 }
2286
2287 *rdata_len = 0;
2288
2289 /* check it's a supported varient */
2290 if ((strcmp(str1,"WWsTP")) ||
2291 (!check_printjob_info(&desc,uLevel,str2)))
2292 return(False);
2293
2294 if (!print_job_exists(sharename, jobid)) {
2295 errcode=NERR_JobNotFound;
2296 goto out;
2297 }
2298
2299 errcode = NERR_notsupported;
2300
2301 switch (function) {
2302 case 0x6:
2303 /* change job place in the queue,
2304 data gives the new place */
2305 place = SVAL(data,0);
2306 if (print_job_set_place(snum, jobid, place)) {
2307 errcode=NERR_Success;
2308 }
2309 break;
2310
2311 case 0xb:
2312 /* change print job name, data gives the name */
2313 if (print_job_set_name(snum, jobid, data)) {
2314 errcode=NERR_Success;
2315 }
2316 break;
2317
2318 default:
2319 return False;
2320 }
2321
2322 out:
2323 SSVALS(*rparam,0,errcode);
2324 SSVAL(*rparam,2,0); /* converter word */
2325
2326 return(True);
2327 }
2328
2329
2330 /****************************************************************************
2331 get info about the server
2332 ****************************************************************************/
2333 static BOOL api_RNetServerGetInfo(connection_struct *conn,uint16 vuid, char *param,char *data,
2334 int mdrcnt,int mprcnt,
2335 char **rdata,char **rparam,
2336 int *rdata_len,int *rparam_len)
2337 {
2338 char *str1 = param+2;
2339 char *str2 = skip_string(str1,1);
2340 char *p = skip_string(str2,1);
2341 int uLevel = SVAL(p,0);
2342 char *p2;
2343 int struct_len;
2344
2345 DEBUG(4,("NetServerGetInfo level %d\n",uLevel));
2346
2347 /* check it's a supported varient */
2348 if (!prefix_ok(str1,"WrLh")) return False;
2349 switch( uLevel ) {
2350 case 0:
2351 if (strcmp(str2,"B16") != 0) return False;
2352 struct_len = 16;
2353 break;
2354 case 1:
2355 if (strcmp(str2,"B16BBDz") != 0) return False;
2356 struct_len = 26;
2357 break;
2358 case 2:
2359 if (strcmp(str2,"B16BBDzDDDWWzWWWWWWWBB21zWWWWWWWWWWWWWWWWWWWWWWz")
2360 != 0) return False;
2361 struct_len = 134;
2362 break;
2363 case 3:
2364 if (strcmp(str2,"B16BBDzDDDWWzWWWWWWWBB21zWWWWWWWWWWWWWWWWWWWWWWzDWz")
2365 != 0) return False;
2366 struct_len = 144;
2367 break;
2368 case 20:
2369 if (strcmp(str2,"DN") != 0) return False;
2370 struct_len = 6;
2371 break;
2372 case 50:
2373 if (strcmp(str2,"B16BBDzWWzzz") != 0) return False;
2374 struct_len = 42;
2375 break;
2376 default: return False;
2377 }
2378
2379 *rdata_len = mdrcnt;
2380 *rdata = SMB_REALLOC_LIMIT(*rdata,*rdata_len);
2381
2382 p = *rdata;
2383 p2 = p + struct_len;
2384 if (uLevel != 20) {
2385 srvstr_push(NULL, p,get_local_machine_name(),16,
2386 STR_ASCII|STR_UPPER|STR_TERMINATE);
2387 }
2388 p += 16;
2389 if (uLevel > 0)
2390 {
2391 struct srv_info_struct *servers=NULL;
2392 int i,count;
2393 pstring comment;
2394 uint32 servertype= lp_default_server_announce();
2395
2396 push_ascii(comment,lp_serverstring(), MAX_SERVER_STRING_LENGTH,STR_TERMINATE);
2397
2398 if ((count=get_server_info(SV_TYPE_ALL,&servers,lp_workgroup()))>0) {
2399 for (i=0;i<count;i++) {
2400 if (strequal(servers[i].name,get_local_machine_name())) {
2401 servertype = servers[i].type;
2402 push_ascii(comment,servers[i].comment,sizeof(pstring),STR_TERMINATE);
2403 }
2404 }
2405 }
2406 SAFE_FREE(servers);
2407
2408 SCVAL(p,0,lp_major_announce_version());
2409 SCVAL(p,1,lp_minor_announce_version());
2410 SIVAL(p,2,servertype);
2411
2412 if (mdrcnt == struct_len) {
2413 SIVAL(p,6,0);
2414 } else {
2415 SIVAL(p,6,PTR_DIFF(p2,*rdata));
2416 standard_sub_conn(conn,comment,sizeof(comment));
2417 StrnCpy(p2,comment,MAX(mdrcnt - struct_len,0));
2418 p2 = skip_string(p2,1);
2419 }
2420 }
2421 if (uLevel > 1)
2422 {
2423 return False; /* not yet implemented */
2424 }
2425
2426 *rdata_len = PTR_DIFF(p2,*rdata);
2427
2428 *rparam_len = 6;
2429 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
2430 SSVAL(*rparam,0,NERR_Success);
2431 SSVAL(*rparam,2,0); /* converter word */
2432 SSVAL(*rparam,4,*rdata_len);
2433
2434 return(True);
2435 }
2436
2437
2438 /****************************************************************************
2439 get info about the server
2440 ****************************************************************************/
2441 static BOOL api_NetWkstaGetInfo(connection_struct *conn,uint16 vuid, char *param,char *data,
2442 int mdrcnt,int mprcnt,
2443 char **rdata,char **rparam,
2444 int *rdata_len,int *rparam_len)
2445 {
2446 char *str1 = param+2;
2447 char *str2 = skip_string(str1,1);
2448 char *p = skip_string(str2,1);
2449 char *p2;
2450 int level = SVAL(p,0);
2451
2452 DEBUG(4,("NetWkstaGetInfo level %d\n",level));
2453
2454 *rparam_len = 6;
2455 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
2456
2457 /* check it's a supported varient */
2458 if (!(level==10 && strcsequal(str1,"WrLh") && strcsequal(str2,"zzzBBzz")))
2459 return(False);
2460
2461 *rdata_len = mdrcnt + 1024;
2462 *rdata = SMB_REALLOC_LIMIT(*rdata,*rdata_len);
2463
2464 SSVAL(*rparam,0,NERR_Success);
2465 SSVAL(*rparam,2,0); /* converter word */
2466
2467 p = *rdata;
2468 p2 = p + 22;
2469
2470
2471 SIVAL(p,0,PTR_DIFF(p2,*rdata)); /* host name */
2472 pstrcpy(p2,get_local_machine_name());
2473 strupper_m(p2);
2474 p2 = skip_string(p2,1);
2475 p += 4;
2476
2477 SIVAL(p,0,PTR_DIFF(p2,*rdata));
2478 pstrcpy(p2,current_user_info.smb_name);
2479 p2 = skip_string(p2,1);
2480 p += 4;
2481
2482 SIVAL(p,0,PTR_DIFF(p2,*rdata)); /* login domain */
2483 pstrcpy(p2,lp_workgroup());
2484 strupper_m(p2);
2485 p2 = skip_string(p2,1);
2486 p += 4;
2487
2488 SCVAL(p,0,lp_major_announce_version()); /* system version - e.g 4 in 4.1 */
2489 SCVAL(p,1,lp_minor_announce_version()); /* system version - e.g .1 in 4.1 */
2490 p += 2;
2491
2492 SIVAL(p,0,PTR_DIFF(p2,*rdata));
2493 pstrcpy(p2,lp_workgroup()); /* don't know. login domain?? */
2494 p2 = skip_string(p2,1);
2495 p += 4;
2496
2497 SIVAL(p,0,PTR_DIFF(p2,*rdata)); /* don't know */
2498 pstrcpy(p2,"");
2499 p2 = skip_string(p2,1);
2500 p += 4;
2501
2502 *rdata_len = PTR_DIFF(p2,*rdata);
2503
2504 SSVAL(*rparam,4,*rdata_len);
2505
2506 return(True);
2507 }
2508
2509 /****************************************************************************
2510 get info about a user
2511
2512 struct user_info_11 {
2513 char usri11_name[21]; 0-20
2514 char usri11_pad; 21
2515 char *usri11_comment; 22-25
2516 char *usri11_usr_comment; 26-29
2517 unsigned short usri11_priv; 30-31
2518 unsigned long usri11_auth_flags; 32-35
2519 long usri11_password_age; 36-39
2520 char *usri11_homedir; 40-43
2521 char *usri11_parms; 44-47
2522 long usri11_last_logon; 48-51
2523 long usri11_last_logoff; 52-55
2524 unsigned short usri11_bad_pw_count; 56-57
2525 unsigned short usri11_num_logons; 58-59
2526 char *usri11_logon_server; 60-63
2527 unsigned short usri11_country_code; 64-65
2528 char *usri11_workstations; 66-69
2529 unsigned long usri11_max_storage; 70-73
2530 unsigned short usri11_units_per_week; 74-75
2531 unsigned char *usri11_logon_hours; 76-79
2532 unsigned short usri11_code_page; 80-81
2533 };
2534
2535 where:
2536
2537 usri11_name specifies the user name for which information is retireved
2538
2539 usri11_pad aligns the next data structure element to a word boundary
2540
2541 usri11_comment is a null terminated ASCII comment
2542
2543 usri11_user_comment is a null terminated ASCII comment about the user
2544
2545 usri11_priv specifies the level of the privilege assigned to the user.
2546 The possible values are:
2547
2548 Name Value Description
2549 USER_PRIV_GUEST 0 Guest privilege
2550 USER_PRIV_USER 1 User privilege
2551 USER_PRV_ADMIN 2 Administrator privilege
2552
2553 usri11_auth_flags specifies the account operator privileges. The
2554 possible values are:
2555
2556 Name Value Description
2557 AF_OP_PRINT 0 Print operator
2558
2559
2560 Leach, Naik [Page 28]
2561 \f
2562
2563
2564 INTERNET-DRAFT CIFS Remote Admin Protocol January 10, 1997
2565
2566
2567 AF_OP_COMM 1 Communications operator
2568 AF_OP_SERVER 2 Server operator
2569 AF_OP_ACCOUNTS 3 Accounts operator
2570
2571
2572 usri11_password_age specifies how many seconds have elapsed since the
2573 password was last changed.
2574
2575 usri11_home_dir points to a null terminated ASCII string that contains
2576 the path name of the user's home directory.
2577
2578 usri11_parms points to a null terminated ASCII string that is set
2579 aside for use by applications.
2580
2581 usri11_last_logon specifies the time when the user last logged on.
2582 This value is stored as the number of seconds elapsed since
2583 00:00:00, January 1, 1970.
2584
2585 usri11_last_logoff specifies the time when the user last logged off.
2586 This value is stored as the number of seconds elapsed since
2587 00:00:00, January 1, 1970. A value of 0 means the last logoff
2588 time is unknown.
2589
2590 usri11_bad_pw_count specifies the number of incorrect passwords
2591 entered since the last successful logon.
2592
2593 usri11_log1_num_logons specifies the number of times this user has
2594 logged on. A value of -1 means the number of logons is unknown.
2595
2596 usri11_logon_server points to a null terminated ASCII string that
2597 contains the name of the server to which logon requests are sent.
2598 A null string indicates logon requests should be sent to the
2599 domain controller.
2600
2601 usri11_country_code specifies the country code for the user's language
2602 of choice.
2603
2604 usri11_workstations points to a null terminated ASCII string that
2605 contains the names of workstations the user may log on from.
2606 There may be up to 8 workstations, with the names separated by
2607 commas. A null strings indicates there are no restrictions.
2608
2609 usri11_max_storage specifies the maximum amount of disk space the user
2610 can occupy. A value of 0xffffffff indicates there are no
2611 restrictions.
2612
2613 usri11_units_per_week specifies the equal number of time units into
2614 which a week is divided. This value must be equal to 168.
2615
2616 usri11_logon_hours points to a 21 byte (168 bits) string that
2617 specifies the time during which the user can log on. Each bit
2618 represents one unique hour in a week. The first bit (bit 0, word
2619 0) is Sunday, 0:00 to 0:59, the second bit (bit 1, word 0) is
2620
2621
2622
2623 Leach, Naik [Page 29]
2624 \f
2625
2626
2627 INTERNET-DRAFT CIFS Remote Admin Protocol January 10, 1997
2628
2629
2630 Sunday, 1:00 to 1:59 and so on. A null pointer indicates there
2631 are no restrictions.
2632
2633 usri11_code_page specifies the code page for the user's language of
2634 choice
2635
2636 All of the pointers in this data structure need to be treated
2637 specially. The pointer is a 32 bit pointer. The higher 16 bits need
2638 to be ignored. The converter word returned in the parameters section
2639 needs to be subtracted from the lower 16 bits to calculate an offset
2640 into the return buffer where this ASCII string resides.
2641
2642 There is no auxiliary data in the response.
2643
2644 ****************************************************************************/
2645
2646 #define usri11_name 0
2647 #define usri11_pad 21
2648 #define usri11_comment 22
2649 #define usri11_usr_comment 26
2650 #define usri11_full_name 30
2651 #define usri11_priv 34
2652 #define usri11_auth_flags 36
2653 #define usri11_password_age 40
2654 #define usri11_homedir 44
2655 #define usri11_parms 48
2656 #define usri11_last_logon 52
2657 #define usri11_last_logoff 56
2658 #define usri11_bad_pw_count 60
2659 #define usri11_num_logons 62
2660 #define usri11_logon_server 64
2661 #define usri11_country_code 68
2662 #define usri11_workstations 70
2663 #define usri11_max_storage 74
2664 #define usri11_units_per_week 78
2665 #define usri11_logon_hours 80
2666 #define usri11_code_page 84
2667 #define usri11_end 86
2668
2669 #define USER_PRIV_GUEST 0
2670 #define USER_PRIV_USER 1
2671 #define USER_PRIV_ADMIN 2
2672
2673 #define AF_OP_PRINT 0
2674 #define AF_OP_COMM 1
2675 #define AF_OP_SERVER 2
2676 #define AF_OP_ACCOUNTS 3
2677
2678
2679 static BOOL api_RNetUserGetInfo(connection_struct *conn,uint16 vuid, char *param,char *data,
2680 int mdrcnt,int mprcnt,
2681 char **rdata,char **rparam,
2682 int *rdata_len,int *rparam_len)
2683 {
2684 char *str1 = param+2;
2685 char *str2 = skip_string(str1,1);
2686 char *UserName = skip_string(str2,1);
2687 char *p = skip_string(UserName,1);
2688 int uLevel = SVAL(p,0);
2689 char *p2;
2690 const char *level_string;
2691
2692 /* get NIS home of a previously validated user - simeon */
2693 /* With share level security vuid will always be zero.
2694 Don't depend on vuser being non-null !!. JRA */
2695 user_struct *vuser = get_valid_user_struct(vuid);
2696 if(vuser != NULL)
2697 DEBUG(3,(" Username of UID %d is %s\n", (int)vuser->uid,
2698 vuser->user.unix_name));
2699
2700 *rparam_len = 6;
2701 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
2702
2703 DEBUG(4,("RNetUserGetInfo level=%d\n", uLevel));
2704
2705 /* check it's a supported variant */
2706 if (strcmp(str1,"zWrLh") != 0) return False;
2707 switch( uLevel )
2708 {
2709 case 0: level_string = "B21"; break;
2710 case 1: level_string = "B21BB16DWzzWz"; break;
2711 case 2: level_string = "B21BB16DWzzWzDzzzzDDDDWb21WWzWW"; break;
2712 case 10: level_string = "B21Bzzz"; break;
2713 case 11: level_string = "B21BzzzWDDzzDDWWzWzDWb21W"; break;
2714 default: return False;
2715 }
2716
2717 if (strcmp(level_string,str2) != 0) return False;
2718
2719 *rdata_len = mdrcnt + 1024;
2720 *rdata = SMB_REALLOC_LIMIT(*rdata,*rdata_len);
2721
2722 SSVAL(*rparam,0,NERR_Success);
2723 SSVAL(*rparam,2,0); /* converter word */
2724
2725 p = *rdata;
2726 p2 = p + usri11_end;
2727
2728 memset(p,0,21);
2729 fstrcpy(p+usri11_name,UserName); /* 21 bytes - user name */
2730
2731 if (uLevel > 0)
2732 {
2733 SCVAL(p,usri11_pad,0); /* padding - 1 byte */
2734 *p2 = 0;
2735 }
2736 if (uLevel >= 10)
2737 {
2738 SIVAL(p,usri11_comment,PTR_DIFF(p2,p)); /* comment */
2739 pstrcpy(p2,"Comment");
2740 p2 = skip_string(p2,1);
2741
2742 SIVAL(p,usri11_usr_comment,PTR_DIFF(p2,p)); /* user_comment */
2743 pstrcpy(p2,"UserComment");
2744 p2 = skip_string(p2,1);
2745
2746 /* EEK! the cifsrap.txt doesn't have this in!!!! */
2747 SIVAL(p,usri11_full_name,PTR_DIFF(p2,p)); /* full name */
2748 pstrcpy(p2,((vuser != NULL) ? vuser->user.full_name : UserName));
2749 p2 = skip_string(p2,1);
2750 }
2751
2752 if (uLevel == 11) /* modelled after NTAS 3.51 reply */
2753 {
2754 SSVAL(p,usri11_priv,conn->admin_user?USER_PRIV_ADMIN:USER_PRIV_USER);
2755 SIVAL(p,usri11_auth_flags,AF_OP_PRINT); /* auth flags */
2756 SIVALS(p,usri11_password_age,-1); /* password age */
2757 SIVAL(p,usri11_homedir,PTR_DIFF(p2,p)); /* home dir */
2758 pstrcpy(p2, vuser && vuser->homedir ? vuser->homedir : "");
2759 p2 = skip_string(p2,1);
2760 SIVAL(p,usri11_parms,PTR_DIFF(p2,p)); /* parms */
2761 pstrcpy(p2,"");
2762 p2 = skip_string(p2,1);
2763 SIVAL(p,usri11_last_logon,0); /* last logon */
2764 SIVAL(p,usri11_last_logoff,0); /* last logoff */
2765 SSVALS(p,usri11_bad_pw_count,-1); /* bad pw counts */
2766 SSVALS(p,usri11_num_logons,-1); /* num logons */
2767 SIVAL(p,usri11_logon_server,PTR_DIFF(p2,p)); /* logon server */
2768 pstrcpy(p2,"\\\\*");
2769 p2 = skip_string(p2,1);
2770 SSVAL(p,usri11_country_code,0); /* country code */
2771
2772 SIVAL(p,usri11_workstations,PTR_DIFF(p2,p)); /* workstations */
2773 pstrcpy(p2,"");
2774 p2 = skip_string(p2,1);
2775
2776 SIVALS(p,usri11_max_storage,-1); /* max storage */
2777 SSVAL(p,usri11_units_per_week,168); /* units per week */
2778 SIVAL(p,usri11_logon_hours,PTR_DIFF(p2,p)); /* logon hours */
2779
2780 /* a simple way to get logon hours at all times. */
2781 memset(p2,0xff,21);
2782 SCVAL(p2,21,0); /* fix zero termination */
2783 p2 = skip_string(p2,1);
2784
2785 SSVAL(p,usri11_code_page,0); /* code page */
2786 }
2787 if (uLevel == 1 || uLevel == 2)
2788 {
2789 memset(p+22,' ',16); /* password */
2790 SIVALS(p,38,-1); /* password age */
2791 SSVAL(p,42,
2792 conn->admin_user?USER_PRIV_ADMIN:USER_PRIV_USER);
2793 SIVAL(p,44,PTR_DIFF(p2,*rdata)); /* home dir */
2794 pstrcpy(p2, vuser && vuser->homedir ? vuser->homedir : "");
2795 p2 = skip_string(p2,1);
2796 SIVAL(p,48,PTR_DIFF(p2,*rdata)); /* comment */
2797 *p2++ = 0;
2798 SSVAL(p,52,0); /* flags */
2799 SIVAL(p,54,PTR_DIFF(p2,*rdata)); /* script_path */
2800 pstrcpy(p2,vuser && vuser->logon_script ? vuser->logon_script : "");
2801 p2 = skip_string(p2,1);
2802 if (uLevel == 2)
2803 {
2804 SIVAL(p,60,0); /* auth_flags */
2805 SIVAL(p,64,PTR_DIFF(p2,*rdata)); /* full_name */
2806 pstrcpy(p2,((vuser != NULL) ? vuser->user.full_name : UserName));
2807 p2 = skip_string(p2,1);
2808 SIVAL(p,68,0); /* urs_comment */
2809 SIVAL(p,72,PTR_DIFF(p2,*rdata)); /* parms */
2810 pstrcpy(p2,"");
2811 p2 = skip_string(p2,1);
2812 SIVAL(p,76,0); /* workstations */
2813 SIVAL(p,80,0); /* last_logon */
2814 SIVAL(p,84,0); /* last_logoff */
2815 SIVALS(p,88,-1); /* acct_expires */
2816 SIVALS(p,92,-1); /* max_storage */
2817 SSVAL(p,96,168); /* units_per_week */
2818 SIVAL(p,98,PTR_DIFF(p2,*rdata)); /* logon_hours */
2819 memset(p2,-1,21);
2820 p2 += 21;
2821 SSVALS(p,102,-1); /* bad_pw_count */
2822 SSVALS(p,104,-1); /* num_logons */
2823 SIVAL(p,106,PTR_DIFF(p2,*rdata)); /* logon_server */
2824 pstrcpy(p2,"\\\\%L");
2825 standard_sub_conn(conn, p2,0);
2826 p2 = skip_string(p2,1);
2827 SSVAL(p,110,49); /* country_code */
2828 SSVAL(p,112,860); /* code page */
2829 }
2830 }
2831
2832 *rdata_len = PTR_DIFF(p2,*rdata);
2833
2834 SSVAL(*rparam,4,*rdata_len); /* is this right?? */
2835
2836 return(True);
2837 }
2838
2839 static BOOL api_WWkstaUserLogon(connection_struct *conn,uint16 vuid, char *param,char *data,
2840 int mdrcnt,int mprcnt,
2841 char **rdata,char **rparam,
2842 int *rdata_len,int *rparam_len)
2843 {
2844 char *str1 = param+2;
2845 char *str2 = skip_string(str1,1);
2846 char *p = skip_string(str2,1);
2847 int uLevel;
2848 struct pack_desc desc;
2849 char* name;
2850 /* With share level security vuid will always be zero.
2851 Don't depend on vuser being non-null !!. JRA */
2852 user_struct *vuser = get_valid_user_struct(vuid);
2853 if(vuser != NULL)
2854 DEBUG(3,(" Username of UID %d is %s\n", (int)vuser->uid,
2855 vuser->user.unix_name));
2856
2857 uLevel = SVAL(p,0);
2858 name = p + 2;
2859
2860 memset((char *)&desc,'\0',sizeof(desc));
2861
2862 DEBUG(3,("WWkstaUserLogon uLevel=%d name=%s\n",uLevel,name));
2863
2864 /* check it's a supported varient */
2865 if (strcmp(str1,"OOWb54WrLh") != 0) return False;
2866 if (uLevel != 1 || strcmp(str2,"WB21BWDWWDDDDDDDzzzD") != 0) return False;
2867 if (mdrcnt > 0) *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
2868 desc.base = *rdata;
2869 desc.buflen = mdrcnt;
2870 desc.subformat = NULL;
2871 desc.format = str2;
2872
2873 if (init_package(&desc,1,0))
2874 {
2875 PACKI(&desc,"W",0); /* code */
2876 PACKS(&desc,"B21",name); /* eff. name */
2877 PACKS(&desc,"B",""); /* pad */
2878 PACKI(&desc,"W",
2879 conn->admin_user?USER_PRIV_ADMIN:USER_PRIV_USER);
2880 PACKI(&desc,"D",0); /* auth flags XXX */
2881 PACKI(&desc,"W",0); /* num logons */
2882 PACKI(&desc,"W",0); /* bad pw count */
2883 PACKI(&desc,"D",0); /* last logon */
2884 PACKI(&desc,"D",-1); /* last logoff */
2885 PACKI(&desc,"D",-1); /* logoff time */
2886 PACKI(&desc,"D",-1); /* kickoff time */
2887 PACKI(&desc,"D",0); /* password age */
2888 PACKI(&desc,"D",0); /* password can change */
2889 PACKI(&desc,"D",-1); /* password must change */
2890 {
2891 fstring mypath;
2892 fstrcpy(mypath,"\\\\");
2893 fstrcat(mypath,get_local_machine_name());
2894 strupper_m(mypath);
2895 PACKS(&desc,"z",mypath); /* computer */
2896 }
2897 PACKS(&desc,"z",lp_workgroup());/* domain */
2898
2899 PACKS(&desc,"z", vuser && vuser->logon_script ? vuser->logon_script :""); /* script path */
2900
2901 PACKI(&desc,"D",0x00000000); /* reserved */
2902 }
2903
2904 *rdata_len = desc.usedlen;
2905 *rparam_len = 6;
2906 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
2907 SSVALS(*rparam,0,desc.errcode);
2908 SSVAL(*rparam,2,0);
2909 SSVAL(*rparam,4,desc.neededlen);
2910
2911 DEBUG(4,("WWkstaUserLogon: errorcode %d\n",desc.errcode));
2912 return(True);
2913 }
2914
2915
2916 /****************************************************************************
2917 api_WAccessGetUserPerms
2918 ****************************************************************************/
2919 static BOOL api_WAccessGetUserPerms(connection_struct *conn,uint16 vuid, char *param,char *data,
2920 int mdrcnt,int mprcnt,
2921 char **rdata,char **rparam,
2922 int *rdata_len,int *rparam_len)
2923 {
2924 char *str1 = param+2;
2925 char *str2 = skip_string(str1,1);
2926 char *user = skip_string(str2,1);
2927 char *resource = skip_string(user,1);
2928
2929 DEBUG(3,("WAccessGetUserPerms user=%s resource=%s\n",user,resource));
2930
2931 /* check it's a supported varient */
2932 if (strcmp(str1,"zzh") != 0) return False;
2933 if (strcmp(str2,"") != 0) return False;
2934
2935 *rparam_len = 6;
2936 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
2937 SSVALS(*rparam,0,0); /* errorcode */
2938 SSVAL(*rparam,2,0); /* converter word */
2939 SSVAL(*rparam,4,0x7f); /* permission flags */
2940
2941 return(True);
2942 }
2943
2944 /****************************************************************************
2945 api_WPrintJobEnumerate
2946 ****************************************************************************/
2947 static BOOL api_WPrintJobGetInfo(connection_struct *conn,uint16 vuid, char *param,char *data,
2948 int mdrcnt,int mprcnt,
2949 char **rdata,char **rparam,
2950 int *rdata_len,int *rparam_len)
2951 {
2952 char *str1 = param+2;
2953 char *str2 = skip_string(str1,1);
2954 char *p = skip_string(str2,1);
2955 int uLevel;
2956 int count;
2957 int i;
2958 int snum;
2959 fstring sharename;
2960 uint32 jobid;
2961 struct pack_desc desc;
2962 print_queue_struct *queue=NULL;
2963 print_status_struct status;
2964 char *tmpdata=NULL;
2965
2966 uLevel = SVAL(p,2);
2967
2968 memset((char *)&desc,'\0',sizeof(desc));
2969 memset((char *)&status,'\0',sizeof(status));
2970
2971 DEBUG(3,("WPrintJobGetInfo uLevel=%d uJobId=0x%X\n",uLevel,SVAL(p,0)));
2972
2973 /* check it's a supported varient */
2974 if (strcmp(str1,"WWrLh") != 0) return False;
2975 if (!check_printjob_info(&desc,uLevel,str2)) return False;
2976
2977 if(!rap_to_pjobid(SVAL(p,0), sharename, &jobid))
2978 return False;
2979
2980 snum = lp_servicenumber( sharename);
2981 if (snum < 0 || !VALID_SNUM(snum)) return(False);
2982
2983 count = print_queue_status(snum,&queue,&status);
2984 for (i = 0; i < count; i++) {
2985 if (queue[i].job == jobid) break;
2986 }
2987
2988 if (mdrcnt > 0) {
2989 *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
2990 desc.base = *rdata;
2991 desc.buflen = mdrcnt;
2992 } else {
2993 /*
2994 * Don't return data but need to get correct length
2995 * init_package will return wrong size if buflen=0
2996 */
2997 desc.buflen = getlen(desc.format);
2998 desc.base = tmpdata = (char *)SMB_MALLOC( desc.buflen );
2999 }
3000
3001 if (init_package(&desc,1,0)) {
3002 if (i < count) {
3003 fill_printjob_info(conn,snum,uLevel,&desc,&queue[i],i);
3004 *rdata_len = desc.usedlen;
3005 }
3006 else {
3007 desc.errcode = NERR_JobNotFound;
3008 *rdata_len = 0;
3009 }
3010 }
3011
3012 *rparam_len = 6;
3013 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
3014 SSVALS(*rparam,0,desc.errcode);
3015 SSVAL(*rparam,2,0);
3016 SSVAL(*rparam,4,desc.neededlen);
3017
3018 SAFE_FREE(queue);
3019 SAFE_FREE(tmpdata);
3020
3021 DEBUG(4,("WPrintJobGetInfo: errorcode %d\n",desc.errcode));
3022 return(True);
3023 }
3024
3025 static BOOL api_WPrintJobEnumerate(connection_struct *conn,uint16 vuid, char *param,char *data,
3026 int mdrcnt,int mprcnt,
3027 char **rdata,char **rparam,
3028 int *rdata_len,int *rparam_len)
3029 {
3030 char *str1 = param+2;
3031 char *str2 = skip_string(str1,1);
3032 char *p = skip_string(str2,1);
3033 char* name = p;
3034 int uLevel;
3035 int count;
3036 int i, succnt=0;
3037 int snum;
3038 struct pack_desc desc;
3039 print_queue_struct *queue=NULL;
3040 print_status_struct status;
3041
3042 memset((char *)&desc,'\0',sizeof(desc));
3043 memset((char *)&status,'\0',sizeof(status));
3044
3045 p = skip_string(p,1);
3046 uLevel = SVAL(p,0);
3047
3048 DEBUG(3,("WPrintJobEnumerate uLevel=%d name=%s\n",uLevel,name));
3049
3050 /* check it's a supported variant */
3051 if (strcmp(str1,"zWrLeh") != 0)
3052 return False;
3053
3054 if (uLevel > 2)
3055 return False; /* defined only for uLevel 0,1,2 */
3056
3057 if (!check_printjob_info(&desc,uLevel,str2))
3058 return False;
3059
3060 snum = find_service(name);
3061 if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) )
3062 return False;
3063
3064 count = print_queue_status(snum,&queue,&status);
3065 if (mdrcnt > 0) *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
3066 desc.base = *rdata;
3067 desc.buflen = mdrcnt;
3068
3069 if (init_package(&desc,count,0)) {
3070 succnt = 0;
3071 for (i = 0; i < count; i++) {
3072 fill_printjob_info(conn,snum,uLevel,&desc,&queue[i],i);
3073 if (desc.errcode == NERR_Success) succnt = i+1;
3074 }
3075 }
3076
3077 *rdata_len = desc.usedlen;
3078
3079 *rparam_len = 8;
3080 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
3081 SSVALS(*rparam,0,desc.errcode);
3082 SSVAL(*rparam,2,0);
3083 SSVAL(*rparam,4,succnt);
3084 SSVAL(*rparam,6,count);
3085
3086 SAFE_FREE(queue);
3087
3088 DEBUG(4,("WPrintJobEnumerate: errorcode %d\n",desc.errcode));
3089 return(True);
3090 }
3091
3092 static int check_printdest_info(struct pack_desc* desc,
3093 int uLevel, char* id)
3094 {
3095 desc->subformat = NULL;
3096 switch( uLevel ) {
3097 case 0: desc->format = "B9"; break;
3098 case 1: desc->format = "B9B21WWzW"; break;
3099 case 2: desc->format = "z"; break;
3100 case 3: desc->format = "zzzWWzzzWW"; break;
3101 default: return False;
3102 }
3103 if (strcmp(desc->format,id) != 0) return False;
3104 return True;
3105 }
3106
3107 static void fill_printdest_info(connection_struct *conn, int snum, int uLevel,
3108 struct pack_desc* desc)
3109 {
3110 char buf[100];
3111 strncpy(buf,SERVICE(snum),sizeof(buf)-1);
3112 buf[sizeof(buf)-1] = 0;
3113 strupper_m(buf);
3114 if (uLevel <= 1) {
3115 PACKS(desc,"B9",buf); /* szName */
3116 if (uLevel == 1) {
3117 PACKS(desc,"B21",""); /* szUserName */
3118 PACKI(desc,"W",0); /* uJobId */
3119 PACKI(desc,"W",0); /* fsStatus */
3120 PACKS(desc,"z",""); /* pszStatus */
3121 PACKI(desc,"W",0); /* time */
3122 }
3123 }
3124 if (uLevel == 2 || uLevel == 3) {
3125 PACKS(desc,"z",buf); /* pszPrinterName */
3126 if (uLevel == 3) {
3127 PACKS(desc,"z",""); /* pszUserName */
3128 PACKS(desc,"z",""); /* pszLogAddr */
3129 PACKI(desc,"W",0); /* uJobId */
3130 PACKI(desc,"W",0); /* fsStatus */
3131 PACKS(desc,"z",""); /* pszStatus */
3132 PACKS(desc,"z",""); /* pszComment */
3133 PACKS(desc,"z","NULL"); /* pszDrivers */
3134 PACKI(desc,"W",0); /* time */
3135 PACKI(desc,"W",0); /* pad1 */
3136 }
3137 }
3138 }
3139
3140 static BOOL api_WPrintDestGetInfo(connection_struct *conn,uint16 vuid, char *param,char *data,
3141 int mdrcnt,int mprcnt,
3142 char **rdata,char **rparam,
3143 int *rdata_len,int *rparam_len)
3144 {
3145 char *str1 = param+2;
3146 char *str2 = skip_string(str1,1);
3147 char *p = skip_string(str2,1);
3148 char* PrinterName = p;
3149 int uLevel;
3150 struct pack_desc desc;
3151 int snum;
3152 char *tmpdata=NULL;
3153
3154 memset((char *)&desc,'\0',sizeof(desc));
3155
3156 p = skip_string(p,1);
3157 uLevel = SVAL(p,0);
3158
3159 DEBUG(3,("WPrintDestGetInfo uLevel=%d PrinterName=%s\n",uLevel,PrinterName));
3160
3161 /* check it's a supported varient */
3162 if (strcmp(str1,"zWrLh") != 0) return False;
3163 if (!check_printdest_info(&desc,uLevel,str2)) return False;
3164
3165 snum = find_service(PrinterName);
3166 if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) ) {
3167 *rdata_len = 0;
3168 desc.errcode = NERR_DestNotFound;
3169 desc.neededlen = 0;
3170 }
3171 else {
3172 if (mdrcnt > 0) {
3173 *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
3174 desc.base = *rdata;
3175 desc.buflen = mdrcnt;
3176 } else {
3177 /*
3178 * Don't return data but need to get correct length
3179 * init_package will return wrong size if buflen=0
3180 */
3181 desc.buflen = getlen(desc.format);
3182 desc.base = tmpdata = (char *)SMB_MALLOC( desc.buflen );
3183 }
3184 if (init_package(&desc,1,0)) {
3185 fill_printdest_info(conn,snum,uLevel,&desc);
3186 }
3187 *rdata_len = desc.usedlen;
3188 }
3189
3190 *rparam_len = 6;
3191 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
3192 SSVALS(*rparam,0,desc.errcode);
3193 SSVAL(*rparam,2,0);
3194 SSVAL(*rparam,4,desc.neededlen);
3195
3196 DEBUG(4,("WPrintDestGetInfo: errorcode %d\n",desc.errcode));
3197 SAFE_FREE(tmpdata);
3198 return(True);
3199 }
3200
3201 static BOOL api_WPrintDestEnum(connection_struct *conn,uint16 vuid, char *param,char *data,
3202 int mdrcnt,int mprcnt,
3203 char **rdata,char **rparam,
3204 int *rdata_len,int *rparam_len)
3205 {
3206 char *str1 = param+2;
3207 char *str2 = skip_string(str1,1);
3208 char *p = skip_string(str2,1);
3209 int uLevel;
3210 int queuecnt;
3211 int i, n, succnt=0;
3212 struct pack_desc desc;
3213 int services = lp_numservices();
3214
3215 memset((char *)&desc,'\0',sizeof(desc));
3216
3217 uLevel = SVAL(p,0);
3218
3219 DEBUG(3,("WPrintDestEnum uLevel=%d\n",uLevel));
3220
3221 /* check it's a supported varient */
3222 if (strcmp(str1,"WrLeh") != 0) return False;
3223 if (!check_printdest_info(&desc,uLevel,str2)) return False;
3224
3225 queuecnt = 0;
3226 for (i = 0; i < services; i++)
3227 if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i))
3228 queuecnt++;
3229
3230 if (mdrcnt > 0) *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
3231 desc.base = *rdata;
3232 desc.buflen = mdrcnt;
3233 if (init_package(&desc,queuecnt,0)) {
3234 succnt = 0;
3235 n = 0;
3236 for (i = 0; i < services; i++) {
3237 if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
3238 fill_printdest_info(conn,i,uLevel,&desc);
3239 n++;
3240 if (desc.errcode == NERR_Success) succnt = n;
3241 }
3242 }
3243 }
3244
3245 *rdata_len = desc.usedlen;
3246
3247 *rparam_len = 8;
3248 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
3249 SSVALS(*rparam,0,desc.errcode);
3250 SSVAL(*rparam,2,0);
3251 SSVAL(*rparam,4,succnt);
3252 SSVAL(*rparam,6,queuecnt);
3253
3254 DEBUG(4,("WPrintDestEnumerate: errorcode %d\n",desc.errcode));
3255 return(True);
3256 }
3257
3258 static BOOL api_WPrintDriverEnum(connection_struct *conn,uint16 vuid, char *param,char *data,
3259 int mdrcnt,int mprcnt,
3260 char **rdata,char **rparam,
3261 int *rdata_len,int *rparam_len)
3262 {
3263 char *str1 = param+2;
3264 char *str2 = skip_string(str1,1);
3265 char *p = skip_string(str2,1);
3266 int uLevel;
3267 int succnt;
3268 struct pack_desc desc;
3269
3270 memset((char *)&desc,'\0',sizeof(desc));
3271
3272 uLevel = SVAL(p,0);
3273
3274 DEBUG(3,("WPrintDriverEnum uLevel=%d\n",uLevel));
3275
3276 /* check it's a supported varient */
3277 if (strcmp(str1,"WrLeh") != 0) return False;
3278 if (uLevel != 0 || strcmp(str2,"B41") != 0) return False;
3279
3280 if (mdrcnt > 0) *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
3281 desc.base = *rdata;
3282 desc.buflen = mdrcnt;
3283 if (init_package(&desc,1,0)) {
3284 PACKS(&desc,"B41","NULL");
3285 }
3286
3287 succnt = (desc.errcode == NERR_Success ? 1 : 0);
3288
3289 *rdata_len = desc.usedlen;
3290
3291 *rparam_len = 8;
3292 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
3293 SSVALS(*rparam,0,desc.errcode);
3294 SSVAL(*rparam,2,0);
3295 SSVAL(*rparam,4,succnt);
3296 SSVAL(*rparam,6,1);
3297
3298 DEBUG(4,("WPrintDriverEnum: errorcode %d\n",desc.errcode));
3299 return(True);
3300 }
3301
3302 static BOOL api_WPrintQProcEnum(connection_struct *conn,uint16 vuid, char *param,char *data,
3303 int mdrcnt,int mprcnt,
3304 char **rdata,char **rparam,
3305 int *rdata_len,int *rparam_len)
3306 {
3307 char *str1 = param+2;
3308 char *str2 = skip_string(str1,1);
3309 char *p = skip_string(str2,1);
3310 int uLevel;
3311 int succnt;
3312 struct pack_desc desc;
3313
3314 memset((char *)&desc,'\0',sizeof(desc));
3315
3316 uLevel = SVAL(p,0);
3317
3318 DEBUG(3,("WPrintQProcEnum uLevel=%d\n",uLevel));
3319
3320 /* check it's a supported varient */
3321 if (strcmp(str1,"WrLeh") != 0) return False;
3322 if (uLevel != 0 || strcmp(str2,"B13") != 0) return False;
3323
3324 if (mdrcnt > 0) *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
3325 desc.base = *rdata;
3326 desc.buflen = mdrcnt;
3327 desc.format = str2;
3328 if (init_package(&desc,1,0)) {
3329 PACKS(&desc,"B13","lpd");
3330 }
3331
3332 succnt = (desc.errcode == NERR_Success ? 1 : 0);
3333
3334 *rdata_len = desc.usedlen;
3335
3336 *rparam_len = 8;
3337 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
3338 SSVALS(*rparam,0,desc.errcode);
3339 SSVAL(*rparam,2,0);
3340 SSVAL(*rparam,4,succnt);
3341 SSVAL(*rparam,6,1);
3342
3343 DEBUG(4,("WPrintQProcEnum: errorcode %d\n",desc.errcode));
3344 return(True);
3345 }
3346
3347 static BOOL api_WPrintPortEnum(connection_struct *conn,uint16 vuid, char *param,char *data,
3348 int mdrcnt,int mprcnt,
3349 char **rdata,char **rparam,
3350 int *rdata_len,int *rparam_len)
3351 {
3352 char *str1 = param+2;
3353 char *str2 = skip_string(str1,1);
3354 char *p = skip_string(str2,1);
3355 int uLevel;
3356 int succnt;
3357 struct pack_desc desc;
3358
3359 memset((char *)&desc,'\0',sizeof(desc));
3360
3361 uLevel = SVAL(p,0);
3362
3363 DEBUG(3,("WPrintPortEnum uLevel=%d\n",uLevel));
3364
3365 /* check it's a supported varient */
3366 if (strcmp(str1,"WrLeh") != 0) return False;
3367 if (uLevel != 0 || strcmp(str2,"B9") != 0) return False;
3368
3369 if (mdrcnt > 0) *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
3370 memset((char *)&desc,'\0',sizeof(desc));
3371 desc.base = *rdata;
3372 desc.buflen = mdrcnt;
3373 desc.format = str2;
3374 if (init_package(&desc,1,0)) {
3375 PACKS(&desc,"B13","lp0");
3376 }
3377
3378 succnt = (desc.errcode == NERR_Success ? 1 : 0);
3379
3380 *rdata_len = desc.usedlen;
3381
3382 *rparam_len = 8;
3383 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
3384 SSVALS(*rparam,0,desc.errcode);
3385 SSVAL(*rparam,2,0);
3386 SSVAL(*rparam,4,succnt);
3387 SSVAL(*rparam,6,1);
3388
3389 DEBUG(4,("WPrintPortEnum: errorcode %d\n",desc.errcode));
3390 return(True);
3391 }
3392
3393
3394 /****************************************************************************
3395 List open sessions
3396 ****************************************************************************/
3397 static BOOL api_RNetSessionEnum(connection_struct *conn,uint16 vuid, char *param, char *data,
3398 int mdrcnt,int mprcnt,
3399 char **rdata,char **rparam,
3400 int *rdata_len,int *rparam_len)
3401
3402 {
3403 char *str1 = param+2;
3404 char *str2 = skip_string(str1,1);
3405 char *p = skip_string(str2,1);
3406 int uLevel;
3407 struct pack_desc desc;
3408 struct sessionid *session_list;
3409 int i, num_sessions;
3410
3411 memset((char *)&desc,'\0',sizeof(desc));
3412
3413 uLevel = SVAL(p,0);
3414
3415 DEBUG(3,("RNetSessionEnum uLevel=%d\n",uLevel));
3416 DEBUG(7,("RNetSessionEnum req string=%s\n",str1));
3417 DEBUG(7,("RNetSessionEnum ret string=%s\n",str2));
3418
3419 /* check it's a supported varient */
3420 if (strcmp(str1,RAP_NetSessionEnum_REQ) != 0) return False;
3421 if (uLevel != 2 || strcmp(str2,RAP_SESSION_INFO_L2) != 0) return False;
3422
3423 num_sessions = list_sessions(&session_list);
3424
3425 if (mdrcnt > 0) *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
3426 memset((char *)&desc,'\0',sizeof(desc));
3427 desc.base = *rdata;
3428 desc.buflen = mdrcnt;
3429 desc.format = str2;
3430 if (!init_package(&desc,num_sessions,0)) {
3431 return False;
3432 }
3433
3434 for(i=0; i<num_sessions; i++) {
3435 PACKS(&desc, "z", session_list[i].remote_machine);
3436 PACKS(&desc, "z", session_list[i].username);
3437 PACKI(&desc, "W", 1); /* num conns */
3438 PACKI(&desc, "W", 0); /* num opens */
3439 PACKI(&desc, "W", 1); /* num users */
3440 PACKI(&desc, "D", 0); /* session time */
3441 PACKI(&desc, "D", 0); /* idle time */
3442 PACKI(&desc, "D", 0); /* flags */
3443 PACKS(&desc, "z", "Unknown Client"); /* client type string */
3444 }
3445
3446 *rdata_len = desc.usedlen;
3447
3448 *rparam_len = 8;
3449 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
3450 SSVALS(*rparam,0,desc.errcode);
3451 SSVAL(*rparam,2,0); /* converter */
3452 SSVAL(*rparam,4,num_sessions); /* count */
3453
3454 DEBUG(4,("RNetSessionEnum: errorcode %d\n",desc.errcode));
3455 return True;
3456 }
3457
3458
3459 /****************************************************************************
3460 The buffer was too small
3461 ****************************************************************************/
3462
3463 static BOOL api_TooSmall(connection_struct *conn,uint16 vuid, char *param,char *data,
3464 int mdrcnt,int mprcnt,
3465 char **rdata,char **rparam,
3466 int *rdata_len,int *rparam_len)
3467 {
3468 *rparam_len = MIN(*rparam_len,mprcnt);
3469 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
3470
3471 *rdata_len = 0;
3472
3473 SSVAL(*rparam,0,NERR_BufTooSmall);
3474
3475 DEBUG(3,("Supplied buffer too small in API command\n"));
3476
3477 return(True);
3478 }
3479
3480
3481 /****************************************************************************
3482 The request is not supported
3483 ****************************************************************************/
3484
3485 static BOOL api_Unsupported(connection_struct *conn,uint16 vuid, char *param,char *data,
3486 int mdrcnt,int mprcnt,
3487 char **rdata,char **rparam,
3488 int *rdata_len,int *rparam_len)
3489 {
3490 *rparam_len = 4;
3491 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
3492
3493 *rdata_len = 0;
3494
3495 SSVAL(*rparam,0,NERR_notsupported);
3496 SSVAL(*rparam,2,0); /* converter word */
3497
3498 DEBUG(3,("Unsupported API command\n"));
3499
3500 return(True);
3501 }
3502
3503
3504
3505
3506 static const struct
3507 {
3508 const char *name;
3509 int id;
3510 BOOL (*fn)(connection_struct *,uint16,char *,char *,
3511 int,int,char **,char **,int *,int *);
3512 BOOL auth_user; /* Deny anonymous access? */
3513 } api_commands[] = {
3514 {"RNetShareEnum", RAP_WshareEnum, api_RNetShareEnum, True},
3515 {"RNetShareGetInfo", RAP_WshareGetInfo, api_RNetShareGetInfo},
3516 {"RNetShareAdd", RAP_WshareAdd, api_RNetShareAdd},
3517 {"RNetSessionEnum", RAP_WsessionEnum, api_RNetSessionEnum, True},
3518 {"RNetServerGetInfo", RAP_WserverGetInfo, api_RNetServerGetInfo},
3519 {"RNetGroupEnum", RAP_WGroupEnum, api_RNetGroupEnum, True},
3520 {"RNetGroupGetUsers", RAP_WGroupGetUsers, api_RNetGroupGetUsers, True},
3521 {"RNetUserEnum", RAP_WUserEnum, api_RNetUserEnum, True},
3522 {"RNetUserGetInfo", RAP_WUserGetInfo, api_RNetUserGetInfo},
3523 {"NetUserGetGroups", RAP_WUserGetGroups, api_NetUserGetGroups},
3524 {"NetWkstaGetInfo", RAP_WWkstaGetInfo, api_NetWkstaGetInfo},
3525 {"DosPrintQEnum", RAP_WPrintQEnum, api_DosPrintQEnum, True},
3526 {"DosPrintQGetInfo", RAP_WPrintQGetInfo, api_DosPrintQGetInfo},
3527 {"WPrintQueuePause", RAP_WPrintQPause, api_WPrintQueueCtrl},
3528 {"WPrintQueueResume", RAP_WPrintQContinue, api_WPrintQueueCtrl},
3529 {"WPrintJobEnumerate",RAP_WPrintJobEnum, api_WPrintJobEnumerate},
3530 {"WPrintJobGetInfo", RAP_WPrintJobGetInfo, api_WPrintJobGetInfo},
3531 {"RDosPrintJobDel", RAP_WPrintJobDel, api_RDosPrintJobDel},
3532 {"RDosPrintJobPause", RAP_WPrintJobPause, api_RDosPrintJobDel},
3533 {"RDosPrintJobResume",RAP_WPrintJobContinue, api_RDosPrintJobDel},
3534 {"WPrintDestEnum", RAP_WPrintDestEnum, api_WPrintDestEnum},
3535 {"WPrintDestGetInfo", RAP_WPrintDestGetInfo, api_WPrintDestGetInfo},
3536 {"NetRemoteTOD", RAP_NetRemoteTOD, api_NetRemoteTOD},
3537 {"WPrintQueuePurge", RAP_WPrintQPurge, api_WPrintQueueCtrl},
3538 {"NetServerEnum", RAP_NetServerEnum2, api_RNetServerEnum}, /* anon OK */
3539 {"WAccessGetUserPerms",RAP_WAccessGetUserPerms,api_WAccessGetUserPerms},
3540 {"SetUserPassword", RAP_WUserPasswordSet2, api_SetUserPassword},
3541 {"WWkstaUserLogon", RAP_WWkstaUserLogon, api_WWkstaUserLogon},
3542 {"PrintJobInfo", RAP_WPrintJobSetInfo, api_PrintJobInfo},
3543 {"WPrintDriverEnum", RAP_WPrintDriverEnum, api_WPrintDriverEnum},
3544 {"WPrintQProcEnum", RAP_WPrintQProcessorEnum,api_WPrintQProcEnum},
3545 {"WPrintPortEnum", RAP_WPrintPortEnum, api_WPrintPortEnum},
3546 {"SamOEMChangePassword",RAP_SamOEMChgPasswordUser2_P,api_SamOEMChangePassword}, /* anon OK */
3547 {NULL, -1, api_Unsupported}};
3548
3549 /* The following RAP calls are not implemented by Samba:
3550
3551 RAP_WFileEnum2 - anon not OK
3552 */
3553
3554 /****************************************************************************
3555 Handle remote api calls
3556 ****************************************************************************/
3557
3558 int api_reply(connection_struct *conn,uint16 vuid,char *outbuf,char *data,char *params,
3559 int tdscnt,int tpscnt,int mdrcnt,int mprcnt)
3560 {
3561 int api_command;
3562 char *rdata = NULL;
3563 char *rparam = NULL;
3564 int rdata_len = 0;
3565 int rparam_len = 0;
3566 BOOL reply=False;
3567 int i;
3568
3569 if (!params) {
3570 DEBUG(0,("ERROR: NULL params in api_reply()\n"));
3571 return 0;
3572 }
3573
3574 api_command = SVAL(params,0);
3575
3576 DEBUG(3,("Got API command %d of form <%s> <%s> (tdscnt=%d,tpscnt=%d,mdrcnt=%d,mprcnt=%d)\n",
3577 api_command,
3578 params+2,
3579 skip_string(params+2,1),
3580 tdscnt,tpscnt,mdrcnt,mprcnt));
3581
3582 for (i=0;api_commands[i].name;i++) {
3583 if (api_commands[i].id == api_command && api_commands[i].fn) {
3584 DEBUG(3,("Doing %s\n",api_commands[i].name));
3585 break;
3586 }
3587 }
3588
3589 /* Check whether this api call can be done anonymously */
3590
3591 if (api_commands[i].auth_user && lp_restrict_anonymous()) {
3592 user_struct *user = get_valid_user_struct(vuid);
3593
3594 if (!user || user->guest)
3595 return ERROR_NT(NT_STATUS_ACCESS_DENIED);
3596 }
3597
3598 rdata = (char *)SMB_MALLOC(1024);
3599 if (rdata)
3600 memset(rdata,'\0',1024);
3601
3602 rparam = (char *)SMB_MALLOC(1024);
3603 if (rparam)
3604 memset(rparam,'\0',1024);
3605
3606 if(!rdata || !rparam) {
3607 DEBUG(0,("api_reply: malloc fail !\n"));
3608 return -1;
3609 }
3610
3611 reply = api_commands[i].fn(conn,vuid,params,data,mdrcnt,mprcnt,
3612 &rdata,&rparam,&rdata_len,&rparam_len);
3613
3614
3615 if (rdata_len > mdrcnt ||
3616 rparam_len > mprcnt) {
3617 reply = api_TooSmall(conn,vuid,params,data,mdrcnt,mprcnt,
3618 &rdata,&rparam,&rdata_len,&rparam_len);
3619 }
3620
3621 /* if we get False back then it's actually unsupported */
3622 if (!reply)
3623 api_Unsupported(conn,vuid,params,data,mdrcnt,mprcnt,
3624 &rdata,&rparam,&rdata_len,&rparam_len);
3625
3626 send_trans_reply(outbuf, rparam, rparam_len, rdata, rdata_len, False);
3627
3628 SAFE_FREE(rdata);
3629 SAFE_FREE(rparam);
3630
3631 return -1;
3632 }
Samba GIT mirror