1 /*
2 * Copyright (c) 2004 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_LICENSE_HEADER_START@
5 *
6 * "Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7 * Reserved. This file contains Original Code and/or Modifications of
8 * Original Code as defined in and that are subject to the Apple Public
9 * Source License Version 1.0 (the 'License'). You may not use this file
10 * except in compliance with the License. Please obtain a copy of the
11 * License at http://www.apple.com/publicsource and read it before using
12 * this file.
13 *
14 * The Original Code and all software distributed under the License are
15 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19 * License for the specific language governing rights and limitations
20 * under the License."
21 *
22 * @APPLE_LICENSE_HEADER_END@
23 */
24
25 /* BEGIN CSTYLED */
26 /*
27 * @(#)ui.c *
28 * (c) 2004 Apple Computer, Inc. All Rights Reserved
29 *
30 *
31 * netshareenum.c -- Routines for getting a list of share information
32 * from a server.
33 *
34 * MODIFICATION HISTORY:
35 * 27-Nov-2004 Guy Harris New today
36 */
37 /* END CSTYLED */
38
39 /*
40 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
41 */
42
43 #include <stdlib.h>
44 #include <string.h>
45 #include <stdio.h>
46 #include <errno.h>
47
48 #include <netsmb/mchain.h>
49 #include <netsmb/smb.h>
50 #include <netsmb/smb_lib.h>
51 #include <netsmb/smb_rap.h>
52 #include <netsmb/smb_netshareenum.h>
53 #include <smb/charsets.h>
54
55 #if 0 /* XXX see below */
56 #include <dce/exc_handling.h>
57 #include <rpc/attrb.h>
58 #include "srvsvc.h"
59 #endif
60
61 /*
62 * Don't want RPC client-side code in here.
63 * It's good code; just doesn't belong here.
64 *
65 * The API provided by this library should be
66 * just files and pipes (and not much more).
67 * It MAY be useful to provide some of the
68 * RAP (remote API) functions functions like
69 * rap_netshareenum below...
70 *
71 * XXX: Not sure this file belongs here at all.
72 * smb_rap.h looks like a reasonable API
73 * for this library to export.
74 */
75 #if 0 /* XXX */
76
77 static int
78 rpc_netshareenum(struct smb_ctx *ctx, int *entriesp, int *totalp,
79 struct share_info **entries_listp)
80 {
81 char ctx_string[2+16+1]; /* enough for 64-bit pointer, in hex */
82 unsigned_char_p_t binding;
83 unsigned32 binding_status;
84 rpc_binding_handle_t binding_h;
85 int error, i, entries;
86 char *addrstr, *srvnamestr;
87 unsigned short *usrvnamestr;
88 unsigned32 level;
89 SHARE_ENUM_STRUCT share_info;
90 SHARE_INFO_1_CONTAINER share_info_1_container;
91 SHARE_INFO_1 *shares, *share;
92 unsigned32 total_entries;
93 unsigned32 status, free_status;
94 struct share_info *entry_list, *elp;
95 static EXCEPTION rpc_x_connect_rejected;
96 static int exceptions_initialized;
97
98 sprintf(ctx_string, "%p", ctx);
99 rpc_string_binding_compose(NULL, "ncacn_np", ctx_string,
100 "srvsvc", NULL, &binding, &binding_status);
101 if (binding_status != rpc_s_ok) {
102 smb_error(dgettext(TEXT_DOMAIN,
103 "rpc_string_binding_compose failed with %d"),
104 0, binding_status);
105 return (EINVAL);
106 }
107 rpc_binding_from_string_binding(binding, &binding_h, &status);
108 rpc_string_free(&binding, (unsigned32 *)&free_status);
109 if (binding_status != rpc_s_ok) {
110 smb_error(dgettext(TEXT_DOMAIN,
111 "rpc_binding_from_string_binding failed with %d"), 0,
112 binding_status);
113 return (EINVAL);
114 }
115 level = 1;
116 share_info.share_union.level = 1;
117 share_info.share_union.tagged_union.share1 = &share_info_1_container;
118 share_info_1_container.share_count = 0;
119 share_info_1_container.shares = NULL;
120 /*
121 * Convert the server IP address to a string, and send that as
122 * the "server name" - that's what Windows appears to do, and
123 * that avoids problems with NetBIOS names containing
124 * non-ASCII characters.
125 */
126 addrstr = inet_ntoa(ctx->ct_srvinaddr.sin_addr);
127 srvnamestr = malloc(strlen(addrstr) + 3);
128 if (srvnamestr == NULL) {
129 status = errno;
130 smb_error(dgettext(TEXT_DOMAIN,
131 "can't allocate string for server address"), status);
132 rpc_binding_free(&binding_h, &free_status);
133 return (status);
134 }
135 strcpy(srvnamestr, "\\\\");
136 strcat(srvnamestr, addrstr);
137 usrvnamestr = convert_utf8_to_leunicode(srvnamestr);
138 if (usrvnamestr == NULL) {
139 smb_error(dgettext(TEXT_DOMAIN,
140 "can't convert string for server address to Unicode"), 0);
141 rpc_binding_free(&binding_h, &free_status);
142 free(srvnamestr);
143 return (EINVAL);
144 }
145 if (!exceptions_initialized) {
146 EXCEPTION_INIT(rpc_x_connect_rejected);
147 exc_set_status(&rpc_x_connect_rejected, rpc_s_connect_rejected);
148 exceptions_initialized = 1;
149 }
150 /* printf("Calling NetrShareEnum.."); XXX */
151 TRY
152 status = NetrShareEnum(binding_h, usrvnamestr, &level,
153 &share_info, 4294967295U, &total_entries, NULL);
154 if (status != 0)
155 smb_error(dgettext(TEXT_DOMAIN,
156 "error from NetrShareEnum call: status = 0x%08x"),
157 0, status);
158 /*CSTYLED*/
159 CATCH (rpc_x_connect_rejected)
160 /*
161 * This is what we get if we can't open the pipe.
162 * That's a normal occurrence when we're talking
163 * to a system that (presumably) doesn't support
164 * DCE RPC on the server side, such as Windows 95/98/Me,
165 * so we don't log an error.
166 */
167 /*CSTYLED*/
168 status = ENOTSUP;
169 CATCH_ALL
170 /*
171 * XXX - should we handle some exceptions differently,
172 * returning different errors, and try RAP only for
173 * ENOTSUP?
174 */
175 smb_error(dgettext(TEXT_DOMAIN,
176 "error from NetrShareEnum call: exception = %u"),
177 0, THIS_CATCH->match.value);
178 status = ENOTSUP;
179 ENDTRY
180 rpc_binding_free(&binding_h, &free_status);
181 free(srvnamestr);
182 free(usrvnamestr);
183 if (status != 0)
184 return (ENOTSUP);
185
186 /*
187 * XXX - if the IDL is correct, it's not clear whether the
188 * unmarshalling code will properly handle the case where
189 * a packet where "share_count" and the max count for the
190 * array of shares don't match; a valid DCE RPC implementation
191 * won't marshal something like that, but there's no guarantee
192 * that the server we're talking to has a valid implementation
193 * (which could be a *malicious* implementation!).
194 */
195 entries = share_info.share_union.tagged_union.share1->share_count;
196 shares = share_info.share_union.tagged_union.share1->shares;
197 entry_list = calloc(entries, sizeof (struct share_info));
198 if (entry_list == NULL) {
199 error = errno;
200 goto cleanup_and_return;
201 }
202 for (share = shares, elp = entry_list, i = 0; i < entries;
203 i++, share++) {
204 elp->type = share->shi1_type;
205 elp->netname = convert_unicode_to_utf8(share->shi1_share);
206 if (elp->netname == NULL)
207 goto fail;
208 elp->remark = convert_unicode_to_utf8(share->shi1_remark);
209 if (elp->remark == NULL)
210 goto fail;
211 elp++;
212 }
213 *entriesp = entries;
214 *totalp = total_entries;
215 *entries_listp = entry_list;
216 error = 0;
217 goto cleanup_and_return;
218
219 fail:
220 error = errno;
221 for (elp = entry_list, i = 0; i < entries; i++, elp++) {
222 /*
223 * elp->netname is set before elp->remark, so if
224 * elp->netname is null, elp->remark is also null.
225 * If either of them is null, we haven't done anything
226 * to any entries after this one.
227 */
228 if (elp->netname == NULL)
229 break;
230 free(elp->netname);
231 if (elp->remark == NULL)
232 break;
233 free(elp->remark);
234 }
235 free(entry_list);
236
237 cleanup_and_return:
238 for (share = shares, i = 0; i < entries; i++, share++) {
239 free(share->shi1_share);
240 free(share->shi1_remark);
241 }
242 free(shares);
243 /*
244 * XXX - "share1" should be a unique pointer, but we haven't
245 * changed the marshalling code to support non-full pointers
246 * in unions, so we leave it as a full pointer.
247 *
248 * That means that this might, or might not, be changed from
249 * pointing to "share_info_1_container" to pointing to a
250 * mallocated structure, according to the DCE RPC 1.1 IDL spec;
251 * we free it only if it's changed.
252 */
253 if (share_info.share_union.tagged_union.share1 !=
254 &share_info_1_container)
255 free(share_info.share_union.tagged_union.share1);
256 return (error);
257 }
258 #endif /* XXX */
259
260 /*
261 * Enumerate shares using RAP
262 */
263
264 struct smb_share_info_1 {
265 char shi1_netname[13];
266 char shi1_pad;
267 uint16_t shi1_type;
268 uint32_t shi1_remark; /* char * */
269 };
270
271 static int
272 smb_rap_NetShareEnum(struct smb_ctx *ctx, int sLevel, void *pbBuffer,
273 int *cbBuffer, int *pcEntriesRead, int *pcTotalAvail)
274 {
275 struct smb_rap *rap;
276 long lval = -1;
277 int error;
278
279 error = smb_rap_create(0, "WrLeh", "B13BWz", &rap);
280 if (error)
281 return (error);
282 (void) smb_rap_setNparam(rap, sLevel); /* W - sLevel */
283 (void) smb_rap_setPparam(rap, pbBuffer); /* r - pbBuffer */
284 (void) smb_rap_setNparam(rap, *cbBuffer); /* L - cbBuffer */
285 error = smb_rap_request(rap, ctx);
286 if (error == 0) {
287 *pcEntriesRead = rap->r_entries;
288 error = smb_rap_getNparam(rap, &lval);
289 *pcTotalAvail = lval;
290 /* Copy the data length into the IN/OUT variable. */
291 *cbBuffer = rap->r_rcvbuflen;
292 }
293 error = smb_rap_error(rap, error);
294 smb_rap_done(rap);
295 return (error);
296 }
297
298 static int
299 rap_netshareenum(struct smb_ctx *ctx, int *entriesp, int *totalp,
300 struct share_info **entries_listp)
301 {
302 int error, bufsize, i, entries, total, nreturned;
303 struct smb_share_info_1 *rpbuf, *ep;
304 struct share_info *entry_list, *elp;
305 char *cp;
306 int lbound, rbound;
307
308 bufsize = 0xffe0; /* samba notes win2k bug for 65535 */
309 rpbuf = malloc(bufsize);
310 if (rpbuf == NULL)
311 return (errno);
312
313 error = smb_rap_NetShareEnum(ctx, 1, rpbuf, &bufsize, &entries, &total);
314 if (error &&
315 error != (ERROR_MORE_DATA | SMB_RAP_ERROR)) {
316 free(rpbuf);
317 return (error);
318 }
319 entry_list = malloc(entries * sizeof (struct share_info));
320 if (entry_list == NULL) {
321 error = errno;
322 free(rpbuf);
323 return (error);
324 }
325 lbound = entries * (sizeof (struct smb_share_info_1));
326 rbound = bufsize;
327 for (ep = rpbuf, elp = entry_list, i = 0, nreturned = 0; i < entries;
328 i++, ep++) {
329 elp->type = letohs(ep->shi1_type);
330 ep->shi1_pad = '\0'; /* ensure null termination */
331 elp->netname = convert_wincs_to_utf8(ep->shi1_netname);
332 if (elp->netname == NULL)
333 continue; /* punt on this entry */
334 /*
335 * Check for validity of offset.
336 */
337 if (ep->shi1_remark >= lbound && ep->shi1_remark < rbound) {
338 cp = (char *)rpbuf + ep->shi1_remark;
339 elp->remark = convert_wincs_to_utf8(cp);
340 } else
341 elp->remark = NULL;
342 elp++;
343 nreturned++;
344 }
345 *entriesp = nreturned;
346 *totalp = total;
347 *entries_listp = entry_list;
348 free(rpbuf);
349 return (0);
350 }
351
352 /*
353 * First we try the RPC-based NetrShareEnum, and, if that fails, we fall
354 * back on the RAP-based NetShareEnum.
355 */
356 int
357 smb_netshareenum(struct smb_ctx *ctx, int *entriesp, int *totalp,
358 struct share_info **entry_listp)
359 {
360 int error;
361
362 #ifdef NOTYETDEFINED
363 /*
364 * Try getting a list of shares with the SRVSVC RPC service.
365 */
366 error = rpc_netshareenum(ctx, entriesp, totalp, entry_listp);
367 if (error == 0)
368 return (0);
369 #endif
370
371 /*
372 * OK, that didn't work - try RAP.
373 * XXX - do so only if it failed because we couldn't open
374 * the pipe?
375 */
376 error = rap_netshareenum(ctx, entriesp, totalp, entry_listp);
377 return (error);
378 }