?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fixed unitialized struct bug in enum_users (whatever it is called)
[Samba/gbeck.git] / source / libsmb / clirap.c
blob5e7e9427f6f8fc167dee6925d6aa4cf752f46d41
1 /*
2 Unix SMB/Netbios implementation.
3 Version 3.0
4 client RAP calls
5 Copyright (C) Andrew Tridgell 1994-1998
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 #define NO_SYSLOG
23
24 #include "includes.h"
25
26
27 /****************************************************************************
28 Call a remote api on an arbitrary pipe. takes param, data and setup buffers.
29 ****************************************************************************/
30 BOOL cli_api_pipe(struct cli_state *cli, char *pipe_name, int pipe_name_len,
31 uint16 *setup, uint32 setup_count, uint32 max_setup_count,
32 char *params, uint32 param_count, uint32 max_param_count,
33 char *data, uint32 data_count, uint32 max_data_count,
34 char **rparam, uint32 *rparam_count,
35 char **rdata, uint32 *rdata_count)
36 {
37 if (pipe_name_len == 0)
38 pipe_name_len = strlen(pipe_name);
39
40 cli_send_trans(cli, SMBtrans,
41 pipe_name, pipe_name_len,
42 0,0, /* fid, flags */
43 setup, setup_count, max_setup_count,
44 params, param_count, max_param_count,
45 data, data_count, max_data_count);
46
47 return (cli_receive_trans(cli, SMBtrans,
48 rparam, (int *)rparam_count,
49 rdata, (int *)rdata_count));
50 }
51
52 /****************************************************************************
53 call a remote api
54 ****************************************************************************/
55 BOOL cli_api(struct cli_state *cli,
56 char *param, int prcnt, int mprcnt,
57 char *data, int drcnt, int mdrcnt,
58 char **rparam, int *rprcnt,
59 char **rdata, int *rdrcnt)
60 {
61 cli_send_trans(cli,SMBtrans,
62 PIPE_LANMAN,strlen(PIPE_LANMAN), /* Name, length */
63 0,0, /* fid, flags */
64 NULL,0,0, /* Setup, length, max */
65 param, prcnt, mprcnt, /* Params, length, max */
66 data, drcnt, mdrcnt /* Data, length, max */
67 );
68
69 return (cli_receive_trans(cli,SMBtrans,
70 rparam, rprcnt,
71 rdata, rdrcnt));
72 }
73
74
75 /****************************************************************************
76 perform a NetWkstaUserLogon
77 ****************************************************************************/
78 BOOL cli_NetWkstaUserLogon(struct cli_state *cli,char *user, char *workstation)
79 {
80 char *rparam = NULL;
81 char *rdata = NULL;
82 char *p;
83 int rdrcnt,rprcnt;
84 pstring param;
85
86 memset(param, 0, sizeof(param));
87
88 /* send a SMBtrans command with api NetWkstaUserLogon */
89 p = param;
90 SSVAL(p,0,132); /* api number */
91 p += 2;
92 pstrcpy(p,"OOWb54WrLh");
93 p = skip_string(p,1);
94 pstrcpy(p,"WB21BWDWWDDDDDDDzzzD");
95 p = skip_string(p,1);
96 SSVAL(p,0,1);
97 p += 2;
98 pstrcpy(p,user);
99 strupper(p);
100 p += 21;
101 p++;
102 p += 15;
103 p++;
104 pstrcpy(p, workstation);
105 strupper(p);
106 p += 16;
107 SSVAL(p, 0, CLI_BUFFER_SIZE);
108 p += 2;
109 SSVAL(p, 0, CLI_BUFFER_SIZE);
110 p += 2;
111
112 if (cli_api(cli,
113 param, PTR_DIFF(p,param),1024, /* param, length, max */
114 NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
115 &rparam, &rprcnt, /* return params, return size */
116 &rdata, &rdrcnt /* return data, return size */
117 )) {
118 cli->rap_error = rparam? SVAL(rparam,0) : -1;
119 p = rdata;
120
121 if (cli->rap_error == 0) {
122 DEBUG(4,("NetWkstaUserLogon success\n"));
123 cli->privileges = SVAL(p, 24);
124 fstrcpy(cli->eff_name,p+2);
125 } else {
126 DEBUG(1,("NetwkstaUserLogon gave error %d\n", cli->rap_error));
127 }
128 }
129
130 if (rparam)
131 free(rparam);
132 if (rdata)
133 free(rdata);
134 return (cli->rap_error == 0);
135 }
136
137 /****************************************************************************
138 call a NetShareEnum - try and browse available connections on a host
139 ****************************************************************************/
140 int cli_RNetShareEnum(struct cli_state *cli, void (*fn)(const char *, uint32, const char *))
141 {
142 char *rparam = NULL;
143 char *rdata = NULL;
144 char *p;
145 int rdrcnt,rprcnt;
146 pstring param;
147 int count = -1;
148
149 /* now send a SMBtrans command with api RNetShareEnum */
150 p = param;
151 SSVAL(p,0,0); /* api number */
152 p += 2;
153 pstrcpy(p,"WrLeh");
154 p = skip_string(p,1);
155 pstrcpy(p,"B13BWz");
156 p = skip_string(p,1);
157 SSVAL(p,0,1);
158 /*
159 * Win2k needs a *smaller* buffer than 0xFFFF here -
160 * it returns "out of server memory" with 0xFFFF !!! JRA.
161 */
162 SSVAL(p,2,0xFFE0);
163 p += 4;
164
165 if (cli_api(cli,
166 param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
167 NULL, 0, 0xFFE0, /* data, length, maxlen - Win2k needs a small buffer here too ! */
168 &rparam, &rprcnt, /* return params, length */
169 &rdata, &rdrcnt)) /* return data, length */
170 {
171 int res = rparam? SVAL(rparam,0) : -1;
172
173 if (res == 0 || res == ERRmoredata) {
174 int converter=SVAL(rparam,2);
175 int i;
176
177 count=SVAL(rparam,4);
178 p = rdata;
179
180 for (i=0;i<count;i++,p+=20) {
181 char *sname = p;
182 int type = SVAL(p,14);
183 int comment_offset = IVAL(p,16) & 0xFFFF;
184 char *cmnt = comment_offset?(rdata+comment_offset-converter):"";
185 dos_to_unix(sname,True);
186 dos_to_unix(cmnt,True);
187 fn(sname, type, cmnt);
188 }
189 } else {
190 DEBUG(4,("NetShareEnum res=%d\n", res));
191 }
192 } else {
193 DEBUG(4,("NetShareEnum failed\n"));
194 }
195
196 if (rparam)
197 free(rparam);
198 if (rdata)
199 free(rdata);
200
201 return count;
202 }
203
204
205 /****************************************************************************
206 call a NetServerEnum for the specified workgroup and servertype mask.
207 This function then calls the specified callback function for each name returned.
208
209 The callback function takes 3 arguments: the machine name, the server type and
210 the comment.
211 ****************************************************************************/
212 BOOL cli_NetServerEnum(struct cli_state *cli, char *workgroup, uint32 stype,
213 void (*fn)(const char *, uint32, const char *))
214 {
215 char *rparam = NULL;
216 char *rdata = NULL;
217 int rdrcnt,rprcnt;
218 char *p;
219 pstring param;
220 int uLevel = 1;
221 int count = -1;
222
223 /* send a SMBtrans command with api NetServerEnum */
224 p = param;
225 SSVAL(p,0,0x68); /* api number */
226 p += 2;
227 pstrcpy(p,"WrLehDz");
228 p = skip_string(p,1);
229
230 pstrcpy(p,"B16BBDz");
231
232 p = skip_string(p,1);
233 SSVAL(p,0,uLevel);
234 SSVAL(p,2,CLI_BUFFER_SIZE);
235 p += 4;
236 SIVAL(p,0,stype);
237 p += 4;
238
239 pstrcpy(p, workgroup);
240 p = skip_string(p,1);
241
242 if (cli_api(cli,
243 param, PTR_DIFF(p,param), 8, /* params, length, max */
244 NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
245 &rparam, &rprcnt, /* return params, return size */
246 &rdata, &rdrcnt /* return data, return size */
247 )) {
248 int res = rparam? SVAL(rparam,0) : -1;
249
250 if (res == 0 || res == ERRmoredata) {
251 int i;
252 int converter=SVAL(rparam,2);
253
254 count=SVAL(rparam,4);
255 p = rdata;
256
257 for (i = 0;i < count;i++, p += 26) {
258 char *sname = p;
259 int comment_offset = (IVAL(p,22) & 0xFFFF)-converter;
260 char *cmnt = comment_offset?(rdata+comment_offset):"";
261 if (comment_offset < 0 || comment_offset > rdrcnt) continue;
262
263 stype = IVAL(p,18) & ~SV_TYPE_LOCAL_LIST_ONLY;
264
265 dos_to_unix(sname, True);
266 dos_to_unix(cmnt, True);
267 fn(sname, stype, cmnt);
268 }
269 }
270 }
271
272 if (rparam)
273 free(rparam);
274 if (rdata)
275 free(rdata);
276
277 return(count > 0);
278 }
279
280
281
282 /****************************************************************************
283 Send a SamOEMChangePassword command
284 ****************************************************************************/
285 BOOL cli_oem_change_password(struct cli_state *cli, const char *user, const char *new_password,
286 const char *old_password)
287 {
288 char param[16+sizeof(fstring)];
289 char data[532];
290 char *p = param;
291 fstring upper_case_old_pw;
292 fstring upper_case_new_pw;
293 unsigned char old_pw_hash[16];
294 unsigned char new_pw_hash[16];
295 int data_len;
296 int param_len = 0;
297 char *rparam = NULL;
298 char *rdata = NULL;
299 int rprcnt, rdrcnt;
300 pstring dos_new_password;
301
302 if (strlen(user) >= sizeof(fstring)-1) {
303 DEBUG(0,("cli_oem_change_password: user name %s is too long.\n", user));
304 return False;
305 }
306
307 SSVAL(p,0,214); /* SamOEMChangePassword command. */
308 p += 2;
309 pstrcpy(p, "zsT");
310 p = skip_string(p,1);
311 pstrcpy(p, "B516B16");
312 p = skip_string(p,1);
313 pstrcpy(p,user);
314 p = skip_string(p,1);
315 SSVAL(p,0,532);
316 p += 2;
317
318 param_len = PTR_DIFF(p,param);
319
320 /*
321 * Get the Lanman hash of the old password, we
322 * use this as the key to make_oem_passwd_hash().
323 */
324 memset(upper_case_old_pw, '\0', sizeof(upper_case_old_pw));
325 fstrcpy(upper_case_old_pw, old_password);
326 unix_to_dos(upper_case_old_pw,True);
327 strupper(upper_case_old_pw);
328 E_P16((uchar *)upper_case_old_pw, old_pw_hash);
329
330 pstrcpy(dos_new_password, new_password);
331 unix_to_dos(dos_new_password, True);
332
333 if (!make_oem_passwd_hash( data, dos_new_password, old_pw_hash, False))
334 return False;
335
336 /*
337 * Now place the old password hash in the data.
338 */
339 memset(upper_case_new_pw, '\0', sizeof(upper_case_new_pw));
340 fstrcpy(upper_case_new_pw, new_password);
341 unix_to_dos(upper_case_new_pw,True);
342 strupper(upper_case_new_pw);
343
344 E_P16((uchar *)upper_case_new_pw, new_pw_hash);
345
346 E_old_pw_hash( new_pw_hash, old_pw_hash, (uchar *)&data[516]);
347
348 data_len = 532;
349
350 if (cli_send_trans(cli,SMBtrans,
351 PIPE_LANMAN,strlen(PIPE_LANMAN), /* name, length */
352 0,0, /* fid, flags */
353 NULL,0,0, /* setup, length, max */
354 param,param_len,2, /* param, length, max */
355 data,data_len,0 /* data, length, max */
356 ) == False) {
357 DEBUG(0,("cli_oem_change_password: Failed to send password change for user %s\n",
358 user ));
359 return False;
360 }
361
362 if (cli_receive_trans(cli,SMBtrans,
363 &rparam, &rprcnt,
364 &rdata, &rdrcnt)) {
365 if (rparam)
366 cli->rap_error = SVAL(rparam,0);
367 }
368
369 if (rparam)
370 free(rparam);
371 if (rdata)
372 free(rdata);
373
374 return (cli->rap_error == 0);
375 }
376
377
378 /****************************************************************************
379 send a qpathinfo call
380 ****************************************************************************/
381 BOOL cli_qpathinfo(struct cli_state *cli, const char *fname,
382 time_t *c_time, time_t *a_time, time_t *m_time,
383 size_t *size, uint16 *mode)
384 {
385 int data_len = 0;
386 int param_len = 0;
387 uint16 setup = TRANSACT2_QPATHINFO;
388 pstring param;
389 char *rparam=NULL, *rdata=NULL;
390 int count=8;
391 BOOL ret;
392 time_t (*date_fn)(void *);
393
394 param_len = strlen(fname) + 7;
395
396 memset(param, 0, param_len);
397 SSVAL(param, 0, SMB_INFO_STANDARD);
398 pstrcpy(&param[6], fname);
399 unix_to_dos(&param[6],True);
400
401 do {
402 ret = (cli_send_trans(cli, SMBtrans2,
403 NULL, 0, /* Name, length */
404 -1, 0, /* fid, flags */
405 &setup, 1, 0, /* setup, length, max */
406 param, param_len, 10, /* param, length, max */
407 NULL, data_len, cli->max_xmit /* data, length, max */
408 ) &&
409 cli_receive_trans(cli, SMBtrans2,
410 &rparam, &param_len,
411 &rdata, &data_len));
412 if (!ret) {
413 /* we need to work around a Win95 bug - sometimes
414 it gives ERRSRV/ERRerror temprarily */
415 uint8 eclass;
416 uint32 ecode;
417 cli_error(cli, &eclass, &ecode, NULL);
418 if (eclass != ERRSRV || ecode != ERRerror) break;
419 msleep(100);
420 }
421 } while (count-- && ret==False);
422
423 if (!ret || !rdata || data_len < 22) {
424 return False;
425 }
426
427 if (cli->win95) {
428 date_fn = make_unix_date;
429 } else {
430 date_fn = make_unix_date2;
431 }
432
433 if (c_time) {
434 *c_time = date_fn(rdata+0);
435 }
436 if (a_time) {
437 *a_time = date_fn(rdata+4);
438 }
439 if (m_time) {
440 *m_time = date_fn(rdata+8);
441 }
442 if (size) {
443 *size = IVAL(rdata, 12);
444 }
445 if (mode) {
446 *mode = SVAL(rdata,l1_attrFile);
447 }
448
449 if (rdata) free(rdata);
450 if (rparam) free(rparam);
451 return True;
452 }
453
454 /****************************************************************************
455 send a qpathinfo call with the SMB_QUERY_FILE_ALL_INFO info level
456 ****************************************************************************/
457 BOOL cli_qpathinfo2(struct cli_state *cli, const char *fname,
458 time_t *c_time, time_t *a_time, time_t *m_time,
459 time_t *w_time, size_t *size, uint16 *mode,
460 SMB_INO_T *ino)
461 {
462 int data_len = 0;
463 int param_len = 0;
464 uint16 setup = TRANSACT2_QPATHINFO;
465 pstring param;
466 char *rparam=NULL, *rdata=NULL;
467
468 param_len = strlen(fname) + 7;
469
470 memset(param, 0, param_len);
471 SSVAL(param, 0, SMB_QUERY_FILE_ALL_INFO);
472 pstrcpy(&param[6], fname);
473 unix_to_dos(&param[6],True);
474
475 if (!cli_send_trans(cli, SMBtrans2,
476 NULL, 0, /* name, length */
477 -1, 0, /* fid, flags */
478 &setup, 1, 0, /* setup, length, max */
479 param, param_len, 10, /* param, length, max */
480 NULL, data_len, cli->max_xmit /* data, length, max */
481 )) {
482 return False;
483 }
484
485 if (!cli_receive_trans(cli, SMBtrans2,
486 &rparam, &param_len,
487 &rdata, &data_len)) {
488 return False;
489 }
490
491 if (!rdata || data_len < 22) {
492 return False;
493 }
494
495 if (c_time) {
496 *c_time = interpret_long_date(rdata+0) - cli->serverzone;
497 }
498 if (a_time) {
499 *a_time = interpret_long_date(rdata+8) - cli->serverzone;
500 }
501 if (m_time) {
502 *m_time = interpret_long_date(rdata+16) - cli->serverzone;
503 }
504 if (w_time) {
505 *w_time = interpret_long_date(rdata+24) - cli->serverzone;
506 }
507 if (mode) {
508 *mode = SVAL(rdata, 32);
509 }
510 if (size) {
511 *size = IVAL(rdata, 48);
512 }
513 if (ino) {
514 *ino = IVAL(rdata, 64);
515 }
516
517 if (rdata) free(rdata);
518 if (rparam) free(rparam);
519 return True;
520 }
521
522
523 /****************************************************************************
524 send a qfileinfo call
525 ****************************************************************************/
526 BOOL cli_qfileinfo(struct cli_state *cli, int fnum,
527 uint16 *mode, size_t *size,
528 time_t *c_time, time_t *a_time, time_t *m_time,
529 time_t *w_time, SMB_INO_T *ino)
530 {
531 int data_len = 0;
532 int param_len = 0;
533 uint16 setup = TRANSACT2_QFILEINFO;
534 pstring param;
535 char *rparam=NULL, *rdata=NULL;
536
537 /* if its a win95 server then fail this - win95 totally screws it
538 up */
539 if (cli->win95) return False;
540
541 param_len = 4;
542
543 memset(param, 0, param_len);
544 SSVAL(param, 0, fnum);
545 SSVAL(param, 2, SMB_QUERY_FILE_ALL_INFO);
546
547 if (!cli_send_trans(cli, SMBtrans2,
548 NULL, 0, /* name, length */
549 -1, 0, /* fid, flags */
550 &setup, 1, 0, /* setup, length, max */
551 param, param_len, 2, /* param, length, max */
552 NULL, data_len, cli->max_xmit /* data, length, max */
553 )) {
554 return False;
555 }
556
557 if (!cli_receive_trans(cli, SMBtrans2,
558 &rparam, &param_len,
559 &rdata, &data_len)) {
560 return False;
561 }
562
563 if (!rdata || data_len < 68) {
564 return False;
565 }
566
567 if (c_time) {
568 *c_time = interpret_long_date(rdata+0) - cli->serverzone;
569 }
570 if (a_time) {
571 *a_time = interpret_long_date(rdata+8) - cli->serverzone;
572 }
573 if (m_time) {
574 *m_time = interpret_long_date(rdata+16) - cli->serverzone;
575 }
576 if (w_time) {
577 *w_time = interpret_long_date(rdata+24) - cli->serverzone;
578 }
579 if (mode) {
580 *mode = SVAL(rdata, 32);
581 }
582 if (size) {
583 *size = IVAL(rdata, 48);
584 }
585 if (ino) {
586 *ino = IVAL(rdata, 64);
587 }
588
589 if (rdata) free(rdata);
590 if (rparam) free(rparam);
591 return True;
592 }
593
WIP