lib/libncp/ncpl_conn.c

   1 /*
   2  * Copyright (c) 1999, 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  *  $FreeBSD: src/lib/libncp/ncpl_conn.c,v 1.2 1999/10/29 12:59:59 bp Exp $
  33  *  $DragonFly: src/lib/libncp/ncpl_conn.c,v 1.4 2005/02/28 16:23:25 joerg Exp $
  34  */
  35
  36 /*
  37  *
  38  * Current scheme to create/open connection:
  39  * 1. ncp_li_init() - lookup -S [-U] options in command line
  40  * 2. ncp_li_init() - try to find existing connection
  41  * 3. ncp_li_init() - if no server name and no accessible connections - bail out
  42  * 4. This is connection candidate, read .rc file, override with command line
  43  *    and go ahead
  44  * Note: connection referenced only via ncp_login() call. Although it is
  45  * possible to get connection handle in other way, it will be unwise to use
  46  * it, since conn can be destroyed at any time.
  47  *
  48  */
  49 #include <sys/param.h>
  50 #include <sys/sysctl.h>
  51 #include <sys/ioctl.h>
  52 #include <sys/time.h>
  53 #include <sys/mount.h>
  54 #include <fcntl.h>
  55 #include <ctype.h>
  56 #include <errno.h>
  57 #include <stdio.h>
  58 #include <string.h>
  59 #include <stdlib.h>
  60 #include <pwd.h>
  61 #include <grp.h>
  62 #include <unistd.h>
  63
  64 #include <netncp/ncp_lib.h>
  65 #include <netncp/ncp_rcfile.h>
  66 #include <nwfs/nwfs.h>
  67
  68 static char *server_name; /* need a better way ! */
  69
  70
  71
  72 int
  73 ncp_li_setserver(struct ncp_conn_loginfo *li, const char *arg) {
  74         if (strlen(arg) >= NCP_BINDERY_NAME_LEN) {
  75                 ncp_error("server name '%s' too long", 0, arg);
  76                 return ENAMETOOLONG;
  77         }
  78         ncp_str_upper(strcpy(li->server, arg));
  79         return 0;
  80 }
  81
  82 int
  83 ncp_li_setuser(struct ncp_conn_loginfo *li, char *arg) {
  84         if (arg && strlen(arg) >= NCP_BINDERY_NAME_LEN) {
  85                 ncp_error("user name '%s' too long", 0, arg);
  86                 return ENAMETOOLONG;
  87         }
  88         if (li->user)
  89                 free(li->user);
  90         if (arg) {
  91                 li->user = strdup(arg);
  92                 if (li->user == NULL)
  93                         return ENOMEM;
  94                 ncp_str_upper(li->user);
  95         } else
  96                 li->user = NULL;
  97         return 0;
  98 }
  99
 100 int
 101 ncp_li_setpassword(struct ncp_conn_loginfo *li, const char *passwd) {
 102         if (passwd && strlen(passwd) >= 127) {
 103                 ncp_error("password too long", 0);
 104                 return ENAMETOOLONG;
 105         }
 106         if (li->password) {
 107                 bzero(li->password, strlen(li->password));
 108                 free(li->password);
 109         }
 110         if (passwd) {
 111                 li->password = strdup(passwd);
 112                 if (li->password == NULL)
 113                         return ENOMEM;
 114         } else
 115                 li->password = NULL;
 116         return 0;
 117 }
 118 /*
 119  * Prescan command line for [-S server] [-U user] arguments
 120  * and fill li structure with defaults
 121  */
 122 int
 123 ncp_li_init(struct ncp_conn_loginfo *li, int argc, char *argv[]) {
 124         int  opt, error = 0;
 125         char *arg;
 126
 127         bzero(li,sizeof(*li));
 128         li->timeout = 15;       /* these values should be large enough to handle */
 129         li->retry_count = 4;    /* slow servers, even on ethernet */
 130         li->access_mode = 0;
 131         li->password = NULL;
 132         li->sig_level = 1;
 133         li->objtype = NCP_BINDERY_USER;
 134         li->owner = NCP_DEFAULT_OWNER;
 135         li->group = NCP_DEFAULT_GROUP;
 136         server_name = NULL;
 137         if (argv == NULL) return 0;
 138         while (error == 0 && (opt = ncp_getopt(argc, argv, ":S:U:")) != -1) {
 139                 arg = ncp_optarg;
 140                 switch (opt) {
 141                     case 'S':
 142                         error = ncp_li_setserver(li, arg);
 143                         break;
 144                     case 'U':
 145                         error = ncp_li_setuser(li, arg);
 146                         break;
 147                 }
 148         }
 149         ncp_optind = ncp_optreset = 1;
 150         return error;
 151 }
 152
 153 void
 154 ncp_li_done(struct ncp_conn_loginfo *li) {
 155         if (li->user)
 156                 free(li->user);
 157         if (li->password)
 158                 free(li->password);
 159 }
 160
 161 /*
 162  * Lookup existing connection based on li structure, if connection
 163  * found, it will be referenced. Otherwise full login sequence performed.
 164  */
 165 int
 166 ncp_li_login(struct ncp_conn_loginfo *li, int *aconnid) {
 167         int connHandle, error;
 168
 169         if ((error = ncp_conn_scan(li, &connHandle)) == 0) {
 170                 *aconnid = connHandle;
 171                 return 0;
 172         }
 173         error = ncp_connect(li, &connHandle);
 174         if (error) return errno;
 175         error = ncp_login(connHandle, li->user, li->objtype, li->password);
 176         if (error) {
 177                 ncp_disconnect(connHandle);
 178         } else
 179                 *aconnid = connHandle;
 180         return error;
 181 }
 182
 183 /*
 184  * read rc file as follows:
 185  * 1. read [server] section
 186  * 2. override with [server:user] section
 187  * Since abcence of rcfile is not a bug, silently ignore that fact.
 188  * rcfile never closed to reduce number of open/close operations.
 189  */
 190 int
 191 ncp_li_readrc(struct ncp_conn_loginfo *li) {
 192         int i, val, error;
 193         char uname[NCP_BINDERY_NAME_LEN*2+1];
 194         char *sect = NULL, *p;
 195
 196         /*
 197          * if info from cmd line incomplete, try to find existing
 198          * connection and fill server/user from it.
 199          */
 200         if (li->server[0] == 0 || li->user == NULL) {
 201                 int connHandle;
 202                 struct ncp_conn_stat cs;
 203
 204                 if ((error = ncp_conn_scan(li, &connHandle)) != 0) {
 205                         ncp_error("no default connection found", errno);
 206                         return error;
 207                 }
 208                 ncp_conn_getinfo(connHandle, &cs);
 209                 ncp_li_setserver(li, cs.li.server);
 210                 ncp_li_setuser(li, cs.user);
 211                 ncp_li_setpassword(li, "");
 212                 ncp_disconnect(connHandle);
 213         }
 214         if (ncp_open_rcfile())  return 0;
 215
 216         for (i = 0; i < 2; i++) {
 217                 switch (i) {
 218                     case 0:
 219                         sect = li->server;
 220                         break;
 221                     case 1:
 222                         strcat(strcat(strcpy(uname,li->server),":"),li->user ? li->user : "default");
 223                         sect = uname;
 224                         break;
 225                 }
 226                 rc_getstringptr(ncp_rc, sect, "password", &p);
 227                 if (p)
 228                         ncp_li_setpassword(li, p);
 229                 rc_getint(ncp_rc,sect, "timeout", &li->timeout);
 230                 rc_getint(ncp_rc,sect, "retry_count", &li->retry_count);
 231                 rc_getint(ncp_rc,sect, "sig_level", &li->sig_level);
 232                 if (rc_getint(ncp_rc,sect,"access_mode",&val) == 0)
 233                         li->access_mode = val;
 234                 if(rc_getbool(ncp_rc,sect,"bindery",&val) == 0 && val) {
 235                         li->opt |= NCP_OPT_BIND;
 236                 }
 237         }
 238         return 0;
 239 }
 240
 241 /*
 242  * check for all uncompleted fields
 243  */
 244 int
 245 ncp_li_check(struct ncp_conn_loginfo *li) {
 246         int error = 0;
 247         char *p;
 248
 249         do {
 250                 if (li->server[0] == 0) {
 251                         ncp_error("no server name specified", 0);
 252                         error = 1;
 253                         break;
 254                 }
 255                 error = ncp_find_fileserver(li,
 256                     (server_name==NULL) ? AF_IPX : AF_INET, server_name);
 257                 if (error) {
 258                         ncp_error("can't find server %s", error, li->server);
 259                         break;
 260                 }
 261                 if (li->user == NULL || li->user[0] == 0) {
 262                         ncp_error("no user name specified for server %s",
 263                             0, li->server);
 264                         error = 1;
 265                         break;
 266                 }
 267                 if (li->password == NULL) {
 268                         p = getpass("Netware password:");
 269                         error = ncp_li_setpassword(li, p) ? 1 : 0;
 270                 }
 271         } while (0);
 272         return error;
 273 }
 274
 275 int
 276 ncp_conn_cnt(void) {
 277         int error, cnt = 0, len = sizeof(cnt);
 278
 279         error = sysctlbyname("net.ncp.conn_cnt", &cnt, &len, NULL, 0);
 280         if (error) cnt = 0;
 281         return cnt;
 282 }
 283
 284 /*
 285  * Find an existing connection and reference it
 286  */
 287 int
 288 ncp_conn_find(char *server,char *user) {
 289         struct ncp_conn_args ca;
 290         int connid, error;
 291
 292         if (server == NULL && user == NULL) {
 293                 error = ncp_conn_scan(NULL,&connid);
 294                 if (error) return -2;
 295                 return connid;
 296         }
 297         if (server == NULL)
 298                 return -2;
 299         ncp_str_upper(server);
 300         if (user) ncp_str_upper(user);
 301         bzero(&ca, sizeof(ca));
 302         ncp_li_setserver(&ca, server);
 303         ncp_li_setuser(&ca, user);
 304         error = ncp_conn_scan(&ca,&connid);
 305         if (error)
 306                 connid = -1;
 307         return connid;
 308 }
 309
 310 int
 311 ncp_li_arg(struct ncp_conn_loginfo *li, int opt, char *arg) {
 312         int error = 0, sig_level;
 313         char *p, *cp;
 314         struct group *gr;
 315         struct passwd *pw;
 316
 317         switch(opt) {
 318             case 'S': /* we already fill server/[user] pair */
 319             case 'U':
 320                 break;
 321             case 'A':
 322                 server_name = arg;
 323                 break;
 324             case 'B':
 325                 li->opt |= NCP_OPT_BIND;
 326                 break;
 327             case 'C':
 328                 li->opt |= NCP_OPT_NOUPCASEPASS;
 329                 break;
 330             case 'I':
 331                 sig_level = atoi(arg);
 332                 if (sig_level < 0 || sig_level > 3) {
 333                         ncp_error("invalid NCP signature level option `%s'\
 334                             (must be a number between 0 and 3)", 0, arg);
 335                         error = 1;
 336                 }
 337                 li->sig_level = sig_level;
 338                 if (sig_level > 1) li->opt |= NCP_OPT_SIGN;
 339                 break;
 340             case 'M':
 341                 li->access_mode = strtol(arg, NULL, 8);
 342                 break;
 343             case 'N':
 344                 ncp_li_setpassword(li, "");
 345                 break;
 346             case 'O':
 347                 p = strdup(arg);
 348                 cp = strchr(p, ':');
 349                 if (cp) {
 350                         *cp++ = '\0';
 351                         if (*cp) {
 352                                 gr = getgrnam(cp);
 353                                 if (gr) {
 354                                         li->group = gr->gr_gid;
 355                                 } else
 356                                         ncp_error("Invalid group name %s, ignored",
 357                                             0, cp);
 358                         }
 359                 }
 360                 if (*p) {
 361                         pw = getpwnam(p);
 362                         if (pw) {
 363                                 li->owner = pw->pw_uid;
 364                         } else
 365                                 ncp_error("Invalid user name %s, ignored", 0, p);
 366                 }
 367                 endpwent();
 368                 free(p);
 369                 break;
 370             case 'P':
 371                 li->opt |= NCP_OPT_PERMANENT;
 372                 break;
 373             case 'R':
 374                 li->retry_count = atoi(arg);
 375                 break;
 376             case 'W':
 377                 li->timeout = atoi(arg);
 378                 break;
 379         }
 380         return error;
 381 }
 382
 383 void *
 384 ncp_conn_list(void) {
 385         int error, cnt = 0, len;
 386         void *p;
 387
 388         cnt = ncp_conn_cnt();
 389         if (cnt == 0) return NULL;
 390         len = cnt*(sizeof(struct ncp_conn_stat))+sizeof(int);
 391         p = malloc(len);
 392         if (p == NULL) return NULL;
 393         error = sysctlbyname("net.ncp.conn_stat", p, &len, NULL, 0);
 394         if (error) {
 395                 free(p);
 396                 p = NULL;
 397         }
 398         return p;
 399 }
 400
 401
 402 int
 403 ncp_conn_setflags(int connid, u_int16_t mask, u_int16_t flags) {
 404         int error;
 405         DECLARE_RQ;
 406
 407         ncp_init_request(conn);
 408         ncp_add_byte(conn, NCP_CONN_SETFLAGS);
 409         ncp_add_word_lh(conn, mask);
 410         ncp_add_word_lh(conn, flags);
 411         if ((error = ncp_conn_request(connid, conn)) < 0)
 412                 return -1;
 413         return error;
 414 }
 415
 416 int
 417 ncp_login(int connHandle, const char *user, int objtype, const char *password) {
 418         int error;
 419         struct ncp_conn_login *p;
 420         DECLARE_RQ;
 421
 422         ncp_init_request(conn);
 423         ncp_add_byte(conn, NCP_CONN_LOGIN);
 424         p = (struct ncp_conn_login *)&conn->packet[conn->rqsize];
 425         p->username = user;
 426         p->objtype = objtype;
 427         p->password = password;
 428         conn->rqsize += sizeof(*p);
 429         if ((error = ncp_conn_request(connHandle, conn)) < 0)
 430                 return -1;
 431         return error;
 432 }
 433
 434 int
 435 ncp_connect_addr(struct sockaddr *sa, NWCONN_HANDLE *chp) {
 436         int error;
 437         struct ncp_conn_args li;
 438
 439         bzero(&li, sizeof(li));
 440         bcopy(sa, &li.addr, sa->sa_len);
 441         /*
 442          * XXX Temporary !!!. server will be filled in kernel !!!
 443          */
 444         strcpy(li.server,ipx_ntoa(li.ipxaddr.sipx_addr));
 445         error = ncp_connect(&li, chp);
 446         return error;
 447 }
 448
 449 int
 450 ncp_conn_getinfo(int connHandle, struct ncp_conn_stat *ps) {
 451         int error;
 452         DECLARE_RQ;
 453
 454         ncp_init_request(conn);
 455         ncp_add_byte(conn, NCP_CONN_GETINFO);
 456         if ((error = ncp_conn_request(connHandle, conn)) < 0)
 457                 return -1;
 458         memcpy(ps, ncp_reply_data(conn,0), sizeof(*ps));
 459         return error;
 460 }
 461
 462 int
 463 ncp_conn_getuser(int connHandle, char **user) {
 464         int error;
 465         DECLARE_RQ;
 466
 467         ncp_init_request(conn);
 468         ncp_add_byte(conn, NCP_CONN_GETUSER);
 469         if ((error = ncp_conn_request(connHandle, conn)) < 0)
 470                 return -1;
 471         *user = strdup(ncp_reply_data(conn,0));
 472         return error;
 473 }
 474
 475 int
 476 ncp_conn2ref(int connHandle, int *connRef) {
 477         int error;
 478         DECLARE_RQ;
 479
 480         ncp_init_request(conn);
 481         ncp_add_byte(conn, NCP_CONN_CONN2REF);
 482         if ((error = ncp_conn_request(connHandle, conn)) < 0)
 483                 return -1;
 484         *connRef = *((int*)ncp_reply_data(conn,0));
 485         return error;
 486 }
 487
 488 int
 489 ncp_path2conn(char *path, int *connHandle) {
 490         struct statfs st;
 491         int d, error;
 492
 493         if ((error = statfs(path, &st)) != 0) return errno;
 494         if (strcmp(st.f_fstypename,"nwfs") != 0) return EINVAL;
 495         if ((d = open(path, O_RDONLY)) < 0) return errno;
 496         if ((error = ioctl(d,NWFSIOC_GETCONN, connHandle)) != 0) return errno;
 497         close(d);
 498         return 0;
 499 }
 500
 501 int
 502 ncp_conn_dup(NWCONN_HANDLE org, NWCONN_HANDLE *res) {
 503         int error;
 504         DECLARE_RQ;
 505
 506         ncp_init_request(conn);
 507         ncp_add_byte(conn, NCP_CONN_DUP);
 508         if ((error = ncp_conn_request(org, conn)) < 0)
 509                 return errno;
 510         *res = *((int*)ncp_reply_data(conn, 0));
 511         return 0;
 512 }