an, awi, cue and kue don't use the miibus interface.
[dragonfly.git] / contrib / smbfs / lib / smb / ctx.c
1 /*
2  * Copyright (c) 2000-2002, Boris Popov
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *    This product includes software developed by Boris Popov.
16  * 4. Neither the name of the author nor the names of any co-contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  * $Id: ctx.c,v 1.24 2002/04/13 14:35:28 bp Exp $
33  */
34 #include <sys/param.h>
35 #include <sys/sysctl.h>
36 #include <sys/ioctl.h>
37 #include <sys/time.h>
38 #include <sys/mount.h>
39 #include <fcntl.h>
40 #include <ctype.h>
41 #include <errno.h>
42 #include <stdio.h>
43 #include <string.h>
44 #include <stdlib.h>
45 #include <pwd.h>
46 #include <grp.h>
47 #include <unistd.h>
48 #include <sys/iconv.h>
49
50 #define NB_NEEDRESOLVER
51
52 #include <netsmb/smb_lib.h>
53 #include <netsmb/netbios.h>
54 #include <netsmb/nb_lib.h>
55 #include <netsmb/smb_conn.h>
56 #include <cflib.h>
57
58 /*
59  * Prescan command line for [-U user] argument
60  * and fill context with defaults
61  */
62 int
63 smb_ctx_init(struct smb_ctx *ctx, int argc, char *argv[],
64         int minlevel, int maxlevel, int sharetype)
65 {
66         int  opt, error = 0;
67         uid_t euid;
68         const char *arg, *cp;
69         struct passwd *pwd;
70
71         bzero(ctx,sizeof(*ctx));
72         error = nb_ctx_create(&ctx->ct_nb);
73         if (error)
74                 return error;
75         ctx->ct_fd = -1;
76         ctx->ct_parsedlevel = SMBL_NONE;
77         ctx->ct_minlevel = minlevel;
78         ctx->ct_maxlevel = maxlevel;
79
80         ctx->ct_ssn.ioc_opt = SMBVOPT_CREATE;
81         ctx->ct_ssn.ioc_timeout = 15;
82         ctx->ct_ssn.ioc_retrycount = 4;
83         ctx->ct_ssn.ioc_owner = SMBM_ANY_OWNER;
84         ctx->ct_ssn.ioc_group = SMBM_ANY_GROUP;
85         ctx->ct_ssn.ioc_mode = SMBM_EXEC;
86         ctx->ct_ssn.ioc_rights = SMBM_DEFAULT;
87
88         ctx->ct_sh.ioc_opt = SMBVOPT_CREATE;
89         ctx->ct_sh.ioc_owner = SMBM_ANY_OWNER;
90         ctx->ct_sh.ioc_group = SMBM_ANY_GROUP;
91         ctx->ct_sh.ioc_mode = SMBM_EXEC;
92         ctx->ct_sh.ioc_rights = SMBM_DEFAULT;
93         ctx->ct_sh.ioc_owner = SMBM_ANY_OWNER;
94         ctx->ct_sh.ioc_group = SMBM_ANY_GROUP;
95
96         nb_ctx_setscope(ctx->ct_nb, "");
97         euid = geteuid();
98         if ((pwd = getpwuid(euid)) != NULL) {
99                 smb_ctx_setuser(ctx, pwd->pw_name);
100                 endpwent();
101         } else if (euid == 0)
102                 smb_ctx_setuser(ctx, "root");
103         else
104                 return 0;
105         if (argv == NULL)
106                 return 0;
107         for (opt = 1; opt < argc; opt++) {
108                 cp = argv[opt];
109                 if (strncmp(cp, "//", 2) != 0)
110                         continue;
111                 error = smb_ctx_parseunc(ctx, cp, sharetype, (const char**)&cp);
112                 if (error)
113                         return error;
114                 ctx->ct_uncnext = cp;
115                 break;
116         }
117         while (error == 0 && (opt = cf_getopt(argc, argv, ":E:L:U:")) != -1) {
118                 arg = cf_optarg;
119                 switch (opt) {
120                     case 'E':
121                         error = smb_ctx_setcharset(ctx, arg);
122                         if (error)
123                                 return error;
124                         break;
125                     case 'L':
126                         error = nls_setlocale(optarg);
127                         if (error)
128                                 break;
129                         break;
130                     case 'U':
131                         error = smb_ctx_setuser(ctx, arg);
132                         break;
133                 }
134         }
135         cf_optind = cf_optreset = 1;
136         return error;
137 }
138
139 void
140 smb_ctx_done(struct smb_ctx *ctx)
141 {
142         if (ctx->ct_ssn.ioc_server)
143                 nb_snbfree(ctx->ct_ssn.ioc_server);
144         if (ctx->ct_ssn.ioc_local)
145                 nb_snbfree(ctx->ct_ssn.ioc_local);
146         if (ctx->ct_srvaddr)
147                 free(ctx->ct_srvaddr);
148         if (ctx->ct_nb)
149                 nb_ctx_done(ctx->ct_nb);
150 }
151
152 static int
153 getsubstring(const char *p, u_char sep, char *dest, int maxlen, const char **next)
154 {
155         int len;
156
157         maxlen--;
158         for (len = 0; len < maxlen && *p != sep; p++, len++, dest++) {
159                 if (*p == 0)
160                         return EINVAL;
161                 *dest = *p;
162         }
163         *dest = 0;
164         *next = *p ? p + 1 : p;
165         return 0;
166 }
167
168 /*
169  * Here we expect something like "[proto:]//[user@]host[/share][/path]"
170  */
171 int
172 smb_ctx_parseunc(struct smb_ctx *ctx, const char *unc, int sharetype,
173         const char **next)
174 {
175         const char *p = unc;
176         char *p1;
177         char tmp[1024];
178         int error ;
179
180         ctx->ct_parsedlevel = SMBL_NONE;
181         if (*p++ != '/' || *p++ != '/') {
182                 smb_error("UNC should start with '//'", 0);
183                 return EINVAL;
184         }
185         p1 = tmp;
186         error = getsubstring(p, '@', p1, sizeof(tmp), &p);
187         if (!error) {
188                 if (ctx->ct_maxlevel < SMBL_VC) {
189                         smb_error("no user name required", 0);
190                         return EINVAL;
191                 }
192                 if (*p1 == 0) {
193                         smb_error("empty user name", 0);
194                         return EINVAL;
195                 }
196                 error = smb_ctx_setuser(ctx, tmp);
197                 if (error)
198                         return error;
199                 ctx->ct_parsedlevel = SMBL_VC;
200         }
201         error = getsubstring(p, '/', p1, sizeof(tmp), &p);
202         if (error) {
203                 error = getsubstring(p, '\0', p1, sizeof(tmp), &p);
204                 if (error) {
205                         smb_error("no server name found", 0);
206                         return error;
207                 }
208         }
209         if (*p1 == 0) {
210                 smb_error("empty server name", 0);
211                 return EINVAL;
212         }
213         error = smb_ctx_setserver(ctx, tmp);
214         if (error)
215                 return error;
216         if (sharetype == SMB_ST_NONE) {
217                 *next = p;
218                 return 0;
219         }
220         if (*p != 0 && ctx->ct_maxlevel < SMBL_SHARE) {
221                 smb_error("no share name required", 0);
222                 return EINVAL;
223         }
224         error = getsubstring(p, '/', p1, sizeof(tmp), &p);
225         if (error) {
226                 error = getsubstring(p, '\0', p1, sizeof(tmp), &p);
227                 if (error) {
228                         smb_error("unexpected end of line", 0);
229                         return error;
230                 }
231         }
232         if (*p1 == 0 && ctx->ct_minlevel >= SMBL_SHARE) {
233                 smb_error("empty share name", 0);
234                 return EINVAL;
235         }
236         *next = p;
237         if (*p1 == 0)
238                 return 0;
239         error = smb_ctx_setshare(ctx, p1, sharetype);
240         return error;
241 }
242
243 int
244 smb_ctx_setcharset(struct smb_ctx *ctx, const char *arg)
245 {
246         char *cp, *servercs, *localcs;
247         int cslen = sizeof(ctx->ct_ssn.ioc_localcs);
248         int scslen, lcslen, error;
249
250         cp = strchr(arg, ':');
251         lcslen = cp ? (cp - arg) : 0;
252         if (lcslen == 0 || lcslen >= cslen) {
253                 smb_error("invalid local charset specification (%s)", 0, arg);
254                 return EINVAL;
255         }
256         scslen = (size_t)strlen(++cp);
257         if (scslen == 0 || scslen >= cslen) {
258                 smb_error("invalid server charset specification (%s)", 0, arg);
259                 return EINVAL;
260         }
261         localcs = memcpy(ctx->ct_ssn.ioc_localcs, arg, lcslen);
262         localcs[lcslen] = 0;
263         servercs = strcpy(ctx->ct_ssn.ioc_servercs, cp);
264         error = nls_setrecode(localcs, servercs);
265         if (error == 0)
266                 return 0;
267         smb_error("can't initialize iconv support (%s:%s)",
268             error, localcs, servercs);
269         localcs[0] = 0;
270         servercs[0] = 0;
271         return error;
272 }
273
274 int
275 smb_ctx_setserver(struct smb_ctx *ctx, const char *name)
276 {
277         if (strlen(name) >= SMB_MAXSRVNAMELEN) {
278                 smb_error("server name '%s' too long", 0, name);
279                 return ENAMETOOLONG;
280         }
281         nls_str_upper(ctx->ct_ssn.ioc_srvname, name);
282         return 0;
283 }
284
285 int
286 smb_ctx_setuser(struct smb_ctx *ctx, const char *name)
287 {
288         if (strlen(name) >= SMB_MAXUSERNAMELEN) {
289                 smb_error("user name '%s' too long", 0, name);
290                 return ENAMETOOLONG;
291         }
292         nls_str_upper(ctx->ct_ssn.ioc_user, name);
293         return 0;
294 }
295
296 int
297 smb_ctx_setworkgroup(struct smb_ctx *ctx, const char *name)
298 {
299         if (strlen(name) >= SMB_MAXUSERNAMELEN) {
300                 smb_error("workgroup name '%s' too long", 0, name);
301                 return ENAMETOOLONG;
302         }
303         nls_str_upper(ctx->ct_ssn.ioc_workgroup, name);
304         return 0;
305 }
306
307 int
308 smb_ctx_setpassword(struct smb_ctx *ctx, const char *passwd)
309 {
310         if (passwd == NULL)
311                 return EINVAL;
312         if (strlen(passwd) >= SMB_MAXPASSWORDLEN) {
313                 smb_error("password too long", 0);
314                 return ENAMETOOLONG;
315         }
316         if (strncmp(passwd, "$$1", 3) == 0)
317                 smb_simpledecrypt(ctx->ct_ssn.ioc_password, passwd);
318         else
319                 strcpy(ctx->ct_ssn.ioc_password, passwd);
320         strcpy(ctx->ct_sh.ioc_password, ctx->ct_ssn.ioc_password);
321         return 0;
322 }
323
324 int
325 smb_ctx_setshare(struct smb_ctx *ctx, const char *share, int stype)
326 {
327         if (strlen(share) >= SMB_MAXSHARENAMELEN) {
328                 smb_error("share name '%s' too long", 0, share);
329                 return ENAMETOOLONG;
330         }
331         nls_str_upper(ctx->ct_sh.ioc_share, share);
332         if (share[0] != 0)
333                 ctx->ct_parsedlevel = SMBL_SHARE;
334         ctx->ct_sh.ioc_stype = stype;
335         return 0;
336 }
337
338 int
339 smb_ctx_setsrvaddr(struct smb_ctx *ctx, const char *addr)
340 {
341         if (addr == NULL || addr[0] == 0)
342                 return EINVAL;
343         if (ctx->ct_srvaddr)
344                 free(ctx->ct_srvaddr);
345         if ((ctx->ct_srvaddr = strdup(addr)) == NULL)
346                 return ENOMEM;
347         return 0;
348 }
349
350 static int
351 smb_parse_owner(char *pair, uid_t *uid, gid_t *gid)
352 {
353         struct group *gr;
354         struct passwd *pw;
355         char *cp;
356
357         cp = strchr(pair, ':');
358         if (cp) {
359                 *cp++ = '\0';
360                 if (*cp) {
361                         gr = getgrnam(cp);
362                         if (gr) {
363                                 *gid = gr->gr_gid;
364                         } else
365                                 smb_error("Invalid group name %s, ignored",
366                                     0, cp);
367                 }
368         }
369         if (*pair) {
370                 pw = getpwnam(pair);
371                 if (pw) {
372                         *uid = pw->pw_uid;
373                 } else
374                         smb_error("Invalid user name %s, ignored", 0, pair);
375         }
376         endpwent();
377         return 0;
378 }
379
380 int
381 smb_ctx_opt(struct smb_ctx *ctx, int opt, const char *arg)
382 {
383         int error = 0;
384         char *p, *cp;
385
386         switch(opt) {
387             case 'U':
388                 break;
389             case 'I':
390                 error = smb_ctx_setsrvaddr(ctx, arg);
391                 break;
392             case 'M':
393                 ctx->ct_ssn.ioc_rights = strtol(arg, &cp, 8);
394                 if (*cp == '/') {
395                         ctx->ct_sh.ioc_rights = strtol(cp + 1, &cp, 8);
396                         ctx->ct_flags |= SMBCF_SRIGHTS;
397                 }
398                 break;
399             case 'N':
400                 ctx->ct_flags |= SMBCF_NOPWD;
401                 break;
402             case 'O':
403                 p = strdup(arg);
404                 cp = strchr(p, '/');
405                 if (cp) {
406                         *cp++ = '\0';
407                         error = smb_parse_owner(cp, &ctx->ct_sh.ioc_owner,
408                             &ctx->ct_sh.ioc_group);
409                 }
410                 if (*p && error == 0) {
411                         error = smb_parse_owner(cp, &ctx->ct_ssn.ioc_owner,
412                             &ctx->ct_ssn.ioc_group);
413                 }
414                 free(p);
415                 break;
416             case 'P':
417 /*              ctx->ct_ssn.ioc_opt |= SMBCOPT_PERMANENT;*/
418                 break;
419             case 'R':
420                 ctx->ct_ssn.ioc_retrycount = atoi(arg);
421                 break;
422             case 'T':
423                 ctx->ct_ssn.ioc_timeout = atoi(arg);
424                 break;
425             case 'W':
426                 error = smb_ctx_setworkgroup(ctx, arg);
427                 break;
428         }
429         return error;
430 }
431
432 #if 0
433 static void
434 smb_hexdump(const u_char *buf, int len) {
435         int ofs = 0;
436
437         while (len--) {
438                 if (ofs % 16 == 0)
439                         printf("\n%02X: ", ofs);
440                 printf("%02x ", *buf++);
441                 ofs++;
442         }
443         printf("\n");
444 }
445 #endif
446
447
448 static int
449 smb_addiconvtbl(const char *to, const char *from, const u_char *tbl)
450 {
451         int error;
452
453         error = kiconv_add_xlat_table(to, from, tbl);
454         if (error && error != EEXIST) {
455                 smb_error("can not setup kernel iconv table (%s:%s)", error,
456                     from, to);
457                 return error;
458         }
459         return 0;
460 }
461
462 /*
463  * Verify context before connect operation(s),
464  * lookup specified server and try to fill all forgotten fields.
465  */
466 int
467 smb_ctx_resolve(struct smb_ctx *ctx)
468 {
469         struct smbioc_ossn *ssn = &ctx->ct_ssn;
470         struct smbioc_oshare *sh = &ctx->ct_sh;
471         struct nb_name nn;
472         struct sockaddr *sap;
473         struct sockaddr_nb *salocal, *saserver;
474         char *cp;
475         u_char cstbl[256];
476         u_int i;
477         int error = 0;
478         
479         ctx->ct_flags &= ~SMBCF_RESOLVED;
480         if (ssn->ioc_srvname[0] == 0) {
481                 smb_error("no server name specified", 0);
482                 return EINVAL;
483         }
484         if (ssn->ioc_user[0] == 0) {
485                 smb_error("no user name specified for server %s",
486                     0, ssn->ioc_srvname);
487                 return EINVAL;
488         }
489         if (ctx->ct_minlevel >= SMBL_SHARE && sh->ioc_share[0] == 0) {
490                 smb_error("no share name specified for %s@%s",
491                     0, ssn->ioc_user, ssn->ioc_srvname);
492                 return EINVAL;
493         }
494         error = nb_ctx_resolve(ctx->ct_nb);
495         if (error)
496                 return error;
497         if (ssn->ioc_localcs[0] == 0)
498                 strcpy(ssn->ioc_localcs, "default");    /* XXX: locale name ? */
499         error = smb_addiconvtbl("tolower", ssn->ioc_localcs, nls_lower);
500         if (error)
501                 return error;
502         error = smb_addiconvtbl("toupper", ssn->ioc_localcs, nls_upper);
503         if (error)
504                 return error;
505         if (ssn->ioc_servercs[0] != 0) {
506                 for(i = 0; i < sizeof(cstbl); i++)
507                         cstbl[i] = i;
508                 nls_mem_toext(cstbl, cstbl, sizeof(cstbl));
509                 error = smb_addiconvtbl(ssn->ioc_servercs, ssn->ioc_localcs, cstbl);
510                 if (error)
511                         return error;
512                 for(i = 0; i < sizeof(cstbl); i++)
513                         cstbl[i] = i;
514                 nls_mem_toloc(cstbl, cstbl, sizeof(cstbl));
515                 error = smb_addiconvtbl(ssn->ioc_localcs, ssn->ioc_servercs, cstbl);
516                 if (error)
517                         return error;
518         }
519         if (ctx->ct_srvaddr) {
520                 error = nb_resolvehost_in(ctx->ct_srvaddr, &sap);
521         } else {
522                 error = nbns_resolvename(ssn->ioc_srvname, ctx->ct_nb, &sap);
523         }
524         if (error) {
525                 smb_error("can't get server address", error);
526                 return error;
527         }
528         nn.nn_scope = ctx->ct_nb->nb_scope;
529         nn.nn_type = NBT_SERVER;
530         strcpy(nn.nn_name, ssn->ioc_srvname);
531         error = nb_sockaddr(sap, &nn, &saserver);
532         nb_snbfree(sap);
533         if (error) {
534                 smb_error("can't allocate server address", error);
535                 return error;
536         }
537         ssn->ioc_server = (struct sockaddr*)saserver;
538         if (ctx->ct_locname[0] == 0) {
539                 error = nb_getlocalname(ctx->ct_locname);
540                 if (error) {
541                         smb_error("can't get local name", error);
542                         return error;
543                 }
544                 nls_str_upper(ctx->ct_locname, ctx->ct_locname);
545         }
546         strcpy(nn.nn_name, ctx->ct_locname);
547         nn.nn_type = NBT_WKSTA;
548         nn.nn_scope = ctx->ct_nb->nb_scope;
549         error = nb_sockaddr(NULL, &nn, &salocal);
550         if (error) {
551                 nb_snbfree((struct sockaddr*)saserver);
552                 smb_error("can't allocate local address", error);
553                 return error;
554         }
555         ssn->ioc_local = (struct sockaddr*)salocal;
556         ssn->ioc_lolen = salocal->snb_len;
557         ssn->ioc_svlen = saserver->snb_len;
558         if (ssn->ioc_password[0] == 0 && (ctx->ct_flags & SMBCF_NOPWD) == 0) {
559                 cp = getpass("Password:");
560                 error = smb_ctx_setpassword(ctx, cp);
561                 if (error)
562                         return error;
563         }
564         ctx->ct_flags |= SMBCF_RESOLVED;
565         return 0;
566 }
567
568 static int
569 smb_ctx_gethandle(struct smb_ctx *ctx)
570 {
571         int fd, i;
572         char buf[20];
573
574         /*
575          * First, try to open as cloned device
576          */
577         fd = open("/dev/"NSMB_NAME, O_RDWR);
578         if (fd >= 0) {
579                 ctx->ct_fd = fd;
580                 return 0;
581         }
582         /*
583          * well, no clone capabilities available - we have to scan
584          * all devices in order to get free one
585          */
586          for (i = 0; i < 1024; i++) {
587                  snprintf(buf, sizeof(buf), "/dev/%s%d", NSMB_NAME, i);
588                  fd = open(buf, O_RDWR);
589                  if (fd >= 0) {
590                         ctx->ct_fd = fd;
591                         return 0;
592                  }
593          }
594          /*
595           * This is a compatibility with old /dev/net/nsmb device
596           */
597          for (i = 0; i < 1024; i++) {
598                  snprintf(buf, sizeof(buf), "/dev/net/%s%d", NSMB_NAME, i);
599                  fd = open(buf, O_RDWR);
600                  if (fd >= 0) {
601                         ctx->ct_fd = fd;
602                         return 0;
603                  }
604                  if (errno == ENOENT)
605                          return ENOENT;
606          }
607          return ENOENT;
608 }
609
610 int
611 smb_ctx_lookup(struct smb_ctx *ctx, int level, int flags)
612 {
613         struct smbioc_lookup rq;
614         int error;
615
616         if ((ctx->ct_flags & SMBCF_RESOLVED) == 0) {
617                 smb_error("smb_ctx_lookup() data is not resolved", 0);
618                 return EINVAL;
619         }
620         if (ctx->ct_fd != -1) {
621                 close(ctx->ct_fd);
622                 ctx->ct_fd = -1;
623         }
624         error = smb_ctx_gethandle(ctx);
625         if (error) {
626                 smb_error("can't get handle to requester (no /dev/"NSMB_NAME"* device)", 0);
627                 return EINVAL;
628         }
629         bzero(&rq, sizeof(rq));
630         bcopy(&ctx->ct_ssn, &rq.ioc_ssn, sizeof(struct smbioc_ossn));
631         bcopy(&ctx->ct_sh, &rq.ioc_sh, sizeof(struct smbioc_oshare));
632         rq.ioc_flags = flags;
633         rq.ioc_level = level;
634         if (ioctl(ctx->ct_fd, SMBIOC_LOOKUP, &rq) == -1) {
635                 error = errno;
636                 if (flags & SMBLK_CREATE)
637                         smb_error("unable to open connection", error);
638                 return error;
639         }
640         return 0;
641 }
642
643 int
644 smb_ctx_login(struct smb_ctx *ctx)
645 {
646         struct smbioc_ossn *ssn = &ctx->ct_ssn;
647         struct smbioc_oshare *sh = &ctx->ct_sh;
648         int error;
649
650         if ((ctx->ct_flags & SMBCF_RESOLVED) == 0) {
651                 smb_error("smb_ctx_resolve() should be called first", 0);
652                 return EINVAL;
653         }
654         if (ctx->ct_fd != -1) {
655                 close(ctx->ct_fd);
656                 ctx->ct_fd = -1;
657         }
658         error = smb_ctx_gethandle(ctx);
659         if (error) {
660                 smb_error("can't get handle to requester", 0);
661                 return EINVAL;
662         }
663         if (ioctl(ctx->ct_fd, SMBIOC_OPENSESSION, ssn) == -1) {
664                 error = errno;
665                 smb_error("can't open session to server %s", error, ssn->ioc_srvname);
666                 return error;
667         }
668         if (sh->ioc_share[0] == 0)
669                 return 0;
670         if (ioctl(ctx->ct_fd, SMBIOC_OPENSHARE, sh) == -1) {
671                 error = errno;
672                 smb_error("can't connect to share //%s/%s", error,
673                     ssn->ioc_srvname, sh->ioc_share);
674                 return error;
675         }
676         return 0;
677 }
678
679 int
680 smb_ctx_setflags(struct smb_ctx *ctx, int level, int mask, int flags)
681 {
682         struct smbioc_flags fl;
683
684         if (ctx->ct_fd == -1)
685                 return EINVAL;
686         fl.ioc_level = level;
687         fl.ioc_mask = mask;
688         fl.ioc_flags = flags;
689         if (ioctl(ctx->ct_fd, SMBIOC_SETFLAGS, &fl) == -1)
690                 return errno;
691         return 0;
692 }
693
694 /*
695  * level values:
696  * 0 - default
697  * 1 - server
698  * 2 - server:user
699  * 3 - server:user:share
700  */
701 static int
702 smb_ctx_readrcsection(struct smb_ctx *ctx, const char *sname, int level)
703 {
704         char *p;
705         int error;
706
707         if (level >= 0) {
708                 rc_getstringptr(smb_rc, sname, "charsets", &p);
709                 if (p) {
710                         error = smb_ctx_setcharset(ctx, p);
711                         if (error)
712                                 smb_error("charset specification in the section '%s' ignored", error, sname);
713                 }
714         }
715         if (level <= 1) {
716                 rc_getint(smb_rc, sname, "timeout", &ctx->ct_ssn.ioc_timeout);
717                 rc_getint(smb_rc, sname, "retry_count", &ctx->ct_ssn.ioc_retrycount);
718         }
719         if (level == 1) {
720                 rc_getstringptr(smb_rc, sname, "addr", &p);
721                 if (p) {
722                         error = smb_ctx_setsrvaddr(ctx, p);
723                         if (error) {
724                                 smb_error("invalid address specified in the section %s", 0, sname);
725                                 return error;
726                         }
727                 }
728         }
729         if (level >= 2) {
730                 rc_getstringptr(smb_rc, sname, "password", &p);
731                 if (p)
732                         smb_ctx_setpassword(ctx, p);
733         }
734         rc_getstringptr(smb_rc, sname, "workgroup", &p);
735         if (p)
736                 smb_ctx_setworkgroup(ctx, p);
737         return 0;
738 }
739
740 /*
741  * read rc file as follows:
742  * 1. read [default] section
743  * 2. override with [server] section
744  * 3. override with [server:user:share] section
745  * Since abcence of rcfile is not fatal, silently ignore this fact.
746  * smb_rc file should be closed by caller.
747  */
748 int
749 smb_ctx_readrc(struct smb_ctx *ctx)
750 {
751         char sname[SMB_MAXSRVNAMELEN + SMB_MAXUSERNAMELEN + SMB_MAXSHARENAMELEN + 4];
752 /*      char *p;*/
753
754         if (smb_open_rcfile() != 0)
755                 return 0;
756
757         if (ctx->ct_ssn.ioc_user[0] == 0 || ctx->ct_ssn.ioc_srvname[0] == 0)
758                 return 0;
759
760         smb_ctx_readrcsection(ctx, "default", 0);
761         nb_ctx_readrcsection(smb_rc, ctx->ct_nb, "default", 0);
762         smb_ctx_readrcsection(ctx, ctx->ct_ssn.ioc_srvname, 1);
763         nb_ctx_readrcsection(smb_rc, ctx->ct_nb, ctx->ct_ssn.ioc_srvname, 1);
764         /*
765          * SERVER:USER parameters
766          */
767         snprintf(sname, sizeof(sname), "%s:%s", ctx->ct_ssn.ioc_srvname,
768             ctx->ct_ssn.ioc_user);
769         smb_ctx_readrcsection(ctx, sname, 2);
770
771         if (ctx->ct_sh.ioc_share[0] != 0) {
772                 /*
773                  * SERVER:USER:SHARE parameters
774                  */
775                 snprintf(sname, sizeof(sname), "%s:%s:%s", ctx->ct_ssn.ioc_srvname,
776                     ctx->ct_ssn.ioc_user, ctx->ct_sh.ioc_share);
777                 smb_ctx_readrcsection(ctx, sname, 3);
778         }
779         return 0;
780 }
781