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