?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sync this function with 2.2 (single check for NULL parameter)
[Samba/gbeck.git] / source / rpc_client / cli_pipe.c
blobc3ebf288093e64fd24331e13a932f1afb049508e
1 /*
2 * Unix SMB/Netbios implementation.
3 * Version 1.9.
4 * RPC Pipe client / server routines
5 * Copyright (C) Andrew Tridgell 1992-1998,
6 * Copyright (C) Luke Kenneth Casson Leighton 1996-1998,
7 * Copyright (C) Paul Ashton 1998.
8 * Copyright (C) Jeremy Allison 1999.
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25 #include "includes.h"
26
27 extern int DEBUGLEVEL;
28 extern struct pipe_id_info pipe_names[];
29 extern fstring global_myworkgroup;
30 extern pstring global_myname;
31
32 /********************************************************************
33 Rpc pipe call id.
34 ********************************************************************/
35
36 static uint32 get_rpc_call_id(void)
37 {
38 static uint32 call_id = 0;
39 return ++call_id;
40 }
41
42 /*******************************************************************
43 Use SMBreadX to get rest of one fragment's worth of rpc data.
44 ********************************************************************/
45
46 static BOOL rpc_read(struct cli_state *cli, prs_struct *rdata, uint32 data_to_read, uint32 *rdata_offset)
47 {
48 size_t size = (size_t)cli->max_recv_frag;
49 int stream_offset = 0;
50 int num_read;
51 char *pdata;
52 int extra_data_size = ((int)*rdata_offset) + ((int)data_to_read) - (int)prs_data_size(rdata);
53
54 DEBUG(5,("rpc_read: data_to_read: %u rdata offset: %u extra_data_size: %d\n",
55 (int)data_to_read, (unsigned int)*rdata_offset, extra_data_size));
56
57 /*
58 * Grow the buffer if needed to accommodate the data to be read.
59 */
60
61 if (extra_data_size > 0) {
62 if(!prs_force_grow(rdata, (uint32)extra_data_size)) {
63 DEBUG(0,("rpc_read: Failed to grow parse struct by %d bytes.\n", extra_data_size ));
64 return False;
65 }
66 DEBUG(5,("rpc_read: grew buffer by %d bytes to %u\n", extra_data_size, prs_data_size(rdata) ));
67 }
68
69 pdata = prs_data_p(rdata) + *rdata_offset;
70
71 do /* read data using SMBreadX */
72 {
73 uint32 ecode;
74 uint8 eclass;
75
76 if (size > (size_t)data_to_read)
77 size = (size_t)data_to_read;
78
79 num_read = (int)cli_read_one(cli, cli->nt_pipe_fnum, pdata, (off_t)stream_offset, size);
80
81 DEBUG(5,("rpc_read: num_read = %d, read offset: %d, to read: %d\n",
82 num_read, stream_offset, data_to_read));
83
84 if (cli_error(cli, &eclass, &ecode, NULL) &&
85 (eclass != ERRDOS && ecode != ERRmoredata)) {
86 DEBUG(0,("rpc_read: Error %d/%u in cli_read\n",
87 eclass, (unsigned int)ecode));
88 return False;
89 }
90
91 data_to_read -= num_read;
92 stream_offset += num_read;
93 pdata += num_read;
94
95 } while (num_read > 0 && data_to_read > 0);
96 /* && err == (0x80000000 | STATUS_BUFFER_OVERFLOW)); */
97
98 /*
99 * Update the current offset into rdata by the amount read.
100 */
101 *rdata_offset += stream_offset;
102
103 return True;
104 }
105
106 /****************************************************************************
107 Checks the header. This will set the endian bit in the rdata prs_struct. JRA.
108 ****************************************************************************/
109
110 static BOOL rpc_check_hdr(prs_struct *rdata, RPC_HDR *rhdr,
111 BOOL *first, BOOL *last, uint32 *len)
112 {
113 DEBUG(5,("rpc_check_hdr: rdata->data_size = %u\n", (uint32)prs_data_size(rdata) ));
114
115 /* Next call sets endian bit. */
116
117 if(!smb_io_rpc_hdr("rpc_hdr ", rhdr, rdata, 0)) {
118 DEBUG(0,("rpc_check_hdr: Failed to unmarshall RPC_HDR.\n"));
119 return False;
120 }
121
122 if (prs_offset(rdata) != RPC_HEADER_LEN) {
123 DEBUG(0,("rpc_check_hdr: offset was %x, should be %x.\n", prs_offset(rdata), RPC_HEADER_LEN));
124 return False;
125 }
126
127 (*first) = ((rhdr->flags & RPC_FLG_FIRST) != 0);
128 (*last) = ((rhdr->flags & RPC_FLG_LAST ) != 0);
129 (*len) = (uint32)rhdr->frag_len - prs_data_size(rdata);
130
131 return (rhdr->pkt_type != RPC_FAULT);
132 }
133
134 static void NTLMSSPcalc_ap( struct cli_state *cli, unsigned char *data, uint32 len)
135 {
136 unsigned char *hash = cli->ntlmssp_hash;
137 unsigned char index_i = hash[256];
138 unsigned char index_j = hash[257];
139 int ind;
140
141 for( ind = 0; ind < len; ind++) {
142 unsigned char tc;
143 unsigned char t;
144
145 index_i++;
146 index_j += hash[index_i];
147
148 tc = hash[index_i];
149 hash[index_i] = hash[index_j];
150 hash[index_j] = tc;
151
152 t = hash[index_i] + hash[index_j];
153 data[ind] = data[ind] ^ hash[t];
154 }
155
156 hash[256] = index_i;
157 hash[257] = index_j;
158 }
159
160 /****************************************************************************
161 Verify data on an rpc pipe.
162 The VERIFY & SEAL code is only executed on packets that look like this :
163
164 Request/Response PDU's look like the following...
165
166 |<------------------PDU len----------------------------------------------->|
167 |<-HDR_LEN-->|<--REQ LEN------>|.............|<-AUTH_HDRLEN->|<-AUTH_LEN-->|
168
169 +------------+-----------------+-------------+---------------+-------------+
170 | RPC HEADER | REQ/RESP HEADER | DATA ...... | AUTH_HDR | AUTH DATA |
171 +------------+-----------------+-------------+---------------+-------------+
172
173 Never on bind requests/responses.
174 ****************************************************************************/
175
176 static BOOL rpc_auth_pipe(struct cli_state *cli, prs_struct *rdata, int len, int auth_len)
177 {
178 /*
179 * The following is that length of the data we must sign or seal.
180 * This doesn't include the RPC headers or the auth_len or the RPC_HDR_AUTH_LEN
181 * preceeding the auth_data.
182 */
183
184 int data_len = len - RPC_HEADER_LEN - RPC_HDR_RESP_LEN - RPC_HDR_AUTH_LEN - auth_len;
185
186 /*
187 * The start of the data to sign/seal is just after the RPC headers.
188 */
189 char *reply_data = prs_data_p(rdata) + RPC_HEADER_LEN + RPC_HDR_REQ_LEN;
190
191 BOOL auth_verify = ((cli->ntlmssp_srv_flgs & NTLMSSP_NEGOTIATE_SIGN) != 0);
192 BOOL auth_seal = ((cli->ntlmssp_srv_flgs & NTLMSSP_NEGOTIATE_SEAL) != 0);
193
194 DEBUG(5,("rpc_auth_pipe: len: %d auth_len: %d verify %s seal %s\n",
195 len, auth_len, BOOLSTR(auth_verify), BOOLSTR(auth_seal)));
196
197 /*
198 * Unseal any sealed data in the PDU, not including the
199 * 8 byte auth_header or the auth_data.
200 */
201
202 if (auth_seal) {
203 DEBUG(10,("rpc_auth_pipe: unseal\n"));
204 dump_data(100, reply_data, data_len);
205 NTLMSSPcalc_ap(cli, (uchar*)reply_data, data_len);
206 dump_data(100, reply_data, data_len);
207 }
208
209 if (auth_verify || auth_seal) {
210 RPC_HDR_AUTH rhdr_auth;
211 prs_struct auth_req;
212 char data[RPC_HDR_AUTH_LEN];
213 /*
214 * We set dp to be the end of the packet, minus the auth_len
215 * and the length of the header that preceeds the auth_data.
216 */
217 char *dp = prs_data_p(rdata) + len - auth_len - RPC_HDR_AUTH_LEN;
218
219 if(dp - prs_data_p(rdata) > prs_data_size(rdata)) {
220 DEBUG(0,("rpc_auth_pipe: auth data > data size !\n"));
221 return False;
222 }
223
224 memcpy(data, dp, sizeof(data));
225
226 prs_init(&auth_req , 0, cli->mem_ctx, UNMARSHALL);
227
228 /* The endianness must be preserved... JRA. */
229
230 prs_set_endian_data(&auth_req, rdata->bigendian_data);
231
232 prs_give_memory(&auth_req, data, RPC_HDR_AUTH_LEN, False);
233
234 /*
235 * Unmarshall the 8 byte auth_header that comes before the
236 * auth data.
237 */
238
239 if(!smb_io_rpc_hdr_auth("hdr_auth", &rhdr_auth, &auth_req, 0)) {
240 DEBUG(0,("rpc_auth_pipe: unmarshalling RPC_HDR_AUTH failed.\n"));
241 return False;
242 }
243
244 if (!rpc_hdr_auth_chk(&rhdr_auth)) {
245 DEBUG(0,("rpc_auth_pipe: rpc_hdr_auth_chk failed.\n"));
246 return False;
247 }
248 }
249
250 /*
251 * Now unseal and check the auth verifier in the auth_data at
252 * then end of the packet. The 4 bytes skipped in the unseal
253 * seem to be a buffer pointer preceeding the sealed data.
254 */
255
256 if (auth_verify) {
257 RPC_AUTH_NTLMSSP_CHK chk;
258 uint32 crc32;
259 prs_struct auth_verf;
260 char data[RPC_AUTH_NTLMSSP_CHK_LEN];
261 char *dp = prs_data_p(rdata) + len - auth_len;
262
263 if(dp - prs_data_p(rdata) > prs_data_size(rdata)) {
264 DEBUG(0,("rpc_auth_pipe: auth data > data size !\n"));
265 return False;
266 }
267
268 DEBUG(10,("rpc_auth_pipe: verify\n"));
269 dump_data(100, dp, auth_len);
270 NTLMSSPcalc_ap(cli, (uchar*)(dp+4), auth_len - 4);
271
272 memcpy(data, dp, RPC_AUTH_NTLMSSP_CHK_LEN);
273 dump_data(100, data, auth_len);
274
275 prs_init(&auth_verf, 0, cli->mem_ctx, UNMARSHALL);
276
277 /* The endinness must be preserved. JRA. */
278 prs_set_endian_data( &auth_verf, rdata->bigendian_data);
279
280 prs_give_memory(&auth_verf, data, RPC_AUTH_NTLMSSP_CHK_LEN, False);
281
282 if(!smb_io_rpc_auth_ntlmssp_chk("auth_sign", &chk, &auth_verf, 0)) {
283 DEBUG(0,("rpc_auth_pipe: unmarshalling RPC_AUTH_NTLMSSP_CHK failed.\n"));
284 return False;
285 }
286
287 crc32 = crc32_calc_buffer(reply_data, data_len);
288
289 if (!rpc_auth_ntlmssp_chk(&chk, crc32 , cli->ntlmssp_seq_num)) {
290 DEBUG(0,("rpc_auth_pipe: rpc_auth_ntlmssp_chk failed.\n"));
291 return False;
292 }
293 cli->ntlmssp_seq_num++;
294 }
295 return True;
296 }
297
298
299 /****************************************************************************
300 Send data on an rpc pipe, which *must* be in one fragment.
301 receive response data from an rpc pipe, which may be large...
302
303 Read the first fragment: unfortunately have to use SMBtrans for the first
304 bit, then SMBreadX for subsequent bits.
305
306 If first fragment received also wasn't the last fragment, continue
307 getting fragments until we _do_ receive the last fragment.
308
309 Request/Response PDU's look like the following...
310
311 |<------------------PDU len----------------------------------------------->|
312 |<-HDR_LEN-->|<--REQ LEN------>|.............|<-AUTH_HDRLEN->|<-AUTH_LEN-->|
313
314 +------------+-----------------+-------------+---------------+-------------+
315 | RPC HEADER | REQ/RESP HEADER | DATA ...... | AUTH_HDR | AUTH DATA |
316 +------------+-----------------+-------------+---------------+-------------+
317
318 Where the presence of the AUTH_HDR and AUTH are dependent on the
319 signing & sealing being neogitated.
320
321 ****************************************************************************/
322
323 static BOOL rpc_api_pipe(struct cli_state *cli, uint16 cmd, prs_struct *data, prs_struct *rdata)
324 {
325 uint32 len;
326 char *rparam = NULL;
327 uint32 rparam_len = 0;
328 uint16 setup[2];
329 BOOL first = True;
330 BOOL last = True;
331 RPC_HDR rhdr;
332 char *pdata = data ? prs_data_p(data) : NULL;
333 uint32 data_len = data ? prs_offset(data) : 0;
334 char *prdata = NULL;
335 uint32 rdata_len = 0;
336 uint32 current_offset = 0;
337
338 /* Create setup parameters - must be in native byte order. */
339
340 setup[0] = cmd;
341 setup[1] = cli->nt_pipe_fnum; /* Pipe file handle. */
342
343 DEBUG(5,("rpc_api_pipe: cmd:%x fnum:%x\n", (int)cmd,
344 (int)cli->nt_pipe_fnum));
345
346 /* Send the RPC request and receive a response. For short RPC
347 calls (about 1024 bytes or so) the RPC request and response
348 appears in a SMBtrans request and response. Larger RPC
349 responses are received further on. */
350
351 if (!cli_api_pipe(cli, "\\PIPE\\",
352 setup, 2, 0, /* Setup, length, max */
353 NULL, 0, 0, /* Params, length, max */
354 pdata, data_len, data_len, /* data, length, max */
355 &rparam, &rparam_len, /* return params, len */
356 &prdata, &rdata_len)) /* return data, len */
357 {
358 DEBUG(0, ("cli_pipe: return critical error. Error was %s\n", cli_errstr(cli)));
359 return False;
360 }
361
362 /* Throw away returned params - we know we won't use them. */
363
364 if(rparam) {
365 free(rparam);
366 rparam = NULL;
367 }
368
369 if (prdata == NULL) {
370 DEBUG(0,("rpc_api_pipe: cmd %x on pipe %x failed to return data.\n",
371 (int)cmd, (int)cli->nt_pipe_fnum));
372 return False;
373 }
374
375 /*
376 * Give this memory as dynamically allocated to the return parse
377 * struct.
378 */
379
380 prs_give_memory(rdata, prdata, rdata_len, True);
381 current_offset = rdata_len;
382
383 /* This next call sets the endian bit correctly in rdata. */
384
385 if (!rpc_check_hdr(rdata, &rhdr, &first, &last, &len)) {
386 prs_mem_free(rdata);
387 return False;
388 }
389
390 if (rhdr.pkt_type == RPC_BINDACK) {
391 if (!last && !first) {
392 DEBUG(5,("rpc_api_pipe: bug in server (AS/U?), setting fragment first/last ON.\n"));
393 first = True;
394 last = True;
395 }
396 }
397
398 if (rhdr.pkt_type == RPC_RESPONSE) {
399 RPC_HDR_RESP rhdr_resp;
400 if(!smb_io_rpc_hdr_resp("rpc_hdr_resp", &rhdr_resp, rdata, 0)) {
401 DEBUG(5,("rpc_api_pipe: failed to unmarshal RPC_HDR_RESP.\n"));
402 prs_mem_free(rdata);
403 return False;
404 }
405 }
406
407 DEBUG(5,("rpc_api_pipe: len left: %u smbtrans read: %u\n",
408 (unsigned int)len, (unsigned int)rdata_len ));
409
410 /* check if data to be sent back was too large for one SMBtrans */
411 /* err status is only informational: the _real_ check is on the
412 length */
413
414 if (len > 0) {
415 /* || err == (0x80000000 | STATUS_BUFFER_OVERFLOW)) */
416
417 /* Read the remaining part of the first response fragment */
418
419 if (!rpc_read(cli, rdata, len, &current_offset)) {
420 prs_mem_free(rdata);
421 return False;
422 }
423 }
424
425 /*
426 * Now we have a complete PDU, check the auth struct if any was sent.
427 */
428
429 if (rhdr.auth_len != 0) {
430 if(!rpc_auth_pipe(cli, rdata, rhdr.frag_len, rhdr.auth_len))
431 return False;
432 /*
433 * Drop the auth footers from the current offset.
434 * We need this if there are more fragments.
435 * The auth footers consist of the auth_data and the
436 * preceeding 8 byte auth_header.
437 */
438 current_offset -= (rhdr.auth_len + RPC_HDR_AUTH_LEN);
439 }
440
441 /*
442 * Only one rpc fragment, and it has been read.
443 */
444
445 if (first && last) {
446 DEBUG(6,("rpc_api_pipe: fragment first and last both set\n"));
447 return True;
448 }
449
450 /*
451 * Read more fragments using SMBreadX until we get one with the
452 * last bit set.
453 */
454
455 while (!last) {
456 RPC_HDR_RESP rhdr_resp;
457 int num_read;
458 char hdr_data[RPC_HEADER_LEN+RPC_HDR_RESP_LEN];
459 prs_struct hps;
460 uint8 eclass;
461 uint32 ecode;
462
463 /*
464 * First read the header of the next PDU.
465 */
466
467 prs_init(&hps, 0, cli->mem_ctx, UNMARSHALL);
468 prs_give_memory(&hps, hdr_data, sizeof(hdr_data), False);
469
470 num_read = cli_read_one(cli, cli->nt_pipe_fnum, hdr_data, 0, RPC_HEADER_LEN+RPC_HDR_RESP_LEN);
471 if (cli_error(cli, &eclass, &ecode, NULL) &&
472 (eclass != ERRDOS && ecode != ERRmoredata)) {
473 DEBUG(0,("rpc_api_pipe: cli_read error : %d/%d\n",
474 eclass, ecode));
475 return False;
476 }
477
478 DEBUG(5,("rpc_api_pipe: read header (size:%d)\n", num_read));
479
480 if (num_read != RPC_HEADER_LEN+RPC_HDR_RESP_LEN) {
481 DEBUG(0,("rpc_api_pipe: Error : requested %d bytes, got %d.\n",
482 RPC_HEADER_LEN+RPC_HDR_RESP_LEN, num_read ));
483 return False;
484 }
485
486 /* This call sets the endianness in hps. */
487
488 if (!rpc_check_hdr(&hps, &rhdr, &first, &last, &len))
489 return False;
490
491 /* Ensure the endianness in rdata is set correctly - must be same as hps. */
492
493 if (hps.bigendian_data != rdata->bigendian_data) {
494 DEBUG(0,("rpc_api_pipe: Error : Endianness changed from %s to %s\n",
495 rdata->bigendian_data ? "big" : "little",
496 hps.bigendian_data ? "big" : "little" ));
497 return False;
498 }
499
500 if(!smb_io_rpc_hdr_resp("rpc_hdr_resp", &rhdr_resp, &hps, 0)) {
501 DEBUG(0,("rpc_api_pipe: Error in unmarshalling RPC_HDR_RESP.\n"));
502 return False;
503 }
504
505 if (first) {
506 DEBUG(0,("rpc_api_pipe: secondary PDU rpc header has 'first' set !\n"));
507 return False;
508 }
509
510 /*
511 * Now read the rest of the PDU.
512 */
513
514 if (!rpc_read(cli, rdata, len, &current_offset))
515 return False;
516
517 /*
518 * Verify any authentication footer.
519 */
520
521 if (rhdr.auth_len != 0 ) {
522 if(!rpc_auth_pipe(cli, rdata, rhdr.frag_len, rhdr.auth_len))
523 return False;
524 /*
525 * Drop the auth footers from the current offset.
526 * The auth footers consist of the auth_data and the
527 * preceeding 8 byte auth_header.
528 * We need this if there are more fragments.
529 */
530 current_offset -= (rhdr.auth_len + RPC_HDR_AUTH_LEN);
531 }
532 }
533
534 return True;
535 }
536
537 /*******************************************************************
538 creates a DCE/RPC bind request
539
540 - initialises the parse structure.
541 - dynamically allocates the header data structure
542 - caller is expected to free the header data structure once used.
543
544 ********************************************************************/
545
546 static BOOL create_rpc_bind_req(prs_struct *rpc_out, BOOL do_auth, uint32 rpc_call_id,
547 RPC_IFACE *abstract, RPC_IFACE *transfer,
548 char *my_name, char *domain, uint32 neg_flags)
549 {
550 RPC_HDR hdr;
551 RPC_HDR_RB hdr_rb;
552 char buffer[4096];
553 prs_struct auth_info;
554 int auth_len = 0;
555
556 prs_init(&auth_info, 0, prs_get_mem_context(rpc_out), MARSHALL);
557
558 if (do_auth) {
559 RPC_HDR_AUTH hdr_auth;
560 RPC_AUTH_VERIFIER auth_verifier;
561 RPC_AUTH_NTLMSSP_NEG ntlmssp_neg;
562
563 /*
564 * Create the auth structs we will marshall.
565 */
566
567 init_rpc_hdr_auth(&hdr_auth, NTLMSSP_AUTH_TYPE, NTLMSSP_AUTH_LEVEL, 0x00, 1);
568 init_rpc_auth_verifier(&auth_verifier, "NTLMSSP", NTLMSSP_NEGOTIATE);
569 init_rpc_auth_ntlmssp_neg(&ntlmssp_neg, neg_flags, my_name, domain);
570
571 /*
572 * Use the 4k buffer to store the auth info.
573 */
574
575 prs_give_memory( &auth_info, buffer, sizeof(buffer), False);
576
577 /*
578 * Now marshall the data into the temporary parse_struct.
579 */
580
581 if(!smb_io_rpc_hdr_auth("hdr_auth", &hdr_auth, &auth_info, 0)) {
582 DEBUG(0,("create_rpc_bind_req: failed to marshall RPC_HDR_AUTH.\n"));
583 return False;
584 }
585
586 if(!smb_io_rpc_auth_verifier("auth_verifier", &auth_verifier, &auth_info, 0)) {
587 DEBUG(0,("create_rpc_bind_req: failed to marshall RPC_AUTH_VERIFIER.\n"));
588 return False;
589 }
590
591 if(!smb_io_rpc_auth_ntlmssp_neg("ntlmssp_neg", &ntlmssp_neg, &auth_info, 0)) {
592 DEBUG(0,("create_rpc_bind_req: failed to marshall RPC_AUTH_NTLMSSP_NEG.\n"));
593 return False;
594 }
595
596 /* Auth len in the rpc header doesn't include auth_header. */
597 auth_len = prs_offset(&auth_info) - RPC_HDR_AUTH_LEN;
598 }
599
600 /* create the request RPC_HDR */
601 init_rpc_hdr(&hdr, RPC_BIND, 0x0, rpc_call_id,
602 RPC_HEADER_LEN + RPC_HDR_RB_LEN + prs_offset(&auth_info),
603 auth_len);
604
605 if(!smb_io_rpc_hdr("hdr" , &hdr, rpc_out, 0)) {
606 DEBUG(0,("create_rpc_bind_req: failed to marshall RPC_HDR.\n"));
607 return False;
608 }
609
610 /* create the bind request RPC_HDR_RB */
611 init_rpc_hdr_rb(&hdr_rb, MAX_PDU_FRAG_LEN, MAX_PDU_FRAG_LEN, 0x0,
612 0x1, 0x0, 0x1, abstract, transfer);
613
614 /* Marshall the bind request data */
615 if(!smb_io_rpc_hdr_rb("", &hdr_rb, rpc_out, 0)) {
616 DEBUG(0,("create_rpc_bind_req: failed to marshall RPC_HDR_RB.\n"));
617 return False;
618 }
619
620 /*
621 * Grow the outgoing buffer to store any auth info.
622 */
623
624 if(hdr.auth_len != 0) {
625 if(!prs_append_prs_data( rpc_out, &auth_info)) {
626 DEBUG(0,("create_rpc_bind_req: failed to grow parse struct to add auth.\n"));
627 return False;
628 }
629 }
630
631 return True;
632 }
633
634 /*******************************************************************
635 Creates a DCE/RPC bind authentication response.
636 This is the packet that is sent back to the server once we
637 have received a BIND-ACK, to finish the third leg of
638 the authentication handshake.
639 ********************************************************************/
640
641 static BOOL create_rpc_bind_resp(struct pwd_info *pwd,
642 char *domain, char *user_name, char *my_name,
643 uint32 ntlmssp_cli_flgs,
644 uint32 rpc_call_id,
645 prs_struct *rpc_out)
646 {
647 unsigned char lm_owf[24];
648 unsigned char nt_owf[24];
649 RPC_HDR hdr;
650 RPC_HDR_AUTHA hdr_autha;
651 RPC_AUTH_VERIFIER auth_verifier;
652 RPC_AUTH_NTLMSSP_RESP ntlmssp_resp;
653 char buffer[4096];
654 prs_struct auth_info;
655
656 /*
657 * Marshall the variable length data into a temporary parse
658 * struct, pointing into a 4k local buffer.
659 */
660 prs_init(&auth_info, 0, prs_get_mem_context(rpc_out), MARSHALL);
661
662 /*
663 * Use the 4k buffer to store the auth info.
664 */
665
666 prs_give_memory( &auth_info, buffer, sizeof(buffer), False);
667
668 /*
669 * Create the variable length auth_data.
670 */
671
672 init_rpc_auth_verifier(&auth_verifier, "NTLMSSP", NTLMSSP_AUTH);
673
674 pwd_get_lm_nt_owf(pwd, lm_owf, nt_owf);
675
676 init_rpc_auth_ntlmssp_resp(&ntlmssp_resp,
677 lm_owf, nt_owf,
678 domain, user_name, my_name,
679 ntlmssp_cli_flgs);
680
681 /*
682 * Marshall the variable length auth_data into a temp parse_struct.
683 */
684
685 if(!smb_io_rpc_auth_verifier("auth_verifier", &auth_verifier, &auth_info, 0)) {
686 DEBUG(0,("create_rpc_bind_resp: failed to marshall RPC_AUTH_VERIFIER.\n"));
687 return False;
688 }
689
690 if(!smb_io_rpc_auth_ntlmssp_resp("ntlmssp_resp", &ntlmssp_resp, &auth_info, 0)) {
691 DEBUG(0,("create_rpc_bind_resp: failed to marshall RPC_AUTH_NTLMSSP_RESP.\n"));
692 return False;
693 }
694
695 /* Create the request RPC_HDR */
696 init_rpc_hdr(&hdr, RPC_BINDRESP, 0x0, rpc_call_id,
697 RPC_HEADER_LEN + RPC_HDR_AUTHA_LEN + prs_offset(&auth_info),
698 prs_offset(&auth_info) );
699
700 /* Marshall it. */
701 if(!smb_io_rpc_hdr("hdr", &hdr, rpc_out, 0)) {
702 DEBUG(0,("create_rpc_bind_resp: failed to marshall RPC_HDR.\n"));
703 return False;
704 }
705
706 /* Create the request RPC_HDR_AUTHA */
707 init_rpc_hdr_autha(&hdr_autha, MAX_PDU_FRAG_LEN, MAX_PDU_FRAG_LEN,
708 NTLMSSP_AUTH_TYPE, NTLMSSP_AUTH_LEVEL, 0x00);
709
710 if(!smb_io_rpc_hdr_autha("hdr_autha", &hdr_autha, rpc_out, 0)) {
711 DEBUG(0,("create_rpc_bind_resp: failed to marshall RPC_HDR_AUTHA.\n"));
712 return False;
713 }
714
715 /*
716 * Append the auth data to the outgoing buffer.
717 */
718
719 if(!prs_append_prs_data(rpc_out, &auth_info)) {
720 DEBUG(0,("create_rpc_bind_req: failed to grow parse struct to add auth.\n"));
721 return False;
722 }
723
724 return True;
725 }
726
727
728 /*******************************************************************
729 Creates a DCE/RPC request.
730 ********************************************************************/
731
732 static BOOL create_rpc_request(prs_struct *rpc_out, uint8 op_num, int data_len, int auth_len)
733 {
734 uint32 alloc_hint;
735 RPC_HDR hdr;
736 RPC_HDR_REQ hdr_req;
737
738 DEBUG(5,("create_rpc_request: opnum: 0x%x data_len: 0x%x\n", op_num, data_len));
739
740 /* create the rpc header RPC_HDR */
741 init_rpc_hdr(&hdr, RPC_REQUEST, RPC_FLG_FIRST | RPC_FLG_LAST,
742 get_rpc_call_id(), data_len, auth_len);
743
744 /*
745 * The alloc hint should be the amount of data, not including
746 * RPC headers & footers.
747 */
748
749 if (auth_len != 0)
750 alloc_hint = data_len - RPC_HEADER_LEN - RPC_HDR_AUTH_LEN - auth_len;
751 else
752 alloc_hint = data_len - RPC_HEADER_LEN;
753
754 DEBUG(10,("create_rpc_request: data_len: %x auth_len: %x alloc_hint: %x\n",
755 data_len, auth_len, alloc_hint));
756
757 /* Create the rpc request RPC_HDR_REQ */
758 init_rpc_hdr_req(&hdr_req, alloc_hint, op_num);
759
760 /* stream-time... */
761 if(!smb_io_rpc_hdr("hdr ", &hdr, rpc_out, 0))
762 return False;
763
764 if(!smb_io_rpc_hdr_req("hdr_req", &hdr_req, rpc_out, 0))
765 return False;
766
767 if (prs_offset(rpc_out) != RPC_HEADER_LEN + RPC_HDR_REQ_LEN)
768 return False;
769
770 return True;
771 }
772
773
774 /****************************************************************************
775 Send a request on an rpc pipe.
776 ****************************************************************************/
777
778 BOOL rpc_api_pipe_req(struct cli_state *cli, uint8 op_num,
779 prs_struct *data, prs_struct *rdata)
780 {
781 prs_struct outgoing_packet;
782 uint32 data_len;
783 uint32 auth_len;
784 BOOL ret;
785 BOOL auth_verify;
786 BOOL auth_seal;
787 uint32 crc32 = 0;
788 char *pdata_out = NULL;
789
790 auth_verify = ((cli->ntlmssp_srv_flgs & NTLMSSP_NEGOTIATE_SIGN) != 0);
791 auth_seal = ((cli->ntlmssp_srv_flgs & NTLMSSP_NEGOTIATE_SEAL) != 0);
792
793 /*
794 * The auth_len doesn't include the RPC_HDR_AUTH_LEN.
795 */
796
797 auth_len = (auth_verify ? RPC_AUTH_NTLMSSP_CHK_LEN : 0);
798
799 /*
800 * PDU len is header, plus request header, plus data, plus
801 * auth_header_len (if present), plus auth_len (if present).
802 * NB. The auth stuff should be aligned on an 8 byte boundary
803 * to be totally DCE/RPC spec complient. For now we cheat and
804 * hope that the data structs defined are a multiple of 8 bytes.
805 */
806
807 if((prs_offset(data) % 8) != 0) {
808 DEBUG(5,("rpc_api_pipe_req: Outgoing data not a multiple of 8 bytes....\n"));
809 }
810
811 data_len = RPC_HEADER_LEN + RPC_HDR_REQ_LEN + prs_offset(data) +
812 (auth_verify ? RPC_HDR_AUTH_LEN : 0) + auth_len;
813
814 /*
815 * Malloc a parse struct to hold it (and enough for alignments).
816 */
817
818 if(!prs_init(&outgoing_packet, data_len + 8, cli->mem_ctx, MARSHALL)) {
819 DEBUG(0,("rpc_api_pipe_req: Failed to malloc %u bytes.\n", (unsigned int)data_len ));
820 return False;
821 }
822
823 pdata_out = prs_data_p(&outgoing_packet);
824
825 /*
826 * Write out the RPC header and the request header.
827 */
828
829 if(!create_rpc_request(&outgoing_packet, op_num, data_len, auth_len)) {
830 DEBUG(0,("rpc_api_pipe_req: Failed to create RPC request.\n"));
831 prs_mem_free(&outgoing_packet);
832 return False;
833 }
834
835 /*
836 * Seal the outgoing data if requested.
837 */
838
839 if (auth_seal) {
840 crc32 = crc32_calc_buffer(prs_data_p(data), prs_offset(data));
841 NTLMSSPcalc_ap(cli, (unsigned char*)prs_data_p(data), prs_offset(data));
842 }
843
844 /*
845 * Now copy the data into the outgoing packet.
846 */
847
848 if(!prs_append_prs_data( &outgoing_packet, data)) {
849 DEBUG(0,("rpc_api_pipe_req: Failed to append data to outgoing packet.\n"));
850 prs_mem_free(&outgoing_packet);
851 return False;
852 }
853
854 /*
855 * Add a trailing auth_verifier if needed.
856 */
857
858 if (auth_seal || auth_verify) {
859 RPC_HDR_AUTH hdr_auth;
860
861 init_rpc_hdr_auth(&hdr_auth, NTLMSSP_AUTH_TYPE,
862 NTLMSSP_AUTH_LEVEL, 0x08, (auth_verify ? 1 : 0));
863 if(!smb_io_rpc_hdr_auth("hdr_auth", &hdr_auth, &outgoing_packet, 0)) {
864 DEBUG(0,("rpc_api_pipe_req: Failed to marshal RPC_HDR_AUTH.\n"));
865 prs_mem_free(&outgoing_packet);
866 return False;
867 }
868 }
869
870 /*
871 * Finally the auth data itself.
872 */
873
874 if (auth_verify) {
875 RPC_AUTH_NTLMSSP_CHK chk;
876 uint32 current_offset = prs_offset(&outgoing_packet);
877
878 init_rpc_auth_ntlmssp_chk(&chk, NTLMSSP_SIGN_VERSION, crc32, cli->ntlmssp_seq_num++);
879 if(!smb_io_rpc_auth_ntlmssp_chk("auth_sign", &chk, &outgoing_packet, 0)) {
880 DEBUG(0,("rpc_api_pipe_req: Failed to marshal RPC_AUTH_NTLMSSP_CHK.\n"));
881 prs_mem_free(&outgoing_packet);
882 return False;
883 }
884 NTLMSSPcalc_ap(cli, (unsigned char*)&pdata_out[current_offset+4], RPC_AUTH_NTLMSSP_CHK_LEN - 4);
885 }
886
887 DEBUG(100,("data_len: %x data_calc_len: %x\n", data_len, prs_offset(&outgoing_packet)));
888
889 ret = rpc_api_pipe(cli, 0x0026, &outgoing_packet, rdata);
890
891 prs_mem_free(&outgoing_packet);
892
893 return ret;
894 }
895
896 /****************************************************************************
897 Set the handle state.
898 ****************************************************************************/
899
900 static BOOL rpc_pipe_set_hnd_state(struct cli_state *cli, char *pipe_name, uint16 device_state)
901 {
902 BOOL state_set = False;
903 char param[2];
904 uint16 setup[2]; /* only need 2 uint16 setup parameters */
905 char *rparam = NULL;
906 char *rdata = NULL;
907 uint32 rparam_len, rdata_len;
908
909 if (pipe_name == NULL)
910 return False;
911
912 DEBUG(5,("Set Handle state Pipe[%x]: %s - device state:%x\n",
913 cli->nt_pipe_fnum, pipe_name, device_state));
914
915 /* create parameters: device state */
916 SSVAL(param, 0, device_state);
917
918 /* create setup parameters. */
919 setup[0] = 0x0001;
920 setup[1] = cli->nt_pipe_fnum; /* pipe file handle. got this from an SMBOpenX. */
921
922 /* send the data on \PIPE\ */
923 if (cli_api_pipe(cli, "\\PIPE\\",
924 setup, 2, 0, /* setup, length, max */
925 param, 2, 0, /* param, length, max */
926 NULL, 0, 1024, /* data, length, max */
927 &rparam, &rparam_len, /* return param, length */
928 &rdata, &rdata_len)) /* return data, length */
929 {
930 DEBUG(5, ("Set Handle state: return OK\n"));
931 state_set = True;
932 }
933
934 if (rparam)
935 free(rparam);
936 if (rdata)
937 free(rdata );
938
939 return state_set;
940 }
941
942 /****************************************************************************
943 check the rpc bind acknowledge response
944 ****************************************************************************/
945
946 static BOOL valid_pipe_name(char *pipe_name, RPC_IFACE *abstract, RPC_IFACE *transfer)
947 {
948 int pipe_idx = 0;
949
950 while (pipe_names[pipe_idx].client_pipe != NULL) {
951 if (strequal(pipe_name, pipe_names[pipe_idx].client_pipe )) {
952 DEBUG(5,("Bind Abstract Syntax: "));
953 dump_data(5, (char*)&(pipe_names[pipe_idx].abstr_syntax),
954 sizeof(pipe_names[pipe_idx].abstr_syntax));
955 DEBUG(5,("Bind Transfer Syntax: "));
956 dump_data(5, (char*)&(pipe_names[pipe_idx].trans_syntax),
957 sizeof(pipe_names[pipe_idx].trans_syntax));
958
959 /* copy the required syntaxes out so we can do the right bind */
960 *transfer = pipe_names[pipe_idx].trans_syntax;
961 *abstract = pipe_names[pipe_idx].abstr_syntax;
962
963 return True;
964 }
965 pipe_idx++;
966 };
967
968 DEBUG(5,("Bind RPC Pipe[%s] unsupported\n", pipe_name));
969 return False;
970 }
971
972 /****************************************************************************
973 check the rpc bind acknowledge response
974 ****************************************************************************/
975
976 static BOOL check_bind_response(RPC_HDR_BA *hdr_ba, char *pipe_name, RPC_IFACE *transfer)
977 {
978 int i = 0;
979
980 while ((pipe_names[i].client_pipe != NULL) && hdr_ba->addr.len > 0) {
981 if ((strequal(pipe_name, pipe_names[i].client_pipe ))) {
982 if (strequal(hdr_ba->addr.str, pipe_names[i].server_pipe )) {
983 DEBUG(5,("bind_rpc_pipe: server pipe_name found: %s\n",
984 pipe_names[i].server_pipe ));
985 break;
986 } else {
987 DEBUG(4,("bind_rpc_pipe: pipe_name %s != expected pipe %s. oh well!\n",
988 pipe_names[i].server_pipe ,
989 hdr_ba->addr.str));
990 break;
991 }
992 } else {
993 i++;
994 }
995 }
996
997 if (pipe_names[i].server_pipe == NULL) {
998 DEBUG(2,("bind_rpc_pipe: pipe name %s unsupported\n", hdr_ba->addr.str));
999 return False;
1000 }
1001
1002 /* check the transfer syntax */
1003 if ((hdr_ba->transfer.version != transfer->version) ||
1004 (memcmp(&hdr_ba->transfer.uuid, &transfer->uuid, sizeof(transfer->uuid)) !=0)) {
1005 DEBUG(0,("bind_rpc_pipe: transfer syntax differs\n"));
1006 return False;
1007 }
1008
1009 /* lkclXXXX only accept one result: check the result(s) */
1010 if (hdr_ba->res.num_results != 0x1 || hdr_ba->res.result != 0) {
1011 DEBUG(2,("bind_rpc_pipe: bind denied results: %d reason: %x\n",
1012 hdr_ba->res.num_results, hdr_ba->res.reason));
1013 }
1014
1015 DEBUG(5,("bind_rpc_pipe: accepted!\n"));
1016 return True;
1017 }
1018
1019 /****************************************************************************
1020 Create and send the third packet in an RPC auth.
1021 ****************************************************************************/
1022
1023 static BOOL rpc_send_auth_reply(struct cli_state *cli, prs_struct *rdata, uint32 rpc_call_id)
1024 {
1025 RPC_HDR_AUTH rhdr_auth;
1026 RPC_AUTH_VERIFIER rhdr_verf;
1027 RPC_AUTH_NTLMSSP_CHAL rhdr_chal;
1028 char buffer[MAX_PDU_FRAG_LEN];
1029 prs_struct rpc_out;
1030 ssize_t ret;
1031
1032 unsigned char p24[24];
1033 unsigned char lm_owf[24];
1034 unsigned char lm_hash[16];
1035
1036 if(!smb_io_rpc_hdr_auth("", &rhdr_auth, rdata, 0)) {
1037 DEBUG(0,("rpc_send_auth_reply: Failed to unmarshall RPC_HDR_AUTH.\n"));
1038 return False;
1039 }
1040 if(!smb_io_rpc_auth_verifier("", &rhdr_verf, rdata, 0)) {
1041 DEBUG(0,("rpc_send_auth_reply: Failed to unmarshall RPC_AUTH_VERIFIER.\n"));
1042 return False;
1043 }
1044 if(!smb_io_rpc_auth_ntlmssp_chal("", &rhdr_chal, rdata, 0)) {
1045 DEBUG(0,("rpc_send_auth_reply: Failed to unmarshall RPC_AUTH_NTLMSSP_CHAL.\n"));
1046 return False;
1047 }
1048
1049 cli->ntlmssp_cli_flgs = rhdr_chal.neg_flags;
1050
1051 pwd_make_lm_nt_owf(&cli->pwd, rhdr_chal.challenge);
1052
1053 prs_init(&rpc_out, 0, cli->mem_ctx, MARSHALL);
1054
1055 prs_give_memory( &rpc_out, buffer, sizeof(buffer), False);
1056
1057 create_rpc_bind_resp(&cli->pwd, cli->domain,
1058 cli->user_name, global_myname,
1059 cli->ntlmssp_cli_flgs, rpc_call_id,
1060 &rpc_out);
1061
1062 pwd_get_lm_nt_owf(&cli->pwd, lm_owf, NULL);
1063 pwd_get_lm_nt_16(&cli->pwd, lm_hash, NULL);
1064
1065 NTLMSSPOWFencrypt(lm_hash, lm_owf, p24);
1066
1067 {
1068 unsigned char j = 0;
1069 int ind;
1070 unsigned char k2[8];
1071
1072 memcpy(k2, p24, 5);
1073 k2[5] = 0xe5;
1074 k2[6] = 0x38;
1075 k2[7] = 0xb0;
1076
1077 for (ind = 0; ind < 256; ind++)
1078 cli->ntlmssp_hash[ind] = (unsigned char)ind;
1079
1080 for( ind = 0; ind < 256; ind++) {
1081 unsigned char tc;
1082
1083 j += (cli->ntlmssp_hash[ind] + k2[ind%8]);
1084
1085 tc = cli->ntlmssp_hash[ind];
1086 cli->ntlmssp_hash[ind] = cli->ntlmssp_hash[j];
1087 cli->ntlmssp_hash[j] = tc;
1088 }
1089
1090 cli->ntlmssp_hash[256] = 0;
1091 cli->ntlmssp_hash[257] = 0;
1092 }
1093
1094 memset((char *)lm_hash, '\0', sizeof(lm_hash));
1095
1096 if ((ret = cli_write(cli, cli->nt_pipe_fnum, 0x8, prs_data_p(&rpc_out),
1097 0, (size_t)prs_offset(&rpc_out))) != (ssize_t)prs_offset(&rpc_out)) {
1098 DEBUG(0,("rpc_send_auth_reply: cli_write failed. Return was %d\n", (int)ret));
1099 return False;
1100 }
1101
1102 cli->ntlmssp_srv_flgs = rhdr_chal.neg_flags;
1103 return True;
1104 }
1105
1106 /****************************************************************************
1107 Do an rpc bind.
1108 ****************************************************************************/
1109
1110 BOOL rpc_pipe_bind(struct cli_state *cli, char *pipe_name, char *my_name)
1111 {
1112 RPC_IFACE abstract;
1113 RPC_IFACE transfer;
1114 prs_struct rpc_out;
1115 prs_struct rdata;
1116 BOOL do_auth = (cli->ntlmssp_cli_flgs != 0);
1117 uint32 rpc_call_id;
1118 char buffer[MAX_PDU_FRAG_LEN];
1119
1120 DEBUG(5,("Bind RPC Pipe[%x]: %s\n", cli->nt_pipe_fnum, pipe_name));
1121
1122 if (!valid_pipe_name(pipe_name, &abstract, &transfer))
1123 return False;
1124
1125 prs_init(&rpc_out, 0, cli->mem_ctx, MARSHALL);
1126
1127 /*
1128 * Use the MAX_PDU_FRAG_LEN buffer to store the bind request.
1129 */
1130
1131 prs_give_memory( &rpc_out, buffer, sizeof(buffer), False);
1132
1133 rpc_call_id = get_rpc_call_id();
1134
1135 /* Marshall the outgoing data. */
1136 create_rpc_bind_req(&rpc_out, do_auth, rpc_call_id,
1137 &abstract, &transfer,
1138 global_myname, cli->domain, cli->ntlmssp_cli_flgs);
1139
1140 /* Initialize the incoming data struct. */
1141 prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
1142
1143 /* send data on \PIPE\. receive a response */
1144 if (rpc_api_pipe(cli, 0x0026, &rpc_out, &rdata)) {
1145 RPC_HDR_BA hdr_ba;
1146
1147 DEBUG(5, ("rpc_pipe_bind: rpc_api_pipe returned OK.\n"));
1148
1149 if(!smb_io_rpc_hdr_ba("", &hdr_ba, &rdata, 0)) {
1150 DEBUG(0,("rpc_pipe_bind: Failed to unmarshall RPC_HDR_BA.\n"));
1151 prs_mem_free(&rdata);
1152 return False;
1153 }
1154
1155 if(!check_bind_response(&hdr_ba, pipe_name, &transfer)) {
1156 DEBUG(0,("rpc_pipe_bind: check_bind_response failed.\n"));
1157 prs_mem_free(&rdata);
1158 return False;
1159 }
1160
1161 cli->max_xmit_frag = hdr_ba.bba.max_tsize;
1162 cli->max_recv_frag = hdr_ba.bba.max_rsize;
1163
1164 /*
1165 * If we're doing NTLMSSP auth we need to send a reply to
1166 * the bind-ack to complete the 3-way challenge response
1167 * handshake.
1168 */
1169
1170 if (do_auth && !rpc_send_auth_reply(cli, &rdata, rpc_call_id)) {
1171 DEBUG(0,("rpc_pipe_bind: rpc_send_auth_reply failed.\n"));
1172 prs_mem_free(&rdata);
1173 return False;
1174 }
1175 }
1176
1177 prs_mem_free(&rdata);
1178 return True;
1179 }
1180
1181 /****************************************************************************
1182 Set ntlmssp negotiation flags.
1183 ****************************************************************************/
1184
1185 void cli_nt_set_ntlmssp_flgs(struct cli_state *cli, uint32 ntlmssp_flgs)
1186 {
1187 cli->ntlmssp_cli_flgs = ntlmssp_flgs;
1188 }
1189
1190
1191 /****************************************************************************
1192 Open a session.
1193 ****************************************************************************/
1194
1195 BOOL cli_nt_session_open(struct cli_state *cli, char *pipe_name)
1196 {
1197 int fnum;
1198
1199 SMB_ASSERT(cli->nt_pipe_fnum == 0);
1200
1201 if (cli->capabilities & CAP_NT_SMBS) {
1202 if ((fnum = cli_nt_create(cli, &(pipe_name[5]), DESIRED_ACCESS_PIPE)) == -1) {
1203 DEBUG(0,("cli_nt_session_open: cli_nt_create failed on pipe %s to machine %s. Error was %s\n",
1204 &(pipe_name[5]), cli->desthost, cli_errstr(cli)));
1205 return False;
1206 }
1207
1208 cli->nt_pipe_fnum = (uint16)fnum;
1209 } else {
1210 if ((fnum = cli_open(cli, pipe_name, O_CREAT|O_RDWR, DENY_NONE)) == -1) {
1211 DEBUG(0,("cli_nt_session_open: cli_open failed on pipe %s to machine %s. Error was %s\n",
1212 pipe_name, cli->desthost, cli_errstr(cli)));
1213 return False;
1214 }
1215
1216 cli->nt_pipe_fnum = (uint16)fnum;
1217
1218 /**************** Set Named Pipe State ***************/
1219 if (!rpc_pipe_set_hnd_state(cli, pipe_name, 0x4300)) {
1220 DEBUG(0,("cli_nt_session_open: pipe hnd state failed. Error was %s\n",
1221 cli_errstr(cli)));
1222 cli_close(cli, cli->nt_pipe_fnum);
1223 return False;
1224 }
1225 }
1226
1227 /******************* bind request on pipe *****************/
1228
1229 if (!rpc_pipe_bind(cli, pipe_name, global_myname)) {
1230 DEBUG(0,("cli_nt_session_open: rpc bind failed. Error was %s\n",
1231 cli_errstr(cli)));
1232 cli_close(cli, cli->nt_pipe_fnum);
1233 return False;
1234 }
1235
1236 /*
1237 * Setup the remote server name prefixed by \ and the machine account name.
1238 */
1239
1240 fstrcpy(cli->srv_name_slash, "\\\\");
1241 fstrcat(cli->srv_name_slash, cli->desthost);
1242 strupper(cli->srv_name_slash);
1243
1244 fstrcpy(cli->clnt_name_slash, "\\\\");
1245 fstrcat(cli->clnt_name_slash, global_myname);
1246 strupper(cli->clnt_name_slash);
1247
1248 fstrcpy(cli->mach_acct, global_myname);
1249 fstrcat(cli->mach_acct, "$");
1250 strupper(cli->mach_acct);
1251
1252 return True;
1253 }
1254
1255 /****************************************************************************
1256 close the session
1257 ****************************************************************************/
1258
1259 void cli_nt_session_close(struct cli_state *cli)
1260 {
1261 cli_close(cli, cli->nt_pipe_fnum);
1262 cli->nt_pipe_fnum = 0;
1263 }
WIP