?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
patch to fix NetServerEnum with multiple workgroup lists kindly supplied.
[Samba.git] / source / smbd / ipc.c
blobc5c87ea07f6599c1e7264c07aefe0cbf2b5cef0d
1 /*
2 Unix SMB/Netbios implementation.
3 Version 1.9.
4 Inter-process communication and named pipe handling
5 Copyright (C) Andrew Tridgell 1992-1995
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21 /*
22 This file handles the named pipe and mailslot calls
23 in the SMBtrans protocol
24 */
25
26 #include "includes.h"
27
28 #ifdef CHECK_TYPES
29 #undef CHECK_TYPES
30 #endif
31 #define CHECK_TYPES 0
32
33 extern int DEBUGLEVEL;
34 extern int maxxmit;
35 extern files_struct Files[];
36 extern connection_struct Connections[];
37
38 extern fstring local_machine;
39
40 #define NERR_Success 0
41 #define NERR_badpass 86
42 #define NERR_notsupported 50
43
44 #define NERR_BASE (2100)
45 #define NERR_BufTooSmall (NERR_BASE+23)
46 #define NERR_JobNotFound (NERR_BASE+51)
47 #define NERR_DestNotFound (NERR_BASE+52)
48 #define ERROR_INVALID_LEVEL 124
49 #define ERROR_MORE_DATA 234
50
51 #define REALLOC(ptr,size) Realloc(ptr,MAX((size),4*1024))
52
53 #define ACCESS_READ 0x01
54 #define ACCESS_WRITE 0x02
55 #define ACCESS_CREATE 0x04
56
57 #define SHPWLEN 8 /* share password length */
58 #define NNLEN 12 /* 8.3 net name length */
59 #define SNLEN 15 /* service name length */
60 #define QNLEN 12 /* queue name maximum length */
61
62 extern int Client;
63
64 static int CopyExpanded(int cnum, int snum, char** dst, char* src, int* n)
65 {
66 pstring buf;
67 int l;
68
69 if (!src || !dst || !n || !(*dst)) return(0);
70
71 StrnCpy(buf,src,sizeof(buf)/2);
72 string_sub(buf,"%S",lp_servicename(snum));
73 standard_sub(cnum,buf);
74 StrnCpy(*dst,buf,*n);
75 l = strlen(*dst) + 1;
76 (*dst) += l;
77 (*n) -= l;
78 return l;
79 }
80
81 static int CopyAndAdvance(char** dst, char* src, int* n)
82 {
83 int l;
84 if (!src || !dst || !n || !(*dst)) return(0);
85 StrnCpy(*dst,src,*n);
86 l = strlen(*dst) + 1;
87 (*dst) += l;
88 (*n) -= l;
89 return l;
90 }
91
92 static int StrlenExpanded(int cnum, int snum, char* s)
93 {
94 pstring buf;
95 if (!s) return(0);
96 StrnCpy(buf,s,sizeof(buf)/2);
97 string_sub(buf,"%S",lp_servicename(snum));
98 standard_sub(cnum,buf);
99 return strlen(buf) + 1;
100 }
101
102 static char* Expand(int cnum, int snum, char* s)
103 {
104 static pstring buf;
105 if (!s) return(NULL);
106 StrnCpy(buf,s,sizeof(buf)/2);
107 string_sub(buf,"%S",lp_servicename(snum));
108 standard_sub(cnum,buf);
109 return &buf[0];
110 }
111
112 /*******************************************************************
113 check a API string for validity when we only need to check the prefix
114 ******************************************************************/
115 static BOOL prefix_ok(char *str,char *prefix)
116 {
117 return(strncmp(str,prefix,strlen(prefix)) == 0);
118 }
119
120
121 /****************************************************************************
122 send a trans reply
123 ****************************************************************************/
124 static void send_trans_reply(char *outbuf,char *data,char *param,uint16 *setup,
125 int ldata,int lparam,int lsetup)
126 {
127 int i;
128 int this_ldata,this_lparam;
129 int tot_data=0,tot_param=0;
130 int align;
131
132 this_lparam = MIN(lparam,maxxmit - (500+lsetup*SIZEOFWORD)); /* hack */
133 this_ldata = MIN(ldata,maxxmit - (500+lsetup*SIZEOFWORD+this_lparam));
134
135 align = (this_lparam%4);
136
137 set_message(outbuf,10+lsetup,align+this_ldata+this_lparam,True);
138 if (this_lparam)
139 memcpy(smb_buf(outbuf),param,this_lparam);
140 if (this_ldata)
141 memcpy(smb_buf(outbuf)+this_lparam+align,data,this_ldata);
142
143 SSVAL(outbuf,smb_vwv0,lparam);
144 SSVAL(outbuf,smb_vwv1,ldata);
145 SSVAL(outbuf,smb_vwv3,this_lparam);
146 SSVAL(outbuf,smb_vwv4,smb_offset(smb_buf(outbuf),outbuf));
147 SSVAL(outbuf,smb_vwv5,0);
148 SSVAL(outbuf,smb_vwv6,this_ldata);
149 SSVAL(outbuf,smb_vwv7,smb_offset(smb_buf(outbuf)+this_lparam+align,outbuf));
150 SSVAL(outbuf,smb_vwv8,0);
151 SSVAL(outbuf,smb_vwv9,lsetup);
152 for (i=0;i<lsetup;i++)
153 SSVAL(outbuf,smb_vwv10+i*SIZEOFWORD,setup[i]);
154
155 show_msg(outbuf);
156 send_smb(Client,outbuf);
157
158 tot_data = this_ldata;
159 tot_param = this_lparam;
160
161 while (tot_data < ldata || tot_param < lparam)
162 {
163 this_lparam = MIN(lparam-tot_param,maxxmit - 500); /* hack */
164 this_ldata = MIN(ldata-tot_data,maxxmit - (500+this_lparam));
165
166 align = (this_lparam%4);
167
168 set_message(outbuf,10,this_ldata+this_lparam+align,False);
169 if (this_lparam)
170 memcpy(smb_buf(outbuf),param+tot_param,this_lparam);
171 if (this_ldata)
172 memcpy(smb_buf(outbuf)+this_lparam+align,data+tot_data,this_ldata);
173
174 SSVAL(outbuf,smb_vwv3,this_lparam);
175 SSVAL(outbuf,smb_vwv4,smb_offset(smb_buf(outbuf),outbuf));
176 SSVAL(outbuf,smb_vwv5,tot_param);
177 SSVAL(outbuf,smb_vwv6,this_ldata);
178 SSVAL(outbuf,smb_vwv7,smb_offset(smb_buf(outbuf)+this_lparam+align,outbuf));
179 SSVAL(outbuf,smb_vwv8,tot_data);
180 SSVAL(outbuf,smb_vwv9,0);
181
182 show_msg(outbuf);
183 send_smb(Client,outbuf);
184
185 tot_data += this_ldata;
186 tot_param += this_lparam;
187 }
188 }
189
190
191
192 /****************************************************************************
193 get a print queue
194 ****************************************************************************/
195
196 struct pack_desc {
197 char* format; /* formatstring for structure */
198 char* subformat; /* subformat for structure */
199 char* base; /* baseaddress of buffer */
200 int buflen; /* remaining size for fixed part; on init: length of base */
201 int subcount; /* count of substructures */
202 char* structbuf; /* pointer into buffer for remaining fixed part */
203 int stringlen; /* remaining size for variable part */
204 char* stringbuf; /* pointer into buffer for remaining variable part */
205 int neededlen; /* total needed size */
206 int usedlen; /* total used size (usedlen <= neededlen and usedlen <= buflen) */
207 char* curpos; /* current position; pointer into format or subformat */
208 int errcode;
209 };
210
211 static int get_counter(char** p)
212 {
213 int i, n;
214 if (!p || !(*p)) return(1);
215 if (!isdigit(**p)) return 1;
216 for (n = 0;;) {
217 i = **p;
218 if (isdigit(i))
219 n = 10 * n + (i - '0');
220 else
221 return n;
222 (*p)++;
223 }
224 }
225
226 static int getlen(char* p)
227 {
228 int n = 0;
229 if (!p) return(0);
230 while (*p) {
231 switch( *p++ ) {
232 case 'W': /* word (2 byte) */
233 n += 2;
234 break;
235 case 'N': /* count of substructures (word) at end */
236 n += 2;
237 break;
238 case 'D': /* double word (4 byte) */
239 case 'z': /* offset to zero terminated string (4 byte) */
240 case 'l': /* offset to user data (4 byte) */
241 n += 4;
242 break;
243 case 'b': /* offset to data (with counter) (4 byte) */
244 n += 4;
245 get_counter(&p);
246 break;
247 case 'B': /* byte (with optional counter) */
248 n += get_counter(&p);
249 break;
250 }
251 }
252 return n;
253 }
254
255 static BOOL init_package(struct pack_desc* p, int count, int subcount)
256 {
257 int n = p->buflen;
258 int i;
259
260 if (!p->format || !p->base) return(False);
261
262 i = count * getlen(p->format);
263 if (p->subformat) i += subcount * getlen(p->subformat);
264 p->structbuf = p->base;
265 p->neededlen = 0;
266 p->usedlen = 0;
267 p->subcount = 0;
268 p->curpos = p->format;
269 if (i > n) {
270 i = n = 0;
271 p->errcode = NERR_BufTooSmall;
272 }
273
274 p->errcode = NERR_Success;
275 p->buflen = i;
276 n -= i;
277 p->stringbuf = p->base + i;
278 p->stringlen = n;
279 return(p->errcode == NERR_Success);
280 }
281
282 #ifdef __STDC__
283 static int package(struct pack_desc* p, ...)
284 {
285 #else
286 static int package(va_alist)
287 va_dcl
288 {
289 struct pack_desc* p;
290 #endif
291 va_list args;
292 int needed=0, stringneeded;
293 char* str=NULL;
294 int is_string=0, stringused;
295 int32 temp;
296
297 #ifdef __STDC__
298 va_start(args,p);
299 #else
300 va_start(args);
301 p = va_arg(args,struct pack_desc *);
302 #endif
303
304 if (!*p->curpos) {
305 if (!p->subcount)
306 p->curpos = p->format;
307 else {
308 p->curpos = p->subformat;
309 p->subcount--;
310 }
311 }
312 #if CHECK_TYPES
313 str = va_arg(args,char*);
314 if (strncmp(str,p->curpos,strlen(str)) != 0) {
315 DEBUG(2,("type error in package: %s instead of %*s\n",str,
316 strlen(str),p->curpos));
317 va_end(args);
318 #if AJT
319 ajt_panic();
320 #endif
321 return 0;
322 }
323 #endif
324 stringneeded = -1;
325
326 if (!p->curpos) return(0);
327
328 switch( *p->curpos++ ) {
329 case 'W': /* word (2 byte) */
330 needed = 2;
331 temp = va_arg(args,int);
332 if (p->buflen >= needed) SSVAL(p->structbuf,0,temp);
333 break;
334 case 'N': /* count of substructures (word) at end */
335 needed = 2;
336 p->subcount = va_arg(args,int);
337 if (p->buflen >= needed) SSVAL(p->structbuf,0,p->subcount);
338 break;
339 case 'D': /* double word (4 byte) */
340 needed = 4;
341 temp = va_arg(args,int);
342 if (p->buflen >= needed) SIVAL(p->structbuf,0,temp);
343 break;
344 case 'B': /* byte (with optional counter) */
345 needed = get_counter(&p->curpos);
346 {
347 char *s = va_arg(args,char*);
348 if (p->buflen >= needed) StrnCpy(p->structbuf,s?s:"",needed);
349 }
350 break;
351 case 'z': /* offset to zero terminated string (4 byte) */
352 str = va_arg(args,char*);
353 stringneeded = (str ? strlen(str)+1 : 0);
354 is_string = 1;
355 break;
356 case 'l': /* offset to user data (4 byte) */
357 str = va_arg(args,char*);
358 stringneeded = va_arg(args,int);
359 is_string = 0;
360 break;
361 case 'b': /* offset to data (with counter) (4 byte) */
362 str = va_arg(args,char*);
363 stringneeded = get_counter(&p->curpos);
364 is_string = 0;
365 break;
366 }
367 va_end(args);
368 if (stringneeded >= 0) {
369 needed = 4;
370 if (p->buflen >= needed) {
371 stringused = stringneeded;
372 if (stringused > p->stringlen) {
373 stringused = (is_string ? p->stringlen : 0);
374 if (p->errcode == NERR_Success) p->errcode = ERROR_MORE_DATA;
375 }
376 if (!stringused)
377 SIVAL(p->structbuf,0,0);
378 else {
379 SIVAL(p->structbuf,0,PTR_DIFF(p->stringbuf,p->base));
380 memcpy(p->stringbuf,str?str:"",stringused);
381 if (is_string) p->stringbuf[stringused-1] = '\0';
382 p->stringbuf += stringused;
383 p->stringlen -= stringused;
384 p->usedlen += stringused;
385 }
386 }
387 p->neededlen += stringneeded;
388 }
389 p->neededlen += needed;
390 if (p->buflen >= needed) {
391 p->structbuf += needed;
392 p->buflen -= needed;
393 p->usedlen += needed;
394 }
395 else {
396 if (p->errcode == NERR_Success) p->errcode = NERR_BufTooSmall;
397 }
398 return 1;
399 }
400
401 #if CHECK_TYPES
402 #define PACK(desc,t,v) package(desc,t,v,0,0,0,0)
403 #define PACKl(desc,t,v,l) package(desc,t,v,l,0,0,0,0)
404 #else
405 #define PACK(desc,t,v) package(desc,v)
406 #define PACKl(desc,t,v,l) package(desc,v,l)
407 #endif
408
409 static void PACKI(struct pack_desc* desc,char *t,int v)
410 {
411 PACK(desc,t,v);
412 }
413
414 static void PACKS(struct pack_desc* desc,char *t,char *v)
415 {
416 PACK(desc,t,v);
417 }
418
419 static void PackDriverData(struct pack_desc* desc)
420 {
421 char drivdata[4+4+32];
422 SIVAL(drivdata,0,sizeof drivdata); /* cb */
423 SIVAL(drivdata,4,1000); /* lVersion */
424 memset(drivdata+8,0,32); /* szDeviceName */
425 strcpy(drivdata+8,"NULL");
426 PACKl(desc,"l",drivdata,sizeof drivdata); /* pDriverData */
427 }
428
429 static int check_printq_info(struct pack_desc* desc,
430 int uLevel, const char* id1, const char* id2)
431 {
432 desc->subformat = NULL;
433 switch( uLevel ) {
434 case 0:
435 desc->format = "B13";
436 break;
437 case 1:
438 desc->format = "B13BWWWzzzzzWW";
439 break;
440 case 2:
441 desc->format = "B13BWWWzzzzzWN";
442 desc->subformat = "WB21BB16B10zWWzDDz";
443 break;
444 case 3:
445 desc->format = "zWWWWzzzzWWzzl";
446 break;
447 case 4:
448 desc->format = "zWWWWzzzzWNzzl";
449 desc->subformat = "WWzWWDDzz";
450 break;
451 case 5:
452 desc->format = "z";
453 break;
454 default: return False;
455 }
456 if (strcmp(desc->format,id1) != 0) return False;
457 if (desc->subformat && strcmp(desc->subformat,id2) != 0) return False;
458 return True;
459 }
460
461 static void fill_printjob_info(int cnum, int snum, int uLevel,
462 struct pack_desc* desc,
463 print_queue_struct* queue, int n)
464 {
465 time_t t = queue->time;
466
467 /* the client expects localtime */
468 t -= TimeDiff(t);
469
470 PACKI(desc,"W",((snum%0xFF)<<8) | (queue->job%0xFF)); /* uJobId */
471 if (uLevel == 1) {
472 PACKS(desc,"B21",queue->user); /* szUserName */
473 PACKS(desc,"B",""); /* pad */
474 PACKS(desc,"B16",""); /* szNotifyName */
475 PACKS(desc,"B10","PM_Q_RAW"); /* szDataType */
476 PACKS(desc,"z",""); /* pszParms */
477 PACKI(desc,"W",n+1); /* uPosition */
478 PACKI(desc,"W",queue->status); /* fsStatus */
479 PACKS(desc,"z",""); /* pszStatus */
480 PACKI(desc,"D",t); /* ulSubmitted */
481 PACKI(desc,"D",queue->size); /* ulSize */
482 PACKS(desc,"z",queue->file); /* pszComment */
483 }
484 if (uLevel == 2 || uLevel == 3) {
485 PACKI(desc,"W",queue->priority); /* uPriority */
486 PACKS(desc,"z",queue->user); /* pszUserName */
487 PACKI(desc,"W",n+1); /* uPosition */
488 PACKI(desc,"W",queue->status); /* fsStatus */
489 PACKI(desc,"D",t); /* ulSubmitted */
490 PACKI(desc,"D",queue->size); /* ulSize */
491 PACKS(desc,"z","Samba"); /* pszComment */
492 PACKS(desc,"z",queue->file); /* pszDocument */
493 if (uLevel == 3) {
494 PACKS(desc,"z",""); /* pszNotifyName */
495 PACKS(desc,"z","PM_Q_RAW"); /* pszDataType */
496 PACKS(desc,"z",""); /* pszParms */
497 PACKS(desc,"z",""); /* pszStatus */
498 PACKS(desc,"z",SERVICE(snum)); /* pszQueue */
499 PACKS(desc,"z","lpd"); /* pszQProcName */
500 PACKS(desc,"z",""); /* pszQProcParms */
501 PACKS(desc,"z","NULL"); /* pszDriverName */
502 PackDriverData(desc); /* pDriverData */
503 PACKS(desc,"z",""); /* pszPrinterName */
504 }
505 }
506 }
507
508 static void fill_printq_info(int cnum, int snum, int uLevel,
509 struct pack_desc* desc,
510 int count, print_queue_struct* queue,
511 print_status_struct* status)
512 {
513 if (uLevel < 3) {
514 PACKS(desc,"B13",SERVICE(snum));
515 } else {
516 PACKS(desc,"z",Expand(cnum,snum,SERVICE(snum)));
517 }
518 if (uLevel == 1 || uLevel == 2) {
519 PACKS(desc,"B",""); /* alignment */
520 PACKI(desc,"W",5); /* priority */
521 PACKI(desc,"W",0); /* start time */
522 PACKI(desc,"W",0); /* until time */
523 PACKS(desc,"z",""); /* pSepFile */
524 PACKS(desc,"z","lpd"); /* pPrProc */
525 PACKS(desc,"z",SERVICE(snum)); /* pDestinations */
526 PACKS(desc,"z",""); /* pParms */
527 if (snum < 0) {
528 PACKS(desc,"z","UNKNOWN PRINTER");
529 PACKI(desc,"W",LPSTAT_ERROR);
530 }
531 else if (!status || !status->message[0]) {
532 PACKS(desc,"z",Expand(cnum,snum,lp_comment(snum)));
533 PACKI(desc,"W",LPSTAT_OK); /* status */
534 } else {
535 PACKS(desc,"z",status->message);
536 PACKI(desc,"W",status->status); /* status */
537 }
538 PACKI(desc,(uLevel == 1 ? "W" : "N"),count);
539 }
540 if (uLevel == 3 || uLevel == 4) {
541 PACKI(desc,"W",5); /* uPriority */
542 PACKI(desc,"W",0); /* uStarttime */
543 PACKI(desc,"W",0); /* uUntiltime */
544 PACKI(desc,"W",5); /* pad1 */
545 PACKS(desc,"z",""); /* pszSepFile */
546 PACKS(desc,"z","lpd"); /* pszPrProc */
547 PACKS(desc,"z",""); /* pszParms */
548 if (!status || !status->message[0]) {
549 PACKS(desc,"z",Expand(cnum,snum,lp_comment(snum))); /* pszComment */
550 PACKI(desc,"W",LPSTAT_OK); /* fsStatus */
551 } else {
552 PACKS(desc,"z",status->message); /* pszComment */
553 PACKI(desc,"W",status->status); /* fsStatus */
554 }
555 PACKI(desc,(uLevel == 3 ? "W" : "N"),count); /* cJobs */
556 PACKS(desc,"z",SERVICE(snum)); /* pszPrinters */
557 PACKS(desc,"z","NULL"); /* pszDriverName */
558 PackDriverData(desc); /* pDriverData */
559 }
560 if (uLevel == 2 || uLevel == 4) {
561 int i;
562 for (i=0;i<count;i++)
563 fill_printjob_info(cnum,snum,uLevel == 2 ? 1 : 2,desc,&queue[i],i);
564 }
565
566 DEBUG(3,("fill_printq_info on <%s> gave %d entries\n",SERVICE(snum),count));
567 }
568
569 static BOOL api_DosPrintQGetInfo(int cnum,int uid, char *param,char *data,
570 int mdrcnt,int mprcnt,
571 char **rdata,char **rparam,
572 int *rdata_len,int *rparam_len)
573 {
574 char *str1 = param+2;
575 char *str2 = skip_string(str1,1);
576 char *p = skip_string(str2,1);
577 char *QueueName = p;
578 int uLevel,cbBuf;
579 int count=0;
580 int snum;
581 char* str3;
582 struct pack_desc desc;
583 print_queue_struct *queue=NULL;
584 print_status_struct status;
585
586 bzero(&status,sizeof(status));
587 bzero(&desc,sizeof(desc));
588
589 p = skip_string(p,1);
590 uLevel = SVAL(p,0);
591 cbBuf = SVAL(p,2);
592 str3 = p + 4;
593
594 if ((p = strchr(QueueName,'%'))) *p = 0;
595
596 DEBUG(3,("PrintQueue uLevel=%d name=%s\n",uLevel,QueueName));
597
598 /* check it's a supported varient */
599 if (!prefix_ok(str1,"zWrLh")) return False;
600 if (!check_printq_info(&desc,uLevel,str2,str3)) return False;
601
602 snum = lp_servicenumber(QueueName);
603 if (snum < 0 && pcap_printername_ok(QueueName,NULL)) {
604 int pnum = lp_servicenumber(PRINTERS_NAME);
605 if (pnum >= 0) {
606 lp_add_printer(QueueName,pnum);
607 snum = lp_servicenumber(QueueName);
608 }
609 }
610
611 if (snum < 0 || !VALID_SNUM(snum)) return(False);
612
613 count = get_printqueue(snum,cnum,&queue,&status);
614 if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
615 desc.base = *rdata;
616 desc.buflen = mdrcnt;
617 if (init_package(&desc,1,count)) {
618 desc.subcount = count;
619 fill_printq_info(cnum,snum,uLevel,&desc,count,queue,&status);
620 }
621
622 *rdata_len = desc.usedlen;
623
624 *rparam_len = 6;
625 *rparam = REALLOC(*rparam,*rparam_len);
626 SSVALS(*rparam,0,desc.errcode);
627 SSVAL(*rparam,2,0);
628 SSVAL(*rparam,4,desc.neededlen);
629
630 DEBUG(4,("printqgetinfo: errorcode %d\n",desc.errcode));
631
632 if (queue) free(queue);
633
634 return(True);
635 }
636
637
638 /****************************************************************************
639 view list of all print jobs on all queues
640 ****************************************************************************/
641 static BOOL api_DosPrintQEnum(int cnum, int uid, char* param, char* data,
642 int mdrcnt, int mprcnt,
643 char **rdata, char** rparam,
644 int *rdata_len, int *rparam_len)
645 {
646 char *param_format = param+2;
647 char *output_format1 = skip_string(param_format,1);
648 char *p = skip_string(output_format1,1);
649 int uLevel = SVAL(p,0);
650 char *output_format2 = p + 4;
651 int services = lp_numservices();
652 int i, n;
653 struct pack_desc desc;
654 print_queue_struct **queue = NULL;
655 print_status_struct *status = NULL;
656 int* subcntarr = NULL;
657 int queuecnt, subcnt=0, succnt=0;
658
659 bzero(&desc,sizeof(desc));
660
661 DEBUG(3,("DosPrintQEnum uLevel=%d\n",uLevel));
662
663 if (prefix_ok(param_format,"WrLeh")) return False;
664 if (!check_printq_info(&desc,uLevel,output_format1,output_format2))
665 return False;
666 queuecnt = 0;
667 for (i = 0; i < services; i++)
668 if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i))
669 queuecnt++;
670 if (uLevel > 0) {
671 queue = (print_queue_struct**)malloc(queuecnt*sizeof(print_queue_struct*));
672 memset(queue,0,queuecnt*sizeof(print_queue_struct*));
673 status = (print_status_struct*)malloc(queuecnt*sizeof(print_status_struct));
674 memset(status,0,queuecnt*sizeof(print_status_struct));
675 subcntarr = (int*)malloc(queuecnt*sizeof(int));
676 subcnt = 0;
677 n = 0;
678 for (i = 0; i < services; i++)
679 if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
680 subcntarr[n] = get_printqueue(i,cnum,&queue[n],&status[n]);
681 subcnt += subcntarr[n];
682 n++;
683 }
684 }
685 if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
686 desc.base = *rdata;
687 desc.buflen = mdrcnt;
688
689 if (init_package(&desc,queuecnt,subcnt)) {
690 n = 0;
691 succnt = 0;
692 for (i = 0; i < services; i++)
693 if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
694 fill_printq_info(cnum,i,uLevel,&desc,subcntarr[n],queue[n],&status[n]);
695 n++;
696 if (desc.errcode == NERR_Success) succnt = n;
697 }
698 }
699
700 if (subcntarr) free(subcntarr);
701
702 *rdata_len = desc.usedlen;
703 *rparam_len = 8;
704 *rparam = REALLOC(*rparam,*rparam_len);
705 SSVALS(*rparam,0,desc.errcode);
706 SSVAL(*rparam,2,0);
707 SSVAL(*rparam,4,succnt);
708 SSVAL(*rparam,6,queuecnt);
709
710 for (i = 0; i < queuecnt; i++) {
711 if (queue && queue[i]) free(queue[i]);
712 }
713
714 if (queue) free(queue);
715 if (status) free(status);
716
717 return True;
718 }
719
720 /****************************************************************************
721 get info level for a server list query
722 ****************************************************************************/
723 static BOOL check_server_info(int uLevel, char* id)
724 {
725 switch( uLevel ) {
726 case 0:
727 if (strcmp(id,"B16") != 0) return False;
728 break;
729 case 1:
730 if (strcmp(id,"B16BBDz") != 0) return False;
731 break;
732 default:
733 return False;
734 }
735 return True;
736 }
737
738 /* used for server information: client, nameserv and ipc */
739 struct srv_info_struct
740 {
741 fstring name;
742 uint32 type;
743 fstring comment;
744 fstring domain; /* used ONLY in ipc.c NOT namework.c */
745 BOOL server_added; /* used ONLY in ipc.c NOT namework.c */
746 };
747
748 /*******************************************************************
749 filter out unwanted server info
750 This function returns True if the entry is wanted.
751 ******************************************************************/
752 static BOOL filter_server_info(struct srv_info_struct *server,
753 BOOL domains,
754 char *domain, uint32 request)
755 {
756 /* If no domain was specified, */
757 if (*domain == 0)
758 {
759 /* If entry's domain matches this server's domain,
760 accept this entry. */
761 if (strequal(lp_workgroup(), server->domain)) {
762 return True;
763 }
764
765 /* If specific domain requested, reject this entry. */
766 else if (domains)
767 {
768 DEBUG(4,("primary domain:reject %8x %s %s\n",request,server->name,server->domain));
769 return False;
770 }
771
772 /* If the request was for a list of domain enumerators,
773 we don't care what domain this entry is in as long
774 as it is a domain enumerator. */
775 else if ((request & SV_TYPE_DOMAIN_ENUM) &&
776 (server->type & SV_TYPE_DOMAIN_ENUM))
777 {
778 return True;
779 }
780
781 DEBUG(4,("wrong domain: %8x: %s %s\n",server->type,server->name,server->domain));
782 return False;
783 }
784
785 /* If a domain name was specified, */
786 else
787 {
788 /* If this entry is in the requested domain, */
789 if (strequal(domain, server->domain))
790 {
791 /*
792 if (request == SV_TYPE_LOCAL_LIST_ONLY &&
793 !(server->type & SV_TYPE_LOCAL_LIST_ONLY))
794 {
795 DEBUG(4,("rej:LOC %8x: ok %s %s\n",request,server->name,server->domain));
796 return False;
797 }
798 */
799 if ((request == (SV_TYPE_LOCAL_LIST_ONLY|SV_TYPE_DOMAIN_ENUM)) &&
800 !(server->type&SV_TYPE_DOMAIN_ENUM))
801 {
802 DEBUG(4,("rej:LOCDOM %8x: ok %s %s\n",request,server->name,server->domain));
803 return False;
804 }
805
806 return True;
807 }
808
809 /* If the user didn't pick a domain,
810 (I don't think this can happen.) */
811 else if (!domains)
812 {
813 DEBUG(4,("domain:%s %s %s\n",domain,server->name,server->domain));
814 return False;
815 }
816
817 return True;
818 }
819 }
820
821 /*******************************************************************
822 get server info lists from the files saved by nmbd. Return the
823 number of entries
824 ******************************************************************/
825 static int get_server_info(uint32 servertype,
826 struct srv_info_struct **servers, BOOL domains,
827 char *domain)
828 {
829 FILE *f;
830 pstring fname;
831 int count=0;
832 int alloced=0;
833 pstring line;
834
835 strcpy(fname,lp_lockdir());
836 trim_string(fname,NULL,"/");
837 strcat(fname,"/");
838 strcat(fname,SERVER_LIST);
839
840 f = fopen(fname,"r");
841
842 if (!f) {
843 DEBUG(4,("Can't open %s - %s\n",fname,strerror(errno)));
844 return(0);
845 }
846
847 /* request for everything is code for request all servers */
848 if (servertype == SV_TYPE_ALL) servertype &= ~SV_TYPE_DOMAIN_ENUM;
849
850 DEBUG(4,("Servertype search: %8x domains:%s\n",servertype,BOOLSTR(domains)));
851
852 while (!feof(f))
853 {
854 fstring stype;
855 struct srv_info_struct *s;
856 char *ptr = line;
857 BOOL ok = True;
858 *ptr = 0;
859
860 fgets(line,sizeof(line)-1,f);
861 if (!*line) continue;
862
863 if (count == alloced) {
864 alloced += 10;
865 (*servers) = (struct srv_info_struct *)
866 Realloc(*servers,sizeof(**servers)*alloced);
867 if (!(*servers)) return(0);
868 bzero((char *)((*servers)+count),sizeof(**servers)*(alloced-count));
869 }
870 s = &(*servers)[count];
871
872 if (!next_token(&ptr,s->name , NULL)) continue;
873 if (!next_token(&ptr,stype , NULL)) continue;
874 if (!next_token(&ptr,s->comment, NULL)) continue;
875 if (!next_token(&ptr,s->domain , NULL)) {
876 /* this allows us to cope with an old nmbd */
877 strcpy(s->domain,my_workgroup());
878 }
879
880 if (sscanf(stype,"%X",&s->type) != 1) {
881 DEBUG(4,("r:host file "));
882 ok = False;
883 }
884
885 /* doesn't match up: don't want it */
886 if (!(servertype & s->type)) {
887 DEBUG(4,("r:serv type "));
888 ok = False;
889 }
890
891 /* If all server, reject DOMIAN_ENUM entries? */
892 if ((servertype == ~SV_TYPE_DOMAIN_ENUM) &&
893 (s->type & SV_TYPE_DOMAIN_ENUM))
894 {
895 DEBUG(4,("s:all x dom "));
896 ok = False;
897 }
898
899 /* If a domain is specified, reject all except the
900 domain enumerators for the specified domain. */
901 if (domains && !(domain && *domain && strequal(domain, s->domain)))
902 {
903 if (!(s->type & SV_TYPE_DOMAIN_ENUM))
904 {
905 DEBUG(4,("r:dom enum "));
906 ok = False;
907 }
908 }
909
910 if (ok)
911 {
912 DEBUG(4,("**SV** %20s %8x %25s %15s\n",
913 s->name, s->type, s->comment, s->domain));
914
915 s->type |= SV_TYPE_LOCAL_LIST_ONLY;
916 s->server_added = True;
917 count++;
918 }
919 else
920 {
921 DEBUG(4,("%20s %8x %25s %15s\n",
922 s->name, s->type, s->comment, s->domain));
923 }
924 }
925
926 fclose(f);
927 return(count);
928 }
929
930
931 /*******************************************************************
932 fill in a server info structure
933 ******************************************************************/
934 static int fill_srv_info(struct srv_info_struct *service,
935 int uLevel, char **buf, int *buflen,
936 char **stringbuf, int *stringspace, char *baseaddr)
937 {
938 int struct_len;
939 char* p;
940 char* p2;
941 int l2;
942 int len;
943
944 switch (uLevel) {
945 case 0: struct_len = 16; break;
946 case 1: struct_len = 26; break;
947 default: return -1;
948 }
949
950 if (!buf)
951 {
952 len = 0;
953 switch (uLevel)
954 {
955 case 1:
956 len = strlen(service->comment)+1;
957 break;
958 }
959
960 if (buflen) *buflen = struct_len;
961 if (stringspace) *stringspace = len;
962 return struct_len + len;
963 }
964
965 len = struct_len;
966 p = *buf;
967 if (*buflen < struct_len) return -1;
968 if (stringbuf)
969 {
970 p2 = *stringbuf;
971 l2 = *stringspace;
972 }
973 else
974 {
975 p2 = p + struct_len;
976 l2 = *buflen - struct_len;
977 }
978 if (!baseaddr) baseaddr = p;
979
980 switch (uLevel)
981 {
982 case 0:
983 StrnCpy(p,service->name,15);
984 break;
985
986 case 1:
987 StrnCpy(p,service->name,15);
988 SIVAL(p,18,service->type);
989 SIVAL(p,22,PTR_DIFF(p2,baseaddr));
990 len += CopyAndAdvance(&p2,service->comment,&l2);
991 break;
992 }
993
994 if (stringbuf)
995 {
996 *buf = p + struct_len;
997 *buflen -= struct_len;
998 *stringbuf = p2;
999 *stringspace = l2;
1000 }
1001 else
1002 {
1003 *buf = p2;
1004 *buflen -= len;
1005 }
1006 return len;
1007 }
1008
1009
1010 static BOOL srv_comp(struct srv_info_struct *s1,struct srv_info_struct *s2)
1011 {
1012 return(strcmp(s1->name,s2->name));
1013 }
1014
1015 /****************************************************************************
1016 view list of servers available (or possibly domains). The info is
1017 extracted from lists saved by nmbd on the local host
1018 ****************************************************************************/
1019 static BOOL api_RNetServerEnum(int cnum, int uid, char *param, char *data,
1020 int mdrcnt, int mprcnt, char **rdata,
1021 char **rparam, int *rdata_len, int *rparam_len)
1022 {
1023 char *str1 = param+2;
1024 char *str2 = skip_string(str1,1);
1025 char *p = skip_string(str2,1);
1026 int uLevel = SVAL(p,0);
1027 int buf_len = SVAL(p,2);
1028 uint32 servertype = IVAL(p,4);
1029 char *p2;
1030 int data_len, fixed_len, string_len;
1031 int f_len, s_len;
1032 struct srv_info_struct *servers=NULL;
1033 int counted=0,total=0;
1034 int i;
1035 fstring domain;
1036 BOOL domains;
1037 BOOL domain_request;
1038 BOOL local_request = servertype & SV_TYPE_LOCAL_LIST_ONLY;
1039
1040 /*if (servertype == SV_TYPE_ALL) servertype &= ~(SV_TYPE_DOMAIN_ENUM|SV_TYPE_LOCAL_LIST_ONLY);*/
1041 if (servertype == SV_TYPE_ALL) servertype &= ~SV_TYPE_DOMAIN_ENUM;
1042
1043 domain_request = servertype & SV_TYPE_DOMAIN_ENUM;
1044
1045 domain[0] = 0;
1046 p += 8;
1047
1048 if (!prefix_ok(str1,"WrLehD")) return False;
1049 if (!check_server_info(uLevel,str2)) return False;
1050
1051 DEBUG(4, ("server request level: %s %8x ", str2, servertype));
1052 DEBUG(4, ("domains_req:%s ", BOOLSTR(domain_request)));
1053 DEBUG(4, ("local_only:%s\n", BOOLSTR(local_request)));
1054
1055 if (strcmp(str1, "WrLehDO") == 0)
1056 {
1057 domains = False;
1058 DEBUG(4, ("all domains\n"));
1059 }
1060 else if (strcmp(str1, "WrLehDz") == 0)
1061 {
1062 domains = True;
1063 StrnCpy(domain, p, sizeof(fstring)-1);
1064 DEBUG(4, ("domains must match \"%s\"\n", domains));
1065 }
1066
1067 if (lp_browse_list())
1068 {
1069 total = get_server_info(servertype,&servers,domains,domain);
1070 }
1071
1072 data_len = fixed_len = string_len = 0;
1073
1074 qsort(servers,total,sizeof(servers[0]),QSORT_CAST srv_comp);
1075
1076 /* A dry run */
1077 {
1078 char *lastname=NULL;
1079
1080 for (i=0;i<total;i++)
1081 {
1082 struct srv_info_struct *s = &servers[i];
1083 if (filter_server_info(s,domains,domain,
1084 local_request|domain_request))
1085 {
1086 if (lastname && strequal(lastname,s->name)) continue;
1087 lastname = s->name;
1088 data_len += fill_srv_info(s,uLevel,0,&f_len,0,&s_len,0);
1089 DEBUG(4,("fill_srv_info %20s %8x %25s %15s\n",
1090 s->name, s->type, s->comment, s->domain));
1091
1092 if (data_len <= buf_len)
1093 {
1094 counted++;
1095 fixed_len += f_len;
1096 string_len += s_len;
1097 }
1098 }
1099 }
1100 }
1101
1102 *rdata_len = fixed_len + string_len;
1103 *rdata = REALLOC(*rdata,*rdata_len);
1104 bzero(*rdata,*rdata_len);
1105
1106 p2 = (*rdata) + fixed_len; /* auxilliary data (strings) will go here */
1107 p = *rdata;
1108 f_len = fixed_len;
1109 s_len = string_len;
1110
1111 /* the real thing */
1112 {
1113 char *lastname=NULL;
1114 int count2 = counted;
1115 for (i = 0; i < total && count2;i++)
1116 {
1117 struct srv_info_struct *s = &servers[i];
1118 if (filter_server_info(s,domains,domain,local_request|domain_request))
1119 {
1120 if (lastname && strequal(lastname,s->name)) continue;
1121 lastname = s->name;
1122 fill_srv_info(s,uLevel,&p,&f_len,&p2,&s_len,*rdata);
1123 DEBUG(4,("fill_srv_info %20s %8x %25s %15s\n",
1124 s->name, s->type, s->comment, s->domain));
1125 count2--;
1126 }
1127 }
1128 }
1129
1130 *rparam_len = 8;
1131 *rparam = REALLOC(*rparam,*rparam_len);
1132 SSVAL(*rparam,0,NERR_Success);
1133 SSVAL(*rparam,2,0);
1134 SSVAL(*rparam,4,counted);
1135 SSVAL(*rparam,6,total);
1136
1137 if (servers) free(servers);
1138
1139 DEBUG(3,("NetServerEnum domain = %s uLevel=%d counted=%d total=%d\n",
1140 domain,uLevel,counted,total));
1141
1142 return(True);
1143 }
1144
1145
1146 /****************************************************************************
1147 get info about a share
1148 ****************************************************************************/
1149 static BOOL check_share_info(int uLevel, char* id)
1150 {
1151 switch( uLevel ) {
1152 case 0:
1153 if (strcmp(id,"B13") != 0) return False;
1154 break;
1155 case 1:
1156 if (strcmp(id,"B13BWz") != 0) return False;
1157 break;
1158 case 2:
1159 if (strcmp(id,"B13BWzWWWzB9B") != 0) return False;
1160 break;
1161 case 91:
1162 if (strcmp(id,"B13BWzWWWzB9BB9BWzWWzWW") != 0) return False;
1163 break;
1164 default: return False;
1165 }
1166 return True;
1167 }
1168
1169 static int fill_share_info(int cnum, int snum, int uLevel,
1170 char** buf, int* buflen,
1171 char** stringbuf, int* stringspace, char* baseaddr)
1172 {
1173 int struct_len;
1174 char* p;
1175 char* p2;
1176 int l2;
1177 int len;
1178
1179 switch( uLevel ) {
1180 case 0: struct_len = 13; break;
1181 case 1: struct_len = 20; break;
1182 case 2: struct_len = 40; break;
1183 case 91: struct_len = 68; break;
1184 default: return -1;
1185 }
1186
1187
1188 if (!buf)
1189 {
1190 len = 0;
1191 if (uLevel > 0) len += StrlenExpanded(cnum,snum,lp_comment(snum));
1192 if (uLevel > 1) len += strlen(lp_pathname(snum)) + 1;
1193 if (buflen) *buflen = struct_len;
1194 if (stringspace) *stringspace = len;
1195 return struct_len + len;
1196 }
1197
1198 len = struct_len;
1199 p = *buf;
1200 if ((*buflen) < struct_len) return -1;
1201 if (stringbuf)
1202 {
1203 p2 = *stringbuf;
1204 l2 = *stringspace;
1205 }
1206 else
1207 {
1208 p2 = p + struct_len;
1209 l2 = (*buflen) - struct_len;
1210 }
1211 if (!baseaddr) baseaddr = p;
1212
1213 StrnCpy(p,lp_servicename(snum),13);
1214
1215 if (uLevel > 0)
1216 {
1217 int type;
1218 CVAL(p,13) = 0;
1219 type = STYPE_DISKTREE;
1220 if (lp_print_ok(snum)) type = STYPE_PRINTQ;
1221 if (strequal("IPC$",lp_servicename(snum))) type = STYPE_IPC;
1222 SSVAL(p,14,type); /* device type */
1223 SIVAL(p,16,PTR_DIFF(p2,baseaddr));
1224 len += CopyExpanded(cnum,snum,&p2,lp_comment(snum),&l2);
1225 }
1226
1227 if (uLevel > 1)
1228 {
1229 SSVAL(p,20,ACCESS_READ|ACCESS_WRITE|ACCESS_CREATE); /* permissions */
1230 SSVALS(p,22,-1); /* max uses */
1231 SSVAL(p,24,1); /* current uses */
1232 SIVAL(p,26,PTR_DIFF(p2,baseaddr)); /* local pathname */
1233 len += CopyAndAdvance(&p2,lp_pathname(snum),&l2);
1234 memset(p+30,0,SHPWLEN+2); /* passwd (reserved), pad field */
1235 }
1236
1237 if (uLevel > 2)
1238 {
1239 memset(p+40,0,SHPWLEN+2);
1240 SSVAL(p,50,0);
1241 SIVAL(p,52,0);
1242 SSVAL(p,56,0);
1243 SSVAL(p,58,0);
1244 SIVAL(p,60,0);
1245 SSVAL(p,64,0);
1246 SSVAL(p,66,0);
1247 }
1248
1249 if (stringbuf)
1250 {
1251 (*buf) = p + struct_len;
1252 (*buflen) -= struct_len;
1253 (*stringbuf) = p2;
1254 (*stringspace) = l2;
1255 }
1256 else
1257 {
1258 (*buf) = p2;
1259 (*buflen) -= len;
1260 }
1261 return len;
1262 }
1263
1264 static BOOL api_RNetShareGetInfo(int cnum,int uid, char *param,char *data,
1265 int mdrcnt,int mprcnt,
1266 char **rdata,char **rparam,
1267 int *rdata_len,int *rparam_len)
1268 {
1269 char *str1 = param+2;
1270 char *str2 = skip_string(str1,1);
1271 char *netname = skip_string(str2,1);
1272 char *p = skip_string(netname,1);
1273 int uLevel = SVAL(p,0);
1274 int snum = find_service(netname);
1275
1276 if (snum < 0) return False;
1277
1278 /* check it's a supported varient */
1279 if (!prefix_ok(str1,"zWrLh")) return False;
1280 if (!check_share_info(uLevel,str2)) return False;
1281
1282 *rdata = REALLOC(*rdata,mdrcnt);
1283 p = *rdata;
1284 *rdata_len = fill_share_info(cnum,snum,uLevel,&p,&mdrcnt,0,0,0);
1285 if (*rdata_len < 0) return False;
1286
1287 *rparam_len = 6;
1288 *rparam = REALLOC(*rparam,*rparam_len);
1289 SSVAL(*rparam,0,NERR_Success);
1290 SSVAL(*rparam,2,0); /* converter word */
1291 SSVAL(*rparam,4,*rdata_len);
1292
1293 return(True);
1294 }
1295
1296 /****************************************************************************
1297 view list of shares available
1298 ****************************************************************************/
1299 static BOOL api_RNetShareEnum(int cnum,int uid, char *param,char *data,
1300 int mdrcnt,int mprcnt,
1301 char **rdata,char **rparam,
1302 int *rdata_len,int *rparam_len)
1303 {
1304 char *str1 = param+2;
1305 char *str2 = skip_string(str1,1);
1306 char *p = skip_string(str2,1);
1307 int uLevel = SVAL(p,0);
1308 int buf_len = SVAL(p,2);
1309 char *p2;
1310 int count=lp_numservices();
1311 int total=0,counted=0;
1312 int i;
1313 int data_len, fixed_len, string_len;
1314 int f_len, s_len;
1315
1316 if (!prefix_ok(str1,"WrLeh")) return False;
1317 if (!check_share_info(uLevel,str2)) return False;
1318
1319 data_len = fixed_len = string_len = 0;
1320 for (i=0;i<count;i++)
1321 if (lp_browseable(i) && lp_snum_ok(i))
1322 {
1323 total++;
1324 data_len += fill_share_info(cnum,i,uLevel,0,&f_len,0,&s_len,0);
1325 if (data_len <= buf_len)
1326 {
1327 counted++;
1328 fixed_len += f_len;
1329 string_len += s_len;
1330 }
1331 }
1332 *rdata_len = fixed_len + string_len;
1333 *rdata = REALLOC(*rdata,*rdata_len);
1334 memset(*rdata,0,*rdata_len);
1335
1336 p2 = (*rdata) + fixed_len; /* auxillery data (strings) will go here */
1337 p = *rdata;
1338 f_len = fixed_len;
1339 s_len = string_len;
1340 for (i = 0; i < count;i++)
1341 if (lp_browseable(i) && lp_snum_ok(i))
1342 if (fill_share_info(cnum,i,uLevel,&p,&f_len,&p2,&s_len,*rdata) < 0)
1343 break;
1344
1345 *rparam_len = 8;
1346 *rparam = REALLOC(*rparam,*rparam_len);
1347 SSVAL(*rparam,0,NERR_Success);
1348 SSVAL(*rparam,2,0);
1349 SSVAL(*rparam,4,counted);
1350 SSVAL(*rparam,6,total);
1351
1352 DEBUG(3,("RNetShareEnum gave %d entries of %d (%d %d %d %d)\n",
1353 counted,total,uLevel,
1354 buf_len,*rdata_len,mdrcnt));
1355 return(True);
1356 }
1357
1358
1359
1360 /****************************************************************************
1361 get the time of day info
1362 ****************************************************************************/
1363 static BOOL api_NetRemoteTOD(int cnum,int uid, char *param,char *data,
1364 int mdrcnt,int mprcnt,
1365 char **rdata,char **rparam,
1366 int *rdata_len,int *rparam_len)
1367 {
1368 char *p;
1369 *rparam_len = 4;
1370 *rparam = REALLOC(*rparam,*rparam_len);
1371
1372 *rdata_len = 21;
1373 *rdata = REALLOC(*rdata,*rdata_len);
1374
1375 SSVAL(*rparam,0,NERR_Success);
1376 SSVAL(*rparam,2,0); /* converter word */
1377
1378 p = *rdata;
1379
1380 {
1381 struct tm *t;
1382 time_t unixdate = time(NULL);
1383
1384 put_dos_date3(p,0,unixdate); /* this is the time that is looked at
1385 by NT in a "net time" operation,
1386 it seems to ignore the one below */
1387
1388 /* the client expects to get localtime, not GMT, in this bit
1389 (I think, this needs testing) */
1390 t = LocalTime(&unixdate);
1391
1392 SIVAL(p,4,0); /* msecs ? */
1393 CVAL(p,8) = t->tm_hour;
1394 CVAL(p,9) = t->tm_min;
1395 CVAL(p,10) = t->tm_sec;
1396 CVAL(p,11) = 0; /* hundredths of seconds */
1397 SSVALS(p,12,TimeDiff(unixdate)/60); /* timezone in minutes from GMT */
1398 SSVAL(p,14,10000); /* timer interval in 0.0001 of sec */
1399 CVAL(p,16) = t->tm_mday;
1400 CVAL(p,17) = t->tm_mon + 1;
1401 SSVAL(p,18,1900+t->tm_year);
1402 CVAL(p,20) = t->tm_wday;
1403 }
1404
1405
1406 return(True);
1407 }
1408
1409 /****************************************************************************
1410 set the user password
1411 ****************************************************************************/
1412 static BOOL api_SetUserPassword(int cnum,int uid, char *param,char *data,
1413 int mdrcnt,int mprcnt,
1414 char **rdata,char **rparam,
1415 int *rdata_len,int *rparam_len)
1416 {
1417 char *p = skip_string(param+2,2);
1418 fstring user;
1419 fstring pass1,pass2;
1420
1421 strcpy(user,p);
1422
1423 p = skip_string(p,1);
1424
1425 StrnCpy(pass1,p,16);
1426 StrnCpy(pass2,p+16,16);
1427
1428 *rparam_len = 4;
1429 *rparam = REALLOC(*rparam,*rparam_len);
1430
1431 *rdata_len = 0;
1432
1433 SSVAL(*rparam,0,NERR_Success);
1434 SSVAL(*rparam,2,0); /* converter word */
1435
1436 DEBUG(3,("Set password for <%s>\n",user));
1437
1438 if (!password_ok(user,pass1,strlen(pass1),NULL,False) ||
1439 !chgpasswd(user,pass1,pass2))
1440 SSVAL(*rparam,0,NERR_badpass);
1441
1442 bzero(pass1,sizeof(fstring));
1443 bzero(pass2,sizeof(fstring));
1444
1445 return(True);
1446 }
1447
1448 /****************************************************************************
1449 delete a print job
1450 Form: <W> <>
1451 ****************************************************************************/
1452 static BOOL api_RDosPrintJobDel(int cnum,int uid, char *param,char *data,
1453 int mdrcnt,int mprcnt,
1454 char **rdata,char **rparam,
1455 int *rdata_len,int *rparam_len)
1456 {
1457 int function = SVAL(param,0);
1458 char *str1 = param+2;
1459 char *str2 = skip_string(str1,1);
1460 char *p = skip_string(str2,1);
1461 int jobid = (SVAL(p,0)&0xFF); /* the snum and jobid are encoded
1462 by the print queue api */
1463 int snum = (SVAL(p,0)>>8);
1464 int i, count;
1465
1466
1467 /* check it's a supported varient */
1468 if (!(strcsequal(str1,"W") && strcsequal(str2,"")))
1469 return(False);
1470
1471 *rparam_len = 4;
1472 *rparam = REALLOC(*rparam,*rparam_len);
1473
1474 *rdata_len = 0;
1475
1476 SSVAL(*rparam,0,NERR_Success);
1477
1478 if (snum >= 0 && VALID_SNUM(snum))
1479 {
1480 print_queue_struct *queue=NULL;
1481 lpq_reset(snum);
1482 count = get_printqueue(snum,cnum,&queue,NULL);
1483
1484 for (i=0;i<count;i++)
1485 if ((queue[i].job%0xFF) == jobid)
1486 {
1487 switch (function) {
1488 case 81: /* delete */
1489 DEBUG(3,("Deleting queue entry %d\n",queue[i].job));
1490 del_printqueue(cnum,snum,queue[i].job);
1491 break;
1492 case 82: /* pause */
1493 case 83: /* resume */
1494 DEBUG(3,("%s queue entry %d\n",
1495 (function==82?"pausing":"resuming"),queue[i].job));
1496 status_printjob(cnum,snum,queue[i].job,
1497 (function==82?LPQ_PAUSED:LPQ_QUEUED));
1498 break;
1499 }
1500 break;
1501 }
1502
1503 if (i==count)
1504 SSVAL(*rparam,0,NERR_JobNotFound);
1505
1506 if (queue) free(queue);
1507 }
1508
1509 SSVAL(*rparam,2,0); /* converter word */
1510
1511 return(True);
1512 }
1513
1514 static BOOL api_WPrintQueuePurge(int cnum,int uid, char *param,char *data,
1515 int mdrcnt,int mprcnt,
1516 char **rdata,char **rparam,
1517 int *rdata_len,int *rparam_len)
1518 {
1519 char *str1 = param+2;
1520 char *str2 = skip_string(str1,1);
1521 char *QueueName = skip_string(str2,1);
1522 int snum;
1523
1524 /* check it's a supported varient */
1525 if (!(strcsequal(str1,"z") && strcsequal(str2,"")))
1526 return(False);
1527
1528 *rparam_len = 4;
1529 *rparam = REALLOC(*rparam,*rparam_len);
1530
1531 *rdata_len = 0;
1532
1533 SSVAL(*rparam,0,NERR_Success);
1534 SSVAL(*rparam,2,0); /* converter word */
1535
1536 snum = lp_servicenumber(QueueName);
1537 if (snum < 0 && pcap_printername_ok(QueueName,NULL)) {
1538 int pnum = lp_servicenumber(PRINTERS_NAME);
1539 if (pnum >= 0) {
1540 lp_add_printer(QueueName,pnum);
1541 snum = lp_servicenumber(QueueName);
1542 }
1543 }
1544
1545 if (snum >= 0 && VALID_SNUM(snum)) {
1546 print_queue_struct *queue=NULL;
1547 int i, count;
1548 lpq_reset(snum);
1549
1550 count = get_printqueue(snum,cnum,&queue,NULL);
1551 for (i = 0; i < count; i++)
1552 del_printqueue(cnum,snum,queue[i].job);
1553
1554 if (queue) free(queue);
1555 }
1556
1557 DEBUG(3,("Print queue purge, queue=%s\n",QueueName));
1558
1559 return(True);
1560 }
1561
1562
1563 /****************************************************************************
1564 set the property of a print job (undocumented?)
1565 ? function = 0xb -> set name of print job
1566 ? function = 0x6 -> move print job up/down
1567 Form: <WWsTP> <WWzWWDDzzzzzzzzzzlz>
1568 or <WWsTP> <WB21BB16B10zWWzDDz>
1569 ****************************************************************************/
1570 static int check_printjob_info(struct pack_desc* desc,
1571 int uLevel, char* id)
1572 {
1573 desc->subformat = NULL;
1574 switch( uLevel ) {
1575 case 0: desc->format = "W"; break;
1576 case 1: desc->format = "WB21BB16B10zWWzDDz"; break;
1577 case 2: desc->format = "WWzWWDDzz"; break;
1578 case 3: desc->format = "WWzWWDDzzzzzzzzzzlz"; break;
1579 default: return False;
1580 }
1581 if (strcmp(desc->format,id) != 0) return False;
1582 return True;
1583 }
1584
1585 static BOOL api_PrintJobInfo(int cnum,int uid,char *param,char *data,
1586 int mdrcnt,int mprcnt,
1587 char **rdata,char **rparam,
1588 int *rdata_len,int *rparam_len)
1589 {
1590 struct pack_desc desc;
1591 char *str1 = param+2;
1592 char *str2 = skip_string(str1,1);
1593 char *p = skip_string(str2,1);
1594 int jobid = (SVAL(p,0)&0xFF); /* the snum and jobid are encoded
1595 by the print queue api */
1596 int snum = (SVAL(p,0)>>8);
1597 int uLevel = SVAL(p,2);
1598 int function = SVAL(p,4); /* what is this ?? */
1599 int i;
1600 char *s = data;
1601
1602 *rparam_len = 4;
1603 *rparam = REALLOC(*rparam,*rparam_len);
1604
1605 *rdata_len = 0;
1606
1607 /* check it's a supported varient */
1608 if ((strcmp(str1,"WWsTP")) || (!check_printjob_info(&desc,uLevel,str2)))
1609 return(False);
1610
1611 switch (function) {
1612 case 0x6: /* change job place in the queue, data gives the new place */
1613 if (snum >= 0 && VALID_SNUM(snum))
1614 {
1615 print_queue_struct *queue=NULL;
1616 int count;
1617
1618 lpq_reset(snum);
1619 count = get_printqueue(snum,cnum,&queue,NULL);
1620 for (i=0;i<count;i++) /* find job */
1621 if ((queue[i].job%0xFF) == jobid) break;
1622
1623 if (i==count) {
1624 desc.errcode=NERR_JobNotFound;
1625 if (queue) free(queue);
1626 }
1627 else {
1628 desc.errcode=NERR_Success;
1629 i++;
1630 #if 0
1631 {
1632 int place= SVAL(data,0);
1633 /* we currently have no way of doing this. Can any unix do it? */
1634 if (i < place) /* move down */;
1635 else if (i > place ) /* move up */;
1636 }
1637 #endif
1638 desc.errcode=NERR_notsupported; /* not yet supported */
1639 if (queue) free(queue);
1640 }
1641 }
1642 else desc.errcode=NERR_JobNotFound;
1643 break;
1644 case 0xb: /* change print job name, data gives the name */
1645 /* jobid, snum should be zero */
1646 if (isalpha(*s))
1647 {
1648 pstring name;
1649 int l = 0;
1650 while (l<64 && *s)
1651 {
1652 if (issafe(*s)) name[l++] = *s;
1653 s++;
1654 }
1655 name[l] = 0;
1656
1657 DEBUG(3,("Setting print name to %s\n",name));
1658
1659 for (i=0;i<MAX_OPEN_FILES;i++)
1660 if (Files[i].open && Files[i].print_file)
1661 {
1662 pstring wd;
1663 GetWd(wd);
1664 unbecome_user();
1665
1666 if (!become_user(Files[i].cnum,uid) ||
1667 !become_service(Files[i].cnum,True))
1668 break;
1669
1670 if (sys_rename(Files[i].name,name) == 0)
1671 string_set(&Files[i].name,name);
1672 break;
1673 }
1674 }
1675 desc.errcode=NERR_Success;
1676
1677 break;
1678 default: /* not implemented */
1679 return False;
1680 }
1681
1682 SSVALS(*rparam,0,desc.errcode);
1683 SSVAL(*rparam,2,0); /* converter word */
1684
1685 return(True);
1686 }
1687
1688
1689 /****************************************************************************
1690 get info about the server
1691 ****************************************************************************/
1692 static BOOL api_RNetServerGetInfo(int cnum,int uid, char *param,char *data,
1693 int mdrcnt,int mprcnt,
1694 char **rdata,char **rparam,
1695 int *rdata_len,int *rparam_len)
1696 {
1697 char *str1 = param+2;
1698 char *str2 = skip_string(str1,1);
1699 char *p = skip_string(str2,1);
1700 int uLevel = SVAL(p,0);
1701 char *p2;
1702 int struct_len;
1703
1704 DEBUG(4,("NetServerGetInfo level %d\n",uLevel));
1705
1706 /* check it's a supported varient */
1707 if (!prefix_ok(str1,"WrLh")) return False;
1708 switch( uLevel ) {
1709 case 0:
1710 if (strcmp(str2,"B16") != 0) return False;
1711 struct_len = 16;
1712 break;
1713 case 1:
1714 if (strcmp(str2,"B16BBDz") != 0) return False;
1715 struct_len = 26;
1716 break;
1717 case 2:
1718 if (strcmp(str2,"B16BBDzDDDWWzWWWWWWWBB21zWWWWWWWWWWWWWWWWWWWWWWz")
1719 != 0) return False;
1720 struct_len = 134;
1721 break;
1722 case 3:
1723 if (strcmp(str2,"B16BBDzDDDWWzWWWWWWWBB21zWWWWWWWWWWWWWWWWWWWWWWzDWz")
1724 != 0) return False;
1725 struct_len = 144;
1726 break;
1727 case 20:
1728 if (strcmp(str2,"DN") != 0) return False;
1729 struct_len = 6;
1730 break;
1731 case 50:
1732 if (strcmp(str2,"B16BBDzWWzzz") != 0) return False;
1733 struct_len = 42;
1734 break;
1735 default: return False;
1736 }
1737
1738 *rdata_len = mdrcnt;
1739 *rdata = REALLOC(*rdata,*rdata_len);
1740
1741 p = *rdata;
1742 p2 = p + struct_len;
1743 if (uLevel != 20) {
1744 StrnCpy(p,local_machine,16);
1745 strupper(p);
1746 }
1747 p += 16;
1748 if (uLevel > 0)
1749 {
1750 struct srv_info_struct *servers=NULL;
1751 int i,count;
1752 pstring comment;
1753 uint32 servertype=SV_TYPE_SERVER_UNIX|SV_TYPE_WORKSTATION|
1754 SV_TYPE_SERVER|SV_TYPE_TIME_SOURCE;
1755
1756 strcpy(comment,lp_serverstring());
1757
1758 if ((count=get_server_info(SV_TYPE_ALL,&servers,False,NULL))>0) {
1759 for (i=0;i<count;i++)
1760 if (strequal(servers[i].name,local_machine)) {
1761 servertype = servers[i].type;
1762 strcpy(comment,servers[i].comment);
1763 }
1764 }
1765 if (servers) free(servers);
1766
1767 SCVAL(p,0,2); /* version_major */
1768 SCVAL(p,1,0); /* version_minor */
1769 SIVAL(p,2,servertype);
1770 if (mdrcnt == struct_len) {
1771 SIVAL(p,6,0);
1772 } else {
1773 SIVAL(p,6,PTR_DIFF(p2,*rdata));
1774 standard_sub(cnum,comment);
1775 StrnCpy(p2,comment,MAX(mdrcnt - struct_len,0));
1776 p2 = skip_string(p2,1);
1777 }
1778 }
1779 if (uLevel > 1)
1780 {
1781 return False; /* not yet implemented */
1782 }
1783
1784 *rdata_len = PTR_DIFF(p2,*rdata);
1785
1786 *rparam_len = 6;
1787 *rparam = REALLOC(*rparam,*rparam_len);
1788 SSVAL(*rparam,0,NERR_Success);
1789 SSVAL(*rparam,2,0); /* converter word */
1790 SSVAL(*rparam,4,*rdata_len);
1791
1792 return(True);
1793 }
1794
1795
1796 /****************************************************************************
1797 get info about the server
1798 ****************************************************************************/
1799 static BOOL api_NetWkstaGetInfo(int cnum,int uid, char *param,char *data,
1800 int mdrcnt,int mprcnt,
1801 char **rdata,char **rparam,
1802 int *rdata_len,int *rparam_len)
1803 {
1804 char *str1 = param+2;
1805 char *str2 = skip_string(str1,1);
1806 char *p = skip_string(str2,1);
1807 char *p2;
1808 extern pstring sesssetup_user;
1809 int level = SVAL(p,0);
1810
1811 DEBUG(4,("NetWkstaGetInfo level %d\n",level));
1812
1813 *rparam_len = 6;
1814 *rparam = REALLOC(*rparam,*rparam_len);
1815
1816 /* check it's a supported varient */
1817 if (!(level==10 && strcsequal(str1,"WrLh") && strcsequal(str2,"zzzBBzz")))
1818 return(False);
1819
1820 *rdata_len = mdrcnt + 1024;
1821 *rdata = REALLOC(*rdata,*rdata_len);
1822
1823 SSVAL(*rparam,0,NERR_Success);
1824 SSVAL(*rparam,2,0); /* converter word */
1825
1826 p = *rdata;
1827 p2 = p + 22;
1828
1829 SIVAL(p,0,PTR_DIFF(p2,*rdata));
1830 strcpy(p2,local_machine);
1831 p2 = skip_string(p2,1);
1832 p += 4;
1833
1834 SIVAL(p,0,PTR_DIFF(p2,*rdata));
1835 strcpy(p2,sesssetup_user);
1836 p2 = skip_string(p2,1);
1837 p += 4;
1838
1839 SIVAL(p,0,PTR_DIFF(p2,*rdata));
1840 strcpy(p2,my_workgroup());
1841 p2 = skip_string(p2,1);
1842 p += 4;
1843
1844 SCVAL(p,0,2); /* major version?? */
1845 SCVAL(p,1,1); /* minor version?? */
1846 p += 2;
1847
1848 SIVAL(p,0,PTR_DIFF(p2,*rdata));
1849 strcpy(p2,my_workgroup()); /* login domain?? */
1850 p2 = skip_string(p2,1);
1851 p += 4;
1852
1853 SIVAL(p,0,PTR_DIFF(p2,*rdata));
1854 strcpy(p2,"");
1855 p2 = skip_string(p2,1);
1856 p += 4;
1857
1858 *rdata_len = PTR_DIFF(p2,*rdata);
1859
1860 SSVAL(*rparam,4,*rdata_len);
1861
1862 return(True);
1863 }
1864
1865
1866 /****************************************************************************
1867 get info about a user
1868 ****************************************************************************/
1869
1870 #define USER_PRIV_GUEST 0
1871 #define USER_PRIV_USER 1
1872 #define USER_PRIV_ADMIN 2
1873
1874 static BOOL api_RNetUserGetInfo(int cnum,int uid, char *param,char *data,
1875 int mdrcnt,int mprcnt,
1876 char **rdata,char **rparam,
1877 int *rdata_len,int *rparam_len)
1878 {
1879 char *str1 = param+2;
1880 char *str2 = skip_string(str1,1);
1881 char *UserName = skip_string(str2,1);
1882 char *p = skip_string(UserName,1);
1883 int uLevel = SVAL(p,0);
1884 char *p2;
1885
1886 *rparam_len = 6;
1887 *rparam = REALLOC(*rparam,*rparam_len);
1888
1889 /* check it's a supported varient */
1890 if (strcmp(str1,"zWrLh") != 0) return False;
1891 switch( uLevel ) {
1892 case 0: p2 = "B21"; break;
1893 case 1: p2 = "B21BB16DWzzWz"; break;
1894 case 2: p2 = "B21BB16DWzzWzDzzzzDDDDWb21WWzWW"; break;
1895 case 10: p2 = "B21Bzzz"; break;
1896 case 11: p2 = "B21BzzzWDDzzDDWWzWzDWb21W"; break;
1897 default: return False;
1898 }
1899 if (strcmp(p2,str2) != 0) return False;
1900
1901 *rdata_len = mdrcnt + 1024;
1902 *rdata = REALLOC(*rdata,*rdata_len);
1903
1904 SSVAL(*rparam,0,NERR_Success);
1905 SSVAL(*rparam,2,0); /* converter word */
1906
1907 p = *rdata;
1908 p2 = p + 86;
1909
1910 memset(p,0,21);
1911 strcpy(p,UserName);
1912 if (uLevel > 0) {
1913 SCVAL(p,21,0);
1914 *p2 = 0;
1915 if (uLevel >= 10) {
1916 SIVAL(p,22,PTR_DIFF(p2,p)); /* comment */
1917 strcpy(p2,"<Comment>");
1918 p2 = skip_string(p2,1);
1919 SIVAL(p,26,PTR_DIFF(p2,p)); /* user_comment */
1920 strcpy(p2,"<UserComment>");
1921 p2 = skip_string(p2,1);
1922 SIVAL(p,30,PTR_DIFF(p2,p)); /* full name */
1923 strcpy(p2,"<FullName>");
1924 p2 = skip_string(p2,1);
1925 }
1926 if (uLevel == 11) { /* modelled after NTAS 3.51 reply */
1927 SSVAL(p,34,USER_PRIV_USER); /* user privilege */
1928 SIVAL(p,36,0); /* auth flags */
1929 SIVALS(p,40,-1); /* password age */
1930 SIVAL(p,44,PTR_DIFF(p2,p)); /* home dir */
1931 strcpy(p2,"\\\\%L\\HOMES");
1932 standard_sub_basic(p2);
1933 p2 = skip_string(p2,1);
1934 SIVAL(p,48,PTR_DIFF(p2,p)); /* parms */
1935 strcpy(p2,"");
1936 p2 = skip_string(p2,1);
1937 SIVAL(p,52,0); /* last logon */
1938 SIVAL(p,56,0); /* last logoff */
1939 SSVALS(p,60,-1); /* bad pw counts */
1940 SSVALS(p,62,-1); /* num logons */
1941 SIVAL(p,64,PTR_DIFF(p2,p)); /* logon server */
1942 strcpy(p2,"\\\\*");
1943 p2 = skip_string(p2,1);
1944 SSVAL(p,68,0); /* country code */
1945
1946 SIVAL(p,70,PTR_DIFF(p2,p)); /* workstations */
1947 strcpy(p2,"");
1948 p2 = skip_string(p2,1);
1949
1950 SIVALS(p,74,-1); /* max storage */
1951 SSVAL(p,78,168); /* units per week */
1952 SIVAL(p,80,PTR_DIFF(p2,p)); /* logon hours */
1953 memset(p2,-1,21);
1954 SCVAL(p2,21,0); /* fix zero termination */
1955 p2 = skip_string(p2,1);
1956
1957 SSVAL(p,84,0); /* code page */
1958 }
1959 if (uLevel == 1 || uLevel == 2) {
1960 memset(p+22,' ',16); /* password */
1961 SIVALS(p,38,-1); /* password age */
1962 SSVAL(p,42,USER_PRIV_ADMIN); /* user privilege */
1963 SIVAL(p,44,PTR_DIFF(p2,*rdata)); /* home dir */
1964 strcpy(p2,"\\\\%L\\HOMES");
1965 standard_sub_basic(p2);
1966 p2 = skip_string(p2,1);
1967 SIVAL(p,48,PTR_DIFF(p2,*rdata)); /* comment */
1968 *p2++ = 0;
1969 SSVAL(p,52,0); /* flags */
1970 SIVAL(p,54,0); /* script_path */
1971 if (uLevel == 2) {
1972 SIVAL(p,60,0); /* auth_flags */
1973 SIVAL(p,64,PTR_DIFF(p2,*rdata)); /* full_name */
1974 strcpy(p2,"<Full Name>");
1975 p2 = skip_string(p2,1);
1976 SIVAL(p,68,0); /* urs_comment */
1977 SIVAL(p,72,PTR_DIFF(p2,*rdata)); /* parms */
1978 strcpy(p2,"");
1979 p2 = skip_string(p2,1);
1980 SIVAL(p,76,0); /* workstations */
1981 SIVAL(p,80,0); /* last_logon */
1982 SIVAL(p,84,0); /* last_logoff */
1983 SIVALS(p,88,-1); /* acct_expires */
1984 SIVALS(p,92,-1); /* max_storage */
1985 SSVAL(p,96,168); /* units_per_week */
1986 SIVAL(p,98,PTR_DIFF(p2,*rdata)); /* logon_hours */
1987 memset(p2,-1,21);
1988 p2 += 21;
1989 SSVALS(p,102,-1); /* bad_pw_count */
1990 SSVALS(p,104,-1); /* num_logons */
1991 SIVAL(p,106,PTR_DIFF(p2,*rdata)); /* logon_server */
1992 strcpy(p2,"\\\\%L");
1993 standard_sub_basic(p2);
1994 p2 = skip_string(p2,1);
1995 SSVAL(p,110,49); /* country_code */
1996 SSVAL(p,112,860); /* code page */
1997 }
1998 }
1999 }
2000
2001 *rdata_len = PTR_DIFF(p2,*rdata);
2002
2003 SSVAL(*rparam,4,*rdata_len); /* is this right?? */
2004
2005 return(True);
2006 }
2007
2008
2009 /*******************************************************************
2010 get groups that a user is a member of
2011 ******************************************************************/
2012 static BOOL api_NetUserGetGroups(int cnum,int uid, char *param,char *data,
2013 int mdrcnt,int mprcnt,
2014 char **rdata,char **rparam,
2015 int *rdata_len,int *rparam_len)
2016 {
2017 char *str1 = param+2;
2018 char *str2 = skip_string(str1,1);
2019 char *UserName = skip_string(str2,1);
2020 char *p = skip_string(UserName,1);
2021 int uLevel = SVAL(p,0);
2022 char *p2;
2023 int count=0;
2024
2025 *rparam_len = 8;
2026 *rparam = REALLOC(*rparam,*rparam_len);
2027
2028 /* check it's a supported varient */
2029 if (strcmp(str1,"zWrLeh") != 0) return False;
2030 switch( uLevel ) {
2031 case 0: p2 = "B21"; break;
2032 default: return False;
2033 }
2034 if (strcmp(p2,str2) != 0) return False;
2035
2036 *rdata_len = mdrcnt + 1024;
2037 *rdata = REALLOC(*rdata,*rdata_len);
2038
2039 SSVAL(*rparam,0,NERR_Success);
2040 SSVAL(*rparam,2,0); /* converter word */
2041
2042 p = *rdata;
2043
2044 /* XXXX we need a real SAM database some day */
2045 strcpy(p,"Users"); p += 21; count++;
2046 strcpy(p,"Domain Users"); p += 21; count++;
2047 strcpy(p,"Guests"); p += 21; count++;
2048 strcpy(p,"Domain Guests"); p += 21; count++;
2049
2050 *rdata_len = PTR_DIFF(p,*rdata);
2051
2052 SSVAL(*rparam,4,count); /* is this right?? */
2053 SSVAL(*rparam,6,count); /* is this right?? */
2054
2055 return(True);
2056 }
2057
2058
2059 static BOOL api_WWkstaUserLogon(int cnum,int uid, char *param,char *data,
2060 int mdrcnt,int mprcnt,
2061 char **rdata,char **rparam,
2062 int *rdata_len,int *rparam_len)
2063 {
2064 char *str1 = param+2;
2065 char *str2 = skip_string(str1,1);
2066 char *p = skip_string(str2,1);
2067 int uLevel;
2068 struct pack_desc desc;
2069 char* name;
2070
2071 uLevel = SVAL(p,0);
2072 name = p + 2;
2073
2074 bzero(&desc,sizeof(desc));
2075
2076 DEBUG(3,("WWkstaUserLogon uLevel=%d name=%s\n",uLevel,name));
2077
2078 /* check it's a supported varient */
2079 if (strcmp(str1,"OOWb54WrLh") != 0) return False;
2080 if (uLevel != 1 || strcmp(str2,"WB21BWDWWDDDDDDDzzzD") != 0) return False;
2081 if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2082 desc.base = *rdata;
2083 desc.buflen = mdrcnt;
2084 desc.subformat = NULL;
2085 desc.format = str2;
2086
2087
2088
2089 if (init_package(&desc,1,0)) {
2090 PACKI(&desc,"W",0); /* code */
2091 PACKS(&desc,"B21",name); /* eff. name */
2092 PACKS(&desc,"B",""); /* pad */
2093 PACKI(&desc,"W",
2094 Connections[cnum].admin_user?USER_PRIV_ADMIN:USER_PRIV_USER);
2095 PACKI(&desc,"D",0); /* auth flags XXX */
2096 PACKI(&desc,"W",0); /* num logons */
2097 PACKI(&desc,"W",0); /* bad pw count */
2098 PACKI(&desc,"D",-1); /* last logon */
2099 PACKI(&desc,"D",-1); /* last logoff */
2100 PACKI(&desc,"D",-1); /* logoff time */
2101 PACKI(&desc,"D",-1); /* kickoff time */
2102 PACKI(&desc,"D",0); /* password age */
2103 PACKI(&desc,"D",0); /* password can change */
2104 PACKI(&desc,"D",-1); /* password must change */
2105 {
2106 fstring mypath;
2107 strcpy(mypath,"\\\\");
2108 strcat(mypath,local_machine);
2109 strupper(mypath);
2110 PACKS(&desc,"z",mypath); /* computer */
2111 }
2112 PACKS(&desc,"z",my_workgroup());/* domain */
2113 PACKS(&desc,"z",lp_logon_script()); /* script path */
2114 PACKI(&desc,"D",0); /* reserved */
2115 }
2116
2117 *rdata_len = desc.usedlen;
2118 *rparam_len = 6;
2119 *rparam = REALLOC(*rparam,*rparam_len);
2120 SSVALS(*rparam,0,desc.errcode);
2121 SSVAL(*rparam,2,0);
2122 SSVAL(*rparam,4,desc.neededlen);
2123
2124 DEBUG(4,("WWkstaUserLogon: errorcode %d\n",desc.errcode));
2125 return(True);
2126 }
2127
2128
2129 /****************************************************************************
2130 api_WAccessGetUserPerms
2131 ****************************************************************************/
2132 static BOOL api_WAccessGetUserPerms(int cnum,int uid, char *param,char *data,
2133 int mdrcnt,int mprcnt,
2134 char **rdata,char **rparam,
2135 int *rdata_len,int *rparam_len)
2136 {
2137 char *str1 = param+2;
2138 char *str2 = skip_string(str1,1);
2139 char *user = skip_string(str2,1);
2140 char *resource = skip_string(user,1);
2141
2142 DEBUG(3,("WAccessGetUserPerms user=%s resource=%s\n",user,resource));
2143
2144 /* check it's a supported varient */
2145 if (strcmp(str1,"zzh") != 0) return False;
2146 if (strcmp(str2,"") != 0) return False;
2147
2148 *rparam_len = 6;
2149 *rparam = REALLOC(*rparam,*rparam_len);
2150 SSVALS(*rparam,0,0); /* errorcode */
2151 SSVAL(*rparam,2,0); /* converter word */
2152 SSVAL(*rparam,4,0x7f); /* permission flags */
2153
2154 return(True);
2155 }
2156
2157 /****************************************************************************
2158 api_WPrintJobEnumerate
2159 ****************************************************************************/
2160 static BOOL api_WPrintJobGetInfo(int cnum,int uid, char *param,char *data,
2161 int mdrcnt,int mprcnt,
2162 char **rdata,char **rparam,
2163 int *rdata_len,int *rparam_len)
2164 {
2165 char *str1 = param+2;
2166 char *str2 = skip_string(str1,1);
2167 char *p = skip_string(str2,1);
2168 int uJobId = SVAL(p,0);
2169 int uLevel,cbBuf;
2170 int count;
2171 int i;
2172 int snum;
2173 int job;
2174 struct pack_desc desc;
2175 print_queue_struct *queue=NULL;
2176 print_status_struct status;
2177
2178 uLevel = SVAL(p,2);
2179 cbBuf = SVAL(p,4);
2180
2181 bzero(&desc,sizeof(desc));
2182 bzero(&status,sizeof(status));
2183
2184 DEBUG(3,("WPrintJobGetInfo uLevel=%d uJobId=0x%X\n",uLevel,uJobId));
2185
2186 /* check it's a supported varient */
2187 if (strcmp(str1,"WWrLh") != 0) return False;
2188 if (!check_printjob_info(&desc,uLevel,str2)) return False;
2189
2190 snum = (unsigned int)uJobId >> 8; /*## valid serice number??*/
2191 job = uJobId & 0xFF;
2192
2193 if (snum < 0 || !VALID_SNUM(snum)) return(False);
2194
2195 count = get_printqueue(snum,cnum,&queue,&status);
2196 for (i = 0; i < count; i++) {
2197 if ((queue[i].job % 0xFF) == job) break;
2198 }
2199 if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2200 desc.base = *rdata;
2201 desc.buflen = mdrcnt;
2202
2203 if (init_package(&desc,1,0)) {
2204 if (i < count) {
2205 fill_printjob_info(cnum,snum,uLevel,&desc,&queue[i],i);
2206 *rdata_len = desc.usedlen;
2207 }
2208 else {
2209 desc.errcode = NERR_JobNotFound;
2210 *rdata_len = 0;
2211 }
2212 }
2213
2214 *rparam_len = 6;
2215 *rparam = REALLOC(*rparam,*rparam_len);
2216 SSVALS(*rparam,0,desc.errcode);
2217 SSVAL(*rparam,2,0);
2218 SSVAL(*rparam,4,desc.neededlen);
2219
2220 if (queue) free(queue);
2221
2222 DEBUG(4,("WPrintJobGetInfo: errorcode %d\n",desc.errcode));
2223 return(True);
2224 }
2225
2226 static BOOL api_WPrintJobEnumerate(int cnum,int uid, char *param,char *data,
2227 int mdrcnt,int mprcnt,
2228 char **rdata,char **rparam,
2229 int *rdata_len,int *rparam_len)
2230 {
2231 char *str1 = param+2;
2232 char *str2 = skip_string(str1,1);
2233 char *p = skip_string(str2,1);
2234 char* name = p;
2235 int uLevel,cbBuf;
2236 int count;
2237 int i, succnt=0;
2238 int snum;
2239 struct pack_desc desc;
2240 print_queue_struct *queue=NULL;
2241 print_status_struct status;
2242
2243 bzero(&desc,sizeof(desc));
2244 bzero(&status,sizeof(status));
2245
2246 p = skip_string(p,1);
2247 uLevel = SVAL(p,0);
2248 cbBuf = SVAL(p,2);
2249
2250 DEBUG(3,("WPrintJobEnumerate uLevel=%d name=%s\n",uLevel,name));
2251
2252 /* check it's a supported varient */
2253 if (strcmp(str1,"zWrLeh") != 0) return False;
2254 if (uLevel > 2) return False; /* defined only for uLevel 0,1,2 */
2255 if (!check_printjob_info(&desc,uLevel,str2)) return False;
2256
2257 snum = lp_servicenumber(name);
2258 if (snum < 0 && pcap_printername_ok(name,NULL)) {
2259 int pnum = lp_servicenumber(PRINTERS_NAME);
2260 if (pnum >= 0) {
2261 lp_add_printer(name,pnum);
2262 snum = lp_servicenumber(name);
2263 }
2264 }
2265
2266 if (snum < 0 || !VALID_SNUM(snum)) return(False);
2267
2268 count = get_printqueue(snum,cnum,&queue,&status);
2269 if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2270 desc.base = *rdata;
2271 desc.buflen = mdrcnt;
2272
2273 if (init_package(&desc,count,0)) {
2274 succnt = 0;
2275 for (i = 0; i < count; i++) {
2276 fill_printjob_info(cnum,snum,uLevel,&desc,&queue[i],i);
2277 if (desc.errcode == NERR_Success) succnt = i+1;
2278 }
2279 }
2280
2281 *rdata_len = desc.usedlen;
2282
2283 *rparam_len = 8;
2284 *rparam = REALLOC(*rparam,*rparam_len);
2285 SSVALS(*rparam,0,desc.errcode);
2286 SSVAL(*rparam,2,0);
2287 SSVAL(*rparam,4,succnt);
2288 SSVAL(*rparam,6,count);
2289
2290 if (queue) free(queue);
2291
2292 DEBUG(4,("WPrintJobEnumerate: errorcode %d\n",desc.errcode));
2293 return(True);
2294 }
2295
2296 static int check_printdest_info(struct pack_desc* desc,
2297 int uLevel, char* id)
2298 {
2299 desc->subformat = NULL;
2300 switch( uLevel ) {
2301 case 0: desc->format = "B9"; break;
2302 case 1: desc->format = "B9B21WWzW"; break;
2303 case 2: desc->format = "z"; break;
2304 case 3: desc->format = "zzzWWzzzWW"; break;
2305 default: return False;
2306 }
2307 if (strcmp(desc->format,id) != 0) return False;
2308 return True;
2309 }
2310
2311 static void fill_printdest_info(int cnum, int snum, int uLevel,
2312 struct pack_desc* desc)
2313 {
2314 char buf[100];
2315 strcpy(buf,SERVICE(snum));
2316 strupper(buf);
2317 if (uLevel <= 1) {
2318 PACKS(desc,"B9",buf); /* szName */
2319 if (uLevel == 1) {
2320 PACKS(desc,"B21",""); /* szUserName */
2321 PACKI(desc,"W",0); /* uJobId */
2322 PACKI(desc,"W",0); /* fsStatus */
2323 PACKS(desc,"z",""); /* pszStatus */
2324 PACKI(desc,"W",0); /* time */
2325 }
2326 }
2327 if (uLevel == 2 || uLevel == 3) {
2328 PACKS(desc,"z",buf); /* pszPrinterName */
2329 if (uLevel == 3) {
2330 PACKS(desc,"z",""); /* pszUserName */
2331 PACKS(desc,"z",""); /* pszLogAddr */
2332 PACKI(desc,"W",0); /* uJobId */
2333 PACKI(desc,"W",0); /* fsStatus */
2334 PACKS(desc,"z",""); /* pszStatus */
2335 PACKS(desc,"z",""); /* pszComment */
2336 PACKS(desc,"z","NULL"); /* pszDrivers */
2337 PACKI(desc,"W",0); /* time */
2338 PACKI(desc,"W",0); /* pad1 */
2339 }
2340 }
2341 }
2342
2343 static BOOL api_WPrintDestGetInfo(int cnum,int uid, char *param,char *data,
2344 int mdrcnt,int mprcnt,
2345 char **rdata,char **rparam,
2346 int *rdata_len,int *rparam_len)
2347 {
2348 char *str1 = param+2;
2349 char *str2 = skip_string(str1,1);
2350 char *p = skip_string(str2,1);
2351 char* PrinterName = p;
2352 int uLevel,cbBuf;
2353 struct pack_desc desc;
2354 int snum;
2355
2356 bzero(&desc,sizeof(desc));
2357
2358 p = skip_string(p,1);
2359 uLevel = SVAL(p,0);
2360 cbBuf = SVAL(p,2);
2361
2362 DEBUG(3,("WPrintDestGetInfo uLevel=%d PrinterName=%s\n",uLevel,PrinterName));
2363
2364 /* check it's a supported varient */
2365 if (strcmp(str1,"zWrLh") != 0) return False;
2366 if (!check_printdest_info(&desc,uLevel,str2)) return False;
2367
2368 snum = lp_servicenumber(PrinterName);
2369 if (snum < 0 && pcap_printername_ok(PrinterName,NULL)) {
2370 int pnum = lp_servicenumber(PRINTERS_NAME);
2371 if (pnum >= 0) {
2372 lp_add_printer(PrinterName,pnum);
2373 snum = lp_servicenumber(PrinterName);
2374 }
2375 }
2376
2377 if (snum < 0) {
2378 *rdata_len = 0;
2379 desc.errcode = NERR_DestNotFound;
2380 desc.neededlen = 0;
2381 }
2382 else {
2383 if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2384 desc.base = *rdata;
2385 desc.buflen = mdrcnt;
2386 if (init_package(&desc,1,0)) {
2387 fill_printdest_info(cnum,snum,uLevel,&desc);
2388 }
2389 *rdata_len = desc.usedlen;
2390 }
2391
2392 *rparam_len = 6;
2393 *rparam = REALLOC(*rparam,*rparam_len);
2394 SSVALS(*rparam,0,desc.errcode);
2395 SSVAL(*rparam,2,0);
2396 SSVAL(*rparam,4,desc.neededlen);
2397
2398 DEBUG(4,("WPrintDestGetInfo: errorcode %d\n",desc.errcode));
2399 return(True);
2400 }
2401
2402 static BOOL api_WPrintDestEnum(int cnum,int uid, char *param,char *data,
2403 int mdrcnt,int mprcnt,
2404 char **rdata,char **rparam,
2405 int *rdata_len,int *rparam_len)
2406 {
2407 char *str1 = param+2;
2408 char *str2 = skip_string(str1,1);
2409 char *p = skip_string(str2,1);
2410 int uLevel,cbBuf;
2411 int queuecnt;
2412 int i, n, succnt=0;
2413 struct pack_desc desc;
2414 int services = lp_numservices();
2415
2416 bzero(&desc,sizeof(desc));
2417
2418 uLevel = SVAL(p,0);
2419 cbBuf = SVAL(p,2);
2420
2421 DEBUG(3,("WPrintDestEnum uLevel=%d\n",uLevel));
2422
2423 /* check it's a supported varient */
2424 if (strcmp(str1,"WrLeh") != 0) return False;
2425 if (!check_printdest_info(&desc,uLevel,str2)) return False;
2426
2427 queuecnt = 0;
2428 for (i = 0; i < services; i++)
2429 if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i))
2430 queuecnt++;
2431
2432 if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2433 desc.base = *rdata;
2434 desc.buflen = mdrcnt;
2435 if (init_package(&desc,queuecnt,0)) {
2436 succnt = 0;
2437 n = 0;
2438 for (i = 0; i < services; i++) {
2439 if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
2440 fill_printdest_info(cnum,i,uLevel,&desc);
2441 n++;
2442 if (desc.errcode == NERR_Success) succnt = n;
2443 }
2444 }
2445 }
2446
2447 *rdata_len = desc.usedlen;
2448
2449 *rparam_len = 8;
2450 *rparam = REALLOC(*rparam,*rparam_len);
2451 SSVALS(*rparam,0,desc.errcode);
2452 SSVAL(*rparam,2,0);
2453 SSVAL(*rparam,4,succnt);
2454 SSVAL(*rparam,6,queuecnt);
2455
2456 DEBUG(4,("WPrintDestEnumerate: errorcode %d\n",desc.errcode));
2457 return(True);
2458 }
2459
2460 static BOOL api_WPrintDriverEnum(int cnum,int uid, char *param,char *data,
2461 int mdrcnt,int mprcnt,
2462 char **rdata,char **rparam,
2463 int *rdata_len,int *rparam_len)
2464 {
2465 char *str1 = param+2;
2466 char *str2 = skip_string(str1,1);
2467 char *p = skip_string(str2,1);
2468 int uLevel,cbBuf;
2469 int succnt;
2470 struct pack_desc desc;
2471
2472 bzero(&desc,sizeof(desc));
2473
2474 uLevel = SVAL(p,0);
2475 cbBuf = SVAL(p,2);
2476
2477 DEBUG(3,("WPrintDriverEnum uLevel=%d\n",uLevel));
2478
2479 /* check it's a supported varient */
2480 if (strcmp(str1,"WrLeh") != 0) return False;
2481 if (uLevel != 0 || strcmp(str2,"B41") != 0) return False;
2482
2483 if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2484 desc.base = *rdata;
2485 desc.buflen = mdrcnt;
2486 if (init_package(&desc,1,0)) {
2487 PACKS(&desc,"B41","NULL");
2488 }
2489
2490 succnt = (desc.errcode == NERR_Success ? 1 : 0);
2491
2492 *rdata_len = desc.usedlen;
2493
2494 *rparam_len = 8;
2495 *rparam = REALLOC(*rparam,*rparam_len);
2496 SSVALS(*rparam,0,desc.errcode);
2497 SSVAL(*rparam,2,0);
2498 SSVAL(*rparam,4,succnt);
2499 SSVAL(*rparam,6,1);
2500
2501 DEBUG(4,("WPrintDriverEnum: errorcode %d\n",desc.errcode));
2502 return(True);
2503 }
2504
2505 static BOOL api_WPrintQProcEnum(int cnum,int uid, char *param,char *data,
2506 int mdrcnt,int mprcnt,
2507 char **rdata,char **rparam,
2508 int *rdata_len,int *rparam_len)
2509 {
2510 char *str1 = param+2;
2511 char *str2 = skip_string(str1,1);
2512 char *p = skip_string(str2,1);
2513 int uLevel,cbBuf;
2514 int succnt;
2515 struct pack_desc desc;
2516
2517 bzero(&desc,sizeof(desc));
2518
2519 uLevel = SVAL(p,0);
2520 cbBuf = SVAL(p,2);
2521
2522 DEBUG(3,("WPrintQProcEnum uLevel=%d\n",uLevel));
2523
2524 /* check it's a supported varient */
2525 if (strcmp(str1,"WrLeh") != 0) return False;
2526 if (uLevel != 0 || strcmp(str2,"B13") != 0) return False;
2527
2528 if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2529 desc.base = *rdata;
2530 desc.buflen = mdrcnt;
2531 desc.format = str2;
2532 if (init_package(&desc,1,0)) {
2533 PACKS(&desc,"B13","lpd");
2534 }
2535
2536 succnt = (desc.errcode == NERR_Success ? 1 : 0);
2537
2538 *rdata_len = desc.usedlen;
2539
2540 *rparam_len = 8;
2541 *rparam = REALLOC(*rparam,*rparam_len);
2542 SSVALS(*rparam,0,desc.errcode);
2543 SSVAL(*rparam,2,0);
2544 SSVAL(*rparam,4,succnt);
2545 SSVAL(*rparam,6,1);
2546
2547 DEBUG(4,("WPrintQProcEnum: errorcode %d\n",desc.errcode));
2548 return(True);
2549 }
2550
2551 static BOOL api_WPrintPortEnum(int cnum,int uid, char *param,char *data,
2552 int mdrcnt,int mprcnt,
2553 char **rdata,char **rparam,
2554 int *rdata_len,int *rparam_len)
2555 {
2556 char *str1 = param+2;
2557 char *str2 = skip_string(str1,1);
2558 char *p = skip_string(str2,1);
2559 int uLevel,cbBuf;
2560 int succnt;
2561 struct pack_desc desc;
2562
2563 bzero(&desc,sizeof(desc));
2564
2565 uLevel = SVAL(p,0);
2566 cbBuf = SVAL(p,2);
2567
2568 DEBUG(3,("WPrintPortEnum uLevel=%d\n",uLevel));
2569
2570 /* check it's a supported varient */
2571 if (strcmp(str1,"WrLeh") != 0) return False;
2572 if (uLevel != 0 || strcmp(str2,"B9") != 0) return False;
2573
2574 if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2575 bzero(&desc,sizeof(desc));
2576 desc.base = *rdata;
2577 desc.buflen = mdrcnt;
2578 desc.format = str2;
2579 if (init_package(&desc,1,0)) {
2580 PACKS(&desc,"B13","lp0");
2581 }
2582
2583 succnt = (desc.errcode == NERR_Success ? 1 : 0);
2584
2585 *rdata_len = desc.usedlen;
2586
2587 *rparam_len = 8;
2588 *rparam = REALLOC(*rparam,*rparam_len);
2589 SSVALS(*rparam,0,desc.errcode);
2590 SSVAL(*rparam,2,0);
2591 SSVAL(*rparam,4,succnt);
2592 SSVAL(*rparam,6,1);
2593
2594 DEBUG(4,("WPrintPortEnum: errorcode %d\n",desc.errcode));
2595 return(True);
2596 }
2597
2598 /****************************************************************************
2599 the buffer was too small
2600 ****************************************************************************/
2601 static BOOL api_TooSmall(int cnum,int uid, char *param,char *data,
2602 int mdrcnt,int mprcnt,
2603 char **rdata,char **rparam,
2604 int *rdata_len,int *rparam_len)
2605 {
2606 *rparam_len = MIN(*rparam_len,mprcnt);
2607 *rparam = REALLOC(*rparam,*rparam_len);
2608
2609 *rdata_len = 0;
2610
2611 SSVAL(*rparam,0,NERR_BufTooSmall);
2612
2613 DEBUG(3,("Supplied buffer too small in API command\n"));
2614
2615 return(True);
2616 }
2617
2618
2619 /****************************************************************************
2620 the request is not supported
2621 ****************************************************************************/
2622 static BOOL api_Unsupported(int cnum,int uid, char *param,char *data,
2623 int mdrcnt,int mprcnt,
2624 char **rdata,char **rparam,
2625 int *rdata_len,int *rparam_len)
2626 {
2627 *rparam_len = 4;
2628 *rparam = REALLOC(*rparam,*rparam_len);
2629
2630 *rdata_len = 0;
2631
2632 SSVAL(*rparam,0,NERR_notsupported);
2633 SSVAL(*rparam,2,0); /* converter word */
2634
2635 DEBUG(3,("Unsupported API command\n"));
2636
2637 return(True);
2638 }
2639
2640
2641
2642
2643 struct
2644 {
2645 char *name;
2646 int id;
2647 BOOL (*fn)();
2648 int flags;
2649 } api_commands[] = {
2650 {"RNetShareEnum", 0, api_RNetShareEnum,0},
2651 {"RNetShareGetInfo", 1, api_RNetShareGetInfo,0},
2652 {"RNetServerGetInfo", 13, api_RNetServerGetInfo,0},
2653 {"RNetUserGetInfo", 56, api_RNetUserGetInfo,0},
2654 {"NetUserGetGroups", 59, api_NetUserGetGroups,0},
2655 {"NetWkstaGetInfo", 63, api_NetWkstaGetInfo,0},
2656 {"DosPrintQEnum", 69, api_DosPrintQEnum,0},
2657 {"DosPrintQGetInfo", 70, api_DosPrintQGetInfo,0},
2658 {"WPrintJobEnumerate",76, api_WPrintJobEnumerate,0},
2659 {"WPrintJobGetInfo", 77, api_WPrintJobGetInfo,0},
2660 {"RDosPrintJobDel", 81, api_RDosPrintJobDel,0},
2661 {"RDosPrintJobPause", 82, api_RDosPrintJobDel,0},
2662 {"RDosPrintJobResume",83, api_RDosPrintJobDel,0},
2663 {"WPrintDestEnum", 84, api_WPrintDestEnum,0},
2664 {"WPrintDestGetInfo", 85, api_WPrintDestGetInfo,0},
2665 {"NetRemoteTOD", 91, api_NetRemoteTOD,0},
2666 {"WPrintQueuePurge", 103, api_WPrintQueuePurge,0},
2667 {"NetServerEnum", 104, api_RNetServerEnum,0},
2668 {"WAccessGetUserPerms",105, api_WAccessGetUserPerms,0},
2669 {"SetUserPassword", 115, api_SetUserPassword,0},
2670 {"WWkstaUserLogon", 132, api_WWkstaUserLogon,0},
2671 {"PrintJobInfo", 147, api_PrintJobInfo,0},
2672 {"WPrintDriverEnum", 205, api_WPrintDriverEnum,0},
2673 {"WPrintQProcEnum", 206, api_WPrintQProcEnum,0},
2674 {"WPrintPortEnum", 207, api_WPrintPortEnum,0},
2675 {NULL, -1, api_Unsupported,0}};
2676
2677
2678 /****************************************************************************
2679 handle remote api calls
2680 ****************************************************************************/
2681 static int api_reply(int cnum,int uid,char *outbuf,char *data,char *params,
2682 int tdscnt,int tpscnt,int mdrcnt,int mprcnt)
2683 {
2684 int api_command = SVAL(params,0);
2685 char *rdata = NULL;
2686 char *rparam = NULL;
2687 int rdata_len = 0;
2688 int rparam_len = 0;
2689 BOOL reply=False;
2690 int i;
2691
2692 DEBUG(3,("Got API command %d of form <%s> <%s> (tdscnt=%d,tpscnt=%d,mdrcnt=%d,mprcnt=%d)\n",
2693 api_command,params+2,skip_string(params+2,1),
2694 tdscnt,tpscnt,mdrcnt,mprcnt));
2695
2696 for (i=0;api_commands[i].name;i++)
2697 if (api_commands[i].id == api_command && api_commands[i].fn)
2698 {
2699 DEBUG(3,("Doing %s\n",api_commands[i].name));
2700 break;
2701 }
2702
2703 rdata = (char *)malloc(1024); if (rdata) bzero(rdata,1024);
2704 rparam = (char *)malloc(1024); if (rparam) bzero(rparam,1024);
2705
2706 reply = api_commands[i].fn(cnum,uid,params,data,mdrcnt,mprcnt,
2707 &rdata,&rparam,&rdata_len,&rparam_len);
2708
2709
2710 if (rdata_len > mdrcnt ||
2711 rparam_len > mprcnt)
2712 {
2713 reply = api_TooSmall(cnum,uid,params,data,mdrcnt,mprcnt,
2714 &rdata,&rparam,&rdata_len,&rparam_len);
2715 }
2716
2717
2718 /* if we get False back then it's actually unsupported */
2719 if (!reply)
2720 api_Unsupported(cnum,uid,params,data,mdrcnt,mprcnt,
2721 &rdata,&rparam,&rdata_len,&rparam_len);
2722
2723
2724
2725 /* now send the reply */
2726 send_trans_reply(outbuf,rdata,rparam,NULL,rdata_len,rparam_len,0);
2727
2728 if (rdata)
2729 free(rdata);
2730 if (rparam)
2731 free(rparam);
2732
2733 return(-1);
2734 }
2735
2736 /****************************************************************************
2737 handle named pipe commands
2738 ****************************************************************************/
2739 static int named_pipe(int cnum,int uid, char *outbuf,char *name,
2740 uint16 *setup,char *data,char *params,
2741 int suwcnt,int tdscnt,int tpscnt,
2742 int msrcnt,int mdrcnt,int mprcnt)
2743 {
2744
2745 if (strequal(name,"LANMAN"))
2746 return(api_reply(cnum,uid,outbuf,data,params,tdscnt,tpscnt,mdrcnt,mprcnt));
2747
2748 DEBUG(3,("named pipe command on <%s> 0x%X setup1=%d\n",
2749 name,(int)setup[0],(int)setup[1]));
2750
2751 return(0);
2752 }
2753
2754
2755 /****************************************************************************
2756 reply to a SMBtrans
2757 ****************************************************************************/
2758 int reply_trans(char *inbuf,char *outbuf)
2759 {
2760 fstring name;
2761
2762 char *data=NULL,*params=NULL;
2763 uint16 *setup=NULL;
2764
2765 int outsize = 0;
2766 int cnum = SVAL(inbuf,smb_tid);
2767 int uid = SVAL(inbuf,smb_uid);
2768
2769 int tpscnt = SVAL(inbuf,smb_vwv0);
2770 int tdscnt = SVAL(inbuf,smb_vwv1);
2771 int mprcnt = SVAL(inbuf,smb_vwv2);
2772 int mdrcnt = SVAL(inbuf,smb_vwv3);
2773 int msrcnt = CVAL(inbuf,smb_vwv4);
2774 BOOL close_on_completion = BITSETW(inbuf+smb_vwv5,0);
2775 BOOL one_way = BITSETW(inbuf+smb_vwv5,1);
2776 int pscnt = SVAL(inbuf,smb_vwv9);
2777 int psoff = SVAL(inbuf,smb_vwv10);
2778 int dscnt = SVAL(inbuf,smb_vwv11);
2779 int dsoff = SVAL(inbuf,smb_vwv12);
2780 int suwcnt = CVAL(inbuf,smb_vwv13);
2781
2782 StrnCpy(name,smb_buf(inbuf),sizeof(name)-1);
2783
2784 if (tdscnt)
2785 {
2786 data = (char *)malloc(tdscnt);
2787 memcpy(data,smb_base(inbuf)+dsoff,dscnt);
2788 }
2789 if (tpscnt)
2790 {
2791 params = (char *)malloc(tpscnt);
2792 memcpy(params,smb_base(inbuf)+psoff,pscnt);
2793 }
2794
2795 if (suwcnt)
2796 {
2797 int i;
2798 setup = (uint16 *)malloc(suwcnt*sizeof(setup[0]));
2799 for (i=0;i<suwcnt;i++)
2800 setup[i] = SVAL(inbuf,smb_vwv14+i*SIZEOFWORD);
2801 }
2802
2803
2804 if (pscnt < tpscnt || dscnt < tdscnt)
2805 {
2806 /* We need to send an interim response then receive the rest
2807 of the parameter/data bytes */
2808 outsize = set_message(outbuf,0,0,True);
2809 show_msg(outbuf);
2810 send_smb(Client,outbuf);
2811 }
2812
2813 /* receive the rest of the trans packet */
2814 while (pscnt < tpscnt || dscnt < tdscnt)
2815 {
2816 int pcnt,poff,dcnt,doff,pdisp,ddisp;
2817
2818 if (!receive_smb(Client,inbuf, SMB_SECONDARY_WAIT*1000) ||
2819 CVAL(inbuf, smb_com) != SMBtrans)
2820 {
2821 DEBUG(2,("Invalid secondary trans2 packet\n"));
2822 if (params) free(params);
2823 if (data) free(data);
2824 if (setup) free(setup);
2825 return(ERROR(ERRSRV,ERRerror));
2826 }
2827
2828 show_msg(inbuf);
2829
2830 tpscnt = SVAL(inbuf,smb_vwv0);
2831 tdscnt = SVAL(inbuf,smb_vwv1);
2832
2833 pcnt = SVAL(inbuf,smb_vwv2);
2834 poff = SVAL(inbuf,smb_vwv3);
2835 pdisp = SVAL(inbuf,smb_vwv4);
2836
2837 dcnt = SVAL(inbuf,smb_vwv5);
2838 doff = SVAL(inbuf,smb_vwv6);
2839 ddisp = SVAL(inbuf,smb_vwv7);
2840
2841 pscnt += pcnt;
2842 dscnt += dcnt;
2843
2844 if (pcnt)
2845 memcpy(params+pdisp,smb_base(inbuf)+poff,pcnt);
2846 if (dcnt)
2847 memcpy(data+ddisp,smb_base(inbuf)+doff,dcnt);
2848 }
2849
2850
2851 DEBUG(3,("trans <%s> data=%d params=%d setup=%d\n",name,tdscnt,tpscnt,suwcnt));
2852
2853
2854 if (strncmp(name,"\\PIPE\\",strlen("\\PIPE\\")) == 0)
2855 outsize = named_pipe(cnum,uid,outbuf,name+strlen("\\PIPE\\"),setup,data,params,
2856 suwcnt,tdscnt,tpscnt,msrcnt,mdrcnt,mprcnt);
2857
2858
2859 if (data) free(data);
2860 if (params) free(params);
2861 if (setup) free(setup);
2862
2863 if (close_on_completion)
2864 close_cnum(cnum,uid);
2865
2866 if (one_way)
2867 return(-1);
2868
2869 if (outsize == 0)
2870 return(ERROR(ERRSRV,ERRnosupport));
2871
2872 return(outsize);
2873 }
2874
2875
Samba GIT mirror