?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r299: updating release notes
[Samba/gebeck_regimport.git] / source3 / libsmb / libsmbclient.c
blobebbf28a12dbb3561f35a00412f7272a05b437d32
1 /*
2 Unix SMB/Netbios implementation.
3 SMB client library implementation
4 Copyright (C) Andrew Tridgell 1998
5 Copyright (C) Richard Sharpe 2000, 2002
6 Copyright (C) John Terpstra 2000
7 Copyright (C) Tom Jansen (Ninja ISD) 2002
8 Copyright (C) Derrell Lipman 2003
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 #include "../include/libsmb_internal.h"
28
29 /*
30 * Internal flags for extended attributes
31 */
32
33 /* internal mode values */
34 #define SMBC_XATTR_MODE_ADD 1
35 #define SMBC_XATTR_MODE_REMOVE 2
36 #define SMBC_XATTR_MODE_REMOVE_ALL 3
37 #define SMBC_XATTR_MODE_SET 4
38 #define SMBC_XATTR_MODE_CHOWN 5
39 #define SMBC_XATTR_MODE_CHGRP 6
40
41 #define CREATE_ACCESS_READ READ_CONTROL_ACCESS
42
43 /*We should test for this in configure ... */
44 #ifndef ENOTSUP
45 #define ENOTSUP EOPNOTSUPP
46 #endif
47
48 /*
49 * Functions exported by libsmb_cache.c that we need here
50 */
51 int smbc_default_cache_functions(SMBCCTX *context);
52
53 /*
54 * check if an element is part of the list.
55 * FIXME: Does not belong here !
56 * Can anyone put this in a macro in dlinklist.h ?
57 * -- Tom
58 */
59 static int DLIST_CONTAINS(SMBCFILE * list, SMBCFILE *p) {
60 if (!p || !list) return False;
61 do {
62 if (p == list) return True;
63 list = list->next;
64 } while (list);
65 return False;
66 }
67
68 extern BOOL in_client;
69
70 /*
71 * Is the logging working / configfile read ?
72 */
73 static int smbc_initialized = 0;
74
75 static int
76 hex2int( unsigned int _char )
77 {
78 if ( _char >= 'A' && _char <='F')
79 return _char - 'A' + 10;
80 if ( _char >= 'a' && _char <='f')
81 return _char - 'a' + 10;
82 if ( _char >= '0' && _char <='9')
83 return _char - '0';
84 return -1;
85 }
86
87 static void
88 decode_urlpart(char *segment, size_t sizeof_segment)
89 {
90 int old_length = strlen(segment);
91 int new_length = 0;
92 int new_length2 = 0;
93 int i = 0;
94 pstring new_segment;
95 char *new_usegment = 0;
96
97 if ( !old_length ) {
98 return;
99 }
100
101 /* make a copy of the old one */
102 new_usegment = (char*)malloc( old_length * 3 + 1 );
103
104 while( i < old_length ) {
105 int bReencode = False;
106 unsigned char character = segment[ i++ ];
107 if ((character <= ' ') || (character > 127))
108 bReencode = True;
109
110 new_usegment [ new_length2++ ] = character;
111 if (character == '%' ) {
112 int a = i+1 < old_length ? hex2int( segment[i] ) : -1;
113 int b = i+1 < old_length ? hex2int( segment[i+1] ) : -1;
114 if ((a == -1) || (b == -1)) { /* Only replace if sequence is valid */
115 /* Contains stray %, make sure to re-encode! */
116 bReencode = True;
117 } else {
118 /* Valid %xx sequence */
119 character = a * 16 + b; /* Replace with value of %dd */
120 if (!character)
121 break; /* Stop at %00 */
122
123 new_usegment [ new_length2++ ] = (unsigned char) segment[i++];
124 new_usegment [ new_length2++ ] = (unsigned char) segment[i++];
125 }
126 }
127 if (bReencode) {
128 unsigned int c = character / 16;
129 new_length2--;
130 new_usegment [ new_length2++ ] = '%';
131
132 c += (c > 9) ? ('A' - 10) : '0';
133 new_usegment[ new_length2++ ] = c;
134
135 c = character % 16;
136 c += (c > 9) ? ('A' - 10) : '0';
137 new_usegment[ new_length2++ ] = c;
138 }
139
140 new_segment [ new_length++ ] = character;
141 }
142 new_segment [ new_length ] = 0;
143
144 free(new_usegment);
145
146 /* realloc it with unix charset */
147 pull_utf8_allocate(&new_usegment, new_segment);
148
149 /* this assumes (very safely) that removing %aa sequences
150 only shortens the string */
151 strncpy(segment, new_usegment, sizeof_segment);
152
153 free(new_usegment);
154 }
155
156 /*
157 * Function to parse a path and turn it into components
158 *
159 * The general format of an SMB URI is explain in Christopher Hertel's CIFS
160 * book, at http://ubiqx.org/cifs/Appendix-D.html. We accept a subset of the
161 * general format ("smb:" only; we do not look for "cifs:"), and expand on
162 * what he calls "context", herein called "options" to avoid conflict with the
163 * SMBCCTX context used throughout this library. We add the "mb" keyword
164 * which applies as follows:
165 *
166 *
167 * We accept:
168 * smb://[[[domain;]user[:password@]]server[/share[/path[/file]]]][?options]
169 *
170 * Meaning of URLs:
171 *
172 * smb:// show all workgroups known by the first master browser found
173 * smb://?mb=.any same as smb:// (i.e. without any options)
174 *
175 * smb://?mb=.all show all workgroups known by every master browser found.
176 * Why might you want this? In an "appliance" application
177 * where the workgroup/domain being used on the local network
178 * is not known ahead of time, but where one wanted to
179 * provide network services via samba, a unique workgroup
180 * could be used. However, when the appliance is first
181 * started, the local samba instance's master browser has not
182 * synchronized with the other master browser(s) on the
183 * network (and might not synchronize for 12 minutes) and
184 * therefore is not aware of the workgroup/ domain names
185 * available on the network. This option may be used to
186 * overcome the problem of a libsmbclient application
187 * arbitrarily selecting the local (still ignorant) master
188 * browser to obtain its list of workgroups/domains and
189 * getting back a practically emmpty list. By requesting
190 * the list of workgroups/domains from each found master
191 * browser on the local network, a complete list of
192 * workgroups/domains can be built.
193 *
194 * smb://?mb=name NOT YET IMPLEMENTED -- show all workgroups known by the
195 * master browser whose name is "name"
196 *
197 * smb://name/ if name<1D> or name<1B> exists, list servers in
198 * workgroup, else, if name<20> exists, list all shares
199 * for server ...
200 *
201 * If "options" are provided, this function returns the entire option list as
202 * a string, for later parsing by the caller.
203 */
204
205 static const char *smbc_prefix = "smb:";
206
207 static int
208 smbc_parse_path(SMBCCTX *context,
209 const char *fname,
210 char *server, int server_len,
211 char *share, int share_len,
212 char *path, int path_len,
213 char *user, int user_len,
214 char *password, int password_len,
215 char *options, int options_len)
216 {
217 static pstring s;
218 pstring userinfo;
219 const char *p;
220 char *q, *r;
221 int len;
222
223 server[0] = share[0] = path[0] = user[0] = password[0] = (char)0;
224 if (options != NULL && options_len > 0) {
225 options[0] = (char)0;
226 }
227 pstrcpy(s, fname);
228
229 /* see if it has the right prefix */
230 len = strlen(smbc_prefix);
231 if (strncmp(s,smbc_prefix,len) || (s[len] != '/' && s[len] != 0)) {
232 return -1; /* What about no smb: ? */
233 }
234
235 p = s + len;
236
237 /* Watch the test below, we are testing to see if we should exit */
238
239 if (strncmp(p, "//", 2) && strncmp(p, "\\\\", 2)) {
240
241 DEBUG(1, ("Invalid path (does not begin with smb://"));
242 return -1;
243
244 }
245
246 p += 2; /* Skip the double slash */
247
248 /* See if any options were specified */
249 if ( (q = strrchr(p, '?')) != NULL ) {
250 /* There are options. Null terminate here and point to them */
251 *q++ = '\0';
252
253 DEBUG(4, ("Found options '%s'", q));
254
255 /* Copy the options */
256 if (options != NULL && options_len > 0) {
257 safe_strcpy(options, q, options_len - 1);
258 }
259 }
260
261 if (*p == (char)0)
262 goto decoding;
263
264 if (*p == '/') {
265
266 strncpy(server, context->workgroup,
267 (strlen(context->workgroup) < 16)?strlen(context->workgroup):16);
268 return 0;
269
270 }
271
272 /*
273 * ok, its for us. Now parse out the server, share etc.
274 *
275 * However, we want to parse out [[domain;]user[:password]@] if it
276 * exists ...
277 */
278
279 /* check that '@' occurs before '/', if '/' exists at all */
280 q = strchr_m(p, '@');
281 r = strchr_m(p, '/');
282 if (q && (!r || q < r)) {
283 pstring username, passwd, domain;
284 const char *u = userinfo;
285
286 next_token(&p, userinfo, "@", sizeof(fstring));
287
288 username[0] = passwd[0] = domain[0] = 0;
289
290 if (strchr_m(u, ';')) {
291
292 next_token(&u, domain, ";", sizeof(fstring));
293
294 }
295
296 if (strchr_m(u, ':')) {
297
298 next_token(&u, username, ":", sizeof(fstring));
299
300 pstrcpy(passwd, u);
301
302 }
303 else {
304
305 pstrcpy(username, u);
306
307 }
308
309 if (username[0])
310 strncpy(user, username, user_len); /* FIXME, domain */
311
312 if (passwd[0])
313 strncpy(password, passwd, password_len);
314
315 }
316
317 if (!next_token(&p, server, "/", sizeof(fstring))) {
318
319 return -1;
320
321 }
322
323 if (*p == (char)0) goto decoding; /* That's it ... */
324
325 if (!next_token(&p, share, "/", sizeof(fstring))) {
326
327 return -1;
328
329 }
330
331 safe_strcpy(path, p, path_len - 1);
332
333 all_string_sub(path, "/", "\\", 0);
334
335 decoding:
336 decode_urlpart(path, path_len);
337 decode_urlpart(server, server_len);
338 decode_urlpart(share, share_len);
339 decode_urlpart(user, user_len);
340 decode_urlpart(password, password_len);
341
342 return 0;
343 }
344
345 /*
346 * Verify that the options specified in a URL are valid
347 */
348 static int smbc_check_options(char *server, char *share, char *path, char *options)
349 {
350 DEBUG(4, ("smbc_check_options(): server='%s' share='%s' path='%s' options='%s'\n", server, share, path, options));
351
352 /* No options at all is always ok */
353 if (! *options) return 0;
354
355 /*
356 * For right now, we only support a very few options possibilities.
357 * No options are supported if server, share, or path are not empty.
358 * If all are empty, then we support the following two choices right
359 * now:
360 *
361 * mb=.any
362 * mb=.all
363 */
364 if ((*server || *share || *path) && *options) {
365 /* Invalid: options provided with server, share, or path */
366 DEBUG(1, ("Found unsupported options (%s) with non-empty server, share, or path\n", options));
367 return -1;
368 }
369
370 if (strcmp(options, "mb=.any") != 0 &&
371 strcmp(options, "mb=.all") != 0) {
372 DEBUG(1, ("Found unsupported options (%s)\n", options));
373 return -1;
374 }
375
376 return 0;
377 }
378
379 /*
380 * Convert an SMB error into a UNIX error ...
381 */
382 static int smbc_errno(SMBCCTX *context, struct cli_state *c)
383 {
384 int ret = cli_errno(c);
385
386 if (cli_is_dos_error(c)) {
387 uint8 eclass;
388 uint32 ecode;
389
390 cli_dos_error(c, &eclass, &ecode);
391
392 DEBUG(3,("smbc_error %d %d (0x%x) -> %d\n",
393 (int)eclass, (int)ecode, (int)ecode, ret));
394 } else {
395 NTSTATUS status;
396
397 status = cli_nt_error(c);
398
399 DEBUG(3,("smbc errno %s -> %d\n",
400 nt_errstr(status), ret));
401 }
402
403 return ret;
404 }
405
406 /*
407 * Check a server_fd.
408 * returns 0 if the server is in shape. Returns 1 on error
409 *
410 * Also useable outside libsmbclient to enable external cache
411 * to do some checks too.
412 */
413 int smbc_check_server(SMBCCTX * context, SMBCSRV * server)
414 {
415 if ( send_keepalive(server->cli.fd) == False )
416 return 1;
417
418 /* connection is ok */
419 return 0;
420 }
421
422 /*
423 * Remove a server from the cached server list it's unused.
424 * On success, 0 is returned. 1 is returned if the server could not be removed.
425 *
426 * Also useable outside libsmbclient
427 */
428 int smbc_remove_unused_server(SMBCCTX * context, SMBCSRV * srv)
429 {
430 SMBCFILE * file;
431
432 /* are we being fooled ? */
433 if (!context || !context->internal ||
434 !context->internal->_initialized || !srv) return 1;
435
436
437 /* Check all open files/directories for a relation with this server */
438 for (file = context->internal->_files; file; file=file->next) {
439 if (file->srv == srv) {
440 /* Still used */
441 DEBUG(3, ("smbc_remove_usused_server: %p still used by %p.\n",
442 srv, file));
443 return 1;
444 }
445 }
446
447 DLIST_REMOVE(context->internal->_servers, srv);
448
449 cli_shutdown(&srv->cli);
450
451 DEBUG(3, ("smbc_remove_usused_server: %p removed.\n", srv));
452
453 context->callbacks.remove_cached_srv_fn(context, srv);
454
455 SAFE_FREE(srv);
456
457 return 0;
458 }
459
460 SMBCSRV *find_server(SMBCCTX *context,
461 const char *server,
462 const char *share,
463 fstring workgroup,
464 fstring username,
465 fstring password)
466 {
467 SMBCSRV *srv;
468 int auth_called = 0;
469
470 check_server_cache:
471
472 srv = context->callbacks.get_cached_srv_fn(context, server, share,
473 workgroup, username);
474
475 if (!auth_called && !srv && (!username[0] || !password[0])) {
476 context->callbacks.auth_fn(server, share,
477 workgroup, sizeof(fstring),
478 username, sizeof(fstring),
479 password, sizeof(fstring));
480 /*
481 * However, smbc_auth_fn may have picked up info relating to
482 * an existing connection, so try for an existing connection
483 * again ...
484 */
485 auth_called = 1;
486 goto check_server_cache;
487
488 }
489
490 if (srv) {
491 if (context->callbacks.check_server_fn(context, srv)) {
492 /*
493 * This server is no good anymore
494 * Try to remove it and check for more possible
495 * servers in the cache
496 */
497 if (context->callbacks.remove_unused_server_fn(context,
498 srv)) {
499 /*
500 * We could not remove the server completely,
501 * remove it from the cache so we will not get
502 * it again. It will be removed when the last
503 * file/dir is closed.
504 */
505 context->callbacks.remove_cached_srv_fn(context,
506 srv);
507 }
508
509 /*
510 * Maybe there are more cached connections to this
511 * server
512 */
513 goto check_server_cache;
514 }
515 return srv;
516 }
517
518 return NULL;
519 }
520
521 /*
522 * Connect to a server, possibly on an existing connection
523 *
524 * Here, what we want to do is: If the server and username
525 * match an existing connection, reuse that, otherwise, establish a
526 * new connection.
527 *
528 * If we have to create a new connection, call the auth_fn to get the
529 * info we need, unless the username and password were passed in.
530 */
531
532 SMBCSRV *smbc_server(SMBCCTX *context,
533 const char *server, const char *share,
534 fstring workgroup, fstring username,
535 fstring password)
536 {
537 SMBCSRV *srv=NULL;
538 struct cli_state c;
539 struct nmb_name called, calling;
540 const char *server_n = server;
541 pstring ipenv;
542 struct in_addr ip;
543 int tried_reverse = 0;
544
545 zero_ip(&ip);
546 ZERO_STRUCT(c);
547
548 if (server[0] == 0) {
549 errno = EPERM;
550 return NULL;
551 }
552
553 srv = find_server(context, server, share,
554 workgroup, username, password);
555 if (srv)
556 return srv;
557
558 make_nmb_name(&calling, context->netbios_name, 0x0);
559 make_nmb_name(&called , server, 0x20);
560
561 DEBUG(4,("smbc_server: server_n=[%s] server=[%s]\n", server_n, server));
562
563 #if 0 /* djl: obsolete code? neither group nor p is used beyond here */
564 if ((p=strchr_m(server_n,'#')) &&
565 (strcmp(p+1,"1D")==0 || strcmp(p+1,"01")==0)) {
566
567 fstrcpy(group, server_n);
568 p = strchr_m(group,'#');
569 *p = 0;
570
571 }
572 #endif
573
574 DEBUG(4,(" -> server_n=[%s] server=[%s]\n", server_n, server));
575
576 again:
577 slprintf(ipenv,sizeof(ipenv)-1,"HOST_%s", server_n);
578
579 zero_ip(&ip);
580
581 /* have to open a new connection */
582 if (!cli_initialise(&c)) {
583 errno = ENOMEM;
584 return NULL;
585 }
586
587 c.timeout = context->timeout;
588
589 /* Force use of port 139 for first try, so browse lists can work */
590 c.port = 139;
591
592 if (!cli_connect(&c, server_n, &ip)) {
593 /*
594 * Port 139 connection failed. Try port 445 to handle
595 * connections to newer (e.g. XP) hosts with NetBIOS disabled.
596 */
597 c.port = 445;
598 if (!cli_connect(&c, server_n, &ip)) {
599 errno = ENETUNREACH;
600 return NULL;
601 }
602 }
603
604 if (!cli_session_request(&c, &calling, &called)) {
605 cli_shutdown(&c);
606 if (strcmp(called.name, "*SMBSERVER")) {
607 make_nmb_name(&called , "*SMBSERVER", 0x20);
608 goto again;
609 }
610 else { /* Try one more time, but ensure we don't loop */
611
612 /* Only try this if server is an IP address ... */
613
614 if (is_ipaddress(server) && !tried_reverse) {
615 fstring remote_name;
616 struct in_addr rem_ip;
617
618 if ((rem_ip.s_addr=inet_addr(server)) == INADDR_NONE) {
619 DEBUG(4, ("Could not convert IP address %s to struct in_addr\n", server));
620 errno = ENOENT;
621 return NULL;
622 }
623
624 tried_reverse++; /* Yuck */
625
626 if (name_status_find("*", 0, 0, rem_ip, remote_name)) {
627 make_nmb_name(&called, remote_name, 0x20);
628 goto again;
629 }
630
631
632 }
633 }
634 errno = ENOENT;
635 return NULL;
636 }
637
638 DEBUG(4,(" session request ok\n"));
639
640 if (!cli_negprot(&c)) {
641 cli_shutdown(&c);
642 errno = ENOENT;
643 return NULL;
644 }
645
646 if (!cli_session_setup(&c, username,
647 password, strlen(password),
648 password, strlen(password),
649 workgroup) &&
650 /* try an anonymous login if it failed */
651 !cli_session_setup(&c, "", "", 1,"", 0, workgroup)) {
652 cli_shutdown(&c);
653 errno = EPERM;
654 return NULL;
655 }
656
657 DEBUG(4,(" session setup ok\n"));
658
659 if (!cli_send_tconX(&c, share, "?????",
660 password, strlen(password)+1)) {
661 errno = smbc_errno(context, &c);
662 cli_shutdown(&c);
663 return NULL;
664 }
665
666 DEBUG(4,(" tconx ok\n"));
667
668 /*
669 * Ok, we have got a nice connection
670 * Let's find a free server_fd
671 */
672
673 srv = (SMBCSRV *)malloc(sizeof(*srv));
674 if (!srv) {
675 errno = ENOMEM;
676 goto failed;
677 }
678
679 ZERO_STRUCTP(srv);
680 srv->cli = c;
681 srv->dev = (dev_t)(str_checksum(server) ^ str_checksum(share));
682
683 /* now add it to the cache (internal or external) */
684 if (context->callbacks.add_cached_srv_fn(context, srv, server, share, workgroup, username)) {
685 DEBUG(3, (" Failed to add server to cache\n"));
686 goto failed;
687 }
688
689
690 DEBUG(2, ("Server connect ok: //%s/%s: %p\n",
691 server, share, srv));
692
693 DLIST_ADD(context->internal->_servers, srv);
694 return srv;
695
696 failed:
697 cli_shutdown(&c);
698 if (!srv) return NULL;
699
700 SAFE_FREE(srv);
701 return NULL;
702 }
703
704 /*
705 * Connect to a server for getting/setting attributes, possibly on an existing
706 * connection. This works similarly to smbc_server().
707 */
708 SMBCSRV *smbc_attr_server(SMBCCTX *context,
709 const char *server, const char *share,
710 fstring workgroup,
711 fstring username, fstring password,
712 POLICY_HND *pol)
713 {
714 struct in_addr ip;
715 struct cli_state *ipc_cli;
716 NTSTATUS nt_status;
717 SMBCSRV *ipc_srv=NULL;
718
719 /*
720 * See if we've already created this special connection. Reference
721 * our "special" share name 'IPC$$'.
722 */
723 ipc_srv = find_server(context, server, "IPC$$",
724 workgroup, username, password);
725 if (!ipc_srv) {
726
727 /* We didn't find a cached connection. Get the password */
728 if (*password == '\0') {
729 /* ... then retrieve it now. */
730 context->callbacks.auth_fn(server, share,
731 workgroup, sizeof(fstring),
732 username, sizeof(fstring),
733 password, sizeof(fstring));
734 }
735
736 zero_ip(&ip);
737 nt_status = cli_full_connection(&ipc_cli,
738 global_myname(), server,
739 &ip, 0, "IPC$", "?????",
740 username, workgroup,
741 password, 0,
742 Undefined, NULL);
743 if (! NT_STATUS_IS_OK(nt_status)) {
744 DEBUG(1,("cli_full_connection failed! (%s)\n",
745 nt_errstr(nt_status)));
746 errno = ENOTSUP;
747 return NULL;
748 }
749
750 if (!cli_nt_session_open(ipc_cli, PI_LSARPC)) {
751 DEBUG(1, ("cli_nt_session_open fail!\n"));
752 errno = ENOTSUP;
753 cli_shutdown(ipc_cli);
754 return NULL;
755 }
756
757 /* Some systems don't support SEC_RIGHTS_MAXIMUM_ALLOWED,
758 but NT sends 0x2000000 so we might as well do it too. */
759
760 nt_status = cli_lsa_open_policy(ipc_cli,
761 ipc_cli->mem_ctx,
762 True,
763 GENERIC_EXECUTE_ACCESS,
764 pol);
765
766 if (!NT_STATUS_IS_OK(nt_status)) {
767 errno = smbc_errno(context, ipc_cli);
768 cli_shutdown(ipc_cli);
769 return NULL;
770 }
771
772 ipc_srv = (SMBCSRV *)malloc(sizeof(*ipc_srv));
773 if (!ipc_srv) {
774 errno = ENOMEM;
775 cli_shutdown(ipc_cli);
776 return NULL;
777 }
778
779 ZERO_STRUCTP(ipc_srv);
780 ipc_srv->cli = *ipc_cli;
781
782 free(ipc_cli);
783
784 /* now add it to the cache (internal or external) */
785
786 errno = 0; /* let cache function set errno if it likes */
787 if (context->callbacks.add_cached_srv_fn(context, ipc_srv,
788 server,
789 "IPC$$",
790 workgroup,
791 username)) {
792 DEBUG(3, (" Failed to add server to cache\n"));
793 if (errno == 0) {
794 errno = ENOMEM;
795 }
796 cli_shutdown(&ipc_srv->cli);
797 free(ipc_srv);
798 return NULL;
799 }
800
801 DLIST_ADD(context->internal->_servers, ipc_srv);
802 }
803
804 return ipc_srv;
805 }
806
807 /*
808 * Routine to open() a file ...
809 */
810
811 static SMBCFILE *smbc_open_ctx(SMBCCTX *context, const char *fname, int flags, mode_t mode)
812 {
813 fstring server, share, user, password, workgroup;
814 pstring path;
815 SMBCSRV *srv = NULL;
816 SMBCFILE *file = NULL;
817 int fd;
818
819 if (!context || !context->internal ||
820 !context->internal->_initialized) {
821
822 errno = EINVAL; /* Best I can think of ... */
823 return NULL;
824
825 }
826
827 if (!fname) {
828
829 errno = EINVAL;
830 return NULL;
831
832 }
833
834 if (smbc_parse_path(context, fname,
835 server, sizeof(server),
836 share, sizeof(share),
837 path, sizeof(path),
838 user, sizeof(user),
839 password, sizeof(password),
840 NULL, 0)) {
841 errno = EINVAL;
842 return NULL;
843 }
844
845 if (user[0] == (char)0) fstrcpy(user, context->user);
846
847 fstrcpy(workgroup, context->workgroup);
848
849 srv = smbc_server(context, server, share, workgroup, user, password);
850
851 if (!srv) {
852
853 if (errno == EPERM) errno = EACCES;
854 return NULL; /* smbc_server sets errno */
855
856 }
857
858 /* Hmmm, the test for a directory is suspect here ... FIXME */
859
860 if (strlen(path) > 0 && path[strlen(path) - 1] == '\\') {
861
862 fd = -1;
863
864 }
865 else {
866
867 file = malloc(sizeof(SMBCFILE));
868
869 if (!file) {
870
871 errno = ENOMEM;
872 return NULL;
873
874 }
875
876 ZERO_STRUCTP(file);
877
878 if ((fd = cli_open(&srv->cli, path, flags, DENY_NONE)) < 0) {
879
880 /* Handle the error ... */
881
882 SAFE_FREE(file);
883 errno = smbc_errno(context, &srv->cli);
884 return NULL;
885
886 }
887
888 /* Fill in file struct */
889
890 file->cli_fd = fd;
891 file->fname = strdup(fname);
892 file->srv = srv;
893 file->offset = 0;
894 file->file = True;
895
896 DLIST_ADD(context->internal->_files, file);
897 return file;
898
899 }
900
901 /* Check if opendir needed ... */
902
903 if (fd == -1) {
904 int eno = 0;
905
906 eno = smbc_errno(context, &srv->cli);
907 file = context->opendir(context, fname);
908 if (!file) errno = eno;
909 return file;
910
911 }
912
913 errno = EINVAL; /* FIXME, correct errno ? */
914 return NULL;
915
916 }
917
918 /*
919 * Routine to create a file
920 */
921
922 static int creat_bits = O_WRONLY | O_CREAT | O_TRUNC; /* FIXME: Do we need this */
923
924 static SMBCFILE *smbc_creat_ctx(SMBCCTX *context, const char *path, mode_t mode)
925 {
926
927 if (!context || !context->internal ||
928 !context->internal->_initialized) {
929
930 errno = EINVAL;
931 return NULL;
932
933 }
934
935 return smbc_open_ctx(context, path, creat_bits, mode);
936 }
937
938 /*
939 * Routine to read() a file ...
940 */
941
942 static ssize_t smbc_read_ctx(SMBCCTX *context, SMBCFILE *file, void *buf, size_t count)
943 {
944 int ret;
945
946 if (!context || !context->internal ||
947 !context->internal->_initialized) {
948
949 errno = EINVAL;
950 return -1;
951
952 }
953
954 DEBUG(4, ("smbc_read(%p, %d)\n", file, (int)count));
955
956 if (!file || !DLIST_CONTAINS(context->internal->_files, file)) {
957
958 errno = EBADF;
959 return -1;
960
961 }
962
963 /* Check that the buffer exists ... */
964
965 if (buf == NULL) {
966
967 errno = EINVAL;
968 return -1;
969
970 }
971
972 ret = cli_read(&file->srv->cli, file->cli_fd, buf, file->offset, count);
973
974 if (ret < 0) {
975
976 errno = smbc_errno(context, &file->srv->cli);
977 return -1;
978
979 }
980
981 file->offset += ret;
982
983 DEBUG(4, (" --> %d\n", ret));
984
985 return ret; /* Success, ret bytes of data ... */
986
987 }
988
989 /*
990 * Routine to write() a file ...
991 */
992
993 static ssize_t smbc_write_ctx(SMBCCTX *context, SMBCFILE *file, void *buf, size_t count)
994 {
995 int ret;
996
997 if (!context || !context->internal ||
998 !context->internal->_initialized) {
999
1000 errno = EINVAL;
1001 return -1;
1002
1003 }
1004
1005 if (!file || !DLIST_CONTAINS(context->internal->_files, file)) {
1006
1007 errno = EBADF;
1008 return -1;
1009
1010 }
1011
1012 /* Check that the buffer exists ... */
1013
1014 if (buf == NULL) {
1015
1016 errno = EINVAL;
1017 return -1;
1018
1019 }
1020
1021 ret = cli_write(&file->srv->cli, file->cli_fd, 0, buf, file->offset, count);
1022
1023 if (ret <= 0) {
1024
1025 errno = smbc_errno(context, &file->srv->cli);
1026 return -1;
1027
1028 }
1029
1030 file->offset += ret;
1031
1032 return ret; /* Success, 0 bytes of data ... */
1033 }
1034
1035 /*
1036 * Routine to close() a file ...
1037 */
1038
1039 static int smbc_close_ctx(SMBCCTX *context, SMBCFILE *file)
1040 {
1041 SMBCSRV *srv;
1042
1043 if (!context || !context->internal ||
1044 !context->internal->_initialized) {
1045
1046 errno = EINVAL;
1047 return -1;
1048
1049 }
1050
1051 if (!file || !DLIST_CONTAINS(context->internal->_files, file)) {
1052
1053 errno = EBADF;
1054 return -1;
1055
1056 }
1057
1058 /* IS a dir ... */
1059 if (!file->file) {
1060
1061 return context->closedir(context, file);
1062
1063 }
1064
1065 if (!cli_close(&file->srv->cli, file->cli_fd)) {
1066
1067 DEBUG(3, ("cli_close failed on %s. purging server.\n",
1068 file->fname));
1069 /* Deallocate slot and remove the server
1070 * from the server cache if unused */
1071 errno = smbc_errno(context, &file->srv->cli);
1072 srv = file->srv;
1073 DLIST_REMOVE(context->internal->_files, file);
1074 SAFE_FREE(file->fname);
1075 SAFE_FREE(file);
1076 context->callbacks.remove_unused_server_fn(context, srv);
1077
1078 return -1;
1079
1080 }
1081
1082 DLIST_REMOVE(context->internal->_files, file);
1083 SAFE_FREE(file->fname);
1084 SAFE_FREE(file);
1085
1086 return 0;
1087 }
1088
1089 /*
1090 * Get info from an SMB server on a file. Use a qpathinfo call first
1091 * and if that fails, use getatr, as Win95 sometimes refuses qpathinfo
1092 */
1093 static BOOL smbc_getatr(SMBCCTX * context, SMBCSRV *srv, char *path,
1094 uint16 *mode, size_t *size,
1095 time_t *c_time, time_t *a_time, time_t *m_time,
1096 SMB_INO_T *ino)
1097 {
1098
1099 if (!context || !context->internal ||
1100 !context->internal->_initialized) {
1101
1102 errno = EINVAL;
1103 return -1;
1104
1105 }
1106
1107 DEBUG(4,("smbc_getatr: sending qpathinfo\n"));
1108
1109 if (!srv->no_pathinfo2 &&
1110 cli_qpathinfo2(&srv->cli, path, c_time, a_time, m_time, NULL,
1111 size, mode, ino)) return True;
1112
1113 /* if this is NT then don't bother with the getatr */
1114 if (srv->cli.capabilities & CAP_NT_SMBS) {
1115 errno = EPERM;
1116 return False;
1117 }
1118
1119 if (cli_getatr(&srv->cli, path, mode, size, m_time)) {
1120 a_time = c_time = m_time;
1121 srv->no_pathinfo2 = True;
1122 return True;
1123 }
1124
1125 errno = EPERM;
1126 return False;
1127
1128 }
1129
1130 /*
1131 * Routine to unlink() a file
1132 */
1133
1134 static int smbc_unlink_ctx(SMBCCTX *context, const char *fname)
1135 {
1136 fstring server, share, user, password, workgroup;
1137 pstring path;
1138 SMBCSRV *srv = NULL;
1139
1140 if (!context || !context->internal ||
1141 !context->internal->_initialized) {
1142
1143 errno = EINVAL; /* Best I can think of ... */
1144 return -1;
1145
1146 }
1147
1148 if (!fname) {
1149
1150 errno = EINVAL;
1151 return -1;
1152
1153 }
1154
1155 if (smbc_parse_path(context, fname,
1156 server, sizeof(server),
1157 share, sizeof(share),
1158 path, sizeof(path),
1159 user, sizeof(user),
1160 password, sizeof(password),
1161 NULL, 0)) {
1162 errno = EINVAL;
1163 return -1;
1164 }
1165
1166 if (user[0] == (char)0) fstrcpy(user, context->user);
1167
1168 fstrcpy(workgroup, context->workgroup);
1169
1170 srv = smbc_server(context, server, share, workgroup, user, password);
1171
1172 if (!srv) {
1173
1174 return -1; /* smbc_server sets errno */
1175
1176 }
1177
1178 /* if (strncmp(srv->cli.dev, "LPT", 3) == 0) {
1179
1180 int job = smbc_stat_printjob(srv, path, NULL, NULL);
1181 if (job == -1) {
1182
1183 return -1;
1184
1185 }
1186 if ((err = cli_printjob_del(&srv->cli, job)) != 0) {
1187
1188
1189 return -1;
1190
1191 }
1192 } else */
1193
1194 if (!cli_unlink(&srv->cli, path)) {
1195
1196 errno = smbc_errno(context, &srv->cli);
1197
1198 if (errno == EACCES) { /* Check if the file is a directory */
1199
1200 int saverr = errno;
1201 size_t size = 0;
1202 uint16 mode = 0;
1203 time_t m_time = 0, a_time = 0, c_time = 0;
1204 SMB_INO_T ino = 0;
1205
1206 if (!smbc_getatr(context, srv, path, &mode, &size,
1207 &c_time, &a_time, &m_time, &ino)) {
1208
1209 /* Hmmm, bad error ... What? */
1210
1211 errno = smbc_errno(context, &srv->cli);
1212 return -1;
1213
1214 }
1215 else {
1216
1217 if (IS_DOS_DIR(mode))
1218 errno = EISDIR;
1219 else
1220 errno = saverr; /* Restore this */
1221
1222 }
1223 }
1224
1225 return -1;
1226
1227 }
1228
1229 return 0; /* Success ... */
1230
1231 }
1232
1233 /*
1234 * Routine to rename() a file
1235 */
1236
1237 static int smbc_rename_ctx(SMBCCTX *ocontext, const char *oname,
1238 SMBCCTX *ncontext, const char *nname)
1239 {
1240 fstring server1, share1, server2, share2, user1, user2, password1, password2, workgroup;
1241 pstring path1, path2;
1242 SMBCSRV *srv = NULL;
1243
1244 if (!ocontext || !ncontext ||
1245 !ocontext->internal || !ncontext->internal ||
1246 !ocontext->internal->_initialized ||
1247 !ncontext->internal->_initialized) {
1248
1249 errno = EINVAL; /* Best I can think of ... */
1250 return -1;
1251
1252 }
1253
1254 if (!oname || !nname) {
1255
1256 errno = EINVAL;
1257 return -1;
1258
1259 }
1260
1261 DEBUG(4, ("smbc_rename(%s,%s)\n", oname, nname));
1262
1263 smbc_parse_path(ocontext, oname,
1264 server1, sizeof(server1),
1265 share1, sizeof(share1),
1266 path1, sizeof(path1),
1267 user1, sizeof(user1),
1268 password1, sizeof(password1),
1269 NULL, 0);
1270
1271 if (user1[0] == (char)0) fstrcpy(user1, ocontext->user);
1272
1273 smbc_parse_path(ncontext, nname,
1274 server2, sizeof(server2),
1275 share2, sizeof(share2),
1276 path2, sizeof(path2),
1277 user2, sizeof(user2),
1278 password2, sizeof(password2),
1279 NULL, 0);
1280
1281 if (user2[0] == (char)0) fstrcpy(user2, ncontext->user);
1282
1283 if (strcmp(server1, server2) || strcmp(share1, share2) ||
1284 strcmp(user1, user2)) {
1285
1286 /* Can't rename across file systems, or users?? */
1287
1288 errno = EXDEV;
1289 return -1;
1290
1291 }
1292
1293 fstrcpy(workgroup, ocontext->workgroup);
1294 /* HELP !!! Which workgroup should I use ? Or are they always the same -- Tom */
1295 srv = smbc_server(ocontext, server1, share1, workgroup, user1, password1);
1296 if (!srv) {
1297
1298 return -1;
1299
1300 }
1301
1302 if (!cli_rename(&srv->cli, path1, path2)) {
1303 int eno = smbc_errno(ocontext, &srv->cli);
1304
1305 if (eno != EEXIST ||
1306 !cli_unlink(&srv->cli, path2) ||
1307 !cli_rename(&srv->cli, path1, path2)) {
1308
1309 errno = eno;
1310 return -1;
1311
1312 }
1313 }
1314
1315 return 0; /* Success */
1316
1317 }
1318
1319 /*
1320 * A routine to lseek() a file
1321 */
1322
1323 static off_t smbc_lseek_ctx(SMBCCTX *context, SMBCFILE *file, off_t offset, int whence)
1324 {
1325 size_t size;
1326
1327 if (!context || !context->internal ||
1328 !context->internal->_initialized) {
1329
1330 errno = EINVAL;
1331 return -1;
1332
1333 }
1334
1335 if (!file || !DLIST_CONTAINS(context->internal->_files, file)) {
1336
1337 errno = EBADF;
1338 return -1;
1339
1340 }
1341
1342 if (!file->file) {
1343
1344 errno = EINVAL;
1345 return -1; /* Can't lseek a dir ... */
1346
1347 }
1348
1349 switch (whence) {
1350 case SEEK_SET:
1351 file->offset = offset;
1352 break;
1353
1354 case SEEK_CUR:
1355 file->offset += offset;
1356 break;
1357
1358 case SEEK_END:
1359 if (!cli_qfileinfo(&file->srv->cli, file->cli_fd, NULL, &size, NULL, NULL,
1360 NULL, NULL, NULL))
1361 {
1362 SMB_BIG_UINT b_size = size;
1363 if (!cli_getattrE(&file->srv->cli, file->cli_fd, NULL, &b_size, NULL, NULL,
1364 NULL))
1365 {
1366 errno = EINVAL;
1367 return -1;
1368 } else
1369 size = b_size;
1370 }
1371 file->offset = size + offset;
1372 break;
1373
1374 default:
1375 errno = EINVAL;
1376 break;
1377
1378 }
1379
1380 return file->offset;
1381
1382 }
1383
1384 /*
1385 * Generate an inode number from file name for those things that need it
1386 */
1387
1388 static
1389 ino_t smbc_inode(SMBCCTX *context, const char *name)
1390 {
1391
1392 if (!context || !context->internal ||
1393 !context->internal->_initialized) {
1394
1395 errno = EINVAL;
1396 return -1;
1397
1398 }
1399
1400 if (!*name) return 2; /* FIXME, why 2 ??? */
1401 return (ino_t)str_checksum(name);
1402
1403 }
1404
1405 /*
1406 * Routine to put basic stat info into a stat structure ... Used by stat and
1407 * fstat below.
1408 */
1409
1410 static
1411 int smbc_setup_stat(SMBCCTX *context, struct stat *st, char *fname, size_t size, int mode)
1412 {
1413
1414 st->st_mode = 0;
1415
1416 if (IS_DOS_DIR(mode)) {
1417 st->st_mode = SMBC_DIR_MODE;
1418 } else {
1419 st->st_mode = SMBC_FILE_MODE;
1420 }
1421
1422 if (IS_DOS_ARCHIVE(mode)) st->st_mode |= S_IXUSR;
1423 if (IS_DOS_SYSTEM(mode)) st->st_mode |= S_IXGRP;
1424 if (IS_DOS_HIDDEN(mode)) st->st_mode |= S_IXOTH;
1425 if (!IS_DOS_READONLY(mode)) st->st_mode |= S_IWUSR;
1426
1427 st->st_size = size;
1428 #ifdef HAVE_STAT_ST_BLKSIZE
1429 st->st_blksize = 512;
1430 #endif
1431 #ifdef HAVE_STAT_ST_BLOCKS
1432 st->st_blocks = (size+511)/512;
1433 #endif
1434 st->st_uid = getuid();
1435 st->st_gid = getgid();
1436
1437 if (IS_DOS_DIR(mode)) {
1438 st->st_nlink = 2;
1439 } else {
1440 st->st_nlink = 1;
1441 }
1442
1443 if (st->st_ino == 0) {
1444 st->st_ino = smbc_inode(context, fname);
1445 }
1446
1447 return True; /* FIXME: Is this needed ? */
1448
1449 }
1450
1451 /*
1452 * Routine to stat a file given a name
1453 */
1454
1455 static int smbc_stat_ctx(SMBCCTX *context, const char *fname, struct stat *st)
1456 {
1457 SMBCSRV *srv;
1458 fstring server, share, user, password, workgroup;
1459 pstring path;
1460 time_t m_time = 0, a_time = 0, c_time = 0;
1461 size_t size = 0;
1462 uint16 mode = 0;
1463 SMB_INO_T ino = 0;
1464
1465 if (!context || !context->internal ||
1466 !context->internal->_initialized) {
1467
1468 errno = EINVAL; /* Best I can think of ... */
1469 return -1;
1470
1471 }
1472
1473 if (!fname) {
1474
1475 errno = EINVAL;
1476 return -1;
1477
1478 }
1479
1480 DEBUG(4, ("smbc_stat(%s)\n", fname));
1481
1482 if (smbc_parse_path(context, fname,
1483 server, sizeof(server),
1484 share, sizeof(share),
1485 path, sizeof(path),
1486 user, sizeof(user),
1487 password, sizeof(password),
1488 NULL, 0)) {
1489 errno = EINVAL;
1490 return -1;
1491 }
1492
1493 if (user[0] == (char)0) fstrcpy(user, context->user);
1494
1495 fstrcpy(workgroup, context->workgroup);
1496
1497 srv = smbc_server(context, server, share, workgroup, user, password);
1498
1499 if (!srv) {
1500 return -1; /* errno set by smbc_server */
1501 }
1502
1503 if (!smbc_getatr(context, srv, path, &mode, &size,
1504 &c_time, &a_time, &m_time, &ino)) {
1505
1506 errno = smbc_errno(context, &srv->cli);
1507 return -1;
1508
1509 }
1510
1511 st->st_ino = ino;
1512
1513 smbc_setup_stat(context, st, path, size, mode);
1514
1515 st->st_atime = a_time;
1516 st->st_ctime = c_time;
1517 st->st_mtime = m_time;
1518 st->st_dev = srv->dev;
1519
1520 return 0;
1521
1522 }
1523
1524 /*
1525 * Routine to stat a file given an fd
1526 */
1527
1528 static int smbc_fstat_ctx(SMBCCTX *context, SMBCFILE *file, struct stat *st)
1529 {
1530 time_t c_time, a_time, m_time;
1531 size_t size;
1532 uint16 mode;
1533 SMB_INO_T ino = 0;
1534
1535 if (!context || !context->internal ||
1536 !context->internal->_initialized) {
1537
1538 errno = EINVAL;
1539 return -1;
1540
1541 }
1542
1543 if (!file || !DLIST_CONTAINS(context->internal->_files, file)) {
1544
1545 errno = EBADF;
1546 return -1;
1547
1548 }
1549
1550 if (!file->file) {
1551
1552 return context->fstatdir(context, file, st);
1553
1554 }
1555
1556 if (!cli_qfileinfo(&file->srv->cli, file->cli_fd,
1557 &mode, &size, &c_time, &a_time, &m_time, NULL, &ino)) {
1558 SMB_BIG_UINT b_size = size;
1559 if (!cli_getattrE(&file->srv->cli, file->cli_fd,
1560 &mode, &b_size, &c_time, &a_time, &m_time)) {
1561
1562 errno = EINVAL;
1563 return -1;
1564 } else
1565 size = b_size;
1566
1567 }
1568
1569 st->st_ino = ino;
1570
1571 smbc_setup_stat(context, st, file->fname, size, mode);
1572
1573 st->st_atime = a_time;
1574 st->st_ctime = c_time;
1575 st->st_mtime = m_time;
1576 st->st_dev = file->srv->dev;
1577
1578 return 0;
1579
1580 }
1581
1582 /*
1583 * Routine to open a directory
1584 * We accept the URL syntax explained in smbc_parse_path(), above.
1585 */
1586
1587 static void smbc_remove_dir(SMBCFILE *dir)
1588 {
1589 struct smbc_dir_list *d,*f;
1590
1591 d = dir->dir_list;
1592 while (d) {
1593
1594 f = d; d = d->next;
1595
1596 SAFE_FREE(f->dirent);
1597 SAFE_FREE(f);
1598
1599 }
1600
1601 dir->dir_list = dir->dir_end = dir->dir_next = NULL;
1602
1603 }
1604
1605 static int add_dirent(SMBCFILE *dir, const char *name, const char *comment, uint32 type)
1606 {
1607 struct smbc_dirent *dirent;
1608 int size;
1609 char *u_name = NULL, *u_comment = NULL;
1610 size_t u_name_len = 0, u_comment_len = 0;
1611
1612 if (name)
1613 u_name_len = push_utf8_allocate(&u_name, name);
1614 if (comment)
1615 u_comment_len = push_utf8_allocate(&u_comment, comment);
1616
1617 /*
1618 * Allocate space for the dirent, which must be increased by the
1619 * size of the name and the comment and 1 for the null on the comment.
1620 * The null on the name is already accounted for.
1621 */
1622
1623 size = sizeof(struct smbc_dirent) + u_name_len + u_comment_len + 1;
1624
1625 dirent = malloc(size);
1626
1627 if (!dirent) {
1628
1629 dir->dir_error = ENOMEM;
1630 return -1;
1631
1632 }
1633
1634 ZERO_STRUCTP(dirent);
1635
1636 if (dir->dir_list == NULL) {
1637
1638 dir->dir_list = malloc(sizeof(struct smbc_dir_list));
1639 if (!dir->dir_list) {
1640
1641 SAFE_FREE(dirent);
1642 dir->dir_error = ENOMEM;
1643 return -1;
1644
1645 }
1646 ZERO_STRUCTP(dir->dir_list);
1647
1648 dir->dir_end = dir->dir_next = dir->dir_list;
1649 }
1650 else {
1651
1652 dir->dir_end->next = malloc(sizeof(struct smbc_dir_list));
1653
1654 if (!dir->dir_end->next) {
1655
1656 SAFE_FREE(dirent);
1657 dir->dir_error = ENOMEM;
1658 return -1;
1659
1660 }
1661 ZERO_STRUCTP(dir->dir_end->next);
1662
1663 dir->dir_end = dir->dir_end->next;
1664 }
1665
1666 dir->dir_end->next = NULL;
1667 dir->dir_end->dirent = dirent;
1668
1669 dirent->smbc_type = type;
1670 dirent->namelen = u_name_len;
1671 dirent->commentlen = u_comment_len;
1672 dirent->dirlen = size;
1673
1674 strncpy(dirent->name, (u_name?u_name:""), dirent->namelen + 1);
1675
1676 dirent->comment = (char *)(&dirent->name + dirent->namelen + 1);
1677 strncpy(dirent->comment, (u_comment?u_comment:""), dirent->commentlen + 1);
1678
1679 SAFE_FREE(u_comment);
1680 SAFE_FREE(u_name);
1681
1682 return 0;
1683
1684 }
1685
1686 static void
1687 list_unique_wg_fn(const char *name, uint32 type, const char *comment, void *state)
1688 {
1689 SMBCFILE *dir = (SMBCFILE *)state;
1690 struct smbc_dir_list *dir_list;
1691 struct smbc_dirent *dirent;
1692 int dirent_type;
1693 int remove = 0;
1694
1695 dirent_type = dir->dir_type;
1696
1697 if (add_dirent(dir, name, comment, dirent_type) < 0) {
1698
1699 /* An error occurred, what do we do? */
1700 /* FIXME: Add some code here */
1701 }
1702
1703 /* Point to the one just added */
1704 dirent = dir->dir_end->dirent;
1705
1706 /* See if this was a duplicate */
1707 for (dir_list = dir->dir_list;
1708 dir_list != dir->dir_end;
1709 dir_list = dir_list->next) {
1710 if (! remove &&
1711 strcmp(dir_list->dirent->name, dirent->name) == 0) {
1712 /* Duplicate. End end of list need to be removed. */
1713 remove = 1;
1714 }
1715
1716 if (remove && dir_list->next == dir->dir_end) {
1717 /* Found the end of the list. Remove it. */
1718 dir->dir_end = dir_list;
1719 free(dir_list->next);
1720 dir_list->next = NULL;
1721 break;
1722 }
1723 }
1724 }
1725
1726 static void
1727 list_fn(const char *name, uint32 type, const char *comment, void *state)
1728 {
1729 SMBCFILE *dir = (SMBCFILE *)state;
1730 int dirent_type;
1731
1732 /* We need to process the type a little ... */
1733
1734 if (dir->dir_type == SMBC_FILE_SHARE) {
1735
1736 switch (type) {
1737 case 0: /* Directory tree */
1738 dirent_type = SMBC_FILE_SHARE;
1739 break;
1740
1741 case 1:
1742 dirent_type = SMBC_PRINTER_SHARE;
1743 break;
1744
1745 case 2:
1746 dirent_type = SMBC_COMMS_SHARE;
1747 break;
1748
1749 case 3:
1750 dirent_type = SMBC_IPC_SHARE;
1751 break;
1752
1753 default:
1754 dirent_type = SMBC_FILE_SHARE; /* FIXME, error? */
1755 break;
1756 }
1757 }
1758 else dirent_type = dir->dir_type;
1759
1760 if (add_dirent(dir, name, comment, dirent_type) < 0) {
1761
1762 /* An error occurred, what do we do? */
1763 /* FIXME: Add some code here */
1764
1765 }
1766 }
1767
1768 static void
1769 dir_list_fn(file_info *finfo, const char *mask, void *state)
1770 {
1771
1772 if (add_dirent((SMBCFILE *)state, finfo->name, "",
1773 (finfo->mode&aDIR?SMBC_DIR:SMBC_FILE)) < 0) {
1774
1775 /* Handle an error ... */
1776
1777 /* FIXME: Add some code ... */
1778
1779 }
1780
1781 }
1782
1783 static SMBCFILE *smbc_opendir_ctx(SMBCCTX *context, const char *fname)
1784 {
1785 fstring server, share, user, password, options;
1786 pstring workgroup;
1787 pstring path;
1788 SMBCSRV *srv = NULL;
1789 SMBCFILE *dir = NULL;
1790 struct in_addr rem_ip;
1791
1792 if (!context || !context->internal ||
1793 !context->internal->_initialized) {
1794 DEBUG(4, ("no valid context\n"));
1795 errno = EINVAL;
1796 return NULL;
1797
1798 }
1799
1800 if (!fname) {
1801 DEBUG(4, ("no valid fname\n"));
1802 errno = EINVAL;
1803 return NULL;
1804 }
1805
1806 if (smbc_parse_path(context, fname,
1807 server, sizeof(server),
1808 share, sizeof(share),
1809 path, sizeof(path),
1810 user, sizeof(path),
1811 password, sizeof(password),
1812 options, sizeof(options))) {
1813 DEBUG(4, ("no valid path\n"));
1814 errno = EINVAL;
1815 return NULL;
1816 }
1817
1818 DEBUG(4, ("parsed path: fname='%s' server='%s' share='%s' path='%s' options='%s'\n", fname, server, share, path, options));
1819
1820 /* Ensure the options are valid */
1821 if (smbc_check_options(server, share, path, options)) {
1822 DEBUG(4, ("unacceptable options (%s)\n", options));
1823 errno = EINVAL;
1824 return NULL;
1825 }
1826
1827 if (user[0] == (char)0) fstrcpy(user, context->user);
1828
1829 pstrcpy(workgroup, context->workgroup);
1830
1831 dir = malloc(sizeof(*dir));
1832
1833 if (!dir) {
1834
1835 errno = ENOMEM;
1836 return NULL;
1837
1838 }
1839
1840 ZERO_STRUCTP(dir);
1841
1842 dir->cli_fd = 0;
1843 dir->fname = strdup(fname);
1844 dir->srv = NULL;
1845 dir->offset = 0;
1846 dir->file = False;
1847 dir->dir_list = dir->dir_next = dir->dir_end = NULL;
1848
1849 if (server[0] == (char)0 &&
1850 (! *options || strcmp(options, "mb=.any") == 0)) {
1851 struct in_addr server_ip;
1852 if (share[0] != (char)0 || path[0] != (char)0) {
1853
1854 errno = EINVAL;
1855 if (dir) {
1856 SAFE_FREE(dir->fname);
1857 SAFE_FREE(dir);
1858 }
1859 return NULL;
1860 }
1861
1862 /*
1863 * We have server and share and path empty ... so list the
1864 * workgroups first try to get the LMB for our workgroup, and
1865 * if that fails, try the DMB
1866 */
1867
1868 pstrcpy(workgroup, lp_workgroup());
1869
1870 if (!find_master_ip(workgroup, &server_ip)) {
1871 struct user_auth_info u_info;
1872 struct cli_state *cli;
1873
1874 DEBUG(4, ("Unable to find master browser for workgroup %s\n",
1875 workgroup));
1876
1877 /* find the name of the server ... */
1878 pstrcpy(u_info.username, user);
1879 pstrcpy(u_info.password, password);
1880
1881 if (!(cli = get_ipc_connect_master_ip_bcast(workgroup, &u_info))) {
1882 DEBUG(4, ("Unable to find master browser by "
1883 "broadcast\n"));
1884 errno = ENOENT;
1885 return NULL;
1886 }
1887
1888 fstrcpy(server, cli->desthost);
1889
1890 cli_shutdown(cli);
1891 } else {
1892 /*
1893 * Do a name status query to find out the name of the
1894 * master browser. We use <01><02>__MSBROWSE__<02>#01 if
1895 * *#00 fails because a domain master browser will not
1896 * respond to a wildcard query (or, at least, an NT4
1897 * server acting as the domain master browser will not).
1898 *
1899 * We might be able to use ONLY the query on MSBROWSE, but
1900 * that's not yet been tested with all Windows versions,
1901 * so until it is, leave the original wildcard query as
1902 * the first choice and fall back to MSBROWSE if the
1903 * wildcard query fails.
1904 */
1905 if (!name_status_find("*", 0, 0x1d, server_ip, server) &&
1906 !name_status_find(MSBROWSE, 1, 0x1d, server_ip, server)) {
1907 errno = ENOENT;
1908 return NULL;
1909 }
1910 }
1911
1912 DEBUG(4, ("using workgroup %s %s\n", workgroup, server));
1913
1914 /*
1915 * Get a connection to IPC$ on the server if we do not already
1916 * have one
1917 */
1918
1919 srv = smbc_server(context, server, "IPC$", workgroup, user, password);
1920 if (!srv) {
1921
1922 if (dir) {
1923 SAFE_FREE(dir->fname);
1924 SAFE_FREE(dir);
1925 }
1926 return NULL;
1927 }
1928
1929 dir->srv = srv;
1930 dir->dir_type = SMBC_WORKGROUP;
1931
1932 /* Now, list the stuff ... */
1933
1934 if (!cli_NetServerEnum(&srv->cli, workgroup, SV_TYPE_DOMAIN_ENUM, list_fn,
1935 (void *)dir)) {
1936
1937 DEBUG(1, ("Could not enumerate domains using '%s'\n", workgroup));
1938 if (dir) {
1939 SAFE_FREE(dir->fname);
1940 SAFE_FREE(dir);
1941 }
1942 errno = cli_errno(&srv->cli);
1943
1944 return NULL;
1945
1946 }
1947 } else if (server[0] == (char)0 &&
1948 (! *options || strcmp(options, "mb=.all") == 0)) {
1949
1950 int i;
1951 int count;
1952 struct ip_service *ip_list;
1953 struct ip_service server_addr;
1954 struct user_auth_info u_info;
1955 struct cli_state *cli;
1956
1957 if (share[0] != (char)0 || path[0] != (char)0) {
1958
1959 errno = EINVAL;
1960 if (dir) {
1961 SAFE_FREE(dir->fname);
1962 SAFE_FREE(dir);
1963 }
1964 return NULL;
1965 }
1966
1967 pstrcpy(u_info.username, user);
1968 pstrcpy(u_info.password, password);
1969
1970 /*
1971 * We have server and share and path empty but options
1972 * requesting that we scan all master browsers for their list
1973 * of workgroups/domains. This implies that we must first try
1974 * broadcast queries to find all master browsers, and if that
1975 * doesn't work, then try our other methods which return only
1976 * a single master browser.
1977 */
1978
1979 if (!name_resolve_bcast(MSBROWSE, 1, &ip_list, &count)) {
1980 if (!find_master_ip(workgroup, &server_addr.ip)) {
1981
1982 errno = ENOENT;
1983 return NULL;
1984 }
1985
1986 ip_list = &server_addr;
1987 count = 1;
1988 }
1989
1990 for (i = 0; i < count; i++) {
1991 DEBUG(99, ("Found master browser %s\n", inet_ntoa(ip_list[i].ip)));
1992
1993 cli = get_ipc_connect_master_ip(&ip_list[i], workgroup, &u_info);
1994 fstrcpy(server, cli->desthost);
1995 cli_shutdown(cli);
1996
1997 DEBUG(4, ("using workgroup %s %s\n", workgroup, server));
1998
1999 /*
2000 * For each returned master browser IP address, get a
2001 * connection to IPC$ on the server if we do not
2002 * already have one, and determine the
2003 * workgroups/domains that it knows about.
2004 */
2005
2006 srv = smbc_server(context, server,
2007 "IPC$", workgroup, user, password);
2008 if (!srv) {
2009
2010 if (dir) {
2011 SAFE_FREE(dir->fname);
2012 SAFE_FREE(dir);
2013 }
2014 return NULL;
2015 }
2016
2017 dir->srv = srv;
2018 dir->dir_type = SMBC_WORKGROUP;
2019
2020 /* Now, list the stuff ... */
2021
2022 if (!cli_NetServerEnum(&srv->cli, workgroup, SV_TYPE_DOMAIN_ENUM, list_unique_wg_fn,
2023 (void *)dir)) {
2024
2025 if (dir) {
2026 SAFE_FREE(dir->fname);
2027 SAFE_FREE(dir);
2028 }
2029 errno = cli_errno(&srv->cli);
2030
2031 return NULL;
2032
2033 }
2034 }
2035 } else {
2036 /*
2037 * Server not an empty string ... Check the rest and see what
2038 * gives
2039 */
2040 if (share[0] == (char)0) {
2041
2042 if (path[0] != (char)0) { /* Should not have empty share with path */
2043
2044 errno = EINVAL;
2045 if (dir) {
2046 SAFE_FREE(dir->fname);
2047 SAFE_FREE(dir);
2048 }
2049 return NULL;
2050
2051 }
2052
2053 /* Check to see if <server><1D>, <server><1B>, or <server><20> translates */
2054 /* However, we check to see if <server> is an IP address first */
2055
2056 if (!is_ipaddress(server) && /* Not an IP addr so check next */
2057 (resolve_name(server, &rem_ip, 0x1d) || /* Found LMB */
2058 resolve_name(server, &rem_ip, 0x1b) )) { /* Found DMB */
2059 fstring buserver;
2060
2061 dir->dir_type = SMBC_SERVER;
2062
2063 /*
2064 * Get the backup list ...
2065 */
2066
2067
2068 if (!name_status_find(server, 0, 0, rem_ip, buserver)) {
2069
2070 DEBUG(0, ("Could not get name of local/domain master browser for server %s\n", server));
2071 errno = EPERM; /* FIXME, is this correct */
2072 return NULL;
2073
2074 }
2075
2076 /*
2077 * Get a connection to IPC$ on the server if we do not already have one
2078 */
2079
2080 srv = smbc_server(context, buserver, "IPC$", workgroup, user, password);
2081
2082 if (!srv) {
2083 DEBUG(0, ("got no contact to IPC$\n"));
2084 if (dir) {
2085 SAFE_FREE(dir->fname);
2086 SAFE_FREE(dir);
2087 }
2088 return NULL;
2089
2090 }
2091
2092 dir->srv = srv;
2093
2094 /* Now, list the servers ... */
2095
2096 if (!cli_NetServerEnum(&srv->cli, server, 0x0000FFFE, list_fn,
2097 (void *)dir)) {
2098
2099 if (dir) {
2100 SAFE_FREE(dir->fname);
2101 SAFE_FREE(dir);
2102 }
2103 errno = cli_errno(&srv->cli);
2104 return NULL;
2105
2106 }
2107 }
2108 else {
2109
2110 if (resolve_name(server, &rem_ip, 0x20)) {
2111
2112 /* Now, list the shares ... */
2113
2114 dir->dir_type = SMBC_FILE_SHARE;
2115
2116 srv = smbc_server(context, server, "IPC$", workgroup, user, password);
2117
2118 if (!srv) {
2119
2120 if (dir) {
2121 SAFE_FREE(dir->fname);
2122 SAFE_FREE(dir);
2123 }
2124 return NULL;
2125
2126 }
2127
2128 dir->srv = srv;
2129
2130 /* Now, list the servers ... */
2131
2132 if (cli_RNetShareEnum(&srv->cli, list_fn,
2133 (void *)dir) < 0) {
2134
2135 errno = cli_errno(&srv->cli);
2136 if (dir) {
2137 SAFE_FREE(dir->fname);
2138 SAFE_FREE(dir);
2139 }
2140 return NULL;
2141
2142 }
2143
2144 }
2145 else {
2146
2147 errno = ENODEV; /* Neither the workgroup nor server exists */
2148 if (dir) {
2149 SAFE_FREE(dir->fname);
2150 SAFE_FREE(dir);
2151 }
2152 return NULL;
2153
2154 }
2155
2156 }
2157
2158 }
2159 else { /* The server and share are specified ... work from there ... */
2160
2161 /* Well, we connect to the server and list the directory */
2162
2163 dir->dir_type = SMBC_FILE_SHARE;
2164
2165 srv = smbc_server(context, server, share, workgroup, user, password);
2166
2167 if (!srv) {
2168
2169 if (dir) {
2170 SAFE_FREE(dir->fname);
2171 SAFE_FREE(dir);
2172 }
2173 return NULL;
2174
2175 }
2176
2177 dir->srv = srv;
2178
2179 /* Now, list the files ... */
2180
2181 pstrcat(path, "\\*");
2182
2183 if (cli_list(&srv->cli, path, aDIR | aSYSTEM | aHIDDEN, dir_list_fn,
2184 (void *)dir) < 0) {
2185
2186 if (dir) {
2187 SAFE_FREE(dir->fname);
2188 SAFE_FREE(dir);
2189 }
2190 errno = smbc_errno(context, &srv->cli);
2191 return NULL;
2192
2193 }
2194 }
2195
2196 }
2197
2198 DLIST_ADD(context->internal->_files, dir);
2199 return dir;
2200
2201 }
2202
2203 /*
2204 * Routine to close a directory
2205 */
2206
2207 static int smbc_closedir_ctx(SMBCCTX *context, SMBCFILE *dir)
2208 {
2209
2210 if (!context || !context->internal ||
2211 !context->internal->_initialized) {
2212
2213 errno = EINVAL;
2214 return -1;
2215
2216 }
2217
2218 if (!dir || !DLIST_CONTAINS(context->internal->_files, dir)) {
2219
2220 errno = EBADF;
2221 return -1;
2222
2223 }
2224
2225 smbc_remove_dir(dir); /* Clean it up */
2226
2227 DLIST_REMOVE(context->internal->_files, dir);
2228
2229 if (dir) {
2230
2231 SAFE_FREE(dir->fname);
2232 SAFE_FREE(dir); /* Free the space too */
2233 }
2234
2235 return 0;
2236
2237 }
2238
2239 /*
2240 * Routine to get a directory entry
2241 */
2242
2243 struct smbc_dirent *smbc_readdir_ctx(SMBCCTX *context, SMBCFILE *dir)
2244 {
2245 struct smbc_dirent *dirp, *dirent;
2246
2247 /* Check that all is ok first ... */
2248
2249 if (!context || !context->internal ||
2250 !context->internal->_initialized) {
2251
2252 errno = EINVAL;
2253 DEBUG(0, ("Invalid context in smbc_readdir_ctx()\n"));
2254 return NULL;
2255
2256 }
2257
2258 if (!dir || !DLIST_CONTAINS(context->internal->_files, dir)) {
2259
2260 errno = EBADF;
2261 DEBUG(0, ("Invalid dir in smbc_readdir_ctx()\n"));
2262 return NULL;
2263
2264 }
2265
2266 if (dir->file != False) { /* FIXME, should be dir, perhaps */
2267
2268 errno = ENOTDIR;
2269 DEBUG(0, ("Found file vs directory in smbc_readdir_ctx()\n"));
2270 return NULL;
2271
2272 }
2273
2274 if (!dir->dir_next) {
2275 return NULL;
2276 }
2277 else {
2278
2279 dirent = dir->dir_next->dirent;
2280 if (!dirent) {
2281
2282 errno = ENOENT;
2283 return NULL;
2284
2285 }
2286
2287 /* Hmmm, do I even need to copy it? */
2288
2289 memcpy(context->internal->_dirent, dirent, dirent->dirlen); /* Copy the dirent */
2290 dirp = (struct smbc_dirent *)context->internal->_dirent;
2291 dirp->comment = (char *)(&dirp->name + dirent->namelen + 1);
2292 dir->dir_next = dir->dir_next->next;
2293
2294 return (struct smbc_dirent *)context->internal->_dirent;
2295 }
2296
2297 }
2298
2299 /*
2300 * Routine to get directory entries
2301 */
2302
2303 static int smbc_getdents_ctx(SMBCCTX *context, SMBCFILE *dir, struct smbc_dirent *dirp, int count)
2304 {
2305 struct smbc_dir_list *dirlist;
2306 int rem = count, reqd;
2307 char *ndir = (char *)dirp;
2308
2309 /* Check that all is ok first ... */
2310
2311 if (!context || !context->internal ||
2312 !context->internal->_initialized) {
2313
2314 errno = EINVAL;
2315 return -1;
2316
2317 }
2318
2319 if (!dir || !DLIST_CONTAINS(context->internal->_files, dir)) {
2320
2321 errno = EBADF;
2322 return -1;
2323
2324 }
2325
2326 if (dir->file != False) { /* FIXME, should be dir, perhaps */
2327
2328 errno = ENOTDIR;
2329 return -1;
2330
2331 }
2332
2333 /*
2334 * Now, retrieve the number of entries that will fit in what was passed
2335 * We have to figure out if the info is in the list, or we need to
2336 * send a request to the server to get the info.
2337 */
2338
2339 while ((dirlist = dir->dir_next)) {
2340 struct smbc_dirent *dirent;
2341
2342 if (!dirlist->dirent) {
2343
2344 errno = ENOENT; /* Bad error */
2345 return -1;
2346
2347 }
2348
2349 if (rem < (reqd = (sizeof(struct smbc_dirent) + dirlist->dirent->namelen +
2350 dirlist->dirent->commentlen + 1))) {
2351
2352 if (rem < count) { /* We managed to copy something */
2353
2354 errno = 0;
2355 return count - rem;
2356
2357 }
2358 else { /* Nothing copied ... */
2359
2360 errno = EINVAL; /* Not enough space ... */
2361 return -1;
2362
2363 }
2364
2365 }
2366
2367 dirent = dirlist->dirent;
2368
2369 memcpy(ndir, dirent, reqd); /* Copy the data in ... */
2370
2371 ((struct smbc_dirent *)ndir)->comment =
2372 (char *)(&((struct smbc_dirent *)ndir)->name + dirent->namelen + 1);
2373
2374 ndir += reqd;
2375
2376 rem -= reqd;
2377
2378 dir->dir_next = dirlist = dirlist -> next;
2379 }
2380
2381 if (rem == count)
2382 return 0;
2383 else
2384 return count - rem;
2385
2386 }
2387
2388 /*
2389 * Routine to create a directory ...
2390 */
2391
2392 static int smbc_mkdir_ctx(SMBCCTX *context, const char *fname, mode_t mode)
2393 {
2394 SMBCSRV *srv;
2395 fstring server, share, user, password, workgroup;
2396 pstring path;
2397
2398 if (!context || !context->internal ||
2399 !context->internal->_initialized) {
2400
2401 errno = EINVAL;
2402 return -1;
2403
2404 }
2405
2406 if (!fname) {
2407
2408 errno = EINVAL;
2409 return -1;
2410
2411 }
2412
2413 DEBUG(4, ("smbc_mkdir(%s)\n", fname));
2414
2415 if (smbc_parse_path(context, fname,
2416 server, sizeof(server),
2417 share, sizeof(share),
2418 path, sizeof(path),
2419 user, sizeof(user),
2420 password, sizeof(password),
2421 NULL, 0)) {
2422 errno = EINVAL;
2423 return -1;
2424 }
2425
2426 if (user[0] == (char)0) fstrcpy(user, context->user);
2427
2428 fstrcpy(workgroup, context->workgroup);
2429
2430 srv = smbc_server(context, server, share, workgroup, user, password);
2431
2432 if (!srv) {
2433
2434 return -1; /* errno set by smbc_server */
2435
2436 }
2437
2438 /* if (strncmp(srv->cli.dev, "IPC", 3) == 0) {
2439
2440 mode = aDIR | aRONLY;
2441
2442 }
2443 else if (strncmp(srv->cli.dev, "LPT", 3) == 0) {
2444
2445 if (strcmp(path, "\\") == 0) {
2446
2447 mode = aDIR | aRONLY;
2448
2449 }
2450 else {
2451
2452 mode = aRONLY;
2453 smbc_stat_printjob(srv, path, &size, &m_time);
2454 c_time = a_time = m_time;
2455
2456 }
2457 else { */
2458
2459 if (!cli_mkdir(&srv->cli, path)) {
2460
2461 errno = smbc_errno(context, &srv->cli);
2462 return -1;
2463
2464 }
2465
2466 return 0;
2467
2468 }
2469
2470 /*
2471 * Our list function simply checks to see if a directory is not empty
2472 */
2473
2474 static int smbc_rmdir_dirempty = True;
2475
2476 static void rmdir_list_fn(file_info *finfo, const char *mask, void *state)
2477 {
2478
2479 if (strncmp(finfo->name, ".", 1) != 0 && strncmp(finfo->name, "..", 2) != 0)
2480 smbc_rmdir_dirempty = False;
2481
2482 }
2483
2484 /*
2485 * Routine to remove a directory
2486 */
2487
2488 static int smbc_rmdir_ctx(SMBCCTX *context, const char *fname)
2489 {
2490 SMBCSRV *srv;
2491 fstring server, share, user, password, workgroup;
2492 pstring path;
2493
2494 if (!context || !context->internal ||
2495 !context->internal->_initialized) {
2496
2497 errno = EINVAL;
2498 return -1;
2499
2500 }
2501
2502 if (!fname) {
2503
2504 errno = EINVAL;
2505 return -1;
2506
2507 }
2508
2509 DEBUG(4, ("smbc_rmdir(%s)\n", fname));
2510
2511 if (smbc_parse_path(context, fname,
2512 server, sizeof(server),
2513 share, sizeof(share),
2514 path, sizeof(path),
2515 user, sizeof(user),
2516 password, sizeof(password),
2517 NULL, 0))
2518 {
2519 errno = EINVAL;
2520 return -1;
2521 }
2522
2523 if (user[0] == (char)0) fstrcpy(user, context->user);
2524
2525 fstrcpy(workgroup, context->workgroup);
2526
2527 srv = smbc_server(context, server, share, workgroup, user, password);
2528
2529 if (!srv) {
2530
2531 return -1; /* errno set by smbc_server */
2532
2533 }
2534
2535 /* if (strncmp(srv->cli.dev, "IPC", 3) == 0) {
2536
2537 mode = aDIR | aRONLY;
2538
2539 }
2540 else if (strncmp(srv->cli.dev, "LPT", 3) == 0) {
2541
2542 if (strcmp(path, "\\") == 0) {
2543
2544 mode = aDIR | aRONLY;
2545
2546 }
2547 else {
2548
2549 mode = aRONLY;
2550 smbc_stat_printjob(srv, path, &size, &m_time);
2551 c_time = a_time = m_time;
2552
2553 }
2554 else { */
2555
2556 if (!cli_rmdir(&srv->cli, path)) {
2557
2558 errno = smbc_errno(context, &srv->cli);
2559
2560 if (errno == EACCES) { /* Check if the dir empty or not */
2561
2562 pstring lpath; /* Local storage to avoid buffer overflows */
2563
2564 smbc_rmdir_dirempty = True; /* Make this so ... */
2565
2566 pstrcpy(lpath, path);
2567 pstrcat(lpath, "\\*");
2568
2569 if (cli_list(&srv->cli, lpath, aDIR | aSYSTEM | aHIDDEN, rmdir_list_fn,
2570 NULL) < 0) {
2571
2572 /* Fix errno to ignore latest error ... */
2573
2574 DEBUG(5, ("smbc_rmdir: cli_list returned an error: %d\n",
2575 smbc_errno(context, &srv->cli)));
2576 errno = EACCES;
2577
2578 }
2579
2580 if (smbc_rmdir_dirempty)
2581 errno = EACCES;
2582 else
2583 errno = ENOTEMPTY;
2584
2585 }
2586
2587 return -1;
2588
2589 }
2590
2591 return 0;
2592
2593 }
2594
2595 /*
2596 * Routine to return the current directory position
2597 */
2598
2599 static off_t smbc_telldir_ctx(SMBCCTX *context, SMBCFILE *dir)
2600 {
2601 off_t ret_val; /* Squash warnings about cast */
2602
2603 if (!context || !context->internal ||
2604 !context->internal->_initialized) {
2605
2606 errno = EINVAL;
2607 return -1;
2608
2609 }
2610
2611 if (!dir || !DLIST_CONTAINS(context->internal->_files, dir)) {
2612
2613 errno = EBADF;
2614 return -1;
2615
2616 }
2617
2618 if (dir->file != False) { /* FIXME, should be dir, perhaps */
2619
2620 errno = ENOTDIR;
2621 return -1;
2622
2623 }
2624
2625 /*
2626 * We return the pointer here as the offset
2627 */
2628 ret_val = (int)dir->dir_next;
2629 return ret_val;
2630
2631 }
2632
2633 /*
2634 * A routine to run down the list and see if the entry is OK
2635 */
2636
2637 struct smbc_dir_list *smbc_check_dir_ent(struct smbc_dir_list *list,
2638 struct smbc_dirent *dirent)
2639 {
2640
2641 /* Run down the list looking for what we want */
2642
2643 if (dirent) {
2644
2645 struct smbc_dir_list *tmp = list;
2646
2647 while (tmp) {
2648
2649 if (tmp->dirent == dirent)
2650 return tmp;
2651
2652 tmp = tmp->next;
2653
2654 }
2655
2656 }
2657
2658 return NULL; /* Not found, or an error */
2659
2660 }
2661
2662
2663 /*
2664 * Routine to seek on a directory
2665 */
2666
2667 static int smbc_lseekdir_ctx(SMBCCTX *context, SMBCFILE *dir, off_t offset)
2668 {
2669 long int l_offset = offset; /* Handle problems of size */
2670 struct smbc_dirent *dirent = (struct smbc_dirent *)l_offset;
2671 struct smbc_dir_list *list_ent = (struct smbc_dir_list *)NULL;
2672
2673 if (!context || !context->internal ||
2674 !context->internal->_initialized) {
2675
2676 errno = EINVAL;
2677 return -1;
2678
2679 }
2680
2681 if (dir->file != False) { /* FIXME, should be dir, perhaps */
2682
2683 errno = ENOTDIR;
2684 return -1;
2685
2686 }
2687
2688 /* Now, check what we were passed and see if it is OK ... */
2689
2690 if (dirent == NULL) { /* Seek to the begining of the list */
2691
2692 dir->dir_next = dir->dir_list;
2693 return 0;
2694
2695 }
2696
2697 /* Now, run down the list and make sure that the entry is OK */
2698 /* This may need to be changed if we change the format of the list */
2699
2700 if ((list_ent = smbc_check_dir_ent(dir->dir_list, dirent)) == NULL) {
2701
2702 errno = EINVAL; /* Bad entry */
2703 return -1;
2704
2705 }
2706
2707 dir->dir_next = list_ent;
2708
2709 return 0;
2710
2711 }
2712
2713 /*
2714 * Routine to fstat a dir
2715 */
2716
2717 static int smbc_fstatdir_ctx(SMBCCTX *context, SMBCFILE *dir, struct stat *st)
2718 {
2719
2720 if (!context || !context->internal ||
2721 !context->internal->_initialized) {
2722
2723 errno = EINVAL;
2724 return -1;
2725
2726 }
2727
2728 /* No code yet ... */
2729
2730 return 0;
2731
2732 }
2733
2734 int smbc_chmod_ctx(SMBCCTX *context, const char *fname, mode_t newmode)
2735 {
2736 SMBCSRV *srv;
2737 fstring server, share, user, password, workgroup;
2738 pstring path;
2739 uint16 mode;
2740
2741 if (!context || !context->internal ||
2742 !context->internal->_initialized) {
2743
2744 errno = EINVAL; /* Best I can think of ... */
2745 return -1;
2746
2747 }
2748
2749 if (!fname) {
2750
2751 errno = EINVAL;
2752 return -1;
2753
2754 }
2755
2756 DEBUG(4, ("smbc_chmod(%s, 0%3o)\n", fname, newmode));
2757
2758 if (smbc_parse_path(context, fname,
2759 server, sizeof(server),
2760 share, sizeof(share),
2761 path, sizeof(path),
2762 user, sizeof(user),
2763 password, sizeof(password),
2764 NULL, 0)) {
2765 errno = EINVAL;
2766 return -1;
2767 }
2768
2769 if (user[0] == (char)0) fstrcpy(user, context->user);
2770
2771 fstrcpy(workgroup, context->workgroup);
2772
2773 srv = smbc_server(context, server, share, workgroup, user, password);
2774
2775 if (!srv) {
2776 return -1; /* errno set by smbc_server */
2777 }
2778
2779 mode = 0;
2780
2781 if (!(newmode & (S_IWUSR | S_IWGRP | S_IWOTH))) mode |= aRONLY;
2782 if ((newmode & S_IXUSR) && lp_map_archive(-1)) mode |= aARCH;
2783 if ((newmode & S_IXGRP) && lp_map_system(-1)) mode |= aSYSTEM;
2784 if ((newmode & S_IXOTH) && lp_map_hidden(-1)) mode |= aHIDDEN;
2785
2786 if (!cli_setatr(&srv->cli, path, mode, 0)) {
2787 errno = smbc_errno(context, &srv->cli);
2788 return -1;
2789 }
2790
2791 return 0;
2792 }
2793
2794 int smbc_utimes_ctx(SMBCCTX *context, const char *fname, struct timeval *tbuf)
2795 {
2796 SMBCSRV *srv;
2797 fstring server, share, user, password, workgroup;
2798 pstring path;
2799 uint16 mode;
2800 time_t t = (tbuf == NULL ? time(NULL) : tbuf->tv_sec);
2801
2802 if (!context || !context->internal ||
2803 !context->internal->_initialized) {
2804
2805 errno = EINVAL; /* Best I can think of ... */
2806 return -1;
2807
2808 }
2809
2810 if (!fname) {
2811
2812 errno = EINVAL;
2813 return -1;
2814
2815 }
2816
2817 DEBUG(4, ("smbc_utimes(%s, [%s])\n", fname, ctime(&t)));
2818
2819 if (smbc_parse_path(context, fname,
2820 server, sizeof(server),
2821 share, sizeof(share),
2822 path, sizeof(path),
2823 user, sizeof(user),
2824 password, sizeof(password),
2825 NULL, 0)) {
2826 errno = EINVAL;
2827 return -1;
2828 }
2829
2830 if (user[0] == (char)0) fstrcpy(user, context->user);
2831
2832 fstrcpy(workgroup, context->workgroup);
2833
2834 srv = smbc_server(context, server, share, workgroup, user, password);
2835
2836 if (!srv) {
2837 return -1; /* errno set by smbc_server */
2838 }
2839
2840 if (!smbc_getatr(context, srv, path,
2841 &mode, NULL,
2842 NULL, NULL, NULL,
2843 NULL)) {
2844 return -1;
2845 }
2846
2847 if (!cli_setatr(&srv->cli, path, mode, t)) {
2848 /* some servers always refuse directory changes */
2849 if (!(mode & aDIR)) {
2850 errno = smbc_errno(context, &srv->cli);
2851 return -1;
2852 }
2853 }
2854
2855 return 0;
2856 }
2857
2858
2859 /* The MSDN is contradictory over the ordering of ACE entries in an ACL.
2860 However NT4 gives a "The information may have been modified by a
2861 computer running Windows NT 5.0" if denied ACEs do not appear before
2862 allowed ACEs. */
2863
2864 static int ace_compare(SEC_ACE *ace1, SEC_ACE *ace2)
2865 {
2866 if (sec_ace_equal(ace1, ace2))
2867 return 0;
2868
2869 if (ace1->type != ace2->type)
2870 return ace2->type - ace1->type;
2871
2872 if (sid_compare(&ace1->trustee, &ace2->trustee))
2873 return sid_compare(&ace1->trustee, &ace2->trustee);
2874
2875 if (ace1->flags != ace2->flags)
2876 return ace1->flags - ace2->flags;
2877
2878 if (ace1->info.mask != ace2->info.mask)
2879 return ace1->info.mask - ace2->info.mask;
2880
2881 if (ace1->size != ace2->size)
2882 return ace1->size - ace2->size;
2883
2884 return memcmp(ace1, ace2, sizeof(SEC_ACE));
2885 }
2886
2887
2888 static void sort_acl(SEC_ACL *the_acl)
2889 {
2890 uint32 i;
2891 if (!the_acl) return;
2892
2893 qsort(the_acl->ace, the_acl->num_aces, sizeof(the_acl->ace[0]), QSORT_CAST ace_compare);
2894
2895 for (i=1;i<the_acl->num_aces;) {
2896 if (sec_ace_equal(&the_acl->ace[i-1], &the_acl->ace[i])) {
2897 int j;
2898 for (j=i; j<the_acl->num_aces-1; j++) {
2899 the_acl->ace[j] = the_acl->ace[j+1];
2900 }
2901 the_acl->num_aces--;
2902 } else {
2903 i++;
2904 }
2905 }
2906 }
2907
2908 /* convert a SID to a string, either numeric or username/group */
2909 static void convert_sid_to_string(struct cli_state *ipc_cli,
2910 POLICY_HND *pol,
2911 fstring str,
2912 BOOL numeric,
2913 DOM_SID *sid)
2914 {
2915 char **domains = NULL;
2916 char **names = NULL;
2917 uint32 *types = NULL;
2918
2919 sid_to_string(str, sid);
2920
2921 if (numeric) return; /* no lookup desired */
2922
2923 /* Ask LSA to convert the sid to a name */
2924
2925 if (!NT_STATUS_IS_OK(cli_lsa_lookup_sids(ipc_cli, ipc_cli->mem_ctx,
2926 pol, 1, sid, &domains,
2927 &names, &types)) ||
2928 !domains || !domains[0] || !names || !names[0]) {
2929 return;
2930 }
2931
2932 /* Converted OK */
2933
2934 slprintf(str, sizeof(fstring) - 1, "%s%s%s",
2935 domains[0], lp_winbind_separator(),
2936 names[0]);
2937 }
2938
2939 /* convert a string to a SID, either numeric or username/group */
2940 static BOOL convert_string_to_sid(struct cli_state *ipc_cli,
2941 POLICY_HND *pol,
2942 BOOL numeric,
2943 DOM_SID *sid,
2944 const char *str)
2945 {
2946 uint32 *types = NULL;
2947 DOM_SID *sids = NULL;
2948 BOOL result = True;
2949
2950 if (numeric) {
2951 if (strncmp(str, "S-", 2) == 0) {
2952 return string_to_sid(sid, str);
2953 }
2954
2955 result = False;
2956 goto done;
2957 }
2958
2959 if (!NT_STATUS_IS_OK(cli_lsa_lookup_names(ipc_cli, ipc_cli->mem_ctx,
2960 pol, 1, &str, &sids,
2961 &types))) {
2962 result = False;
2963 goto done;
2964 }
2965
2966 sid_copy(sid, &sids[0]);
2967 done:
2968
2969 return result;
2970 }
2971
2972
2973 /* parse an ACE in the same format as print_ace() */
2974 static BOOL parse_ace(struct cli_state *ipc_cli,
2975 POLICY_HND *pol,
2976 SEC_ACE *ace,
2977 BOOL numeric,
2978 char *str)
2979 {
2980 char *p;
2981 const char *cp;
2982 fstring tok;
2983 unsigned atype, aflags, amask;
2984 DOM_SID sid;
2985 SEC_ACCESS mask;
2986 const struct perm_value *v;
2987 struct perm_value {
2988 const char *perm;
2989 uint32 mask;
2990 };
2991
2992 /* These values discovered by inspection */
2993 static const struct perm_value special_values[] = {
2994 { "R", 0x00120089 },
2995 { "W", 0x00120116 },
2996 { "X", 0x001200a0 },
2997 { "D", 0x00010000 },
2998 { "P", 0x00040000 },
2999 { "O", 0x00080000 },
3000 { NULL, 0 },
3001 };
3002
3003 static const struct perm_value standard_values[] = {
3004 { "READ", 0x001200a9 },
3005 { "CHANGE", 0x001301bf },
3006 { "FULL", 0x001f01ff },
3007 { NULL, 0 },
3008 };
3009
3010
3011 ZERO_STRUCTP(ace);
3012 p = strchr_m(str,':');
3013 if (!p) return False;
3014 *p = '\0';
3015 p++;
3016 /* Try to parse numeric form */
3017
3018 if (sscanf(p, "%i/%i/%i", &atype, &aflags, &amask) == 3 &&
3019 convert_string_to_sid(ipc_cli, pol, numeric, &sid, str)) {
3020 goto done;
3021 }
3022
3023 /* Try to parse text form */
3024
3025 if (!convert_string_to_sid(ipc_cli, pol, numeric, &sid, str)) {
3026 return False;
3027 }
3028
3029 cp = p;
3030 if (!next_token(&cp, tok, "/", sizeof(fstring))) {
3031 return False;
3032 }
3033
3034 if (StrnCaseCmp(tok, "ALLOWED", strlen("ALLOWED")) == 0) {
3035 atype = SEC_ACE_TYPE_ACCESS_ALLOWED;
3036 } else if (StrnCaseCmp(tok, "DENIED", strlen("DENIED")) == 0) {
3037 atype = SEC_ACE_TYPE_ACCESS_DENIED;
3038 } else {
3039 return False;
3040 }
3041
3042 /* Only numeric form accepted for flags at present */
3043
3044 if (!(next_token(&cp, tok, "/", sizeof(fstring)) &&
3045 sscanf(tok, "%i", &aflags))) {
3046 return False;
3047 }
3048
3049 if (!next_token(&cp, tok, "/", sizeof(fstring))) {
3050 return False;
3051 }
3052
3053 if (strncmp(tok, "0x", 2) == 0) {
3054 if (sscanf(tok, "%i", &amask) != 1) {
3055 return False;
3056 }
3057 goto done;
3058 }
3059
3060 for (v = standard_values; v->perm; v++) {
3061 if (strcmp(tok, v->perm) == 0) {
3062 amask = v->mask;
3063 goto done;
3064 }
3065 }
3066
3067 p = tok;
3068
3069 while(*p) {
3070 BOOL found = False;
3071
3072 for (v = special_values; v->perm; v++) {
3073 if (v->perm[0] == *p) {
3074 amask |= v->mask;
3075 found = True;
3076 }
3077 }
3078
3079 if (!found) return False;
3080 p++;
3081 }
3082
3083 if (*p) {
3084 return False;
3085 }
3086
3087 done:
3088 mask.mask = amask;
3089 init_sec_ace(ace, &sid, atype, mask, aflags);
3090 return True;
3091 }
3092
3093 /* add an ACE to a list of ACEs in a SEC_ACL */
3094 static BOOL add_ace(SEC_ACL **the_acl, SEC_ACE *ace, TALLOC_CTX *ctx)
3095 {
3096 SEC_ACL *new;
3097 SEC_ACE *aces;
3098 if (! *the_acl) {
3099 (*the_acl) = make_sec_acl(ctx, 3, 1, ace);
3100 return True;
3101 }
3102
3103 aces = calloc(1+(*the_acl)->num_aces,sizeof(SEC_ACE));
3104 memcpy(aces, (*the_acl)->ace, (*the_acl)->num_aces * sizeof(SEC_ACE));
3105 memcpy(aces+(*the_acl)->num_aces, ace, sizeof(SEC_ACE));
3106 new = make_sec_acl(ctx,(*the_acl)->revision,1+(*the_acl)->num_aces, aces);
3107 SAFE_FREE(aces);
3108 (*the_acl) = new;
3109 return True;
3110 }
3111
3112
3113 /* parse a ascii version of a security descriptor */
3114 static SEC_DESC *sec_desc_parse(TALLOC_CTX *ctx,
3115 struct cli_state *ipc_cli,
3116 POLICY_HND *pol,
3117 BOOL numeric,
3118 char *str)
3119 {
3120 const char *p = str;
3121 fstring tok;
3122 SEC_DESC *ret;
3123 size_t sd_size;
3124 DOM_SID *grp_sid=NULL, *owner_sid=NULL;
3125 SEC_ACL *dacl=NULL;
3126 int revision=1;
3127
3128 while (next_token(&p, tok, "\t,\r\n", sizeof(tok))) {
3129
3130 if (StrnCaseCmp(tok,"REVISION:", 9) == 0) {
3131 revision = strtol(tok+9, NULL, 16);
3132 continue;
3133 }
3134
3135 if (StrnCaseCmp(tok,"OWNER:", 6) == 0) {
3136 owner_sid = (DOM_SID *)calloc(1, sizeof(DOM_SID));
3137 if (!owner_sid ||
3138 !convert_string_to_sid(ipc_cli, pol,
3139 numeric,
3140 owner_sid, tok+6)) {
3141 DEBUG(5, ("Failed to parse owner sid\n"));
3142 return NULL;
3143 }
3144 continue;
3145 }
3146
3147 if (StrnCaseCmp(tok,"OWNER+:", 7) == 0) {
3148 owner_sid = (DOM_SID *)calloc(1, sizeof(DOM_SID));
3149 if (!owner_sid ||
3150 !convert_string_to_sid(ipc_cli, pol,
3151 False,
3152 owner_sid, tok+7)) {
3153 DEBUG(5, ("Failed to parse owner sid\n"));
3154 return NULL;
3155 }
3156 continue;
3157 }
3158
3159 if (StrnCaseCmp(tok,"GROUP:", 6) == 0) {
3160 grp_sid = (DOM_SID *)calloc(1, sizeof(DOM_SID));
3161 if (!grp_sid ||
3162 !convert_string_to_sid(ipc_cli, pol,
3163 numeric,
3164 grp_sid, tok+6)) {
3165 DEBUG(5, ("Failed to parse group sid\n"));
3166 return NULL;
3167 }
3168 continue;
3169 }
3170
3171 if (StrnCaseCmp(tok,"GROUP+:", 7) == 0) {
3172 grp_sid = (DOM_SID *)calloc(1, sizeof(DOM_SID));
3173 if (!grp_sid ||
3174 !convert_string_to_sid(ipc_cli, pol,
3175 False,
3176 grp_sid, tok+6)) {
3177 DEBUG(5, ("Failed to parse group sid\n"));
3178 return NULL;
3179 }
3180 continue;
3181 }
3182
3183 if (StrnCaseCmp(tok,"ACL:", 4) == 0) {
3184 SEC_ACE ace;
3185 if (!parse_ace(ipc_cli, pol, &ace, numeric, tok+4)) {
3186 DEBUG(5, ("Failed to parse ACL %s\n", tok));
3187 return NULL;
3188 }
3189 if(!add_ace(&dacl, &ace, ctx)) {
3190 DEBUG(5, ("Failed to add ACL %s\n", tok));
3191 return NULL;
3192 }
3193 continue;
3194 }
3195
3196 if (StrnCaseCmp(tok,"ACL+:", 5) == 0) {
3197 SEC_ACE ace;
3198 if (!parse_ace(ipc_cli, pol, &ace, False, tok+5)) {
3199 DEBUG(5, ("Failed to parse ACL %s\n", tok));
3200 return NULL;
3201 }
3202 if(!add_ace(&dacl, &ace, ctx)) {
3203 DEBUG(5, ("Failed to add ACL %s\n", tok));
3204 return NULL;
3205 }
3206 continue;
3207 }
3208
3209 DEBUG(5, ("Failed to parse security descriptor\n"));
3210 return NULL;
3211 }
3212
3213 ret = make_sec_desc(ctx, revision, SEC_DESC_SELF_RELATIVE,
3214 owner_sid, grp_sid, NULL, dacl, &sd_size);
3215
3216 SAFE_FREE(grp_sid);
3217 SAFE_FREE(owner_sid);
3218
3219 return ret;
3220 }
3221
3222
3223 /*****************************************************
3224 retrieve the acls for a file
3225 *******************************************************/
3226 static int cacl_get(TALLOC_CTX *ctx, struct cli_state *cli,
3227 struct cli_state *ipc_cli, POLICY_HND *pol,
3228 char *filename, char *name, char *buf, int bufsize)
3229 {
3230 uint32 i;
3231 int n = 0;
3232 int n_used;
3233 BOOL all;
3234 BOOL numeric = True;
3235 BOOL determine_size = (bufsize == 0);
3236 int fnum = -1;
3237 SEC_DESC *sd;
3238 fstring sidstr;
3239 char *p;
3240
3241 fnum = cli_nt_create(cli, filename, CREATE_ACCESS_READ);
3242
3243 if (fnum == -1) {
3244 DEBUG(5, ("cacl_get failed to open %s: %s\n",
3245 filename, cli_errstr(cli)));
3246 errno = 0;
3247 return -1;
3248 }
3249
3250 sd = cli_query_secdesc(cli, fnum, ctx);
3251
3252 if (!sd) {
3253 DEBUG(5, ("cacl_get Failed to query old descriptor\n"));
3254 errno = 0;
3255 return -1;
3256 }
3257
3258 cli_close(cli, fnum);
3259
3260 all = (*name == '*');
3261 numeric = (* (name + strlen(name) - 1) != '+');
3262
3263 n_used = 0;
3264
3265 if (all) {
3266 if (determine_size) {
3267 p = talloc_asprintf(ctx,
3268 "REVISION:%d", sd->revision);
3269 if (!p) {
3270 errno = ENOMEM;
3271 return -1;
3272 }
3273 n = strlen(p);
3274 } else {
3275 n = snprintf(buf, bufsize,
3276 "REVISION:%d", sd->revision);
3277 }
3278 } else if (StrCaseCmp(name, "revision") == 0) {
3279 if (determine_size) {
3280 p = talloc_asprintf(ctx, "%d", sd->revision);
3281 if (!p) {
3282 errno = ENOMEM;
3283 return -1;
3284 }
3285 n = strlen(p);
3286 } else {
3287 n = snprintf(buf, bufsize, "%d", sd->revision);
3288 }
3289 }
3290
3291 if (!determine_size && n > bufsize) {
3292 errno = ERANGE;
3293 return -1;
3294 }
3295 buf += n;
3296 n_used += n;
3297 bufsize -= n;
3298
3299 /* Get owner and group sid */
3300
3301 if (sd->owner_sid) {
3302 convert_sid_to_string(ipc_cli, pol,
3303 sidstr, numeric, sd->owner_sid);
3304 } else {
3305 fstrcpy(sidstr, "");
3306 }
3307
3308 if (all) {
3309 if (determine_size) {
3310 p = talloc_asprintf(ctx, ",OWNER:%s", sidstr);
3311 if (!p) {
3312 errno = ENOMEM;
3313 return -1;
3314 }
3315 n = strlen(p);
3316 } else {
3317 n = snprintf(buf, bufsize, ",OWNER:%s", sidstr);
3318 }
3319 } else if (StrnCaseCmp(name, "owner", 5) == 0) {
3320 if (determine_size) {
3321 p = talloc_asprintf(ctx, "%s", sidstr);
3322 if (!p) {
3323 errno = ENOMEM;
3324 return -1;
3325 }
3326 n = strlen(p);
3327 } else {
3328 n = snprintf(buf, bufsize, "%s", sidstr);
3329 }
3330 }
3331
3332 if (!determine_size && n > bufsize) {
3333 errno = ERANGE;
3334 return -1;
3335 }
3336 buf += n;
3337 n_used += n;
3338 bufsize -= n;
3339
3340 if (sd->grp_sid) {
3341 convert_sid_to_string(ipc_cli, pol,
3342 sidstr, numeric, sd->grp_sid);
3343 } else {
3344 fstrcpy(sidstr, "");
3345 }
3346
3347 if (all) {
3348 if (determine_size) {
3349 p = talloc_asprintf(ctx, ",GROUP:%s", sidstr);
3350 if (!p) {
3351 errno = ENOMEM;
3352 return -1;
3353 }
3354 n = strlen(p);
3355 } else {
3356 n = snprintf(buf, bufsize, ",GROUP:%s", sidstr);
3357 }
3358 } else if (StrnCaseCmp(name, "group", 5) == 0) {
3359 if (determine_size) {
3360 p = talloc_asprintf(ctx, "%s", sidstr);
3361 if (!p) {
3362 errno = ENOMEM;
3363 return -1;
3364 }
3365 n = strlen(p);
3366 } else {
3367 n = snprintf(buf, bufsize, "%s", sidstr);
3368 }
3369 }
3370
3371 if (!determine_size && n > bufsize) {
3372 errno = ERANGE;
3373 return -1;
3374 }
3375 buf += n;
3376 n_used += n;
3377 bufsize -= n;
3378
3379 /* Add aces to value buffer */
3380 for (i = 0; sd->dacl && i < sd->dacl->num_aces; i++) {
3381
3382 SEC_ACE *ace = &sd->dacl->ace[i];
3383 convert_sid_to_string(ipc_cli, pol,
3384 sidstr, numeric, &ace->trustee);
3385
3386 if (all) {
3387 if (determine_size) {
3388 p = talloc_asprintf(ctx,
3389 ",ACL:%s:%d/%d/0x%08x",
3390 sidstr,
3391 ace->type,
3392 ace->flags,
3393 ace->info.mask);
3394 if (!p) {
3395 errno = ENOMEM;
3396 return -1;
3397 }
3398 n = strlen(p);
3399 } else {
3400 n = snprintf(buf, bufsize,
3401 ",ACL:%s:%d/%d/0x%08x",
3402 sidstr,
3403 ace->type,
3404 ace->flags,
3405 ace->info.mask);
3406 }
3407 } else if ((StrnCaseCmp(name, "acl", 3) == 0 &&
3408 StrCaseCmp(name + 3, sidstr) == 0) ||
3409 (StrnCaseCmp(name, "acl+", 4) == 0 &&
3410 StrCaseCmp(name + 4, sidstr) == 0)) {
3411 if (determine_size) {
3412 p = talloc_asprintf(ctx,
3413 "%d/%d/0x%08x",
3414 ace->type,
3415 ace->flags,
3416 ace->info.mask);
3417 if (!p) {
3418 errno = ENOMEM;
3419 return -1;
3420 }
3421 n = strlen(p);
3422 } else {
3423 n = snprintf(buf, bufsize,
3424 "%d/%d/0x%08x",
3425 ace->type, ace->flags, ace->info.mask);
3426 }
3427 }
3428 if (n > bufsize) {
3429 errno = ERANGE;
3430 return -1;
3431 }
3432 buf += n;
3433 n_used += n;
3434 bufsize -= n;
3435 }
3436
3437 if (n_used == 0) {
3438 errno = ENOATTR;
3439 return -1;
3440 }
3441 return n_used;
3442 }
3443
3444
3445 /*****************************************************
3446 set the ACLs on a file given an ascii description
3447 *******************************************************/
3448 static int cacl_set(TALLOC_CTX *ctx, struct cli_state *cli,
3449 struct cli_state *ipc_cli, POLICY_HND *pol,
3450 const char *filename, const char *the_acl,
3451 int mode, int flags)
3452 {
3453 int fnum;
3454 int err = 0;
3455 SEC_DESC *sd = NULL, *old;
3456 SEC_ACL *dacl = NULL;
3457 DOM_SID *owner_sid = NULL;
3458 DOM_SID *grp_sid = NULL;
3459 uint32 i, j;
3460 size_t sd_size;
3461 int ret = 0;
3462 char *p;
3463 BOOL numeric = True;
3464
3465 /* the_acl will be null for REMOVE_ALL operations */
3466 if (the_acl) {
3467 numeric = ((p = strchr(the_acl, ':')) != NULL &&
3468 p > the_acl &&
3469 p[-1] != '+');
3470
3471 /* if this is to set the entire ACL... */
3472 if (*the_acl == '*') {
3473 /* ... then increment past the first colon */
3474 the_acl = p + 1;
3475 }
3476
3477 sd = sec_desc_parse(ctx, ipc_cli, pol,
3478 numeric, (char *) the_acl);
3479
3480 if (!sd) {
3481 errno = EINVAL;
3482 return -1;
3483 }
3484 }
3485
3486 /* The desired access below is the only one I could find that works
3487 with NT4, W2KP and Samba */
3488
3489 fnum = cli_nt_create(cli, filename, CREATE_ACCESS_READ);
3490
3491 if (fnum == -1) {
3492 DEBUG(5, ("cacl_set failed to open %s: %s\n",
3493 filename, cli_errstr(cli)));
3494 errno = 0;
3495 return -1;
3496 }
3497
3498 old = cli_query_secdesc(cli, fnum, ctx);
3499
3500 if (!old) {
3501 DEBUG(5, ("cacl_set Failed to query old descriptor\n"));
3502 errno = 0;
3503 return -1;
3504 }
3505
3506 cli_close(cli, fnum);
3507
3508 switch (mode) {
3509 case SMBC_XATTR_MODE_REMOVE_ALL:
3510 old->dacl->num_aces = 0;
3511 SAFE_FREE(old->dacl->ace);
3512 SAFE_FREE(old->dacl);
3513 old->off_dacl = 0;
3514 dacl = old->dacl;
3515 break;
3516
3517 case SMBC_XATTR_MODE_REMOVE:
3518 for (i=0;sd->dacl && i<sd->dacl->num_aces;i++) {
3519 BOOL found = False;
3520
3521 for (j=0;old->dacl && j<old->dacl->num_aces;j++) {
3522 if (sec_ace_equal(&sd->dacl->ace[i],
3523 &old->dacl->ace[j])) {
3524 uint32 k;
3525 for (k=j; k<old->dacl->num_aces-1;k++) {
3526 old->dacl->ace[k] = old->dacl->ace[k+1];
3527 }
3528 old->dacl->num_aces--;
3529 if (old->dacl->num_aces == 0) {
3530 SAFE_FREE(old->dacl->ace);
3531 SAFE_FREE(old->dacl);
3532 old->off_dacl = 0;
3533 }
3534 found = True;
3535 dacl = old->dacl;
3536 break;
3537 }
3538 }
3539
3540 if (!found) {
3541 err = ENOATTR;
3542 ret = -1;
3543 goto failed;
3544 }
3545 }
3546 break;
3547
3548 case SMBC_XATTR_MODE_ADD:
3549 for (i=0;sd->dacl && i<sd->dacl->num_aces;i++) {
3550 BOOL found = False;
3551
3552 for (j=0;old->dacl && j<old->dacl->num_aces;j++) {
3553 if (sid_equal(&sd->dacl->ace[i].trustee,
3554 &old->dacl->ace[j].trustee)) {
3555 if (!(flags & SMBC_XATTR_FLAG_CREATE)) {
3556 err = EEXIST;
3557 ret = -1;
3558 goto failed;
3559 }
3560 old->dacl->ace[j] = sd->dacl->ace[i];
3561 ret = -1;
3562 found = True;
3563 }
3564 }
3565
3566 if (!found && (flags & SMBC_XATTR_FLAG_REPLACE)) {
3567 err = ENOATTR;
3568 ret = -1;
3569 goto failed;
3570 }
3571
3572 for (i=0;sd->dacl && i<sd->dacl->num_aces;i++) {
3573 add_ace(&old->dacl, &sd->dacl->ace[i], ctx);
3574 }
3575 }
3576 dacl = old->dacl;
3577 break;
3578
3579 case SMBC_XATTR_MODE_SET:
3580 old = sd;
3581 owner_sid = old->owner_sid;
3582 grp_sid = old->grp_sid;
3583 dacl = old->dacl;
3584 break;
3585
3586 case SMBC_XATTR_MODE_CHOWN:
3587 owner_sid = sd->owner_sid;
3588 break;
3589
3590 case SMBC_XATTR_MODE_CHGRP:
3591 grp_sid = sd->grp_sid;
3592 break;
3593 }
3594
3595 /* Denied ACE entries must come before allowed ones */
3596 sort_acl(old->dacl);
3597
3598 /* Create new security descriptor and set it */
3599 sd = make_sec_desc(ctx, old->revision, SEC_DESC_SELF_RELATIVE,
3600 owner_sid, grp_sid, NULL, dacl, &sd_size);
3601
3602 fnum = cli_nt_create(cli, filename,
3603 WRITE_DAC_ACCESS | WRITE_OWNER_ACCESS);
3604
3605 if (fnum == -1) {
3606 DEBUG(5, ("cacl_set failed to open %s: %s\n",
3607 filename, cli_errstr(cli)));
3608 errno = 0;
3609 return -1;
3610 }
3611
3612 if (!cli_set_secdesc(cli, fnum, sd)) {
3613 DEBUG(5, ("ERROR: secdesc set failed: %s\n", cli_errstr(cli)));
3614 ret = -1;
3615 }
3616
3617 /* Clean up */
3618
3619 failed:
3620 cli_close(cli, fnum);
3621
3622 if (err != 0) {
3623 errno = err;
3624 }
3625
3626 return ret;
3627 }
3628
3629
3630 int smbc_setxattr_ctx(SMBCCTX *context,
3631 const char *fname,
3632 const char *name,
3633 const void *value,
3634 size_t size,
3635 int flags)
3636 {
3637 int ret;
3638 SMBCSRV *srv;
3639 SMBCSRV *ipc_srv;
3640 fstring server, share, user, password, workgroup;
3641 pstring path;
3642 TALLOC_CTX *ctx;
3643 POLICY_HND pol;
3644
3645 if (!context || !context->internal ||
3646 !context->internal->_initialized) {
3647
3648 errno = EINVAL; /* Best I can think of ... */
3649 return -1;
3650
3651 }
3652
3653 if (!fname) {
3654
3655 errno = EINVAL;
3656 return -1;
3657
3658 }
3659
3660 DEBUG(4, ("smbc_setxattr(%s, %s, %.*s)\n",
3661 fname, name, (int) size, (char *) value));
3662
3663 if (smbc_parse_path(context, fname,
3664 server, sizeof(server),
3665 share, sizeof(share),
3666 path, sizeof(path),
3667 user, sizeof(user),
3668 password, sizeof(password),
3669 NULL, 0)) {
3670 errno = EINVAL;
3671 return -1;
3672 }
3673
3674 if (user[0] == (char)0) fstrcpy(user, context->user);
3675
3676 fstrcpy(workgroup, context->workgroup);
3677
3678 srv = smbc_server(context, server, share, workgroup, user, password);
3679 if (!srv) {
3680 return -1; /* errno set by smbc_server */
3681 }
3682
3683 ipc_srv = smbc_attr_server(context, server, share,
3684 workgroup, user, password,
3685 &pol);
3686 if (!ipc_srv) {
3687 return -1;
3688 }
3689
3690 ctx = talloc_init("smbc_setxattr");
3691 if (!ctx) {
3692 errno = ENOMEM;
3693 return -1;
3694 }
3695
3696 /*
3697 * Are they asking to set an access control element or to set
3698 * the entire access control list?
3699 */
3700 if (StrCaseCmp(name, "system.nt_sec_desc.*") == 0 ||
3701 StrCaseCmp(name, "system.nt_sec_desc.*+") == 0 ||
3702 StrCaseCmp(name, "system.nt_sec_desc.revision") == 0 ||
3703 StrnCaseCmp(name, "system.nt_sec_desc.acl", 22) == 0 ||
3704 StrnCaseCmp(name, "system.nt_sec_desc.acl+", 23) == 0) {
3705
3706 /* Yup. */
3707 char *namevalue =
3708 talloc_asprintf(ctx, "%s:%s", name+19, (char *) value);
3709 if (! namevalue) {
3710 errno = ENOMEM;
3711 ret = -1;
3712 } else {
3713 ret = cacl_set(ctx, &srv->cli,
3714 &ipc_srv->cli, &pol, path,
3715 namevalue,
3716 (*namevalue == '*'
3717 ? SMBC_XATTR_MODE_SET
3718 : SMBC_XATTR_MODE_ADD),
3719 flags);
3720 }
3721 talloc_destroy(ctx);
3722 return ret;
3723 }
3724
3725 /*
3726 * Are they asking to set the owner?
3727 */
3728 if (StrCaseCmp(name, "system.nt_sec_desc.owner") == 0 ||
3729 StrCaseCmp(name, "system.nt_sec_desc.owner+") == 0) {
3730
3731 /* Yup. */
3732 char *namevalue =
3733 talloc_asprintf(ctx, "%s:%s", name+19, (char *) value);
3734 if (! namevalue) {
3735 errno = ENOMEM;
3736 ret = -1;
3737 } else {
3738 ret = cacl_set(ctx, &srv->cli,
3739 &ipc_srv->cli, &pol, path,
3740 namevalue, SMBC_XATTR_MODE_CHOWN, 0);
3741 }
3742 talloc_destroy(ctx);
3743 return ret;
3744 }
3745
3746 /*
3747 * Are they asking to set the group?
3748 */
3749 if (StrCaseCmp(name, "system.nt_sec_desc.group") == 0 ||
3750 StrCaseCmp(name, "system.nt_sec_desc.group+") == 0) {
3751
3752 /* Yup. */
3753 char *namevalue =
3754 talloc_asprintf(ctx, "%s:%s", name+19, (char *) value);
3755 if (! namevalue) {
3756 errno = ENOMEM;
3757 ret = -1;
3758 } else {
3759 ret = cacl_set(ctx, &srv->cli,
3760 &ipc_srv->cli, &pol, path,
3761 namevalue, SMBC_XATTR_MODE_CHOWN, 0);
3762 }
3763 talloc_destroy(ctx);
3764 return ret;
3765 }
3766
3767 /* Unsupported attribute name */
3768 talloc_destroy(ctx);
3769 errno = EINVAL;
3770 return -1;
3771 }
3772
3773 int smbc_getxattr_ctx(SMBCCTX *context,
3774 const char *fname,
3775 const char *name,
3776 const void *value,
3777 size_t size)
3778 {
3779 int ret;
3780 SMBCSRV *srv;
3781 SMBCSRV *ipc_srv;
3782 fstring server, share, user, password, workgroup;
3783 pstring path;
3784 TALLOC_CTX *ctx;
3785 POLICY_HND pol;
3786
3787 if (!context || !context->internal ||
3788 !context->internal->_initialized) {
3789
3790 errno = EINVAL; /* Best I can think of ... */
3791 return -1;
3792
3793 }
3794
3795 if (!fname) {
3796
3797 errno = EINVAL;
3798 return -1;
3799
3800 }
3801
3802 DEBUG(4, ("smbc_getxattr(%s, %s)\n", fname, name));
3803
3804 if (smbc_parse_path(context, fname,
3805 server, sizeof(server),
3806 share, sizeof(share),
3807 path, sizeof(path),
3808 user, sizeof(user),
3809 password, sizeof(password),
3810 NULL, 0)) {
3811 errno = EINVAL;
3812 return -1;
3813 }
3814
3815 if (user[0] == (char)0) fstrcpy(user, context->user);
3816
3817 fstrcpy(workgroup, context->workgroup);
3818
3819 srv = smbc_server(context, server, share, workgroup, user, password);
3820 if (!srv) {
3821 return -1; /* errno set by smbc_server */
3822 }
3823
3824 ipc_srv = smbc_attr_server(context, server, share,
3825 workgroup, user, password,
3826 &pol);
3827 if (!ipc_srv) {
3828 return -1;
3829 }
3830
3831 ctx = talloc_init("smbc:getxattr");
3832 if (!ctx) {
3833 errno = ENOMEM;
3834 return -1;
3835 }
3836
3837 /* Are they requesting a supported attribute? */
3838 if (StrCaseCmp(name, "system.nt_sec_desc.*") == 0 ||
3839 StrCaseCmp(name, "system.nt_sec_desc.*+") == 0 ||
3840 StrCaseCmp(name, "system.nt_sec_desc.revision") == 0 ||
3841 StrCaseCmp(name, "system.nt_sec_desc.owner") == 0 ||
3842 StrCaseCmp(name, "system.nt_sec_desc.owner+") == 0 ||
3843 StrCaseCmp(name, "system.nt_sec_desc.group") == 0 ||
3844 StrCaseCmp(name, "system.nt_sec_desc.group+") == 0 ||
3845 StrnCaseCmp(name, "system.nt_sec_desc.acl", 22) == 0 ||
3846 StrnCaseCmp(name, "system.nt_sec_desc.acl+", 23) == 0) {
3847
3848 /* Yup. */
3849 ret = cacl_get(ctx, &srv->cli,
3850 &ipc_srv->cli, &pol,
3851 (char *) path, (char *) name + 19,
3852 (char *) value, size);
3853 if (ret < 0 && errno == 0) {
3854 errno = smbc_errno(context, &srv->cli);
3855 }
3856 talloc_destroy(ctx);
3857 return ret;
3858 }
3859
3860 /* Unsupported attribute name */
3861 talloc_destroy(ctx);
3862 errno = EINVAL;
3863 return -1;
3864 }
3865
3866
3867 int smbc_removexattr_ctx(SMBCCTX *context,
3868 const char *fname,
3869 const char *name)
3870 {
3871 int ret;
3872 SMBCSRV *srv;
3873 SMBCSRV *ipc_srv;
3874 fstring server, share, user, password, workgroup;
3875 pstring path;
3876 TALLOC_CTX *ctx;
3877 POLICY_HND pol;
3878
3879 if (!context || !context->internal ||
3880 !context->internal->_initialized) {
3881
3882 errno = EINVAL; /* Best I can think of ... */
3883 return -1;
3884
3885 }
3886
3887 if (!fname) {
3888
3889 errno = EINVAL;
3890 return -1;
3891
3892 }
3893
3894 DEBUG(4, ("smbc_removexattr(%s, %s)\n", fname, name));
3895
3896 if (smbc_parse_path(context, fname,
3897 server, sizeof(server),
3898 share, sizeof(share),
3899 path, sizeof(path),
3900 user, sizeof(user),
3901 password, sizeof(password),
3902 NULL, 0)) {
3903 errno = EINVAL;
3904 return -1;
3905 }
3906
3907 if (user[0] == (char)0) fstrcpy(user, context->user);
3908
3909 fstrcpy(workgroup, context->workgroup);
3910
3911 srv = smbc_server(context, server, share, workgroup, user, password);
3912 if (!srv) {
3913 return -1; /* errno set by smbc_server */
3914 }
3915
3916 ipc_srv = smbc_attr_server(context, server, share,
3917 workgroup, user, password,
3918 &pol);
3919 if (!ipc_srv) {
3920 return -1;
3921 }
3922
3923 ipc_srv = smbc_attr_server(context, server, share,
3924 workgroup, user, password,
3925 &pol);
3926 if (!ipc_srv) {
3927 return -1;
3928 }
3929
3930 ctx = talloc_init("smbc_removexattr");
3931 if (!ctx) {
3932 errno = ENOMEM;
3933 return -1;
3934 }
3935
3936 /* Are they asking to set the entire ACL? */
3937 if (StrCaseCmp(name, "system.nt_sec_desc.*") == 0 ||
3938 StrCaseCmp(name, "system.nt_sec_desc.*+") == 0) {
3939
3940 /* Yup. */
3941 ret = cacl_set(ctx, &srv->cli,
3942 &ipc_srv->cli, &pol, path,
3943 NULL, SMBC_XATTR_MODE_REMOVE_ALL, 0);
3944 talloc_destroy(ctx);
3945 return ret;
3946 }
3947
3948 /*
3949 * Are they asking to remove one or more spceific security descriptor
3950 * attributes?
3951 */
3952 if (StrCaseCmp(name, "system.nt_sec_desc.revision") == 0 ||
3953 StrCaseCmp(name, "system.nt_sec_desc.owner") == 0 ||
3954 StrCaseCmp(name, "system.nt_sec_desc.owner+") == 0 ||
3955 StrCaseCmp(name, "system.nt_sec_desc.group") == 0 ||
3956 StrCaseCmp(name, "system.nt_sec_desc.group+") == 0 ||
3957 StrnCaseCmp(name, "system.nt_sec_desc.acl", 22) == 0 ||
3958 StrnCaseCmp(name, "system.nt_sec_desc.acl+", 23) == 0) {
3959
3960 /* Yup. */
3961 ret = cacl_set(ctx, &srv->cli,
3962 &ipc_srv->cli, &pol, path,
3963 name + 19, SMBC_XATTR_MODE_REMOVE, 0);
3964 talloc_destroy(ctx);
3965 return ret;
3966 }
3967
3968 /* Unsupported attribute name */
3969 talloc_destroy(ctx);
3970 errno = EINVAL;
3971 return -1;
3972 }
3973
3974 int smbc_listxattr_ctx(SMBCCTX *context,
3975 const char *fname,
3976 char *list,
3977 size_t size)
3978 {
3979 /*
3980 * This isn't quite what listxattr() is supposed to do. This returns
3981 * the complete set of attributes, always, rather than only those
3982 * attribute names which actually exist for a file. Hmmm...
3983 */
3984 const char supported[] =
3985 "system.nt_sec_desc.revision\0"
3986 "system.nt_sec_desc.owner\0"
3987 "system.nt_sec_desc.owner+\0"
3988 "system.nt_sec_desc.group\0"
3989 "system.nt_sec_desc.group+\0"
3990 "system.nt_sec_desc.acl\0"
3991 "system.nt_sec_desc.acl+\0"
3992 "system.nt_sec_desc.*\0"
3993 "system.nt_sec_desc.*+\0"
3994 ;
3995
3996 if (size == 0) {
3997 return sizeof(supported);
3998 }
3999
4000 if (sizeof(supported) > size) {
4001 errno = ERANGE;
4002 return -1;
4003 }
4004
4005 /* this can't be strcpy() because there are embedded null characters */
4006 memcpy(list, supported, sizeof(supported));
4007 return sizeof(supported);
4008 }
4009
4010
4011 /*
4012 * Open a print file to be written to by other calls
4013 */
4014
4015 static SMBCFILE *smbc_open_print_job_ctx(SMBCCTX *context, const char *fname)
4016 {
4017 fstring server, share, user, password;
4018 pstring path;
4019
4020 if (!context || !context->internal ||
4021 !context->internal->_initialized) {
4022
4023 errno = EINVAL;
4024 return NULL;
4025
4026 }
4027
4028 if (!fname) {
4029
4030 errno = EINVAL;
4031 return NULL;
4032
4033 }
4034
4035 DEBUG(4, ("smbc_open_print_job_ctx(%s)\n", fname));
4036
4037 if (smbc_parse_path(context, fname,
4038 server, sizeof(server),
4039 share, sizeof(share),
4040 path, sizeof(path),
4041 user, sizeof(user),
4042 password, sizeof(password),
4043 NULL, 0)) {
4044 errno = EINVAL;
4045 return NULL;
4046 }
4047
4048 /* What if the path is empty, or the file exists? */
4049
4050 return context->open(context, fname, O_WRONLY, 666);
4051
4052 }
4053
4054 /*
4055 * Routine to print a file on a remote server ...
4056 *
4057 * We open the file, which we assume to be on a remote server, and then
4058 * copy it to a print file on the share specified by printq.
4059 */
4060
4061 static int smbc_print_file_ctx(SMBCCTX *c_file, const char *fname, SMBCCTX *c_print, const char *printq)
4062 {
4063 SMBCFILE *fid1, *fid2;
4064 int bytes, saverr, tot_bytes = 0;
4065 char buf[4096];
4066
4067 if (!c_file || !c_file->internal->_initialized || !c_print ||
4068 !c_print->internal->_initialized) {
4069
4070 errno = EINVAL;
4071 return -1;
4072
4073 }
4074
4075 if (!fname && !printq) {
4076
4077 errno = EINVAL;
4078 return -1;
4079
4080 }
4081
4082 /* Try to open the file for reading ... */
4083
4084 if ((int)(fid1 = c_file->open(c_file, fname, O_RDONLY, 0666)) < 0) {
4085
4086 DEBUG(3, ("Error, fname=%s, errno=%i\n", fname, errno));
4087 return -1; /* smbc_open sets errno */
4088
4089 }
4090
4091 /* Now, try to open the printer file for writing */
4092
4093 if ((int)(fid2 = c_print->open_print_job(c_print, printq)) < 0) {
4094
4095 saverr = errno; /* Save errno */
4096 c_file->close(c_file, fid1);
4097 errno = saverr;
4098 return -1;
4099
4100 }
4101
4102 while ((bytes = c_file->read(c_file, fid1, buf, sizeof(buf))) > 0) {
4103
4104 tot_bytes += bytes;
4105
4106 if ((c_print->write(c_print, fid2, buf, bytes)) < 0) {
4107
4108 saverr = errno;
4109 c_file->close(c_file, fid1);
4110 c_print->close(c_print, fid2);
4111 errno = saverr;
4112
4113 }
4114
4115 }
4116
4117 saverr = errno;
4118
4119 c_file->close(c_file, fid1); /* We have to close these anyway */
4120 c_print->close(c_print, fid2);
4121
4122 if (bytes < 0) {
4123
4124 errno = saverr;
4125 return -1;
4126
4127 }
4128
4129 return tot_bytes;
4130
4131 }
4132
4133 /*
4134 * Routine to list print jobs on a printer share ...
4135 */
4136
4137 static int smbc_list_print_jobs_ctx(SMBCCTX *context, const char *fname, smbc_list_print_job_fn fn)
4138 {
4139 SMBCSRV *srv;
4140 fstring server, share, user, password, workgroup;
4141 pstring path;
4142
4143 if (!context || !context->internal ||
4144 !context->internal->_initialized) {
4145
4146 errno = EINVAL;
4147 return -1;
4148
4149 }
4150
4151 if (!fname) {
4152
4153 errno = EINVAL;
4154 return -1;
4155
4156 }
4157
4158 DEBUG(4, ("smbc_list_print_jobs(%s)\n", fname));
4159
4160 if (smbc_parse_path(context, fname,
4161 server, sizeof(server),
4162 share, sizeof(share),
4163 path, sizeof(path),
4164 user, sizeof(user),
4165 password, sizeof(password),
4166 NULL, 0)) {
4167 errno = EINVAL;
4168 return -1;
4169 }
4170
4171 if (user[0] == (char)0) fstrcpy(user, context->user);
4172
4173 fstrcpy(workgroup, context->workgroup);
4174
4175 srv = smbc_server(context, server, share, workgroup, user, password);
4176
4177 if (!srv) {
4178
4179 return -1; /* errno set by smbc_server */
4180
4181 }
4182
4183 if (cli_print_queue(&srv->cli, (void (*)(struct print_job_info *))fn) < 0) {
4184
4185 errno = smbc_errno(context, &srv->cli);
4186 return -1;
4187
4188 }
4189
4190 return 0;
4191
4192 }
4193
4194 /*
4195 * Delete a print job from a remote printer share
4196 */
4197
4198 static int smbc_unlink_print_job_ctx(SMBCCTX *context, const char *fname, int id)
4199 {
4200 SMBCSRV *srv;
4201 fstring server, share, user, password, workgroup;
4202 pstring path;
4203 int err;
4204
4205 if (!context || !context->internal ||
4206 !context->internal->_initialized) {
4207
4208 errno = EINVAL;
4209 return -1;
4210
4211 }
4212
4213 if (!fname) {
4214
4215 errno = EINVAL;
4216 return -1;
4217
4218 }
4219
4220 DEBUG(4, ("smbc_unlink_print_job(%s)\n", fname));
4221
4222 if (smbc_parse_path(context, fname,
4223 server, sizeof(server),
4224 share, sizeof(share),
4225 path, sizeof(path),
4226 user, sizeof(user),
4227 password, sizeof(password),
4228 NULL, 0)) {
4229 errno = EINVAL;
4230 return -1;
4231 }
4232
4233 if (user[0] == (char)0) fstrcpy(user, context->user);
4234
4235 fstrcpy(workgroup, context->workgroup);
4236
4237 srv = smbc_server(context, server, share, workgroup, user, password);
4238
4239 if (!srv) {
4240
4241 return -1; /* errno set by smbc_server */
4242
4243 }
4244
4245 if ((err = cli_printjob_del(&srv->cli, id)) != 0) {
4246
4247 if (err < 0)
4248 errno = smbc_errno(context, &srv->cli);
4249 else if (err == ERRnosuchprintjob)
4250 errno = EINVAL;
4251 return -1;
4252
4253 }
4254
4255 return 0;
4256
4257 }
4258
4259 /*
4260 * Get a new empty handle to fill in with your own info
4261 */
4262 SMBCCTX * smbc_new_context(void)
4263 {
4264 SMBCCTX * context;
4265
4266 context = malloc(sizeof(SMBCCTX));
4267 if (!context) {
4268 errno = ENOMEM;
4269 return NULL;
4270 }
4271
4272 ZERO_STRUCTP(context);
4273
4274 context->internal = malloc(sizeof(struct smbc_internal_data));
4275 if (!context->internal) {
4276 errno = ENOMEM;
4277 return NULL;
4278 }
4279
4280 ZERO_STRUCTP(context->internal);
4281
4282
4283 /* ADD REASONABLE DEFAULTS */
4284 context->debug = 0;
4285 context->timeout = 20000; /* 20 seconds */
4286
4287 context->open = smbc_open_ctx;
4288 context->creat = smbc_creat_ctx;
4289 context->read = smbc_read_ctx;
4290 context->write = smbc_write_ctx;
4291 context->close = smbc_close_ctx;
4292 context->unlink = smbc_unlink_ctx;
4293 context->rename = smbc_rename_ctx;
4294 context->lseek = smbc_lseek_ctx;
4295 context->stat = smbc_stat_ctx;
4296 context->fstat = smbc_fstat_ctx;
4297 context->opendir = smbc_opendir_ctx;
4298 context->closedir = smbc_closedir_ctx;
4299 context->readdir = smbc_readdir_ctx;
4300 context->getdents = smbc_getdents_ctx;
4301 context->mkdir = smbc_mkdir_ctx;
4302 context->rmdir = smbc_rmdir_ctx;
4303 context->telldir = smbc_telldir_ctx;
4304 context->lseekdir = smbc_lseekdir_ctx;
4305 context->fstatdir = smbc_fstatdir_ctx;
4306 context->chmod = smbc_chmod_ctx;
4307 context->utimes = smbc_utimes_ctx;
4308 context->setxattr = smbc_setxattr_ctx;
4309 context->getxattr = smbc_getxattr_ctx;
4310 context->removexattr = smbc_removexattr_ctx;
4311 context->listxattr = smbc_listxattr_ctx;
4312 context->open_print_job = smbc_open_print_job_ctx;
4313 context->print_file = smbc_print_file_ctx;
4314 context->list_print_jobs = smbc_list_print_jobs_ctx;
4315 context->unlink_print_job = smbc_unlink_print_job_ctx;
4316
4317 context->callbacks.check_server_fn = smbc_check_server;
4318 context->callbacks.remove_unused_server_fn = smbc_remove_unused_server;
4319
4320 smbc_default_cache_functions(context);
4321
4322 return context;
4323 }
4324
4325 /*
4326 * Free a context
4327 *
4328 * Returns 0 on success. Otherwise returns 1, the SMBCCTX is _not_ freed
4329 * and thus you'll be leaking memory if not handled properly.
4330 *
4331 */
4332 int smbc_free_context(SMBCCTX * context, int shutdown_ctx)
4333 {
4334 if (!context) {
4335 errno = EBADF;
4336 return 1;
4337 }
4338
4339 if (shutdown_ctx) {
4340 SMBCFILE * f;
4341 DEBUG(1,("Performing aggressive shutdown.\n"));
4342
4343 f = context->internal->_files;
4344 while (f) {
4345 context->close(context, f);
4346 f = f->next;
4347 }
4348 context->internal->_files = NULL;
4349
4350 /* First try to remove the servers the nice way. */
4351 if (context->callbacks.purge_cached_fn(context)) {
4352 SMBCSRV * s;
4353 SMBCSRV * next;
4354 DEBUG(1, ("Could not purge all servers, Nice way shutdown failed.\n"));
4355 s = context->internal->_servers;
4356 while (s) {
4357 DEBUG(1, ("Forced shutdown: %p (fd=%d)\n", s, s->cli.fd));
4358 cli_shutdown(&s->cli);
4359 context->callbacks.remove_cached_srv_fn(context, s);
4360 next = s->next;
4361 DLIST_REMOVE(context->internal->_servers, s);
4362 SAFE_FREE(s);
4363 s = next;
4364 }
4365 context->internal->_servers = NULL;
4366 }
4367 }
4368 else {
4369 /* This is the polite way */
4370 if (context->callbacks.purge_cached_fn(context)) {
4371 DEBUG(1, ("Could not purge all servers, free_context failed.\n"));
4372 errno = EBUSY;
4373 return 1;
4374 }
4375 if (context->internal->_servers) {
4376 DEBUG(1, ("Active servers in context, free_context failed.\n"));
4377 errno = EBUSY;
4378 return 1;
4379 }
4380 if (context->internal->_files) {
4381 DEBUG(1, ("Active files in context, free_context failed.\n"));
4382 errno = EBUSY;
4383 return 1;
4384 }
4385 }
4386
4387 /* Things we have to clean up */
4388 SAFE_FREE(context->workgroup);
4389 SAFE_FREE(context->netbios_name);
4390 SAFE_FREE(context->user);
4391
4392 DEBUG(3, ("Context %p succesfully freed\n", context));
4393 SAFE_FREE(context->internal);
4394 SAFE_FREE(context);
4395 return 0;
4396 }
4397
4398
4399 /*
4400 * Initialise the library etc
4401 *
4402 * We accept a struct containing handle information.
4403 * valid values for info->debug from 0 to 100,
4404 * and insist that info->fn must be non-null.
4405 */
4406 SMBCCTX * smbc_init_context(SMBCCTX * context)
4407 {
4408 pstring conf;
4409 int pid;
4410 char *user = NULL, *home = NULL;
4411
4412 if (!context || !context->internal) {
4413 errno = EBADF;
4414 return NULL;
4415 }
4416
4417 /* Do not initialise the same client twice */
4418 if (context->internal->_initialized) {
4419 return 0;
4420 }
4421
4422 if (!context->callbacks.auth_fn || context->debug < 0 || context->debug > 100) {
4423
4424 errno = EINVAL;
4425 return NULL;
4426
4427 }
4428
4429 if (!smbc_initialized) {
4430 /* Do some library wide intialisations the first time we get called */
4431
4432 /* Set this to what the user wants */
4433 DEBUGLEVEL = context->debug;
4434
4435 setup_logging( "libsmbclient", True);
4436
4437 /* Here we would open the smb.conf file if needed ... */
4438
4439 home = getenv("HOME");
4440
4441 slprintf(conf, sizeof(conf), "%s/.smb/smb.conf", home);
4442
4443 load_interfaces(); /* Load the list of interfaces ... */
4444
4445 in_client = True; /* FIXME, make a param */
4446
4447 if (!lp_load(conf, True, False, False)) {
4448
4449 /*
4450 * Well, if that failed, try the dyn_CONFIGFILE
4451 * Which points to the standard locn, and if that
4452 * fails, silently ignore it and use the internal
4453 * defaults ...
4454 */
4455
4456 if (!lp_load(dyn_CONFIGFILE, True, False, False)) {
4457 DEBUG(5, ("Could not load either config file: %s or %s\n",
4458 conf, dyn_CONFIGFILE));
4459 }
4460 }
4461
4462 reopen_logs(); /* Get logging working ... */
4463
4464 /*
4465 * Block SIGPIPE (from lib/util_sock.c: write())
4466 * It is not needed and should not stop execution
4467 */
4468 BlockSignals(True, SIGPIPE);
4469
4470 /* Done with one-time initialisation */
4471 smbc_initialized = 1;
4472
4473 }
4474
4475 if (!context->user) {
4476 /*
4477 * FIXME: Is this the best way to get the user info?
4478 */
4479 user = getenv("USER");
4480 /* walk around as "guest" if no username can be found */
4481 if (!user) context->user = strdup("guest");
4482 else context->user = strdup(user);
4483 }
4484
4485 if (!context->netbios_name) {
4486 /*
4487 * We try to get our netbios name from the config. If that fails we fall
4488 * back on constructing our netbios name from our hostname etc
4489 */
4490 if (global_myname()) {
4491 context->netbios_name = strdup(global_myname());
4492 }
4493 else {
4494 /*
4495 * Hmmm, I want to get hostname as well, but I am too lazy for the moment
4496 */
4497 pid = sys_getpid();
4498 context->netbios_name = malloc(17);
4499 if (!context->netbios_name) {
4500 errno = ENOMEM;
4501 return NULL;
4502 }
4503 slprintf(context->netbios_name, 16, "smbc%s%d", context->user, pid);
4504 }
4505 }
4506
4507 DEBUG(1, ("Using netbios name %s.\n", context->netbios_name));
4508
4509 if (!context->workgroup) {
4510 if (lp_workgroup()) {
4511 context->workgroup = strdup(lp_workgroup());
4512 }
4513 else {
4514 /* TODO: Think about a decent default workgroup */
4515 context->workgroup = strdup("samba");
4516 }
4517 }
4518
4519 DEBUG(1, ("Using workgroup %s.\n", context->workgroup));
4520
4521 /* shortest timeout is 1 second */
4522 if (context->timeout > 0 && context->timeout < 1000)
4523 context->timeout = 1000;
4524
4525 /*
4526 * FIXME: Should we check the function pointers here?
4527 */
4528
4529 context->internal->_initialized = 1;
4530
4531 return context;
4532 }
reg import