2
Unix SMB/CIFS implementation.
3
Inter-process communication and named pipe handling
4
Copyright (C) Andrew Tridgell 1992-1998
5
Copyright (C) Jeremy Allison 2007.
8
Copyright (C) John H Terpstra 1995-1998
10
This program is free software; you can redistribute it and/or modify
11
it under the terms of the GNU General Public License as published by
12
the Free Software Foundation; either version 3 of the License, or
13
(at your option) any later version.
15
This program is distributed in the hope that it will be useful,
16
but WITHOUT ANY WARRANTY; without even the implied warranty of
17
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18
GNU General Public License for more details.
20
You should have received a copy of the GNU General Public License
21
along with this program. If not, see <http://www.gnu.org/licenses/>.
24
This file handles the named pipe and mailslot calls
25
in the SMBtrans protocol
29
#include "../lib/util/binsearch.h"
36
#define NERR_Success 0
37
#define NERR_badpass 86
38
#define NERR_notsupported 50
40
#define NERR_BASE (2100)
41
#define NERR_BufTooSmall (NERR_BASE+23)
42
#define NERR_JobNotFound (NERR_BASE+51)
43
#define NERR_DestNotFound (NERR_BASE+52)
45
#define ACCESS_READ 0x01
46
#define ACCESS_WRITE 0x02
47
#define ACCESS_CREATE 0x04
49
#define SHPWLEN 8 /* share password length */
51
/* Limit size of ipc replies */
53
static char *smb_realloc_limit(void *ptr, size_t size)
57
size = MAX((size),4*1024);
58
val = (char *)SMB_REALLOC(ptr,size);
60
memset(val,'\0',size);
65
static bool api_Unsupported(connection_struct *conn, uint16 vuid,
66
char *param, int tpscnt,
67
char *data, int tdscnt,
68
int mdrcnt, int mprcnt,
69
char **rdata, char **rparam,
70
int *rdata_len, int *rparam_len);
72
static bool api_TooSmall(connection_struct *conn, uint16 vuid, char *param, char *data,
73
int mdrcnt, int mprcnt,
74
char **rdata, char **rparam,
75
int *rdata_len, int *rparam_len);
78
static int CopyExpanded(connection_struct *conn,
79
int snum, char **dst, char *src, int *p_space_remaining)
81
TALLOC_CTX *ctx = talloc_tos();
85
if (!src || !dst || !p_space_remaining || !(*dst) ||
86
*p_space_remaining <= 0) {
90
buf = talloc_strdup(ctx, src);
92
*p_space_remaining = 0;
95
buf = talloc_string_sub(ctx, buf,"%S",lp_servicename(snum));
97
*p_space_remaining = 0;
100
buf = talloc_sub_advanced(ctx,
101
lp_servicename(SNUM(conn)),
102
conn->server_info->unix_name,
104
conn->server_info->utok.gid,
105
conn->server_info->sanitized_username,
106
pdb_get_domain(conn->server_info->sam_account),
109
*p_space_remaining = 0;
112
l = push_ascii(*dst,buf,*p_space_remaining, STR_TERMINATE);
117
(*p_space_remaining) -= l;
121
static int CopyAndAdvance(char **dst, char *src, int *n)
124
if (!src || !dst || !n || !(*dst)) {
127
l = push_ascii(*dst,src,*n, STR_TERMINATE);
136
static int StrlenExpanded(connection_struct *conn, int snum, char *s)
138
TALLOC_CTX *ctx = talloc_tos();
143
buf = talloc_strdup(ctx,s);
147
buf = talloc_string_sub(ctx,buf,"%S",lp_servicename(snum));
151
buf = talloc_sub_advanced(ctx,
152
lp_servicename(SNUM(conn)),
153
conn->server_info->unix_name,
155
conn->server_info->utok.gid,
156
conn->server_info->sanitized_username,
157
pdb_get_domain(conn->server_info->sam_account),
162
return strlen(buf) + 1;
165
static char *Expand(connection_struct *conn, int snum, char *s)
167
TALLOC_CTX *ctx = talloc_tos();
173
buf = talloc_strdup(ctx,s);
177
buf = talloc_string_sub(ctx,buf,"%S",lp_servicename(snum));
181
return talloc_sub_advanced(ctx,
182
lp_servicename(SNUM(conn)),
183
conn->server_info->unix_name,
185
conn->server_info->utok.gid,
186
conn->server_info->sanitized_username,
187
pdb_get_domain(conn->server_info->sam_account),
191
/*******************************************************************
192
Check a API string for validity when we only need to check the prefix.
193
******************************************************************/
195
static bool prefix_ok(const char *str, const char *prefix)
197
return(strncmp(str,prefix,strlen(prefix)) == 0);
201
const char *format; /* formatstring for structure */
202
const char *subformat; /* subformat for structure */
203
char *base; /* baseaddress of buffer */
204
int buflen; /* remaining size for fixed part; on init: length of base */
205
int subcount; /* count of substructures */
206
char *structbuf; /* pointer into buffer for remaining fixed part */
207
int stringlen; /* remaining size for variable part */
208
char *stringbuf; /* pointer into buffer for remaining variable part */
209
int neededlen; /* total needed size */
210
int usedlen; /* total used size (usedlen <= neededlen and usedlen <= buflen) */
211
const char *curpos; /* current position; pointer into format or subformat */
215
static int get_counter(const char **p)
221
if (!isdigit((int)**p)) {
227
n = 10 * n + (i - '0');
235
static int getlen(const char *p)
244
case 'W': /* word (2 byte) */
247
case 'K': /* status word? (2 byte) */
250
case 'N': /* count of substructures (word) at end */
253
case 'D': /* double word (4 byte) */
254
case 'z': /* offset to zero terminated string (4 byte) */
255
case 'l': /* offset to user data (4 byte) */
258
case 'b': /* offset to data (with counter) (4 byte) */
262
case 'B': /* byte (with optional counter) */
263
n += get_counter(&p);
270
static bool init_package(struct pack_desc *p, int count, int subcount)
275
if (!p->format || !p->base) {
279
i = count * getlen(p->format);
281
i += subcount * getlen(p->subformat);
283
p->structbuf = p->base;
287
p->curpos = p->format;
293
* This is the old error code we used. Aparently
294
* WinNT/2k systems return ERRbuftoosmall (2123) and
295
* OS/2 needs this. I'm leaving this here so we can revert
298
p->errcode = ERRmoredata;
300
p->errcode = ERRbuftoosmall;
303
p->errcode = NERR_Success;
307
p->stringbuf = p->base + i;
309
return (p->errcode == NERR_Success);
312
static int package(struct pack_desc *p, ...)
315
int needed=0, stringneeded;
316
const char *str=NULL;
317
int is_string=0, stringused;
324
p->curpos = p->format;
326
p->curpos = p->subformat;
331
str = va_arg(args,char*);
332
SMB_ASSERT(strncmp(str,p->curpos,strlen(str)) == 0);
341
switch( *p->curpos++ ) {
342
case 'W': /* word (2 byte) */
344
temp = va_arg(args,int);
345
if (p->buflen >= needed) {
346
SSVAL(p->structbuf,0,temp);
349
case 'K': /* status word? (2 byte) */
351
temp = va_arg(args,int);
352
if (p->buflen >= needed) {
353
SSVAL(p->structbuf,0,temp);
356
case 'N': /* count of substructures (word) at end */
358
p->subcount = va_arg(args,int);
359
if (p->buflen >= needed) {
360
SSVAL(p->structbuf,0,p->subcount);
363
case 'D': /* double word (4 byte) */
365
temp = va_arg(args,int);
366
if (p->buflen >= needed) {
367
SIVAL(p->structbuf,0,temp);
370
case 'B': /* byte (with optional counter) */
371
needed = get_counter(&p->curpos);
373
char *s = va_arg(args,char*);
374
if (p->buflen >= needed) {
375
StrnCpy(p->structbuf,s?s:"",needed-1);
379
case 'z': /* offset to zero terminated string (4 byte) */
380
str = va_arg(args,char*);
381
stringneeded = (str ? strlen(str)+1 : 0);
384
case 'l': /* offset to user data (4 byte) */
385
str = va_arg(args,char*);
386
stringneeded = va_arg(args,int);
389
case 'b': /* offset to data (with counter) (4 byte) */
390
str = va_arg(args,char*);
391
stringneeded = get_counter(&p->curpos);
397
if (stringneeded >= 0) {
399
if (p->buflen >= needed) {
400
stringused = stringneeded;
401
if (stringused > p->stringlen) {
402
stringused = (is_string ? p->stringlen : 0);
403
if (p->errcode == NERR_Success) {
404
p->errcode = ERRmoredata;
408
SIVAL(p->structbuf,0,0);
410
SIVAL(p->structbuf,0,PTR_DIFF(p->stringbuf,p->base));
411
memcpy(p->stringbuf,str?str:"",stringused);
413
p->stringbuf[stringused-1] = '\0';
415
p->stringbuf += stringused;
416
p->stringlen -= stringused;
417
p->usedlen += stringused;
420
p->neededlen += stringneeded;
423
p->neededlen += needed;
424
if (p->buflen >= needed) {
425
p->structbuf += needed;
427
p->usedlen += needed;
429
if (p->errcode == NERR_Success) {
430
p->errcode = ERRmoredata;
437
#define PACK(desc,t,v) package(desc,t,v,0,0,0,0)
438
#define PACKl(desc,t,v,l) package(desc,t,v,l,0,0,0,0)
440
#define PACK(desc,t,v) package(desc,v)
441
#define PACKl(desc,t,v,l) package(desc,v,l)
444
static void PACKI(struct pack_desc* desc, const char *t,int v)
449
static void PACKS(struct pack_desc* desc,const char *t,const char *v)
454
/****************************************************************************
456
****************************************************************************/
458
static void PackDriverData(struct pack_desc* desc)
460
char drivdata[4+4+32];
461
SIVAL(drivdata,0,sizeof drivdata); /* cb */
462
SIVAL(drivdata,4,1000); /* lVersion */
463
memset(drivdata+8,0,32); /* szDeviceName */
464
push_ascii(drivdata+8,"NULL",32, STR_TERMINATE);
465
PACKl(desc,"l",drivdata,sizeof drivdata); /* pDriverData */
468
static int check_printq_info(struct pack_desc* desc,
469
unsigned int uLevel, char *id1, char *id2)
471
desc->subformat = NULL;
474
desc->format = "B13";
477
desc->format = "B13BWWWzzzzzWW";
480
desc->format = "B13BWWWzzzzzWN";
481
desc->subformat = "WB21BB16B10zWWzDDz";
484
desc->format = "zWWWWzzzzWWzzl";
487
desc->format = "zWWWWzzzzWNzzl";
488
desc->subformat = "WWzWWDDzz";
497
desc->format = "WzzzzzzzzN";
498
desc->subformat = "z";
501
DEBUG(0,("check_printq_info: invalid level %d\n",
505
if (id1 == NULL || strcmp(desc->format,id1) != 0) {
506
DEBUG(0,("check_printq_info: invalid format %s\n",
507
id1 ? id1 : "<NULL>" ));
510
if (desc->subformat && (id2 == NULL || strcmp(desc->subformat,id2) != 0)) {
511
DEBUG(0,("check_printq_info: invalid subformat %s\n",
512
id2 ? id2 : "<NULL>" ));
519
#define RAP_JOB_STATUS_QUEUED 0
520
#define RAP_JOB_STATUS_PAUSED 1
521
#define RAP_JOB_STATUS_SPOOLING 2
522
#define RAP_JOB_STATUS_PRINTING 3
523
#define RAP_JOB_STATUS_PRINTED 4
525
#define RAP_QUEUE_STATUS_PAUSED 1
526
#define RAP_QUEUE_STATUS_ERROR 2
528
/* turn a print job status into a on the wire status
530
static int printj_status(int v)
534
return RAP_JOB_STATUS_QUEUED;
536
return RAP_JOB_STATUS_PAUSED;
538
return RAP_JOB_STATUS_SPOOLING;
540
return RAP_JOB_STATUS_PRINTING;
545
/* turn a print queue status into a on the wire status
547
static int printq_status(int v)
553
return RAP_QUEUE_STATUS_PAUSED;
555
return RAP_QUEUE_STATUS_ERROR;
558
static void fill_printjob_info(connection_struct *conn, int snum, int uLevel,
559
struct pack_desc *desc,
560
print_queue_struct *queue, int n)
562
time_t t = queue->time;
564
/* the client expects localtime */
565
t -= get_time_zone(t);
567
PACKI(desc,"W",pjobid_to_rap(lp_const_servicename(snum),queue->job)); /* uJobId */
569
PACKS(desc,"B21",queue->fs_user); /* szUserName */
570
PACKS(desc,"B",""); /* pad */
571
PACKS(desc,"B16",""); /* szNotifyName */
572
PACKS(desc,"B10","PM_Q_RAW"); /* szDataType */
573
PACKS(desc,"z",""); /* pszParms */
574
PACKI(desc,"W",n+1); /* uPosition */
575
PACKI(desc,"W",printj_status(queue->status)); /* fsStatus */
576
PACKS(desc,"z",""); /* pszStatus */
577
PACKI(desc,"D",t); /* ulSubmitted */
578
PACKI(desc,"D",queue->size); /* ulSize */
579
PACKS(desc,"z",queue->fs_file); /* pszComment */
581
if (uLevel == 2 || uLevel == 3 || uLevel == 4) {
582
PACKI(desc,"W",queue->priority); /* uPriority */
583
PACKS(desc,"z",queue->fs_user); /* pszUserName */
584
PACKI(desc,"W",n+1); /* uPosition */
585
PACKI(desc,"W",printj_status(queue->status)); /* fsStatus */
586
PACKI(desc,"D",t); /* ulSubmitted */
587
PACKI(desc,"D",queue->size); /* ulSize */
588
PACKS(desc,"z","Samba"); /* pszComment */
589
PACKS(desc,"z",queue->fs_file); /* pszDocument */
591
PACKS(desc,"z",""); /* pszNotifyName */
592
PACKS(desc,"z","PM_Q_RAW"); /* pszDataType */
593
PACKS(desc,"z",""); /* pszParms */
594
PACKS(desc,"z",""); /* pszStatus */
595
PACKS(desc,"z",SERVICE(snum)); /* pszQueue */
596
PACKS(desc,"z","lpd"); /* pszQProcName */
597
PACKS(desc,"z",""); /* pszQProcParms */
598
PACKS(desc,"z","NULL"); /* pszDriverName */
599
PackDriverData(desc); /* pDriverData */
600
PACKS(desc,"z",""); /* pszPrinterName */
601
} else if (uLevel == 4) { /* OS2 */
602
PACKS(desc,"z",""); /* pszSpoolFileName */
603
PACKS(desc,"z",""); /* pszPortName */
604
PACKS(desc,"z",""); /* pszStatus */
605
PACKI(desc,"D",0); /* ulPagesSpooled */
606
PACKI(desc,"D",0); /* ulPagesSent */
607
PACKI(desc,"D",0); /* ulPagesPrinted */
608
PACKI(desc,"D",0); /* ulTimePrinted */
609
PACKI(desc,"D",0); /* ulExtendJobStatus */
610
PACKI(desc,"D",0); /* ulStartPage */
611
PACKI(desc,"D",0); /* ulEndPage */
616
/********************************************************************
617
Return a driver name given an snum.
618
Returns True if from tdb, False otherwise.
619
********************************************************************/
621
static bool get_driver_name(int snum, char **pp_drivername)
623
NT_PRINTER_INFO_LEVEL *info = NULL;
626
get_a_printer (NULL, &info, 2, lp_servicename(snum));
628
*pp_drivername = talloc_strdup(talloc_tos(),
629
info->info_2->drivername);
631
free_a_printer(&info, 2);
632
if (!*pp_drivername) {
640
/********************************************************************
641
Respond to the DosPrintQInfo command with a level of 52
642
This is used to get printer driver information for Win9x clients
643
********************************************************************/
644
static void fill_printq_info_52(connection_struct *conn, int snum,
645
struct pack_desc* desc, int count )
649
NT_PRINTER_DRIVER_INFO_LEVEL driver;
650
NT_PRINTER_INFO_LEVEL *printer = NULL;
654
if ( !W_ERROR_IS_OK(get_a_printer( NULL, &printer, 2, lp_servicename(snum))) ) {
655
DEBUG(3,("fill_printq_info_52: Failed to lookup printer [%s]\n",
656
lp_servicename(snum)));
660
if ( !W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername,
663
DEBUG(3,("fill_printq_info_52: Failed to lookup driver [%s]\n",
664
printer->info_2->drivername));
668
trim_string(driver.info_3->driverpath, "\\print$\\WIN40\\0\\", 0);
669
trim_string(driver.info_3->datafile, "\\print$\\WIN40\\0\\", 0);
670
trim_string(driver.info_3->helpfile, "\\print$\\WIN40\\0\\", 0);
672
PACKI(desc, "W", 0x0400); /* don't know */
673
PACKS(desc, "z", driver.info_3->name); /* long printer name */
674
PACKS(desc, "z", driver.info_3->driverpath); /* Driverfile Name */
675
PACKS(desc, "z", driver.info_3->datafile); /* Datafile name */
676
PACKS(desc, "z", driver.info_3->monitorname); /* language monitor */
678
fstrcpy(location, "\\\\%L\\print$\\WIN40\\0");
679
standard_sub_basic( "", "", location, sizeof(location)-1 );
680
PACKS(desc,"z", location); /* share to retrieve files */
682
PACKS(desc,"z", driver.info_3->defaultdatatype); /* default data type */
683
PACKS(desc,"z", driver.info_3->helpfile); /* helpfile name */
684
PACKS(desc,"z", driver.info_3->driverpath); /* driver name */
686
DEBUG(3,("Printer Driver Name: %s:\n",driver.info_3->name));
687
DEBUG(3,("Driver: %s:\n",driver.info_3->driverpath));
688
DEBUG(3,("Data File: %s:\n",driver.info_3->datafile));
689
DEBUG(3,("Language Monitor: %s:\n",driver.info_3->monitorname));
690
DEBUG(3,("Driver Location: %s:\n",location));
691
DEBUG(3,("Data Type: %s:\n",driver.info_3->defaultdatatype));
692
DEBUG(3,("Help File: %s:\n",driver.info_3->helpfile));
693
PACKI(desc,"N",count); /* number of files to copy */
695
for ( i=0; i<count && driver.info_3->dependentfiles && *driver.info_3->dependentfiles[i]; i++)
697
trim_string(driver.info_3->dependentfiles[i], "\\print$\\WIN40\\0\\", 0);
698
PACKS(desc,"z",driver.info_3->dependentfiles[i]); /* driver files to copy */
699
DEBUG(3,("Dependent File: %s:\n",driver.info_3->dependentfiles[i]));
704
DEBUG(3,("fill_printq_info_52: file count specified by client [%d] != number of dependent files [%i]\n",
707
DEBUG(3,("fill_printq_info on <%s> gave %d entries\n", SERVICE(snum),i));
709
desc->errcode=NERR_Success;
713
DEBUG(3,("fill_printq_info: Can't supply driver files\n"));
714
desc->errcode=NERR_notsupported;
718
free_a_printer( &printer, 2 );
721
free_a_printer_driver( driver, 3 );
725
static void fill_printq_info(connection_struct *conn, int snum, int uLevel,
726
struct pack_desc* desc,
727
int count, print_queue_struct* queue,
728
print_status_struct* status)
733
PACKS(desc,"B13",SERVICE(snum));
738
PACKS(desc,"z",Expand(conn,snum,SERVICE(snum)));
741
PACKI(desc,"K",printq_status(status->status));
745
if (uLevel == 1 || uLevel == 2) {
746
PACKS(desc,"B",""); /* alignment */
747
PACKI(desc,"W",5); /* priority */
748
PACKI(desc,"W",0); /* start time */
749
PACKI(desc,"W",0); /* until time */
750
PACKS(desc,"z",""); /* pSepFile */
751
PACKS(desc,"z","lpd"); /* pPrProc */
752
PACKS(desc,"z",SERVICE(snum)); /* pDestinations */
753
PACKS(desc,"z",""); /* pParms */
755
PACKS(desc,"z","UNKNOWN PRINTER");
756
PACKI(desc,"W",LPSTAT_ERROR);
758
else if (!status || !status->message[0]) {
759
PACKS(desc,"z",Expand(conn,snum,lp_comment(snum)));
760
PACKI(desc,"W",LPSTAT_OK); /* status */
762
PACKS(desc,"z",status->message);
763
PACKI(desc,"W",printq_status(status->status)); /* status */
765
PACKI(desc,(uLevel == 1 ? "W" : "N"),count);
768
if (uLevel == 3 || uLevel == 4) {
769
char *drivername = NULL;
771
PACKI(desc,"W",5); /* uPriority */
772
PACKI(desc,"W",0); /* uStarttime */
773
PACKI(desc,"W",0); /* uUntiltime */
774
PACKI(desc,"W",5); /* pad1 */
775
PACKS(desc,"z",""); /* pszSepFile */
776
PACKS(desc,"z","WinPrint"); /* pszPrProc */
777
PACKS(desc,"z",NULL); /* pszParms */
778
PACKS(desc,"z",NULL); /* pszComment - don't ask.... JRA */
779
/* "don't ask" that it's done this way to fix corrupted
780
Win9X/ME printer comments. */
782
PACKI(desc,"W",LPSTAT_OK); /* fsStatus */
784
PACKI(desc,"W",printq_status(status->status)); /* fsStatus */
786
PACKI(desc,(uLevel == 3 ? "W" : "N"),count); /* cJobs */
787
PACKS(desc,"z",SERVICE(snum)); /* pszPrinters */
788
get_driver_name(snum,&drivername);
792
PACKS(desc,"z",drivername); /* pszDriverName */
793
PackDriverData(desc); /* pDriverData */
796
if (uLevel == 2 || uLevel == 4) {
798
for (i=0;i<count;i++)
799
fill_printjob_info(conn,snum,uLevel == 2 ? 1 : 2,desc,&queue[i],i);
803
fill_printq_info_52( conn, snum, desc, count );
806
/* This function returns the number of files for a given driver */
807
static int get_printerdrivernumber(int snum)
810
NT_PRINTER_DRIVER_INFO_LEVEL driver;
811
NT_PRINTER_INFO_LEVEL *printer = NULL;
815
if ( !W_ERROR_IS_OK(get_a_printer( NULL, &printer, 2, lp_servicename(snum))) ) {
816
DEBUG(3,("get_printerdrivernumber: Failed to lookup printer [%s]\n",
817
lp_servicename(snum)));
821
if ( !W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername,
824
DEBUG(3,("get_printerdrivernumber: Failed to lookup driver [%s]\n",
825
printer->info_2->drivername));
829
/* count the number of files */
830
while ( driver.info_3->dependentfiles && *driver.info_3->dependentfiles[result] )
835
free_a_printer( &printer, 2 );
838
free_a_printer_driver( driver, 3 );
843
static bool api_DosPrintQGetInfo(connection_struct *conn, uint16 vuid,
844
char *param, int tpscnt,
845
char *data, int tdscnt,
846
int mdrcnt,int mprcnt,
847
char **rdata,char **rparam,
848
int *rdata_len,int *rparam_len)
850
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
851
char *str2 = skip_string(param,tpscnt,str1);
852
char *p = skip_string(param,tpscnt,str2);
858
struct pack_desc desc;
859
print_queue_struct *queue=NULL;
860
print_status_struct status;
863
if (!str1 || !str2 || !p) {
866
memset((char *)&status,'\0',sizeof(status));
867
memset((char *)&desc,'\0',sizeof(desc));
869
p = skip_string(param,tpscnt,p);
873
uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
874
str3 = get_safe_str_ptr(param,tpscnt,p,4);
875
/* str3 may be null here and is checked in check_printq_info(). */
877
/* remove any trailing username */
878
if ((p = strchr_m(QueueName,'%')))
881
DEBUG(3,("api_DosPrintQGetInfo uLevel=%d name=%s\n",uLevel,QueueName));
883
/* check it's a supported varient */
884
if (!prefix_ok(str1,"zWrLh"))
886
if (!check_printq_info(&desc,uLevel,str2,str3)) {
888
* Patch from Scott Moomaw <scott@bridgewater.edu>
889
* to return the 'invalid info level' error if an
890
* unknown level was requested.
894
*rparam = smb_realloc_limit(*rparam,*rparam_len);
898
SSVALS(*rparam,0,ERRunknownlevel);
904
snum = find_service(QueueName);
905
if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) )
909
count = get_printerdrivernumber(snum);
910
DEBUG(3,("api_DosPrintQGetInfo: Driver files count: %d\n",count));
912
count = print_queue_status(snum, &queue,&status);
916
*rdata = smb_realloc_limit(*rdata,mdrcnt);
922
desc.buflen = mdrcnt;
925
* Don't return data but need to get correct length
926
* init_package will return wrong size if buflen=0
928
desc.buflen = getlen(desc.format);
929
desc.base = tmpdata = (char *) SMB_MALLOC (desc.buflen);
932
if (init_package(&desc,1,count)) {
933
desc.subcount = count;
934
fill_printq_info(conn,snum,uLevel,&desc,count,queue,&status);
937
*rdata_len = desc.usedlen;
940
* We must set the return code to ERRbuftoosmall
941
* in order to support lanman style printing with Win NT/2k
944
if (!mdrcnt && lp_disable_spoolss())
945
desc.errcode = ERRbuftoosmall;
947
*rdata_len = desc.usedlen;
949
*rparam = smb_realloc_limit(*rparam,*rparam_len);
955
SSVALS(*rparam,0,desc.errcode);
957
SSVAL(*rparam,4,desc.neededlen);
959
DEBUG(4,("printqgetinfo: errorcode %d\n",desc.errcode));
967
/****************************************************************************
968
View list of all print jobs on all queues.
969
****************************************************************************/
971
static bool api_DosPrintQEnum(connection_struct *conn, uint16 vuid,
972
char *param, int tpscnt,
973
char *data, int tdscnt,
974
int mdrcnt, int mprcnt,
975
char **rdata, char** rparam,
976
int *rdata_len, int *rparam_len)
978
char *param_format = get_safe_str_ptr(param,tpscnt,param,2);
979
char *output_format1 = skip_string(param,tpscnt,param_format);
980
char *p = skip_string(param,tpscnt,output_format1);
981
unsigned int uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
982
char *output_format2 = get_safe_str_ptr(param,tpscnt,p,4);
983
int services = lp_numservices();
985
struct pack_desc desc;
986
print_queue_struct **queue = NULL;
987
print_status_struct *status = NULL;
988
int *subcntarr = NULL;
989
int queuecnt = 0, subcnt = 0, succnt = 0;
991
if (!param_format || !output_format1 || !p) {
995
memset((char *)&desc,'\0',sizeof(desc));
997
DEBUG(3,("DosPrintQEnum uLevel=%d\n",uLevel));
999
if (!prefix_ok(param_format,"WrLeh")) {
1002
if (!check_printq_info(&desc,uLevel,output_format1,output_format2)) {
1004
* Patch from Scott Moomaw <scott@bridgewater.edu>
1005
* to return the 'invalid info level' error if an
1006
* unknown level was requested.
1010
*rparam = smb_realloc_limit(*rparam,*rparam_len);
1014
SSVALS(*rparam,0,ERRunknownlevel);
1020
for (i = 0; i < services; i++) {
1021
if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
1026
if((queue = SMB_MALLOC_ARRAY(print_queue_struct*, queuecnt)) == NULL) {
1027
DEBUG(0,("api_DosPrintQEnum: malloc fail !\n"));
1030
memset(queue,0,queuecnt*sizeof(print_queue_struct*));
1031
if((status = SMB_MALLOC_ARRAY(print_status_struct,queuecnt)) == NULL) {
1032
DEBUG(0,("api_DosPrintQEnum: malloc fail !\n"));
1035
memset(status,0,queuecnt*sizeof(print_status_struct));
1036
if((subcntarr = SMB_MALLOC_ARRAY(int,queuecnt)) == NULL) {
1037
DEBUG(0,("api_DosPrintQEnum: malloc fail !\n"));
1043
for (i = 0; i < services; i++) {
1044
if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
1045
subcntarr[n] = print_queue_status(i, &queue[n],&status[n]);
1046
subcnt += subcntarr[n];
1052
*rdata = smb_realloc_limit(*rdata,mdrcnt);
1058
desc.buflen = mdrcnt;
1060
if (init_package(&desc,queuecnt,subcnt)) {
1063
for (i = 0; i < services; i++) {
1064
if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
1065
fill_printq_info(conn,i,uLevel,&desc,subcntarr[n],queue[n],&status[n]);
1067
if (desc.errcode == NERR_Success) {
1074
SAFE_FREE(subcntarr);
1076
*rdata_len = desc.usedlen;
1078
*rparam = smb_realloc_limit(*rparam,*rparam_len);
1082
SSVALS(*rparam,0,desc.errcode);
1084
SSVAL(*rparam,4,succnt);
1085
SSVAL(*rparam,6,queuecnt);
1087
for (i = 0; i < queuecnt; i++) {
1089
SAFE_FREE(queue[i]);
1100
SAFE_FREE(subcntarr);
1101
for (i = 0; i < queuecnt; i++) {
1103
SAFE_FREE(queue[i]);
1112
/****************************************************************************
1113
Get info level for a server list query.
1114
****************************************************************************/
1116
static bool check_server_info(int uLevel, char* id)
1120
if (strcmp(id,"B16") != 0) {
1125
if (strcmp(id,"B16BBDz") != 0) {
1135
struct srv_info_struct {
1143
/*******************************************************************
1144
Get server info lists from the files saved by nmbd. Return the
1146
******************************************************************/
1148
static int get_server_info(uint32 servertype,
1149
struct srv_info_struct **servers,
1155
bool local_list_only;
1158
lines = file_lines_load(cache_path(SERVER_LIST), NULL, 0, NULL);
1160
DEBUG(4,("Can't open %s - %s\n",cache_path(SERVER_LIST),strerror(errno)));
1164
/* request for everything is code for request all servers */
1165
if (servertype == SV_TYPE_ALL) {
1166
servertype &= ~(SV_TYPE_DOMAIN_ENUM|SV_TYPE_LOCAL_LIST_ONLY);
1169
local_list_only = (servertype & SV_TYPE_LOCAL_LIST_ONLY);
1171
DEBUG(4,("Servertype search: %8x\n",servertype));
1173
for (i=0;lines[i];i++) {
1175
struct srv_info_struct *s;
1176
const char *ptr = lines[i];
1178
TALLOC_CTX *frame = NULL;
1185
if (count == alloced) {
1187
*servers = SMB_REALLOC_ARRAY(*servers,struct srv_info_struct, alloced);
1189
DEBUG(0,("get_server_info: failed to enlarge servers info struct!\n"));
1193
memset((char *)((*servers)+count),'\0',sizeof(**servers)*(alloced-count));
1195
s = &(*servers)[count];
1197
frame = talloc_stackframe();
1199
if (!next_token_talloc(frame,&ptr,&p, NULL)) {
1203
fstrcpy(s->name, p);
1206
if (!next_token_talloc(frame,&ptr, &p, NULL)) {
1212
s->comment[0] = '\0';
1213
if (!next_token_talloc(frame,&ptr, &p, NULL)) {
1217
fstrcpy(s->comment, p);
1218
string_truncate(s->comment, MAX_SERVER_STRING_LENGTH);
1220
s->domain[0] = '\0';
1221
if (!next_token_talloc(frame,&ptr,&p, NULL)) {
1222
/* this allows us to cope with an old nmbd */
1223
fstrcpy(s->domain,lp_workgroup());
1225
fstrcpy(s->domain, p);
1229
if (sscanf(stype,"%X",&s->type) != 1) {
1230
DEBUG(4,("r:host file "));
1234
/* Filter the servers/domains we return based on what was asked for. */
1236
/* Check to see if we are being asked for a local list only. */
1237
if(local_list_only && ((s->type & SV_TYPE_LOCAL_LIST_ONLY) == 0)) {
1238
DEBUG(4,("r: local list only"));
1242
/* doesn't match up: don't want it */
1243
if (!(servertype & s->type)) {
1244
DEBUG(4,("r:serv type "));
1248
if ((servertype & SV_TYPE_DOMAIN_ENUM) !=
1249
(s->type & SV_TYPE_DOMAIN_ENUM)) {
1250
DEBUG(4,("s: dom mismatch "));
1254
if (!strequal(domain, s->domain) && !(servertype & SV_TYPE_DOMAIN_ENUM)) {
1258
/* We should never return a server type with a SV_TYPE_LOCAL_LIST_ONLY set. */
1259
s->type &= ~SV_TYPE_LOCAL_LIST_ONLY;
1262
DEBUG(4,("**SV** %20s %8x %25s %15s\n",
1263
s->name, s->type, s->comment, s->domain));
1264
s->server_added = True;
1267
DEBUG(4,("%20s %8x %25s %15s\n",
1268
s->name, s->type, s->comment, s->domain));
1276
/*******************************************************************
1277
Fill in a server info structure.
1278
******************************************************************/
1280
static int fill_srv_info(struct srv_info_struct *service,
1281
int uLevel, char **buf, int *buflen,
1282
char **stringbuf, int *stringspace, char *baseaddr)
1305
len = strlen(service->comment)+1;
1309
*buflen = struct_len;
1311
return struct_len + len;
1316
if (*buflen < struct_len) {
1323
p2 = p + struct_len;
1324
l2 = *buflen - struct_len;
1332
push_ascii(p,service->name, MAX_NETBIOSNAME_LEN, STR_TERMINATE);
1336
push_ascii(p,service->name,MAX_NETBIOSNAME_LEN, STR_TERMINATE);
1337
SIVAL(p,18,service->type);
1338
SIVAL(p,22,PTR_DIFF(p2,baseaddr));
1339
len += CopyAndAdvance(&p2,service->comment,&l2);
1344
*buf = p + struct_len;
1345
*buflen -= struct_len;
1356
static int srv_comp(struct srv_info_struct *s1,struct srv_info_struct *s2)
1358
return StrCaseCmp(s1->name,s2->name);
1361
/****************************************************************************
1362
View list of servers available (or possibly domains). The info is
1363
extracted from lists saved by nmbd on the local host.
1364
****************************************************************************/
1366
static bool api_RNetServerEnum2(connection_struct *conn, uint16 vuid,
1367
char *param, int tpscnt,
1368
char *data, int tdscnt,
1369
int mdrcnt, int mprcnt, char **rdata,
1370
char **rparam, int *rdata_len, int *rparam_len)
1372
char *str1 = get_safe_str_ptr(param, tpscnt, param, 2);
1373
char *str2 = skip_string(param,tpscnt,str1);
1374
char *p = skip_string(param,tpscnt,str2);
1375
int uLevel = get_safe_SVAL(param, tpscnt, p, 0, -1);
1376
int buf_len = get_safe_SVAL(param,tpscnt, p, 2, 0);
1377
uint32 servertype = get_safe_IVAL(param,tpscnt,p,4, 0);
1379
int data_len, fixed_len, string_len;
1380
int f_len = 0, s_len = 0;
1381
struct srv_info_struct *servers=NULL;
1382
int counted=0,total=0;
1385
bool domain_request;
1388
if (!str1 || !str2 || !p) {
1392
/* If someone sets all the bits they don't really mean to set
1393
DOMAIN_ENUM and LOCAL_LIST_ONLY, they just want all the
1396
if (servertype == SV_TYPE_ALL) {
1397
servertype &= ~(SV_TYPE_DOMAIN_ENUM|SV_TYPE_LOCAL_LIST_ONLY);
1400
/* If someone sets SV_TYPE_LOCAL_LIST_ONLY but hasn't set
1401
any other bit (they may just set this bit on its own) they
1402
want all the locally seen servers. However this bit can be
1403
set on its own so set the requested servers to be
1404
ALL - DOMAIN_ENUM. */
1406
if ((servertype & SV_TYPE_LOCAL_LIST_ONLY) && !(servertype & SV_TYPE_DOMAIN_ENUM)) {
1407
servertype = SV_TYPE_ALL & ~(SV_TYPE_DOMAIN_ENUM);
1410
domain_request = ((servertype & SV_TYPE_DOMAIN_ENUM) != 0);
1411
local_request = ((servertype & SV_TYPE_LOCAL_LIST_ONLY) != 0);
1415
if (!prefix_ok(str1,"WrLehD")) {
1418
if (!check_server_info(uLevel,str2)) {
1422
DEBUG(4, ("server request level: %s %8x ", str2, servertype));
1423
DEBUG(4, ("domains_req:%s ", BOOLSTR(domain_request)));
1424
DEBUG(4, ("local_only:%s\n", BOOLSTR(local_request)));
1426
if (strcmp(str1, "WrLehDz") == 0) {
1427
if (skip_string(param,tpscnt,p) == NULL) {
1430
pull_ascii_fstring(domain, p);
1432
fstrcpy(domain, lp_workgroup());
1435
DEBUG(4, ("domain [%s]\n", domain));
1437
if (lp_browse_list()) {
1438
total = get_server_info(servertype,&servers,domain);
1441
data_len = fixed_len = string_len = 0;
1445
qsort(servers,total,sizeof(servers[0]),QSORT_CAST srv_comp);
1449
char *lastname=NULL;
1451
for (i=0;i<total;i++) {
1452
struct srv_info_struct *s = &servers[i];
1454
if (lastname && strequal(lastname,s->name)) {
1458
data_len += fill_srv_info(s,uLevel,0,&f_len,0,&s_len,0);
1459
DEBUG(4,("fill_srv_info[%d] %20s %8x %25s %15s\n",
1460
i, s->name, s->type, s->comment, s->domain));
1462
if (data_len < buf_len) {
1465
string_len += s_len;
1472
*rdata_len = fixed_len + string_len;
1473
*rdata = smb_realloc_limit(*rdata,*rdata_len);
1478
p2 = (*rdata) + fixed_len; /* auxilliary data (strings) will go here */
1484
char *lastname=NULL;
1485
int count2 = counted;
1487
for (i = 0; i < total && count2;i++) {
1488
struct srv_info_struct *s = &servers[i];
1490
if (lastname && strequal(lastname,s->name)) {
1494
fill_srv_info(s,uLevel,&p,&f_len,&p2,&s_len,*rdata);
1495
DEBUG(4,("fill_srv_info[%d] %20s %8x %25s %15s\n",
1496
i, s->name, s->type, s->comment, s->domain));
1502
*rparam = smb_realloc_limit(*rparam,*rparam_len);
1506
SSVAL(*rparam,0,(missed == 0 ? NERR_Success : ERRmoredata));
1508
SSVAL(*rparam,4,counted);
1509
SSVAL(*rparam,6,counted+missed);
1513
DEBUG(3,("NetServerEnum2 domain = %s uLevel=%d counted=%d total=%d\n",
1514
domain,uLevel,counted,counted+missed));
1519
static int srv_name_match(const char *n1, const char *n2)
1522
* [MS-RAP] footnote <88> for Section 3.2.5.15 says:
1524
* In Windows, FirstNameToReturn need not be an exact match:
1525
* the server will return a list of servers that exist on
1526
* the network greater than or equal to the FirstNameToReturn.
1528
int ret = StrCaseCmp(n1, n2);
1537
static bool api_RNetServerEnum3(connection_struct *conn, uint16 vuid,
1538
char *param, int tpscnt,
1539
char *data, int tdscnt,
1540
int mdrcnt, int mprcnt, char **rdata,
1541
char **rparam, int *rdata_len, int *rparam_len)
1543
char *str1 = get_safe_str_ptr(param, tpscnt, param, 2);
1544
char *str2 = skip_string(param,tpscnt,str1);
1545
char *p = skip_string(param,tpscnt,str2);
1546
int uLevel = get_safe_SVAL(param, tpscnt, p, 0, -1);
1547
int buf_len = get_safe_SVAL(param,tpscnt, p, 2, 0);
1548
uint32 servertype = get_safe_IVAL(param,tpscnt,p,4, 0);
1550
int data_len, fixed_len, string_len;
1551
int f_len = 0, s_len = 0;
1552
struct srv_info_struct *servers=NULL;
1553
int counted=0,first=0,total=0;
1557
bool domain_request;
1560
if (!str1 || !str2 || !p) {
1564
/* If someone sets all the bits they don't really mean to set
1565
DOMAIN_ENUM and LOCAL_LIST_ONLY, they just want all the
1568
if (servertype == SV_TYPE_ALL) {
1569
servertype &= ~(SV_TYPE_DOMAIN_ENUM|SV_TYPE_LOCAL_LIST_ONLY);
1572
/* If someone sets SV_TYPE_LOCAL_LIST_ONLY but hasn't set
1573
any other bit (they may just set this bit on its own) they
1574
want all the locally seen servers. However this bit can be
1575
set on its own so set the requested servers to be
1576
ALL - DOMAIN_ENUM. */
1578
if ((servertype & SV_TYPE_LOCAL_LIST_ONLY) && !(servertype & SV_TYPE_DOMAIN_ENUM)) {
1579
servertype = SV_TYPE_ALL & ~(SV_TYPE_DOMAIN_ENUM);
1582
domain_request = ((servertype & SV_TYPE_DOMAIN_ENUM) != 0);
1583
local_request = ((servertype & SV_TYPE_LOCAL_LIST_ONLY) != 0);
1587
if (strcmp(str1, "WrLehDzz") != 0) {
1590
if (!check_server_info(uLevel,str2)) {
1594
DEBUG(4, ("server request level: %s %8x ", str2, servertype));
1595
DEBUG(4, ("domains_req:%s ", BOOLSTR(domain_request)));
1596
DEBUG(4, ("local_only:%s\n", BOOLSTR(local_request)));
1598
if (skip_string(param,tpscnt,p) == NULL) {
1601
pull_ascii_fstring(domain, p);
1602
if (domain[0] == '\0') {
1603
fstrcpy(domain, lp_workgroup());
1605
p = skip_string(param,tpscnt,p);
1606
if (skip_string(param,tpscnt,p) == NULL) {
1609
pull_ascii_fstring(first_name, p);
1611
DEBUG(4, ("domain: '%s' first_name: '%s'\n",
1612
domain, first_name));
1614
if (lp_browse_list()) {
1615
total = get_server_info(servertype,&servers,domain);
1618
data_len = fixed_len = string_len = 0;
1622
qsort(servers,total,sizeof(servers[0]),QSORT_CAST srv_comp);
1625
if (first_name[0] != '\0') {
1626
struct srv_info_struct *first_server = NULL;
1628
BINARY_ARRAY_SEARCH(servers, total, name, first_name,
1629
srv_name_match, first_server);
1631
first = PTR_DIFF(first_server, servers) / sizeof(*servers);
1633
* The binary search may not find the exact match
1634
* so we need to search backward to find the first match
1636
* This implements the strange matching windows
1637
* implements. (see the comment in srv_name_match().
1641
ret = StrCaseCmp(first_name,
1642
servers[first-1].name);
1649
/* we should return no entries */
1655
char *lastname=NULL;
1657
for (i=first;i<total;i++) {
1658
struct srv_info_struct *s = &servers[i];
1660
if (lastname && strequal(lastname,s->name)) {
1664
data_len += fill_srv_info(s,uLevel,0,&f_len,0,&s_len,0);
1665
DEBUG(4,("fill_srv_info[%d] %20s %8x %25s %15s\n",
1666
i, s->name, s->type, s->comment, s->domain));
1668
if (data_len < buf_len) {
1671
string_len += s_len;
1678
*rdata_len = fixed_len + string_len;
1679
*rdata = smb_realloc_limit(*rdata,*rdata_len);
1684
p2 = (*rdata) + fixed_len; /* auxilliary data (strings) will go here */
1690
char *lastname=NULL;
1691
int count2 = counted;
1693
for (i = first; i < total && count2;i++) {
1694
struct srv_info_struct *s = &servers[i];
1696
if (lastname && strequal(lastname,s->name)) {
1700
fill_srv_info(s,uLevel,&p,&f_len,&p2,&s_len,*rdata);
1701
DEBUG(4,("fill_srv_info[%d] %20s %8x %25s %15s\n",
1702
i, s->name, s->type, s->comment, s->domain));
1708
*rparam = smb_realloc_limit(*rparam,*rparam_len);
1712
SSVAL(*rparam,0,(missed == 0 ? NERR_Success : ERRmoredata));
1714
SSVAL(*rparam,4,counted);
1715
SSVAL(*rparam,6,counted+missed);
1717
DEBUG(3,("NetServerEnum3 domain = %s uLevel=%d first=%d[%s => %s] counted=%d total=%d\n",
1718
domain,uLevel,first,first_name,
1719
first < total ? servers[first].name : "",
1720
counted,counted+missed));
1727
/****************************************************************************
1728
command 0x34 - suspected of being a "Lookup Names" stub api
1729
****************************************************************************/
1731
static bool api_RNetGroupGetUsers(connection_struct *conn, uint16 vuid,
1732
char *param, int tpscnt,
1733
char *data, int tdscnt,
1734
int mdrcnt, int mprcnt, char **rdata,
1735
char **rparam, int *rdata_len, int *rparam_len)
1737
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
1738
char *str2 = skip_string(param,tpscnt,str1);
1739
char *p = skip_string(param,tpscnt,str2);
1740
int uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
1741
int buf_len = get_safe_SVAL(param,tpscnt,p,2,0);
1745
if (!str1 || !str2 || !p) {
1749
DEBUG(5,("RNetGroupGetUsers: %s %s %s %d %d\n",
1750
str1, str2, p, uLevel, buf_len));
1752
if (!prefix_ok(str1,"zWrLeh")) {
1759
*rparam = smb_realloc_limit(*rparam,*rparam_len);
1764
SSVAL(*rparam,0,0x08AC); /* informational warning message */
1766
SSVAL(*rparam,4,counted);
1767
SSVAL(*rparam,6,counted+missed);
1772
/****************************************************************************
1773
get info about a share
1774
****************************************************************************/
1776
static bool check_share_info(int uLevel, char* id)
1780
if (strcmp(id,"B13") != 0) {
1785
if (strcmp(id,"B13BWz") != 0) {
1790
if (strcmp(id,"B13BWzWWWzB9B") != 0) {
1795
if (strcmp(id,"B13BWzWWWzB9BB9BWzWWzWW") != 0) {
1805
static int fill_share_info(connection_struct *conn, int snum, int uLevel,
1806
char** buf, int* buflen,
1807
char** stringbuf, int* stringspace, char* baseaddr)
1836
len += StrlenExpanded(conn,snum,lp_comment(snum));
1839
len += strlen(lp_pathname(snum)) + 1;
1842
*buflen = struct_len;
1847
return struct_len + len;
1852
if ((*buflen) < struct_len) {
1860
p2 = p + struct_len;
1861
l2 = (*buflen) - struct_len;
1868
push_ascii(p,lp_servicename(snum),13, STR_TERMINATE);
1874
type = STYPE_DISKTREE;
1875
if (lp_print_ok(snum)) {
1876
type = STYPE_PRINTQ;
1878
if (strequal("IPC",lp_fstype(snum))) {
1881
SSVAL(p,14,type); /* device type */
1882
SIVAL(p,16,PTR_DIFF(p2,baseaddr));
1883
len += CopyExpanded(conn,snum,&p2,lp_comment(snum),&l2);
1887
SSVAL(p,20,ACCESS_READ|ACCESS_WRITE|ACCESS_CREATE); /* permissions */
1888
SSVALS(p,22,-1); /* max uses */
1889
SSVAL(p,24,1); /* current uses */
1890
SIVAL(p,26,PTR_DIFF(p2,baseaddr)); /* local pathname */
1891
len += CopyAndAdvance(&p2,lp_pathname(snum),&l2);
1892
memset(p+30,0,SHPWLEN+2); /* passwd (reserved), pad field */
1896
memset(p+40,0,SHPWLEN+2);
1907
(*buf) = p + struct_len;
1908
(*buflen) -= struct_len;
1910
(*stringspace) = l2;
1919
static bool api_RNetShareGetInfo(connection_struct *conn,uint16 vuid,
1920
char *param, int tpscnt,
1921
char *data, int tdscnt,
1922
int mdrcnt,int mprcnt,
1923
char **rdata,char **rparam,
1924
int *rdata_len,int *rparam_len)
1926
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
1927
char *str2 = skip_string(param,tpscnt,str1);
1928
char *netname = skip_string(param,tpscnt,str2);
1929
char *p = skip_string(param,tpscnt,netname);
1930
int uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
1933
if (!str1 || !str2 || !netname || !p) {
1937
snum = find_service(netname);
1942
/* check it's a supported varient */
1943
if (!prefix_ok(str1,"zWrLh")) {
1946
if (!check_share_info(uLevel,str2)) {
1950
*rdata = smb_realloc_limit(*rdata,mdrcnt);
1955
*rdata_len = fill_share_info(conn,snum,uLevel,&p,&mdrcnt,0,0,0);
1956
if (*rdata_len < 0) {
1961
*rparam = smb_realloc_limit(*rparam,*rparam_len);
1965
SSVAL(*rparam,0,NERR_Success);
1966
SSVAL(*rparam,2,0); /* converter word */
1967
SSVAL(*rparam,4,*rdata_len);
1972
/****************************************************************************
1973
View the list of available shares.
1975
This function is the server side of the NetShareEnum() RAP call.
1976
It fills the return buffer with share names and share comments.
1977
Note that the return buffer normally (in all known cases) allows only
1978
twelve byte strings for share names (plus one for a nul terminator).
1979
Share names longer than 12 bytes must be skipped.
1980
****************************************************************************/
1982
static bool api_RNetShareEnum( connection_struct *conn, uint16 vuid,
1983
char *param, int tpscnt,
1984
char *data, int tdscnt,
1992
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
1993
char *str2 = skip_string(param,tpscnt,str1);
1994
char *p = skip_string(param,tpscnt,str2);
1995
int uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
1996
int buf_len = get_safe_SVAL(param,tpscnt,p,2,0);
1999
int total=0,counted=0;
2000
bool missed = False;
2002
int data_len, fixed_len, string_len;
2003
int f_len = 0, s_len = 0;
2005
if (!str1 || !str2 || !p) {
2009
if (!prefix_ok(str1,"WrLeh")) {
2012
if (!check_share_info(uLevel,str2)) {
2016
/* Ensure all the usershares are loaded. */
2018
load_registry_shares();
2019
count = load_usershare_shares();
2022
data_len = fixed_len = string_len = 0;
2023
for (i=0;i<count;i++) {
2024
fstring servicename_dos;
2025
if (!(lp_browseable(i) && lp_snum_ok(i))) {
2028
push_ascii_fstring(servicename_dos, lp_servicename(i));
2029
/* Maximum name length = 13. */
2030
if( lp_browseable( i ) && lp_snum_ok( i ) && (strlen(servicename_dos) < 13)) {
2032
data_len += fill_share_info(conn,i,uLevel,0,&f_len,0,&s_len,0);
2033
if (data_len < buf_len) {
2036
string_len += s_len;
2043
*rdata_len = fixed_len + string_len;
2044
*rdata = smb_realloc_limit(*rdata,*rdata_len);
2049
p2 = (*rdata) + fixed_len; /* auxiliary data (strings) will go here */
2054
for( i = 0; i < count; i++ ) {
2055
fstring servicename_dos;
2056
if (!(lp_browseable(i) && lp_snum_ok(i))) {
2060
push_ascii_fstring(servicename_dos, lp_servicename(i));
2061
if (lp_browseable(i) && lp_snum_ok(i) && (strlen(servicename_dos) < 13)) {
2062
if (fill_share_info( conn,i,uLevel,&p,&f_len,&p2,&s_len,*rdata ) < 0) {
2069
*rparam = smb_realloc_limit(*rparam,*rparam_len);
2073
SSVAL(*rparam,0,missed ? ERRmoredata : NERR_Success);
2075
SSVAL(*rparam,4,counted);
2076
SSVAL(*rparam,6,total);
2078
DEBUG(3,("RNetShareEnum gave %d entries of %d (%d %d %d %d)\n",
2079
counted,total,uLevel,
2080
buf_len,*rdata_len,mdrcnt));
2085
/****************************************************************************
2087
****************************************************************************/
2089
static bool api_RNetShareAdd(connection_struct *conn,uint16 vuid,
2090
char *param, int tpscnt,
2091
char *data, int tdscnt,
2092
int mdrcnt,int mprcnt,
2093
char **rdata,char **rparam,
2094
int *rdata_len,int *rparam_len)
2096
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
2097
char *str2 = skip_string(param,tpscnt,str1);
2098
char *p = skip_string(param,tpscnt,str2);
2099
int uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
2102
char *pathname = NULL;
2103
char *command, *cmdname;
2104
unsigned int offset;
2107
size_t converted_size;
2109
if (!str1 || !str2 || !p) {
2113
/* check it's a supported varient */
2114
if (!prefix_ok(str1,RAP_WShareAdd_REQ)) {
2117
if (!check_share_info(uLevel,str2)) {
2124
/* Do we have a string ? */
2125
if (skip_string(data,mdrcnt,data) == NULL) {
2128
pull_ascii_fstring(sharename,data);
2129
snum = find_service(sharename);
2130
if (snum >= 0) { /* already exists */
2139
/* only support disk share adds */
2140
if (SVAL(data,14)!=STYPE_DISKTREE) {
2144
offset = IVAL(data, 16);
2145
if (offset >= mdrcnt) {
2146
res = ERRinvalidparam;
2150
/* Do we have a string ? */
2151
if (skip_string(data,mdrcnt,data+offset) == NULL) {
2154
pull_ascii_fstring(comment, offset? (data+offset) : "");
2156
offset = IVAL(data, 26);
2158
if (offset >= mdrcnt) {
2159
res = ERRinvalidparam;
2163
/* Do we have a string ? */
2164
if (skip_string(data,mdrcnt,data+offset) == NULL) {
2168
if (!pull_ascii_talloc(talloc_tos(), &pathname,
2169
offset ? (data+offset) : "", &converted_size))
2171
DEBUG(0,("api_RNetShareAdd: pull_ascii_talloc failed: %s",
2179
string_replace(sharename, '"', ' ');
2180
string_replace(pathname, '"', ' ');
2181
string_replace(comment, '"', ' ');
2183
cmdname = lp_add_share_cmd();
2185
if (!cmdname || *cmdname == '\0') {
2189
if (asprintf(&command, "%s \"%s\" \"%s\" \"%s\" \"%s\"",
2190
lp_add_share_cmd(), get_dyn_CONFIGFILE(), sharename,
2191
pathname, comment) == -1) {
2195
DEBUG(10,("api_RNetShareAdd: Running [%s]\n", command ));
2197
if ((res = smbrun(command, NULL)) != 0) {
2198
DEBUG(1,("api_RNetShareAdd: Running [%s] returned (%d)\n",
2205
message_send_all(smbd_messaging_context(),
2206
MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
2210
*rparam = smb_realloc_limit(*rparam,*rparam_len);
2214
SSVAL(*rparam,0,NERR_Success);
2215
SSVAL(*rparam,2,0); /* converter word */
2216
SSVAL(*rparam,4,*rdata_len);
2224
*rparam = smb_realloc_limit(*rparam,*rparam_len);
2229
SSVAL(*rparam,0,res);
2234
/****************************************************************************
2235
view list of groups available
2236
****************************************************************************/
2238
static bool api_RNetGroupEnum(connection_struct *conn,uint16 vuid,
2239
char *param, int tpscnt,
2240
char *data, int tdscnt,
2241
int mdrcnt,int mprcnt,
2242
char **rdata,char **rparam,
2243
int *rdata_len,int *rparam_len)
2247
int resume_context, cli_buf_size;
2248
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
2249
char *str2 = skip_string(param,tpscnt,str1);
2250
char *p = skip_string(param,tpscnt,str2);
2252
uint32_t num_groups;
2253
uint32_t resume_handle;
2254
struct rpc_pipe_client *samr_pipe;
2255
struct policy_handle samr_handle, domain_handle;
2258
if (!str1 || !str2 || !p) {
2262
if (strcmp(str1,"WrLeh") != 0) {
2267
* W-> resume context (number of users to skip)
2268
* r -> return parameter pointer to receive buffer
2269
* L -> length of receive buffer
2270
* e -> return parameter number of entries
2271
* h -> return parameter total number of users
2274
if (strcmp("B21",str2) != 0) {
2278
status = rpc_pipe_open_internal(
2279
talloc_tos(), &ndr_table_samr.syntax_id, rpc_samr_dispatch,
2280
conn->server_info, &samr_pipe);
2281
if (!NT_STATUS_IS_OK(status)) {
2282
DEBUG(0, ("api_RNetUserEnum: Could not connect to samr: %s\n",
2283
nt_errstr(status)));
2287
status = rpccli_samr_Connect2(samr_pipe, talloc_tos(), global_myname(),
2288
SAMR_ACCESS_LOOKUP_DOMAIN, &samr_handle);
2289
if (!NT_STATUS_IS_OK(status)) {
2290
DEBUG(0, ("api_RNetUserEnum: samr_Connect2 failed: %s\n",
2291
nt_errstr(status)));
2295
status = rpccli_samr_OpenDomain(samr_pipe, talloc_tos(), &samr_handle,
2296
SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS,
2297
get_global_sam_sid(), &domain_handle);
2298
if (!NT_STATUS_IS_OK(status)) {
2299
DEBUG(0, ("api_RNetUserEnum: samr_OpenDomain failed: %s\n",
2300
nt_errstr(status)));
2301
rpccli_samr_Close(samr_pipe, talloc_tos(), &samr_handle);
2305
resume_context = get_safe_SVAL(param,tpscnt,p,0,-1);
2306
cli_buf_size= get_safe_SVAL(param,tpscnt,p,2,0);
2307
DEBUG(10,("api_RNetGroupEnum:resume context: %d, client buffer size: "
2308
"%d\n", resume_context, cli_buf_size));
2310
*rdata_len = cli_buf_size;
2311
*rdata = smb_realloc_limit(*rdata,*rdata_len);
2318
errflags = NERR_Success;
2323
struct samr_SamArray *sam_entries;
2324
uint32_t num_entries;
2326
status = rpccli_samr_EnumDomainGroups(samr_pipe, talloc_tos(),
2331
if (!NT_STATUS_IS_OK(status)) {
2332
DEBUG(10, ("rpccli_samr_EnumDomainGroups returned "
2333
"%s\n", nt_errstr(status)));
2337
if (num_entries == 0) {
2338
DEBUG(10, ("rpccli_samr_EnumDomainGroups returned "
2339
"no entries -- done\n"));
2343
for(i=0; i<num_entries; i++) {
2346
name = sam_entries->entries[i].name.string;
2348
if( ((PTR_DIFF(p,*rdata)+21) > *rdata_len) ) {
2349
/* set overflow error */
2350
DEBUG(3,("overflow on entry %d group %s\n", i,
2356
/* truncate the name at 21 chars. */
2358
strlcpy(p, name, 21);
2359
DEBUG(10,("adding entry %d group %s\n", i, p));
2361
p += 5; /* Both NT4 and W2k3SP1 do padding here. No
2366
if (errflags != NERR_Success) {
2370
TALLOC_FREE(sam_entries);
2373
rpccli_samr_Close(samr_pipe, talloc_tos(), &domain_handle);
2374
rpccli_samr_Close(samr_pipe, talloc_tos(), &samr_handle);
2376
*rdata_len = PTR_DIFF(p,*rdata);
2379
*rparam = smb_realloc_limit(*rparam,*rparam_len);
2383
SSVAL(*rparam, 0, errflags);
2384
SSVAL(*rparam, 2, 0); /* converter word */
2385
SSVAL(*rparam, 4, num_groups); /* is this right?? */
2386
SSVAL(*rparam, 6, resume_context+num_groups); /* is this right?? */
2391
/*******************************************************************
2392
Get groups that a user is a member of.
2393
******************************************************************/
2395
static bool api_NetUserGetGroups(connection_struct *conn,uint16 vuid,
2396
char *param, int tpscnt,
2397
char *data, int tdscnt,
2398
int mdrcnt,int mprcnt,
2399
char **rdata,char **rparam,
2400
int *rdata_len,int *rparam_len)
2402
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
2403
char *str2 = skip_string(param,tpscnt,str1);
2404
char *UserName = skip_string(param,tpscnt,str2);
2405
char *p = skip_string(param,tpscnt,UserName);
2406
int uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
2407
const char *level_string;
2413
struct rpc_pipe_client *samr_pipe;
2414
struct policy_handle samr_handle, domain_handle, user_handle;
2415
struct lsa_String name;
2416
struct lsa_Strings names;
2417
struct samr_Ids type, rid;
2418
struct samr_RidWithAttributeArray *rids;
2421
if (!str1 || !str2 || !UserName || !p) {
2426
*rparam = smb_realloc_limit(*rparam,*rparam_len);
2431
/* check it's a supported varient */
2433
if ( strcmp(str1,"zWrLeh") != 0 )
2438
level_string = "B21";
2444
if (strcmp(level_string,str2) != 0)
2447
*rdata_len = mdrcnt + 1024;
2448
*rdata = smb_realloc_limit(*rdata,*rdata_len);
2453
SSVAL(*rparam,0,NERR_Success);
2454
SSVAL(*rparam,2,0); /* converter word */
2457
endp = *rdata + *rdata_len;
2459
status = rpc_pipe_open_internal(
2460
talloc_tos(), &ndr_table_samr.syntax_id, rpc_samr_dispatch,
2461
conn->server_info, &samr_pipe);
2462
if (!NT_STATUS_IS_OK(status)) {
2463
DEBUG(0, ("api_RNetUserEnum: Could not connect to samr: %s\n",
2464
nt_errstr(status)));
2468
status = rpccli_samr_Connect2(samr_pipe, talloc_tos(), global_myname(),
2469
SAMR_ACCESS_LOOKUP_DOMAIN, &samr_handle);
2470
if (!NT_STATUS_IS_OK(status)) {
2471
DEBUG(0, ("api_RNetUserEnum: samr_Connect2 failed: %s\n",
2472
nt_errstr(status)));
2476
status = rpccli_samr_OpenDomain(samr_pipe, talloc_tos(), &samr_handle,
2477
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
2478
get_global_sam_sid(), &domain_handle);
2479
if (!NT_STATUS_IS_OK(status)) {
2480
DEBUG(0, ("api_RNetUserEnum: samr_OpenDomain failed: %s\n",
2481
nt_errstr(status)));
2485
name.string = UserName;
2487
status = rpccli_samr_LookupNames(samr_pipe, talloc_tos(),
2488
&domain_handle, 1, &name,
2490
if (!NT_STATUS_IS_OK(status)) {
2491
DEBUG(0, ("api_RNetUserEnum: samr_LookupNames failed: %s\n",
2492
nt_errstr(status)));
2496
if (type.ids[0] != SID_NAME_USER) {
2497
DEBUG(10, ("%s is a %s, not a user\n", UserName,
2498
sid_type_lookup(type.ids[0])));
2502
status = rpccli_samr_OpenUser(samr_pipe, talloc_tos(),
2504
SAMR_USER_ACCESS_GET_GROUPS,
2505
rid.ids[0], &user_handle);
2506
if (!NT_STATUS_IS_OK(status)) {
2507
DEBUG(0, ("api_RNetUserEnum: samr_LookupNames failed: %s\n",
2508
nt_errstr(status)));
2512
status = rpccli_samr_GetGroupsForUser(samr_pipe, talloc_tos(),
2513
&user_handle, &rids);
2514
if (!NT_STATUS_IS_OK(status)) {
2515
DEBUG(0, ("api_RNetUserEnum: samr_LookupNames failed: %s\n",
2516
nt_errstr(status)));
2520
for (i=0; i<rids->count; i++) {
2522
status = rpccli_samr_LookupRids(samr_pipe, talloc_tos(),
2524
1, &rids->rids[i].rid,
2526
if (NT_STATUS_IS_OK(status) && (names.count == 1)) {
2527
strlcpy(p, names.names[0].string, PTR_DIFF(endp,p));
2533
*rdata_len = PTR_DIFF(p,*rdata);
2535
SSVAL(*rparam,4,count); /* is this right?? */
2536
SSVAL(*rparam,6,count); /* is this right?? */
2541
rpccli_samr_Close(samr_pipe, talloc_tos(), &user_handle);
2543
rpccli_samr_Close(samr_pipe, talloc_tos(), &domain_handle);
2545
rpccli_samr_Close(samr_pipe, talloc_tos(), &samr_handle);
2550
/*******************************************************************
2552
******************************************************************/
2554
static bool api_RNetUserEnum(connection_struct *conn, uint16 vuid,
2555
char *param, int tpscnt,
2556
char *data, int tdscnt,
2557
int mdrcnt,int mprcnt,
2558
char **rdata,char **rparam,
2559
int *rdata_len,int *rparam_len)
2564
int i, resume_context, cli_buf_size;
2565
uint32_t resume_handle;
2567
struct rpc_pipe_client *samr_pipe;
2568
struct policy_handle samr_handle, domain_handle;
2571
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
2572
char *str2 = skip_string(param,tpscnt,str1);
2573
char *p = skip_string(param,tpscnt,str2);
2576
if (!str1 || !str2 || !p) {
2580
if (strcmp(str1,"WrLeh") != 0)
2583
* W-> resume context (number of users to skip)
2584
* r -> return parameter pointer to receive buffer
2585
* L -> length of receive buffer
2586
* e -> return parameter number of entries
2587
* h -> return parameter total number of users
2590
resume_context = get_safe_SVAL(param,tpscnt,p,0,-1);
2591
cli_buf_size= get_safe_SVAL(param,tpscnt,p,2,0);
2592
DEBUG(10,("api_RNetUserEnum:resume context: %d, client buffer size: %d\n",
2593
resume_context, cli_buf_size));
2596
*rparam = smb_realloc_limit(*rparam,*rparam_len);
2601
/* check it's a supported varient */
2602
if (strcmp("B21",str2) != 0)
2605
*rdata_len = cli_buf_size;
2606
*rdata = smb_realloc_limit(*rdata,*rdata_len);
2612
endp = *rdata + *rdata_len;
2614
status = rpc_pipe_open_internal(
2615
talloc_tos(), &ndr_table_samr.syntax_id, rpc_samr_dispatch,
2616
conn->server_info, &samr_pipe);
2617
if (!NT_STATUS_IS_OK(status)) {
2618
DEBUG(0, ("api_RNetUserEnum: Could not connect to samr: %s\n",
2619
nt_errstr(status)));
2623
status = rpccli_samr_Connect2(samr_pipe, talloc_tos(), global_myname(),
2624
SAMR_ACCESS_LOOKUP_DOMAIN, &samr_handle);
2625
if (!NT_STATUS_IS_OK(status)) {
2626
DEBUG(0, ("api_RNetUserEnum: samr_Connect2 failed: %s\n",
2627
nt_errstr(status)));
2631
status = rpccli_samr_OpenDomain(samr_pipe, talloc_tos(), &samr_handle,
2632
SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS,
2633
get_global_sam_sid(), &domain_handle);
2634
if (!NT_STATUS_IS_OK(status)) {
2635
DEBUG(0, ("api_RNetUserEnum: samr_OpenDomain failed: %s\n",
2636
nt_errstr(status)));
2637
rpccli_samr_Close(samr_pipe, talloc_tos(), &samr_handle);
2641
errflags=NERR_Success;
2646
struct samr_SamArray *sam_entries;
2647
uint32_t num_entries;
2649
status = rpccli_samr_EnumDomainUsers(samr_pipe, talloc_tos(),
2655
if (!NT_STATUS_IS_OK(status)) {
2656
DEBUG(10, ("rpccli_samr_EnumDomainUsers returned "
2657
"%s\n", nt_errstr(status)));
2661
if (num_entries == 0) {
2662
DEBUG(10, ("rpccli_samr_EnumDomainUsers returned "
2663
"no entries -- done\n"));
2667
for (i=0; i<num_entries; i++) {
2670
name = sam_entries->entries[i].name.string;
2672
if(((PTR_DIFF(p,*rdata)+21)<=*rdata_len)
2673
&&(strlen(name)<=21)) {
2674
strlcpy(p,name,PTR_DIFF(endp,p));
2675
DEBUG(10,("api_RNetUserEnum:adding entry %d "
2676
"username %s\n",count_sent,p));
2680
/* set overflow error */
2681
DEBUG(10,("api_RNetUserEnum:overflow on entry %d "
2682
"username %s\n",count_sent,name));
2688
if (errflags != NERR_Success) {
2692
TALLOC_FREE(sam_entries);
2695
rpccli_samr_Close(samr_pipe, talloc_tos(), &domain_handle);
2696
rpccli_samr_Close(samr_pipe, talloc_tos(), &samr_handle);
2698
*rdata_len = PTR_DIFF(p,*rdata);
2700
SSVAL(*rparam,0,errflags);
2701
SSVAL(*rparam,2,0); /* converter word */
2702
SSVAL(*rparam,4,count_sent); /* is this right?? */
2703
SSVAL(*rparam,6,num_users); /* is this right?? */
2708
/****************************************************************************
2709
Get the time of day info.
2710
****************************************************************************/
2712
static bool api_NetRemoteTOD(connection_struct *conn,uint16 vuid,
2713
char *param, int tpscnt,
2714
char *data, int tdscnt,
2715
int mdrcnt,int mprcnt,
2716
char **rdata,char **rparam,
2717
int *rdata_len,int *rparam_len)
2720
time_t unixdate = time(NULL);
2724
*rparam = smb_realloc_limit(*rparam,*rparam_len);
2730
*rdata = smb_realloc_limit(*rdata,*rdata_len);
2735
SSVAL(*rparam,0,NERR_Success);
2736
SSVAL(*rparam,2,0); /* converter word */
2740
srv_put_dos_date3(p,0,unixdate); /* this is the time that is looked at
2741
by NT in a "net time" operation,
2742
it seems to ignore the one below */
2744
/* the client expects to get localtime, not GMT, in this bit
2745
(I think, this needs testing) */
2746
t = localtime(&unixdate);
2751
SIVAL(p,4,0); /* msecs ? */
2752
SCVAL(p,8,t->tm_hour);
2753
SCVAL(p,9,t->tm_min);
2754
SCVAL(p,10,t->tm_sec);
2755
SCVAL(p,11,0); /* hundredths of seconds */
2756
SSVALS(p,12,get_time_zone(unixdate)/60); /* timezone in minutes from GMT */
2757
SSVAL(p,14,10000); /* timer interval in 0.0001 of sec */
2758
SCVAL(p,16,t->tm_mday);
2759
SCVAL(p,17,t->tm_mon + 1);
2760
SSVAL(p,18,1900+t->tm_year);
2761
SCVAL(p,20,t->tm_wday);
2766
/****************************************************************************
2767
Set the user password.
2768
*****************************************************************************/
2770
static bool api_SetUserPassword(connection_struct *conn,uint16 vuid,
2771
char *param, int tpscnt,
2772
char *data, int tdscnt,
2773
int mdrcnt,int mprcnt,
2774
char **rdata,char **rparam,
2775
int *rdata_len,int *rparam_len)
2777
char *np = get_safe_str_ptr(param,tpscnt,param,2);
2780
fstring pass1,pass2;
2782
/* Skip 2 strings. */
2783
p = skip_string(param,tpscnt,np);
2784
p = skip_string(param,tpscnt,p);
2790
/* Do we have a string ? */
2791
if (skip_string(param,tpscnt,p) == NULL) {
2794
pull_ascii_fstring(user,p);
2796
p = skip_string(param,tpscnt,p);
2801
memset(pass1,'\0',sizeof(pass1));
2802
memset(pass2,'\0',sizeof(pass2));
2804
* We use 31 here not 32 as we're checking
2805
* the last byte we want to access is safe.
2807
if (!is_offset_safe(param,tpscnt,p,31)) {
2811
memcpy(pass2,p+16,16);
2814
*rparam = smb_realloc_limit(*rparam,*rparam_len);
2821
SSVAL(*rparam,0,NERR_badpass);
2822
SSVAL(*rparam,2,0); /* converter word */
2824
DEBUG(3,("Set password for <%s>\n",user));
2827
* Attempt to verify the old password against smbpasswd entries
2828
* Win98 clients send old and new password in plaintext for this call.
2832
auth_serversupplied_info *server_info = NULL;
2833
DATA_BLOB password = data_blob(pass1, strlen(pass1)+1);
2835
if (NT_STATUS_IS_OK(check_plaintext_password(user,password,&server_info))) {
2838
if (NT_STATUS_IS_OK(change_oem_password(server_info->sam_account, pass1, pass2, False, NULL))) {
2839
SSVAL(*rparam,0,NERR_Success);
2843
TALLOC_FREE(server_info);
2845
data_blob_clear_free(&password);
2849
* If the plaintext change failed, attempt
2850
* the old encrypted method. NT will generate this
2851
* after trying the samr method. Note that this
2852
* method is done as a last resort as this
2853
* password change method loses the NT password hash
2854
* and cannot change the UNIX password as no plaintext
2858
if(SVAL(*rparam,0) != NERR_Success) {
2859
struct samu *hnd = NULL;
2861
if (check_lanman_password(user,(unsigned char *)pass1,(unsigned char *)pass2, &hnd)) {
2863
if (change_lanman_password(hnd,(uchar *)pass2)) {
2864
SSVAL(*rparam,0,NERR_Success);
2871
memset((char *)pass1,'\0',sizeof(fstring));
2872
memset((char *)pass2,'\0',sizeof(fstring));
2877
/****************************************************************************
2878
Set the user password (SamOEM version - gets plaintext).
2879
****************************************************************************/
2881
static bool api_SamOEMChangePassword(connection_struct *conn,uint16 vuid,
2882
char *param, int tpscnt,
2883
char *data, int tdscnt,
2884
int mdrcnt,int mprcnt,
2885
char **rdata,char **rparam,
2886
int *rdata_len,int *rparam_len)
2889
char *p = get_safe_str_ptr(param,tpscnt,param,2);
2891
*rparam = smb_realloc_limit(*rparam,*rparam_len);
2901
SSVAL(*rparam,0,NERR_badpass);
2904
* Check the parameter definition is correct.
2907
/* Do we have a string ? */
2908
if (skip_string(param,tpscnt,p) == 0) {
2911
if(!strequal(p, "zsT")) {
2912
DEBUG(0,("api_SamOEMChangePassword: Invalid parameter string %s\n", p));
2915
p = skip_string(param, tpscnt, p);
2920
/* Do we have a string ? */
2921
if (skip_string(param,tpscnt,p) == 0) {
2924
if(!strequal(p, "B516B16")) {
2925
DEBUG(0,("api_SamOEMChangePassword: Invalid data parameter string %s\n", p));
2928
p = skip_string(param,tpscnt,p);
2932
/* Do we have a string ? */
2933
if (skip_string(param,tpscnt,p) == 0) {
2936
p += pull_ascii_fstring(user,p);
2938
DEBUG(3,("api_SamOEMChangePassword: Change password for <%s>\n",user));
2941
* Pass the user through the NT -> unix user mapping
2945
(void)map_username(user);
2947
if (NT_STATUS_IS_OK(pass_oem_change(user, (uchar*) data, (uchar *)&data[516], NULL, NULL, NULL))) {
2948
SSVAL(*rparam,0,NERR_Success);
2954
/****************************************************************************
2957
****************************************************************************/
2959
static bool api_RDosPrintJobDel(connection_struct *conn,uint16 vuid,
2960
char *param, int tpscnt,
2961
char *data, int tdscnt,
2962
int mdrcnt,int mprcnt,
2963
char **rdata,char **rparam,
2964
int *rdata_len,int *rparam_len)
2966
int function = get_safe_SVAL(param,tpscnt,param,0,0);
2967
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
2968
char *str2 = skip_string(param,tpscnt,str1);
2969
char *p = skip_string(param,tpscnt,str2);
2974
WERROR werr = WERR_OK;
2976
if (!str1 || !str2 || !p) {
2980
* We use 1 here not 2 as we're checking
2981
* the last byte we want to access is safe.
2983
if (!is_offset_safe(param,tpscnt,p,1)) {
2986
if(!rap_to_pjobid(SVAL(p,0), sharename, &jobid))
2989
/* check it's a supported varient */
2990
if (!(strcsequal(str1,"W") && strcsequal(str2,"")))
2994
*rparam = smb_realloc_limit(*rparam,*rparam_len);
3000
if (!print_job_exists(sharename, jobid)) {
3001
errcode = NERR_JobNotFound;
3005
snum = lp_servicenumber( sharename);
3007
errcode = NERR_DestNotFound;
3011
errcode = NERR_notsupported;
3014
case 81: /* delete */
3015
if (print_job_delete(conn->server_info, snum, jobid, &werr))
3016
errcode = NERR_Success;
3018
case 82: /* pause */
3019
if (print_job_pause(conn->server_info, snum, jobid, &werr))
3020
errcode = NERR_Success;
3022
case 83: /* resume */
3023
if (print_job_resume(conn->server_info, snum, jobid, &werr))
3024
errcode = NERR_Success;
3028
if (!W_ERROR_IS_OK(werr))
3029
errcode = W_ERROR_V(werr);
3032
SSVAL(*rparam,0,errcode);
3033
SSVAL(*rparam,2,0); /* converter word */
3038
/****************************************************************************
3039
Purge a print queue - or pause or resume it.
3040
****************************************************************************/
3042
static bool api_WPrintQueueCtrl(connection_struct *conn,uint16 vuid,
3043
char *param, int tpscnt,
3044
char *data, int tdscnt,
3045
int mdrcnt,int mprcnt,
3046
char **rdata,char **rparam,
3047
int *rdata_len,int *rparam_len)
3049
int function = get_safe_SVAL(param,tpscnt,param,0,0);
3050
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
3051
char *str2 = skip_string(param,tpscnt,str1);
3052
char *QueueName = skip_string(param,tpscnt,str2);
3053
int errcode = NERR_notsupported;
3055
WERROR werr = WERR_OK;
3057
if (!str1 || !str2 || !QueueName) {
3061
/* check it's a supported varient */
3062
if (!(strcsequal(str1,"z") && strcsequal(str2,"")))
3066
*rparam = smb_realloc_limit(*rparam,*rparam_len);
3072
if (skip_string(param,tpscnt,QueueName) == NULL) {
3075
snum = print_queue_snum(QueueName);
3078
errcode = NERR_JobNotFound;
3083
case 74: /* Pause queue */
3084
werr = print_queue_pause(conn->server_info, snum);
3086
case 75: /* Resume queue */
3087
werr = print_queue_resume(conn->server_info, snum);
3089
case 103: /* Purge */
3090
werr = print_queue_purge(conn->server_info, snum);
3093
werr = WERR_NOT_SUPPORTED;
3097
errcode = W_ERROR_V(werr);
3100
SSVAL(*rparam,0,errcode);
3101
SSVAL(*rparam,2,0); /* converter word */
3106
/****************************************************************************
3107
set the property of a print job (undocumented?)
3108
? function = 0xb -> set name of print job
3109
? function = 0x6 -> move print job up/down
3110
Form: <WWsTP> <WWzWWDDzzzzzzzzzzlz>
3111
or <WWsTP> <WB21BB16B10zWWzDDz>
3112
****************************************************************************/
3114
static int check_printjob_info(struct pack_desc* desc,
3115
int uLevel, char* id)
3117
desc->subformat = NULL;
3119
case 0: desc->format = "W"; break;
3120
case 1: desc->format = "WB21BB16B10zWWzDDz"; break;
3121
case 2: desc->format = "WWzWWDDzz"; break;
3122
case 3: desc->format = "WWzWWDDzzzzzzzzzzlz"; break;
3123
case 4: desc->format = "WWzWWDDzzzzzDDDDDDD"; break;
3125
DEBUG(0,("check_printjob_info: invalid level %d\n",
3129
if (id == NULL || strcmp(desc->format,id) != 0) {
3130
DEBUG(0,("check_printjob_info: invalid format %s\n",
3131
id ? id : "<NULL>" ));
3137
static bool api_PrintJobInfo(connection_struct *conn, uint16 vuid,
3138
char *param, int tpscnt,
3139
char *data, int tdscnt,
3140
int mdrcnt,int mprcnt,
3141
char **rdata,char **rparam,
3142
int *rdata_len,int *rparam_len)
3144
struct pack_desc desc;
3145
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
3146
char *str2 = skip_string(param,tpscnt,str1);
3147
char *p = skip_string(param,tpscnt,str2);
3150
int uLevel = get_safe_SVAL(param,tpscnt,p,2,-1);
3151
int function = get_safe_SVAL(param,tpscnt,p,4,-1);
3154
if (!str1 || !str2 || !p) {
3158
* We use 1 here not 2 as we're checking
3159
* the last byte we want to access is safe.
3161
if (!is_offset_safe(param,tpscnt,p,1)) {
3164
if(!rap_to_pjobid(SVAL(p,0), sharename, &jobid))
3167
*rparam = smb_realloc_limit(*rparam,*rparam_len);
3172
if (!share_defined(sharename)) {
3173
DEBUG(0,("api_PrintJobInfo: sharen [%s] not defined\n",
3180
/* check it's a supported varient */
3181
if ((strcmp(str1,"WWsTP")) ||
3182
(!check_printjob_info(&desc,uLevel,str2)))
3185
if (!print_job_exists(sharename, jobid)) {
3186
errcode=NERR_JobNotFound;
3190
errcode = NERR_notsupported;
3194
/* change job place in the queue,
3195
data gives the new place */
3196
place = SVAL(data,0);
3197
if (print_job_set_place(sharename, jobid, place)) {
3198
errcode=NERR_Success;
3203
/* change print job name, data gives the name */
3204
if (print_job_set_name(sharename, jobid, data)) {
3205
errcode=NERR_Success;
3214
SSVALS(*rparam,0,errcode);
3215
SSVAL(*rparam,2,0); /* converter word */
3221
/****************************************************************************
3222
Get info about the server.
3223
****************************************************************************/
3225
static bool api_RNetServerGetInfo(connection_struct *conn,uint16 vuid,
3226
char *param, int tpscnt,
3227
char *data, int tdscnt,
3228
int mdrcnt,int mprcnt,
3229
char **rdata,char **rparam,
3230
int *rdata_len,int *rparam_len)
3232
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
3233
char *str2 = skip_string(param,tpscnt,str1);
3234
char *p = skip_string(param,tpscnt,str2);
3235
int uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
3239
if (!str1 || !str2 || !p) {
3243
DEBUG(4,("NetServerGetInfo level %d\n",uLevel));
3245
/* check it's a supported varient */
3246
if (!prefix_ok(str1,"WrLh")) {
3252
if (strcmp(str2,"B16") != 0) {
3258
if (strcmp(str2,"B16BBDz") != 0) {
3264
if (strcmp(str2,"B16BBDzDDDWWzWWWWWWWBB21zWWWWWWWWWWWWWWWWWWWWWWz")!= 0) {
3270
if (strcmp(str2,"B16BBDzDDDWWzWWWWWWWBB21zWWWWWWWWWWWWWWWWWWWWWWzDWz") != 0) {
3276
if (strcmp(str2,"DN") != 0) {
3282
if (strcmp(str2,"B16BBDzWWzzz") != 0) {
3291
*rdata_len = mdrcnt;
3292
*rdata = smb_realloc_limit(*rdata,*rdata_len);
3298
p2 = p + struct_len;
3300
srvstr_push(NULL, 0, p,global_myname(),16,
3301
STR_ASCII|STR_UPPER|STR_TERMINATE);
3305
struct srv_info_struct *servers=NULL;
3307
char *comment = NULL;
3308
TALLOC_CTX *ctx = talloc_tos();
3309
uint32 servertype= lp_default_server_announce();
3311
comment = talloc_strdup(ctx,lp_serverstring());
3316
if ((count=get_server_info(SV_TYPE_ALL,&servers,lp_workgroup()))>0) {
3317
for (i=0;i<count;i++) {
3318
if (strequal(servers[i].name,global_myname())) {
3319
servertype = servers[i].type;
3320
TALLOC_FREE(comment);
3321
comment = talloc_strdup(ctx,
3322
servers[i].comment);
3332
SCVAL(p,0,lp_major_announce_version());
3333
SCVAL(p,1,lp_minor_announce_version());
3334
SIVAL(p,2,servertype);
3336
if (mdrcnt == struct_len) {
3339
SIVAL(p,6,PTR_DIFF(p2,*rdata));
3340
comment = talloc_sub_advanced(
3342
lp_servicename(SNUM(conn)),
3343
conn->server_info->unix_name,
3345
conn->server_info->utok.gid,
3346
conn->server_info->sanitized_username,
3347
pdb_get_domain(conn->server_info->sam_account),
3352
if (mdrcnt - struct_len <= 0) {
3357
MIN(mdrcnt - struct_len,
3358
MAX_SERVER_STRING_LENGTH),
3360
p2 = skip_string(*rdata,*rdata_len,p2);
3368
return False; /* not yet implemented */
3371
*rdata_len = PTR_DIFF(p2,*rdata);
3374
*rparam = smb_realloc_limit(*rparam,*rparam_len);
3378
SSVAL(*rparam,0,NERR_Success);
3379
SSVAL(*rparam,2,0); /* converter word */
3380
SSVAL(*rparam,4,*rdata_len);
3385
/****************************************************************************
3386
Get info about the server.
3387
****************************************************************************/
3389
static bool api_NetWkstaGetInfo(connection_struct *conn,uint16 vuid,
3390
char *param, int tpscnt,
3391
char *data, int tdscnt,
3392
int mdrcnt,int mprcnt,
3393
char **rdata,char **rparam,
3394
int *rdata_len,int *rparam_len)
3396
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
3397
char *str2 = skip_string(param,tpscnt,str1);
3398
char *p = skip_string(param,tpscnt,str2);
3401
int level = get_safe_SVAL(param,tpscnt,p,0,-1);
3403
if (!str1 || !str2 || !p) {
3407
DEBUG(4,("NetWkstaGetInfo level %d\n",level));
3410
*rparam = smb_realloc_limit(*rparam,*rparam_len);
3415
/* check it's a supported varient */
3416
if (!(level==10 && strcsequal(str1,"WrLh") && strcsequal(str2,"zzzBBzz"))) {
3420
*rdata_len = mdrcnt + 1024;
3421
*rdata = smb_realloc_limit(*rdata,*rdata_len);
3426
SSVAL(*rparam,0,NERR_Success);
3427
SSVAL(*rparam,2,0); /* converter word */
3430
endp = *rdata + *rdata_len;
3432
p2 = get_safe_ptr(*rdata,*rdata_len,p,22);
3437
SIVAL(p,0,PTR_DIFF(p2,*rdata)); /* host name */
3438
strlcpy(p2,get_local_machine_name(),PTR_DIFF(endp,p2));
3440
p2 = skip_string(*rdata,*rdata_len,p2);
3446
SIVAL(p,0,PTR_DIFF(p2,*rdata));
3447
strlcpy(p2,conn->server_info->sanitized_username,PTR_DIFF(endp,p2));
3448
p2 = skip_string(*rdata,*rdata_len,p2);
3454
SIVAL(p,0,PTR_DIFF(p2,*rdata)); /* login domain */
3455
strlcpy(p2,lp_workgroup(),PTR_DIFF(endp,p2));
3457
p2 = skip_string(*rdata,*rdata_len,p2);
3463
SCVAL(p,0,lp_major_announce_version()); /* system version - e.g 4 in 4.1 */
3464
SCVAL(p,1,lp_minor_announce_version()); /* system version - e.g .1 in 4.1 */
3467
SIVAL(p,0,PTR_DIFF(p2,*rdata));
3468
strlcpy(p2,lp_workgroup(),PTR_DIFF(endp,p2)); /* don't know. login domain?? */
3469
p2 = skip_string(*rdata,*rdata_len,p2);
3475
SIVAL(p,0,PTR_DIFF(p2,*rdata)); /* don't know */
3476
strlcpy(p2,"",PTR_DIFF(endp,p2));
3477
p2 = skip_string(*rdata,*rdata_len,p2);
3483
*rdata_len = PTR_DIFF(p2,*rdata);
3485
SSVAL(*rparam,4,*rdata_len);
3490
/****************************************************************************
3491
get info about a user
3493
struct user_info_11 {
3494
char usri11_name[21]; 0-20
3496
char *usri11_comment; 22-25
3497
char *usri11_usr_comment; 26-29
3498
unsigned short usri11_priv; 30-31
3499
unsigned long usri11_auth_flags; 32-35
3500
long usri11_password_age; 36-39
3501
char *usri11_homedir; 40-43
3502
char *usri11_parms; 44-47
3503
long usri11_last_logon; 48-51
3504
long usri11_last_logoff; 52-55
3505
unsigned short usri11_bad_pw_count; 56-57
3506
unsigned short usri11_num_logons; 58-59
3507
char *usri11_logon_server; 60-63
3508
unsigned short usri11_country_code; 64-65
3509
char *usri11_workstations; 66-69
3510
unsigned long usri11_max_storage; 70-73
3511
unsigned short usri11_units_per_week; 74-75
3512
unsigned char *usri11_logon_hours; 76-79
3513
unsigned short usri11_code_page; 80-81
3518
usri11_name specifies the user name for which information is retrieved
3520
usri11_pad aligns the next data structure element to a word boundary
3522
usri11_comment is a null terminated ASCII comment
3524
usri11_user_comment is a null terminated ASCII comment about the user
3526
usri11_priv specifies the level of the privilege assigned to the user.
3527
The possible values are:
3529
Name Value Description
3530
USER_PRIV_GUEST 0 Guest privilege
3531
USER_PRIV_USER 1 User privilege
3532
USER_PRV_ADMIN 2 Administrator privilege
3534
usri11_auth_flags specifies the account operator privileges. The
3535
possible values are:
3537
Name Value Description
3538
AF_OP_PRINT 0 Print operator
3541
Leach, Naik [Page 28]
3545
INTERNET-DRAFT CIFS Remote Admin Protocol January 10, 1997
3548
AF_OP_COMM 1 Communications operator
3549
AF_OP_SERVER 2 Server operator
3550
AF_OP_ACCOUNTS 3 Accounts operator
3553
usri11_password_age specifies how many seconds have elapsed since the
3554
password was last changed.
3556
usri11_home_dir points to a null terminated ASCII string that contains
3557
the path name of the user's home directory.
3559
usri11_parms points to a null terminated ASCII string that is set
3560
aside for use by applications.
3562
usri11_last_logon specifies the time when the user last logged on.
3563
This value is stored as the number of seconds elapsed since
3564
00:00:00, January 1, 1970.
3566
usri11_last_logoff specifies the time when the user last logged off.
3567
This value is stored as the number of seconds elapsed since
3568
00:00:00, January 1, 1970. A value of 0 means the last logoff
3571
usri11_bad_pw_count specifies the number of incorrect passwords
3572
entered since the last successful logon.
3574
usri11_log1_num_logons specifies the number of times this user has
3575
logged on. A value of -1 means the number of logons is unknown.
3577
usri11_logon_server points to a null terminated ASCII string that
3578
contains the name of the server to which logon requests are sent.
3579
A null string indicates logon requests should be sent to the
3582
usri11_country_code specifies the country code for the user's language
3585
usri11_workstations points to a null terminated ASCII string that
3586
contains the names of workstations the user may log on from.
3587
There may be up to 8 workstations, with the names separated by
3588
commas. A null strings indicates there are no restrictions.
3590
usri11_max_storage specifies the maximum amount of disk space the user
3591
can occupy. A value of 0xffffffff indicates there are no
3594
usri11_units_per_week specifies the equal number of time units into
3595
which a week is divided. This value must be equal to 168.
3597
usri11_logon_hours points to a 21 byte (168 bits) string that
3598
specifies the time during which the user can log on. Each bit
3599
represents one unique hour in a week. The first bit (bit 0, word
3600
0) is Sunday, 0:00 to 0:59, the second bit (bit 1, word 0) is
3604
Leach, Naik [Page 29]
3608
INTERNET-DRAFT CIFS Remote Admin Protocol January 10, 1997
3611
Sunday, 1:00 to 1:59 and so on. A null pointer indicates there
3612
are no restrictions.
3614
usri11_code_page specifies the code page for the user's language of
3617
All of the pointers in this data structure need to be treated
3618
specially. The pointer is a 32 bit pointer. The higher 16 bits need
3619
to be ignored. The converter word returned in the parameters section
3620
needs to be subtracted from the lower 16 bits to calculate an offset
3621
into the return buffer where this ASCII string resides.
3623
There is no auxiliary data in the response.
3625
****************************************************************************/
3627
#define usri11_name 0
3628
#define usri11_pad 21
3629
#define usri11_comment 22
3630
#define usri11_usr_comment 26
3631
#define usri11_full_name 30
3632
#define usri11_priv 34
3633
#define usri11_auth_flags 36
3634
#define usri11_password_age 40
3635
#define usri11_homedir 44
3636
#define usri11_parms 48
3637
#define usri11_last_logon 52
3638
#define usri11_last_logoff 56
3639
#define usri11_bad_pw_count 60
3640
#define usri11_num_logons 62
3641
#define usri11_logon_server 64
3642
#define usri11_country_code 68
3643
#define usri11_workstations 70
3644
#define usri11_max_storage 74
3645
#define usri11_units_per_week 78
3646
#define usri11_logon_hours 80
3647
#define usri11_code_page 84
3648
#define usri11_end 86
3650
#define USER_PRIV_GUEST 0
3651
#define USER_PRIV_USER 1
3652
#define USER_PRIV_ADMIN 2
3654
#define AF_OP_PRINT 0
3655
#define AF_OP_COMM 1
3656
#define AF_OP_SERVER 2
3657
#define AF_OP_ACCOUNTS 3
3660
static bool api_RNetUserGetInfo(connection_struct *conn, uint16 vuid,
3661
char *param, int tpscnt,
3662
char *data, int tdscnt,
3663
int mdrcnt,int mprcnt,
3664
char **rdata,char **rparam,
3665
int *rdata_len,int *rparam_len)
3667
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
3668
char *str2 = skip_string(param,tpscnt,str1);
3669
char *UserName = skip_string(param,tpscnt,str2);
3670
char *p = skip_string(param,tpscnt,UserName);
3671
int uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
3674
const char *level_string;
3676
/* get NIS home of a previously validated user - simeon */
3677
/* With share level security vuid will always be zero.
3678
Don't depend on vuser being non-null !!. JRA */
3679
user_struct *vuser = get_valid_user_struct(vuid);
3681
DEBUG(3,(" Username of UID %d is %s\n",
3682
(int)vuser->server_info->utok.uid,
3683
vuser->server_info->unix_name));
3686
if (!str1 || !str2 || !UserName || !p) {
3691
*rparam = smb_realloc_limit(*rparam,*rparam_len);
3696
DEBUG(4,("RNetUserGetInfo level=%d\n", uLevel));
3698
/* check it's a supported variant */
3699
if (strcmp(str1,"zWrLh") != 0) {
3703
case 0: level_string = "B21"; break;
3704
case 1: level_string = "B21BB16DWzzWz"; break;
3705
case 2: level_string = "B21BB16DWzzWzDzzzzDDDDWb21WWzWW"; break;
3706
case 10: level_string = "B21Bzzz"; break;
3707
case 11: level_string = "B21BzzzWDDzzDDWWzWzDWb21W"; break;
3708
default: return False;
3711
if (strcmp(level_string,str2) != 0) {
3715
*rdata_len = mdrcnt + 1024;
3716
*rdata = smb_realloc_limit(*rdata,*rdata_len);
3721
SSVAL(*rparam,0,NERR_Success);
3722
SSVAL(*rparam,2,0); /* converter word */
3725
endp = *rdata + *rdata_len;
3726
p2 = get_safe_ptr(*rdata,*rdata_len,p,usri11_end);
3732
fstrcpy(p+usri11_name,UserName); /* 21 bytes - user name */
3735
SCVAL(p,usri11_pad,0); /* padding - 1 byte */
3740
SIVAL(p,usri11_comment,PTR_DIFF(p2,p)); /* comment */
3741
strlcpy(p2,"Comment",PTR_DIFF(endp,p2));
3742
p2 = skip_string(*rdata,*rdata_len,p2);
3747
SIVAL(p,usri11_usr_comment,PTR_DIFF(p2,p)); /* user_comment */
3748
strlcpy(p2,"UserComment",PTR_DIFF(endp,p2));
3749
p2 = skip_string(*rdata,*rdata_len,p2);
3754
/* EEK! the cifsrap.txt doesn't have this in!!!! */
3755
SIVAL(p,usri11_full_name,PTR_DIFF(p2,p)); /* full name */
3756
strlcpy(p2,((vuser != NULL)
3757
? pdb_get_fullname(vuser->server_info->sam_account)
3758
: UserName),PTR_DIFF(endp,p2));
3759
p2 = skip_string(*rdata,*rdata_len,p2);
3766
const char *homedir = "";
3767
if (vuser != NULL) {
3768
homedir = pdb_get_homedir(
3769
vuser->server_info->sam_account);
3771
/* modelled after NTAS 3.51 reply */
3772
SSVAL(p,usri11_priv,conn->admin_user?USER_PRIV_ADMIN:USER_PRIV_USER);
3773
SIVAL(p,usri11_auth_flags,AF_OP_PRINT); /* auth flags */
3774
SIVALS(p,usri11_password_age,-1); /* password age */
3775
SIVAL(p,usri11_homedir,PTR_DIFF(p2,p)); /* home dir */
3776
strlcpy(p2, homedir, PTR_DIFF(endp,p2));
3777
p2 = skip_string(*rdata,*rdata_len,p2);
3781
SIVAL(p,usri11_parms,PTR_DIFF(p2,p)); /* parms */
3782
strlcpy(p2,"",PTR_DIFF(endp,p2));
3783
p2 = skip_string(*rdata,*rdata_len,p2);
3787
SIVAL(p,usri11_last_logon,0); /* last logon */
3788
SIVAL(p,usri11_last_logoff,0); /* last logoff */
3789
SSVALS(p,usri11_bad_pw_count,-1); /* bad pw counts */
3790
SSVALS(p,usri11_num_logons,-1); /* num logons */
3791
SIVAL(p,usri11_logon_server,PTR_DIFF(p2,p)); /* logon server */
3792
strlcpy(p2,"\\\\*",PTR_DIFF(endp,p2));
3793
p2 = skip_string(*rdata,*rdata_len,p2);
3797
SSVAL(p,usri11_country_code,0); /* country code */
3799
SIVAL(p,usri11_workstations,PTR_DIFF(p2,p)); /* workstations */
3800
strlcpy(p2,"",PTR_DIFF(endp,p2));
3801
p2 = skip_string(*rdata,*rdata_len,p2);
3806
SIVALS(p,usri11_max_storage,-1); /* max storage */
3807
SSVAL(p,usri11_units_per_week,168); /* units per week */
3808
SIVAL(p,usri11_logon_hours,PTR_DIFF(p2,p)); /* logon hours */
3810
/* a simple way to get logon hours at all times. */
3812
SCVAL(p2,21,0); /* fix zero termination */
3813
p2 = skip_string(*rdata,*rdata_len,p2);
3818
SSVAL(p,usri11_code_page,0); /* code page */
3821
if (uLevel == 1 || uLevel == 2) {
3822
memset(p+22,' ',16); /* password */
3823
SIVALS(p,38,-1); /* password age */
3825
conn->admin_user?USER_PRIV_ADMIN:USER_PRIV_USER);
3826
SIVAL(p,44,PTR_DIFF(p2,*rdata)); /* home dir */
3827
strlcpy(p2, vuser ? pdb_get_homedir(
3828
vuser->server_info->sam_account) : "",
3830
p2 = skip_string(*rdata,*rdata_len,p2);
3834
SIVAL(p,48,PTR_DIFF(p2,*rdata)); /* comment */
3836
SSVAL(p,52,0); /* flags */
3837
SIVAL(p,54,PTR_DIFF(p2,*rdata)); /* script_path */
3838
strlcpy(p2, vuser ? pdb_get_logon_script(
3839
vuser->server_info->sam_account) : "",
3841
p2 = skip_string(*rdata,*rdata_len,p2);
3846
SIVAL(p,60,0); /* auth_flags */
3847
SIVAL(p,64,PTR_DIFF(p2,*rdata)); /* full_name */
3848
strlcpy(p2,((vuser != NULL)
3849
? pdb_get_fullname(vuser->server_info->sam_account)
3850
: UserName),PTR_DIFF(endp,p2));
3851
p2 = skip_string(*rdata,*rdata_len,p2);
3855
SIVAL(p,68,0); /* urs_comment */
3856
SIVAL(p,72,PTR_DIFF(p2,*rdata)); /* parms */
3857
strlcpy(p2,"",PTR_DIFF(endp,p2));
3858
p2 = skip_string(*rdata,*rdata_len,p2);
3862
SIVAL(p,76,0); /* workstations */
3863
SIVAL(p,80,0); /* last_logon */
3864
SIVAL(p,84,0); /* last_logoff */
3865
SIVALS(p,88,-1); /* acct_expires */
3866
SIVALS(p,92,-1); /* max_storage */
3867
SSVAL(p,96,168); /* units_per_week */
3868
SIVAL(p,98,PTR_DIFF(p2,*rdata)); /* logon_hours */
3871
SSVALS(p,102,-1); /* bad_pw_count */
3872
SSVALS(p,104,-1); /* num_logons */
3873
SIVAL(p,106,PTR_DIFF(p2,*rdata)); /* logon_server */
3875
TALLOC_CTX *ctx = talloc_tos();
3876
int space_rem = *rdata_len - (p2 - *rdata);
3879
if (space_rem <= 0) {
3882
tmp = talloc_strdup(ctx, "\\\\%L");
3886
tmp = talloc_sub_basic(ctx,
3899
p2 = skip_string(*rdata,*rdata_len,p2);
3903
SSVAL(p,110,49); /* country_code */
3904
SSVAL(p,112,860); /* code page */
3908
*rdata_len = PTR_DIFF(p2,*rdata);
3910
SSVAL(*rparam,4,*rdata_len); /* is this right?? */
3915
static bool api_WWkstaUserLogon(connection_struct *conn,uint16 vuid,
3916
char *param, int tpscnt,
3917
char *data, int tdscnt,
3918
int mdrcnt,int mprcnt,
3919
char **rdata,char **rparam,
3920
int *rdata_len,int *rparam_len)
3922
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
3923
char *str2 = skip_string(param,tpscnt,str1);
3924
char *p = skip_string(param,tpscnt,str2);
3926
struct pack_desc desc;
3928
/* With share level security vuid will always be zero.
3929
Don't depend on vuser being non-null !!. JRA */
3930
user_struct *vuser = get_valid_user_struct(vuid);
3932
if (!str1 || !str2 || !p) {
3937
DEBUG(3,(" Username of UID %d is %s\n",
3938
(int)vuser->server_info->utok.uid,
3939
vuser->server_info->unix_name));
3942
uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
3943
name = get_safe_str_ptr(param,tpscnt,p,2);
3948
memset((char *)&desc,'\0',sizeof(desc));
3950
DEBUG(3,("WWkstaUserLogon uLevel=%d name=%s\n",uLevel,name));
3952
/* check it's a supported varient */
3953
if (strcmp(str1,"OOWb54WrLh") != 0) {
3956
if (uLevel != 1 || strcmp(str2,"WB21BWDWWDDDDDDDzzzD") != 0) {
3960
*rdata = smb_realloc_limit(*rdata,mdrcnt);
3967
desc.buflen = mdrcnt;
3968
desc.subformat = NULL;
3971
if (init_package(&desc,1,0)) {
3972
PACKI(&desc,"W",0); /* code */
3973
PACKS(&desc,"B21",name); /* eff. name */
3974
PACKS(&desc,"B",""); /* pad */
3975
PACKI(&desc,"W", conn->admin_user?USER_PRIV_ADMIN:USER_PRIV_USER);
3976
PACKI(&desc,"D",0); /* auth flags XXX */
3977
PACKI(&desc,"W",0); /* num logons */
3978
PACKI(&desc,"W",0); /* bad pw count */
3979
PACKI(&desc,"D",0); /* last logon */
3980
PACKI(&desc,"D",-1); /* last logoff */
3981
PACKI(&desc,"D",-1); /* logoff time */
3982
PACKI(&desc,"D",-1); /* kickoff time */
3983
PACKI(&desc,"D",0); /* password age */
3984
PACKI(&desc,"D",0); /* password can change */
3985
PACKI(&desc,"D",-1); /* password must change */
3989
fstrcpy(mypath,"\\\\");
3990
fstrcat(mypath,get_local_machine_name());
3992
PACKS(&desc,"z",mypath); /* computer */
3995
PACKS(&desc,"z",lp_workgroup());/* domain */
3996
PACKS(&desc,"z", vuser ? pdb_get_logon_script(
3997
vuser->server_info->sam_account) : ""); /* script path */
3998
PACKI(&desc,"D",0x00000000); /* reserved */
4001
*rdata_len = desc.usedlen;
4003
*rparam = smb_realloc_limit(*rparam,*rparam_len);
4007
SSVALS(*rparam,0,desc.errcode);
4009
SSVAL(*rparam,4,desc.neededlen);
4011
DEBUG(4,("WWkstaUserLogon: errorcode %d\n",desc.errcode));
4016
/****************************************************************************
4017
api_WAccessGetUserPerms
4018
****************************************************************************/
4020
static bool api_WAccessGetUserPerms(connection_struct *conn,uint16 vuid,
4021
char *param, int tpscnt,
4022
char *data, int tdscnt,
4023
int mdrcnt,int mprcnt,
4024
char **rdata,char **rparam,
4025
int *rdata_len,int *rparam_len)
4027
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
4028
char *str2 = skip_string(param,tpscnt,str1);
4029
char *user = skip_string(param,tpscnt,str2);
4030
char *resource = skip_string(param,tpscnt,user);
4032
if (!str1 || !str2 || !user || !resource) {
4036
if (skip_string(param,tpscnt,resource) == NULL) {
4039
DEBUG(3,("WAccessGetUserPerms user=%s resource=%s\n",user,resource));
4041
/* check it's a supported varient */
4042
if (strcmp(str1,"zzh") != 0) {
4045
if (strcmp(str2,"") != 0) {
4050
*rparam = smb_realloc_limit(*rparam,*rparam_len);
4054
SSVALS(*rparam,0,0); /* errorcode */
4055
SSVAL(*rparam,2,0); /* converter word */
4056
SSVAL(*rparam,4,0x7f); /* permission flags */
4061
/****************************************************************************
4062
api_WPrintJobEnumerate
4063
****************************************************************************/
4065
static bool api_WPrintJobGetInfo(connection_struct *conn, uint16 vuid,
4066
char *param, int tpscnt,
4067
char *data, int tdscnt,
4068
int mdrcnt,int mprcnt,
4069
char **rdata,char **rparam,
4070
int *rdata_len,int *rparam_len)
4072
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
4073
char *str2 = skip_string(param,tpscnt,str1);
4074
char *p = skip_string(param,tpscnt,str2);
4081
struct pack_desc desc;
4082
print_queue_struct *queue=NULL;
4083
print_status_struct status;
4086
if (!str1 || !str2 || !p) {
4090
uLevel = get_safe_SVAL(param,tpscnt,p,2,-1);
4092
memset((char *)&desc,'\0',sizeof(desc));
4093
memset((char *)&status,'\0',sizeof(status));
4095
DEBUG(3,("WPrintJobGetInfo uLevel=%d uJobId=0x%X\n",uLevel,SVAL(p,0)));
4097
/* check it's a supported varient */
4098
if (strcmp(str1,"WWrLh") != 0) {
4101
if (!check_printjob_info(&desc,uLevel,str2)) {
4105
if(!rap_to_pjobid(SVAL(p,0), sharename, &jobid)) {
4109
snum = lp_servicenumber( sharename);
4110
if (snum < 0 || !VALID_SNUM(snum)) {
4114
count = print_queue_status(snum,&queue,&status);
4115
for (i = 0; i < count; i++) {
4116
if (queue[i].job == jobid) {
4122
*rdata = smb_realloc_limit(*rdata,mdrcnt);
4127
desc.buflen = mdrcnt;
4130
* Don't return data but need to get correct length
4131
* init_package will return wrong size if buflen=0
4133
desc.buflen = getlen(desc.format);
4134
desc.base = tmpdata = (char *)SMB_MALLOC( desc.buflen );
4137
if (init_package(&desc,1,0)) {
4139
fill_printjob_info(conn,snum,uLevel,&desc,&queue[i],i);
4140
*rdata_len = desc.usedlen;
4142
desc.errcode = NERR_JobNotFound;
4148
*rparam = smb_realloc_limit(*rparam,*rparam_len);
4152
SSVALS(*rparam,0,desc.errcode);
4154
SSVAL(*rparam,4,desc.neededlen);
4159
DEBUG(4,("WPrintJobGetInfo: errorcode %d\n",desc.errcode));
4164
static bool api_WPrintJobEnumerate(connection_struct *conn, uint16 vuid,
4165
char *param, int tpscnt,
4166
char *data, int tdscnt,
4167
int mdrcnt,int mprcnt,
4168
char **rdata,char **rparam,
4169
int *rdata_len,int *rparam_len)
4171
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
4172
char *str2 = skip_string(param,tpscnt,str1);
4173
char *p = skip_string(param,tpscnt,str2);
4179
struct pack_desc desc;
4180
print_queue_struct *queue=NULL;
4181
print_status_struct status;
4183
if (!str1 || !str2 || !p) {
4187
memset((char *)&desc,'\0',sizeof(desc));
4188
memset((char *)&status,'\0',sizeof(status));
4190
p = skip_string(param,tpscnt,p);
4194
uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
4196
DEBUG(3,("WPrintJobEnumerate uLevel=%d name=%s\n",uLevel,name));
4198
/* check it's a supported variant */
4199
if (strcmp(str1,"zWrLeh") != 0) {
4204
return False; /* defined only for uLevel 0,1,2 */
4207
if (!check_printjob_info(&desc,uLevel,str2)) {
4211
snum = find_service(name);
4212
if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) ) {
4216
count = print_queue_status(snum,&queue,&status);
4218
*rdata = smb_realloc_limit(*rdata,mdrcnt);
4224
desc.buflen = mdrcnt;
4226
if (init_package(&desc,count,0)) {
4228
for (i = 0; i < count; i++) {
4229
fill_printjob_info(conn,snum,uLevel,&desc,&queue[i],i);
4230
if (desc.errcode == NERR_Success) {
4236
*rdata_len = desc.usedlen;
4239
*rparam = smb_realloc_limit(*rparam,*rparam_len);
4243
SSVALS(*rparam,0,desc.errcode);
4245
SSVAL(*rparam,4,succnt);
4246
SSVAL(*rparam,6,count);
4250
DEBUG(4,("WPrintJobEnumerate: errorcode %d\n",desc.errcode));
4255
static int check_printdest_info(struct pack_desc* desc,
4256
int uLevel, char* id)
4258
desc->subformat = NULL;
4261
desc->format = "B9";
4264
desc->format = "B9B21WWzW";
4270
desc->format = "zzzWWzzzWW";
4273
DEBUG(0,("check_printdest_info: invalid level %d\n",
4277
if (id == NULL || strcmp(desc->format,id) != 0) {
4278
DEBUG(0,("check_printdest_info: invalid string %s\n",
4279
id ? id : "<NULL>" ));
4285
static void fill_printdest_info(connection_struct *conn, int snum, int uLevel,
4286
struct pack_desc* desc)
4290
strncpy(buf,SERVICE(snum),sizeof(buf)-1);
4291
buf[sizeof(buf)-1] = 0;
4295
PACKS(desc,"B9",buf); /* szName */
4297
PACKS(desc,"B21",""); /* szUserName */
4298
PACKI(desc,"W",0); /* uJobId */
4299
PACKI(desc,"W",0); /* fsStatus */
4300
PACKS(desc,"z",""); /* pszStatus */
4301
PACKI(desc,"W",0); /* time */
4305
if (uLevel == 2 || uLevel == 3) {
4306
PACKS(desc,"z",buf); /* pszPrinterName */
4308
PACKS(desc,"z",""); /* pszUserName */
4309
PACKS(desc,"z",""); /* pszLogAddr */
4310
PACKI(desc,"W",0); /* uJobId */
4311
PACKI(desc,"W",0); /* fsStatus */
4312
PACKS(desc,"z",""); /* pszStatus */
4313
PACKS(desc,"z",""); /* pszComment */
4314
PACKS(desc,"z","NULL"); /* pszDrivers */
4315
PACKI(desc,"W",0); /* time */
4316
PACKI(desc,"W",0); /* pad1 */
4321
static bool api_WPrintDestGetInfo(connection_struct *conn, uint16 vuid,
4322
char *param, int tpscnt,
4323
char *data, int tdscnt,
4324
int mdrcnt,int mprcnt,
4325
char **rdata,char **rparam,
4326
int *rdata_len,int *rparam_len)
4328
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
4329
char *str2 = skip_string(param,tpscnt,str1);
4330
char *p = skip_string(param,tpscnt,str2);
4331
char* PrinterName = p;
4333
struct pack_desc desc;
4337
if (!str1 || !str2 || !p) {
4341
memset((char *)&desc,'\0',sizeof(desc));
4343
p = skip_string(param,tpscnt,p);
4347
uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
4349
DEBUG(3,("WPrintDestGetInfo uLevel=%d PrinterName=%s\n",uLevel,PrinterName));
4351
/* check it's a supported varient */
4352
if (strcmp(str1,"zWrLh") != 0) {
4355
if (!check_printdest_info(&desc,uLevel,str2)) {
4359
snum = find_service(PrinterName);
4360
if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) ) {
4362
desc.errcode = NERR_DestNotFound;
4366
*rdata = smb_realloc_limit(*rdata,mdrcnt);
4371
desc.buflen = mdrcnt;
4374
* Don't return data but need to get correct length
4375
* init_package will return wrong size if buflen=0
4377
desc.buflen = getlen(desc.format);
4378
desc.base = tmpdata = (char *)SMB_MALLOC( desc.buflen );
4380
if (init_package(&desc,1,0)) {
4381
fill_printdest_info(conn,snum,uLevel,&desc);
4383
*rdata_len = desc.usedlen;
4387
*rparam = smb_realloc_limit(*rparam,*rparam_len);
4391
SSVALS(*rparam,0,desc.errcode);
4393
SSVAL(*rparam,4,desc.neededlen);
4395
DEBUG(4,("WPrintDestGetInfo: errorcode %d\n",desc.errcode));
4401
static bool api_WPrintDestEnum(connection_struct *conn, uint16 vuid,
4402
char *param, int tpscnt,
4403
char *data, int tdscnt,
4404
int mdrcnt,int mprcnt,
4405
char **rdata,char **rparam,
4406
int *rdata_len,int *rparam_len)
4408
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
4409
char *str2 = skip_string(param,tpscnt,str1);
4410
char *p = skip_string(param,tpscnt,str2);
4414
struct pack_desc desc;
4415
int services = lp_numservices();
4417
if (!str1 || !str2 || !p) {
4421
memset((char *)&desc,'\0',sizeof(desc));
4423
uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
4425
DEBUG(3,("WPrintDestEnum uLevel=%d\n",uLevel));
4427
/* check it's a supported varient */
4428
if (strcmp(str1,"WrLeh") != 0) {
4431
if (!check_printdest_info(&desc,uLevel,str2)) {
4436
for (i = 0; i < services; i++) {
4437
if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
4443
*rdata = smb_realloc_limit(*rdata,mdrcnt);
4450
desc.buflen = mdrcnt;
4451
if (init_package(&desc,queuecnt,0)) {
4454
for (i = 0; i < services; i++) {
4455
if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
4456
fill_printdest_info(conn,i,uLevel,&desc);
4458
if (desc.errcode == NERR_Success) {
4465
*rdata_len = desc.usedlen;
4468
*rparam = smb_realloc_limit(*rparam,*rparam_len);
4472
SSVALS(*rparam,0,desc.errcode);
4474
SSVAL(*rparam,4,succnt);
4475
SSVAL(*rparam,6,queuecnt);
4477
DEBUG(4,("WPrintDestEnumerate: errorcode %d\n",desc.errcode));
4482
static bool api_WPrintDriverEnum(connection_struct *conn, uint16 vuid,
4483
char *param, int tpscnt,
4484
char *data, int tdscnt,
4485
int mdrcnt,int mprcnt,
4486
char **rdata,char **rparam,
4487
int *rdata_len,int *rparam_len)
4489
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
4490
char *str2 = skip_string(param,tpscnt,str1);
4491
char *p = skip_string(param,tpscnt,str2);
4494
struct pack_desc desc;
4496
if (!str1 || !str2 || !p) {
4500
memset((char *)&desc,'\0',sizeof(desc));
4502
uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
4504
DEBUG(3,("WPrintDriverEnum uLevel=%d\n",uLevel));
4506
/* check it's a supported varient */
4507
if (strcmp(str1,"WrLeh") != 0) {
4510
if (uLevel != 0 || strcmp(str2,"B41") != 0) {
4515
*rdata = smb_realloc_limit(*rdata,mdrcnt);
4521
desc.buflen = mdrcnt;
4522
if (init_package(&desc,1,0)) {
4523
PACKS(&desc,"B41","NULL");
4526
succnt = (desc.errcode == NERR_Success ? 1 : 0);
4528
*rdata_len = desc.usedlen;
4531
*rparam = smb_realloc_limit(*rparam,*rparam_len);
4535
SSVALS(*rparam,0,desc.errcode);
4537
SSVAL(*rparam,4,succnt);
4540
DEBUG(4,("WPrintDriverEnum: errorcode %d\n",desc.errcode));
4545
static bool api_WPrintQProcEnum(connection_struct *conn, uint16 vuid,
4546
char *param, int tpscnt,
4547
char *data, int tdscnt,
4548
int mdrcnt,int mprcnt,
4549
char **rdata,char **rparam,
4550
int *rdata_len,int *rparam_len)
4552
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
4553
char *str2 = skip_string(param,tpscnt,str1);
4554
char *p = skip_string(param,tpscnt,str2);
4557
struct pack_desc desc;
4559
if (!str1 || !str2 || !p) {
4562
memset((char *)&desc,'\0',sizeof(desc));
4564
uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
4566
DEBUG(3,("WPrintQProcEnum uLevel=%d\n",uLevel));
4568
/* check it's a supported varient */
4569
if (strcmp(str1,"WrLeh") != 0) {
4572
if (uLevel != 0 || strcmp(str2,"B13") != 0) {
4577
*rdata = smb_realloc_limit(*rdata,mdrcnt);
4583
desc.buflen = mdrcnt;
4585
if (init_package(&desc,1,0)) {
4586
PACKS(&desc,"B13","lpd");
4589
succnt = (desc.errcode == NERR_Success ? 1 : 0);
4591
*rdata_len = desc.usedlen;
4594
*rparam = smb_realloc_limit(*rparam,*rparam_len);
4598
SSVALS(*rparam,0,desc.errcode);
4600
SSVAL(*rparam,4,succnt);
4603
DEBUG(4,("WPrintQProcEnum: errorcode %d\n",desc.errcode));
4608
static bool api_WPrintPortEnum(connection_struct *conn, uint16 vuid,
4609
char *param, int tpscnt,
4610
char *data, int tdscnt,
4611
int mdrcnt,int mprcnt,
4612
char **rdata,char **rparam,
4613
int *rdata_len,int *rparam_len)
4615
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
4616
char *str2 = skip_string(param,tpscnt,str1);
4617
char *p = skip_string(param,tpscnt,str2);
4620
struct pack_desc desc;
4622
if (!str1 || !str2 || !p) {
4626
memset((char *)&desc,'\0',sizeof(desc));
4628
uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
4630
DEBUG(3,("WPrintPortEnum uLevel=%d\n",uLevel));
4632
/* check it's a supported varient */
4633
if (strcmp(str1,"WrLeh") != 0) {
4636
if (uLevel != 0 || strcmp(str2,"B9") != 0) {
4641
*rdata = smb_realloc_limit(*rdata,mdrcnt);
4646
memset((char *)&desc,'\0',sizeof(desc));
4648
desc.buflen = mdrcnt;
4650
if (init_package(&desc,1,0)) {
4651
PACKS(&desc,"B13","lp0");
4654
succnt = (desc.errcode == NERR_Success ? 1 : 0);
4656
*rdata_len = desc.usedlen;
4659
*rparam = smb_realloc_limit(*rparam,*rparam_len);
4663
SSVALS(*rparam,0,desc.errcode);
4665
SSVAL(*rparam,4,succnt);
4668
DEBUG(4,("WPrintPortEnum: errorcode %d\n",desc.errcode));
4673
/****************************************************************************
4675
****************************************************************************/
4677
static bool api_RNetSessionEnum(connection_struct *conn, uint16 vuid,
4678
char *param, int tpscnt,
4679
char *data, int tdscnt,
4680
int mdrcnt,int mprcnt,
4681
char **rdata,char **rparam,
4682
int *rdata_len,int *rparam_len)
4685
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
4686
char *str2 = skip_string(param,tpscnt,str1);
4687
char *p = skip_string(param,tpscnt,str2);
4689
struct pack_desc desc;
4690
struct sessionid *session_list;
4691
int i, num_sessions;
4693
if (!str1 || !str2 || !p) {
4697
memset((char *)&desc,'\0',sizeof(desc));
4699
uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
4701
DEBUG(3,("RNetSessionEnum uLevel=%d\n",uLevel));
4702
DEBUG(7,("RNetSessionEnum req string=%s\n",str1));
4703
DEBUG(7,("RNetSessionEnum ret string=%s\n",str2));
4705
/* check it's a supported varient */
4706
if (strcmp(str1,RAP_NetSessionEnum_REQ) != 0) {
4709
if (uLevel != 2 || strcmp(str2,RAP_SESSION_INFO_L2) != 0) {
4713
num_sessions = list_sessions(talloc_tos(), &session_list);
4716
*rdata = smb_realloc_limit(*rdata,mdrcnt);
4721
memset((char *)&desc,'\0',sizeof(desc));
4723
desc.buflen = mdrcnt;
4725
if (!init_package(&desc,num_sessions,0)) {
4729
for(i=0; i<num_sessions; i++) {
4730
PACKS(&desc, "z", session_list[i].remote_machine);
4731
PACKS(&desc, "z", session_list[i].username);
4732
PACKI(&desc, "W", 1); /* num conns */
4733
PACKI(&desc, "W", 0); /* num opens */
4734
PACKI(&desc, "W", 1); /* num users */
4735
PACKI(&desc, "D", 0); /* session time */
4736
PACKI(&desc, "D", 0); /* idle time */
4737
PACKI(&desc, "D", 0); /* flags */
4738
PACKS(&desc, "z", "Unknown Client"); /* client type string */
4741
*rdata_len = desc.usedlen;
4744
*rparam = smb_realloc_limit(*rparam,*rparam_len);
4748
SSVALS(*rparam,0,desc.errcode);
4749
SSVAL(*rparam,2,0); /* converter */
4750
SSVAL(*rparam,4,num_sessions); /* count */
4752
DEBUG(4,("RNetSessionEnum: errorcode %d\n",desc.errcode));
4758
/****************************************************************************
4759
The buffer was too small.
4760
****************************************************************************/
4762
static bool api_TooSmall(connection_struct *conn,uint16 vuid, char *param, char *data,
4763
int mdrcnt, int mprcnt,
4764
char **rdata, char **rparam,
4765
int *rdata_len, int *rparam_len)
4767
*rparam_len = MIN(*rparam_len,mprcnt);
4768
*rparam = smb_realloc_limit(*rparam,*rparam_len);
4775
SSVAL(*rparam,0,NERR_BufTooSmall);
4777
DEBUG(3,("Supplied buffer too small in API command\n"));
4782
/****************************************************************************
4783
The request is not supported.
4784
****************************************************************************/
4786
static bool api_Unsupported(connection_struct *conn, uint16 vuid,
4787
char *param, int tpscnt,
4788
char *data, int tdscnt,
4789
int mdrcnt, int mprcnt,
4790
char **rdata, char **rparam,
4791
int *rdata_len, int *rparam_len)
4794
*rparam = smb_realloc_limit(*rparam,*rparam_len);
4801
SSVAL(*rparam,0,NERR_notsupported);
4802
SSVAL(*rparam,2,0); /* converter word */
4804
DEBUG(3,("Unsupported API command\n"));
4809
static const struct {
4812
bool (*fn)(connection_struct *, uint16,
4815
int,int,char **,char **,int *,int *);
4816
bool auth_user; /* Deny anonymous access? */
4817
} api_commands[] = {
4818
{"RNetShareEnum", RAP_WshareEnum, api_RNetShareEnum, True},
4819
{"RNetShareGetInfo", RAP_WshareGetInfo, api_RNetShareGetInfo},
4820
{"RNetShareAdd", RAP_WshareAdd, api_RNetShareAdd},
4821
{"RNetSessionEnum", RAP_WsessionEnum, api_RNetSessionEnum, True},
4822
{"RNetServerGetInfo", RAP_WserverGetInfo, api_RNetServerGetInfo},
4823
{"RNetGroupEnum", RAP_WGroupEnum, api_RNetGroupEnum, True},
4824
{"RNetGroupGetUsers", RAP_WGroupGetUsers, api_RNetGroupGetUsers, True},
4825
{"RNetUserEnum", RAP_WUserEnum, api_RNetUserEnum, True},
4826
{"RNetUserGetInfo", RAP_WUserGetInfo, api_RNetUserGetInfo},
4827
{"NetUserGetGroups", RAP_WUserGetGroups, api_NetUserGetGroups},
4828
{"NetWkstaGetInfo", RAP_WWkstaGetInfo, api_NetWkstaGetInfo},
4829
{"DosPrintQEnum", RAP_WPrintQEnum, api_DosPrintQEnum, True},
4830
{"DosPrintQGetInfo", RAP_WPrintQGetInfo, api_DosPrintQGetInfo},
4831
{"WPrintQueuePause", RAP_WPrintQPause, api_WPrintQueueCtrl},
4832
{"WPrintQueueResume", RAP_WPrintQContinue, api_WPrintQueueCtrl},
4833
{"WPrintJobEnumerate",RAP_WPrintJobEnum, api_WPrintJobEnumerate},
4834
{"WPrintJobGetInfo", RAP_WPrintJobGetInfo, api_WPrintJobGetInfo},
4835
{"RDosPrintJobDel", RAP_WPrintJobDel, api_RDosPrintJobDel},
4836
{"RDosPrintJobPause", RAP_WPrintJobPause, api_RDosPrintJobDel},
4837
{"RDosPrintJobResume",RAP_WPrintJobContinue, api_RDosPrintJobDel},
4838
{"WPrintDestEnum", RAP_WPrintDestEnum, api_WPrintDestEnum},
4839
{"WPrintDestGetInfo", RAP_WPrintDestGetInfo, api_WPrintDestGetInfo},
4840
{"NetRemoteTOD", RAP_NetRemoteTOD, api_NetRemoteTOD},
4841
{"WPrintQueuePurge", RAP_WPrintQPurge, api_WPrintQueueCtrl},
4842
{"NetServerEnum2", RAP_NetServerEnum2, api_RNetServerEnum2}, /* anon OK */
4843
{"NetServerEnum3", RAP_NetServerEnum3, api_RNetServerEnum3}, /* anon OK */
4844
{"WAccessGetUserPerms",RAP_WAccessGetUserPerms,api_WAccessGetUserPerms},
4845
{"SetUserPassword", RAP_WUserPasswordSet2, api_SetUserPassword},
4846
{"WWkstaUserLogon", RAP_WWkstaUserLogon, api_WWkstaUserLogon},
4847
{"PrintJobInfo", RAP_WPrintJobSetInfo, api_PrintJobInfo},
4848
{"WPrintDriverEnum", RAP_WPrintDriverEnum, api_WPrintDriverEnum},
4849
{"WPrintQProcEnum", RAP_WPrintQProcessorEnum,api_WPrintQProcEnum},
4850
{"WPrintPortEnum", RAP_WPrintPortEnum, api_WPrintPortEnum},
4851
{"SamOEMChangePassword",RAP_SamOEMChgPasswordUser2_P,api_SamOEMChangePassword}, /* anon OK */
4852
{NULL, -1, api_Unsupported}
4853
/* The following RAP calls are not implemented by Samba:
4855
RAP_WFileEnum2 - anon not OK
4860
/****************************************************************************
4861
Handle remote api calls.
4862
****************************************************************************/
4864
void api_reply(connection_struct *conn, uint16 vuid,
4865
struct smb_request *req,
4866
char *data, char *params,
4867
int tdscnt, int tpscnt,
4868
int mdrcnt, int mprcnt)
4872
char *rparam = NULL;
4873
const char *name1 = NULL;
4874
const char *name2 = NULL;
4881
DEBUG(0,("ERROR: NULL params in api_reply()\n"));
4882
reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4887
reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4890
api_command = SVAL(params,0);
4891
/* Is there a string at position params+2 ? */
4892
if (skip_string(params,tpscnt,params+2)) {
4897
name2 = skip_string(params,tpscnt,params+2);
4902
DEBUG(3,("Got API command %d of form <%s> <%s> (tdscnt=%d,tpscnt=%d,mdrcnt=%d,mprcnt=%d)\n",
4906
tdscnt,tpscnt,mdrcnt,mprcnt));
4908
for (i=0;api_commands[i].name;i++) {
4909
if (api_commands[i].id == api_command && api_commands[i].fn) {
4910
DEBUG(3,("Doing %s\n",api_commands[i].name));
4915
/* Check whether this api call can be done anonymously */
4917
if (api_commands[i].auth_user && lp_restrict_anonymous()) {
4918
user_struct *user = get_valid_user_struct(vuid);
4920
if (!user || user->server_info->guest) {
4921
reply_nterror(req, NT_STATUS_ACCESS_DENIED);
4926
rdata = (char *)SMB_MALLOC(1024);
4928
memset(rdata,'\0',1024);
4931
rparam = (char *)SMB_MALLOC(1024);
4933
memset(rparam,'\0',1024);
4936
if(!rdata || !rparam) {
4937
DEBUG(0,("api_reply: malloc fail !\n"));
4940
reply_nterror(req, NT_STATUS_NO_MEMORY);
4944
reply = api_commands[i].fn(conn,
4946
params,tpscnt, /* params + length */
4947
data,tdscnt, /* data + length */
4949
&rdata,&rparam,&rdata_len,&rparam_len);
4952
if (rdata_len > mdrcnt || rparam_len > mprcnt) {
4953
reply = api_TooSmall(conn,vuid,params,data,mdrcnt,mprcnt,
4954
&rdata,&rparam,&rdata_len,&rparam_len);
4957
/* if we get False back then it's actually unsupported */
4959
reply = api_Unsupported(conn,vuid,params,tpscnt,data,tdscnt,mdrcnt,mprcnt,
4960
&rdata,&rparam,&rdata_len,&rparam_len);
4963
/* If api_Unsupported returns false we can't return anything. */
4965
send_trans_reply(conn, req, rparam, rparam_len,
4966
rdata, rdata_len, False);
added
removed
source3/smbd/lanman.c
