external/bsd/libbind/dist/irs/irpmarshall.c

   1 /*      $NetBSD$        */
   2
   3 /*
   4  * Copyright(c) 1989, 1993, 1995
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *      This product includes software developed by the University of
  18  *      California, Berkeley and its contributors.
  19  * 4. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 /*
  37  * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
  38  * Portions Copyright (c) 1996 by Internet Software Consortium.
  39  *
  40  * Permission to use, copy, modify, and distribute this software for any
  41  * purpose with or without fee is hereby granted, provided that the above
  42  * copyright notice and this permission notice appear in all copies.
  43  *
  44  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
  45  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  46  * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
  47  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  48  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  49  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  50  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  51  */
  52
  53 #if defined(LIBC_SCCS) && !defined(lint)
  54 static const char rcsid[] = "Id: irpmarshall.c,v 1.7 2006/03/09 23:57:56 marka Exp";
  55 #endif /* LIBC_SCCS and not lint */
  56
  57 #if 0
  58
  59 Check values are in approrpriate endian order.
  60
  61 Double check memory allocations on unmarhsalling
  62
  63 #endif
  64
  65
  66 /* Extern */
  67
  68 #include "port_before.h"
  69
  70 #include <sys/types.h>
  71 #include <sys/socket.h>
  72
  73 #include <netinet/in.h>
  74 #include <arpa/inet.h>
  75 #include <arpa/nameser.h>
  76
  77 #include <stdio.h>
  78 #include <ctype.h>
  79 #include <pwd.h>
  80 #include <stdlib.h>
  81 #include <string.h>
  82 #include <syslog.h>
  83 #include <utmp.h>
  84 #include <unistd.h>
  85 #include <assert.h>
  86 #include <errno.h>
  87
  88 #include <irs.h>
  89 #include <isc/memcluster.h>
  90 #include <isc/irpmarshall.h>
  91
  92 #include "port_after.h"
  93
  94
  95 #ifndef HAVE_STRNDUP
  96 static char    *strndup(const char *str, size_t len);
  97 #endif
  98
  99 static char   **splitarray(const char *buffer, const char *buffend, char delim);
 100 static int      joinarray(char * const * argv, char *buffer, char delim);
 101 static char    *getfield(char **res, size_t reslen, char **buffer, char delim);
 102 static size_t   joinlength(char * const *argv);
 103 static void     free_array(char **argv, size_t entries);
 104
 105 #define ADDR_T_STR(x) (x == AF_INET ? "AF_INET" :\
 106                        (x == AF_INET6 ? "AF_INET6" : "UNKNOWN"))
 107
 108 #define MAXPADDRSIZE (sizeof "255.255.255.255" + 1)
 109
 110 static char COMMA = ',';
 111
 112 static const char *COMMASTR = ",";
 113 static const char *COLONSTR = ":";
 114
 115
 116
 117 /* See big comment at bottom of irpmarshall.h for description. */
 118
 119
 120 #ifdef WANT_IRS_PW
 121 /* +++++++++++++++++++++++++ struct passwd +++++++++++++++++++++++++ */
 122
 123 /*%
 124  * int irp_marshall_pw(const struct passwd *pw, char **buffer, size_t *len)
 125  *
 126  * notes: \li
 127  *
 128  *      See irpmarshall.h
 129  *
 130  * return: \li
 131  *
 132  *      0 on sucess, -1 on failure.
 133  *
 134  */
 135
 136 int
 137 irp_marshall_pw(const struct passwd *pw, char **buffer, size_t *len) {
 138         size_t need = 1 ;               /*%< for null byte */
 139         char pwUid[24];
 140         char pwGid[24];
 141         char pwChange[24];
 142         char pwExpire[24];
 143         const char *pwClass;
 144         const char *fieldsep = COLONSTR;
 145
 146         if (pw == NULL || len == NULL) {
 147                 errno = EINVAL;
 148                 return (-1);
 149         }
 150
 151         sprintf(pwUid, "%ld", (long)pw->pw_uid);
 152         sprintf(pwGid, "%ld", (long)pw->pw_gid);
 153
 154 #ifdef HAVE_PW_CHANGE
 155         sprintf(pwChange, "%ld", (long)pw->pw_change);
 156 #else
 157         pwChange[0] = '0';
 158         pwChange[1] = '\0';
 159 #endif
 160
 161 #ifdef HAVE_PW_EXPIRE
 162         sprintf(pwExpire, "%ld", (long)pw->pw_expire);
 163 #else
 164         pwExpire[0] = '0';
 165         pwExpire[1] = '\0';
 166 #endif
 167
 168 #ifdef HAVE_PW_CLASS
 169         pwClass = pw->pw_class;
 170 #else
 171         pwClass = "";
 172 #endif
 173
 174         need += strlen(pw->pw_name)     + 1; /*%< one for fieldsep */
 175         need += strlen(pw->pw_passwd)   + 1;
 176         need += strlen(pwUid)           + 1;
 177         need += strlen(pwGid)           + 1;
 178         need += strlen(pwClass)         + 1;
 179         need += strlen(pwChange)        + 1;
 180         need += strlen(pwExpire)        + 1;
 181         need += strlen(pw->pw_gecos)    + 1;
 182         need += strlen(pw->pw_dir)      + 1;
 183         need += strlen(pw->pw_shell)    + 1;
 184
 185         if (buffer == NULL) {
 186                 *len = need;
 187                 return (0);
 188         }
 189
 190         if (*buffer != NULL && need > *len) {
 191                 errno = EINVAL;
 192                 return (-1);
 193         }
 194
 195         if (*buffer == NULL) {
 196                 need += 2;              /*%< for CRLF */
 197                 *buffer = memget(need);
 198                 if (*buffer == NULL) {
 199                         errno = ENOMEM;
 200                         return (-1);
 201                 }
 202
 203                 *len = need;
 204         }
 205
 206         strcpy(*buffer, pw->pw_name);           strcat(*buffer, fieldsep);
 207         strcat(*buffer, pw->pw_passwd);         strcat(*buffer, fieldsep);
 208         strcat(*buffer, pwUid);                 strcat(*buffer, fieldsep);
 209         strcat(*buffer, pwGid);                 strcat(*buffer, fieldsep);
 210         strcat(*buffer, pwClass);               strcat(*buffer, fieldsep);
 211         strcat(*buffer, pwChange);              strcat(*buffer, fieldsep);
 212         strcat(*buffer, pwExpire);              strcat(*buffer, fieldsep);
 213         strcat(*buffer, pw->pw_gecos);          strcat(*buffer, fieldsep);
 214         strcat(*buffer, pw->pw_dir);            strcat(*buffer, fieldsep);
 215         strcat(*buffer, pw->pw_shell);          strcat(*buffer, fieldsep);
 216
 217         return (0);
 218 }
 219
 220 /*%
 221  * int irp_unmarshall_pw(struct passwd *pw, char *buffer)
 222  *
 223  * notes: \li
 224  *
 225  *      See irpmarshall.h
 226  *
 227  * return: \li
 228  *
 229  *      0 on success, -1 on failure
 230  *
 231  */
 232
 233 int
 234 irp_unmarshall_pw(struct passwd *pw, char *buffer) {
 235         char *name, *pass, *class, *gecos, *dir, *shell;
 236         uid_t pwuid;
 237         gid_t pwgid;
 238         time_t pwchange;
 239         time_t pwexpire;
 240         char *p;
 241         long t;
 242         char tmpbuf[24];
 243         char *tb = &tmpbuf[0];
 244         char fieldsep = ':';
 245         int myerrno = EINVAL;
 246
 247         name = pass = class = gecos = dir = shell = NULL;
 248         p = buffer;
 249
 250         /* pw_name field */
 251         name = NULL;
 252         if (getfield(&name, 0, &p, fieldsep) == NULL || strlen(name) == 0) {
 253                 goto error;
 254         }
 255
 256         /* pw_passwd field */
 257         pass = NULL;
 258         if (getfield(&pass, 0, &p, fieldsep) == NULL) { /*%< field can be empty */
 259                 goto error;
 260         }
 261
 262
 263         /* pw_uid field */
 264         tb = tmpbuf;
 265         if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
 266             strlen(tb) == 0) {
 267                 goto error;
 268         }
 269         t = strtol(tmpbuf, &tb, 10);
 270         if (*tb) {
 271                 goto error;     /*%< junk in value */
 272         }
 273         pwuid = (uid_t)t;
 274         if ((long) pwuid != t) {        /*%< value must have been too big. */
 275                 goto error;
 276         }
 277
 278
 279
 280         /* pw_gid field */
 281         tb = tmpbuf;
 282         if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
 283             strlen(tb) == 0) {
 284                 goto error;
 285         }
 286         t = strtol(tmpbuf, &tb, 10);
 287         if (*tb) {
 288                 goto error;     /*%< junk in value */
 289         }
 290         pwgid = (gid_t)t;
 291         if ((long)pwgid != t) { /*%< value must have been too big. */
 292                 goto error;
 293         }
 294
 295
 296
 297         /* pw_class field */
 298         class = NULL;
 299         if (getfield(&class, 0, &p, fieldsep) == NULL) {
 300                 goto error;
 301         }
 302
 303
 304
 305         /* pw_change field */
 306         tb = tmpbuf;
 307         if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
 308             strlen(tb) == 0) {
 309                 goto error;
 310         }
 311         t = strtol(tmpbuf, &tb, 10);
 312         if (*tb) {
 313                 goto error;     /*%< junk in value */
 314         }
 315         pwchange = (time_t)t;
 316         if ((long)pwchange != t) {      /*%< value must have been too big. */
 317                 goto error;
 318         }
 319
 320
 321
 322         /* pw_expire field */
 323         tb = tmpbuf;
 324         if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
 325             strlen(tb) == 0) {
 326                 goto error;
 327         }
 328         t = strtol(tmpbuf, &tb, 10);
 329         if (*tb) {
 330                 goto error;     /*%< junk in value */
 331         }
 332         pwexpire = (time_t)t;
 333         if ((long) pwexpire != t) {     /*%< value must have been too big. */
 334                 goto error;
 335         }
 336
 337
 338
 339         /* pw_gecos field */
 340         gecos = NULL;
 341         if (getfield(&gecos, 0, &p, fieldsep) == NULL) {
 342                 goto error;
 343         }
 344
 345
 346
 347         /* pw_dir field */
 348         dir = NULL;
 349         if (getfield(&dir, 0, &p, fieldsep) == NULL) {
 350                 goto error;
 351         }
 352
 353
 354
 355         /* pw_shell field */
 356         shell = NULL;
 357         if (getfield(&shell, 0, &p, fieldsep) == NULL) {
 358                 goto error;
 359         }
 360
 361
 362
 363         pw->pw_name = name;
 364         pw->pw_passwd = pass;
 365         pw->pw_uid = pwuid;
 366         pw->pw_gid = pwgid;
 367         pw->pw_gecos = gecos;
 368         pw->pw_dir = dir;
 369         pw->pw_shell = shell;
 370
 371 #ifdef HAVE_PW_CHANGE
 372         pw->pw_change = pwchange;
 373 #endif
 374 #ifdef HAVE_PW_CLASS
 375         pw->pw_class = class;
 376 #endif
 377 #ifdef HAVE_PW_EXPIRE
 378         pw->pw_expire = pwexpire;
 379 #endif
 380
 381         return (0);
 382
 383  error:
 384         errno = myerrno;
 385
 386         if (name != NULL) free(name);
 387         if (pass != NULL) free(pass);
 388         if (gecos != NULL) free(gecos);
 389         if (dir != NULL) free(dir);
 390         if (shell != NULL) free(shell);
 391
 392         return (-1);
 393 }
 394
 395 /* ------------------------- struct passwd ------------------------- */
 396 #endif /* WANT_IRS_PW */
 397 /* +++++++++++++++++++++++++ struct group +++++++++++++++++++++++++ */
 398
 399 /*%
 400  * int irp_marshall_gr(const struct group *gr, char **buffer, size_t *len)
 401  *
 402  * notes: \li
 403  *
 404  *      See irpmarshall.h.
 405  *
 406  * return: \li
 407  *
 408  *      0 on success, -1 on failure
 409  */
 410
 411 int
 412 irp_marshall_gr(const struct group *gr, char **buffer, size_t *len) {
 413         size_t need = 1;        /*%< for null byte */
 414         char grGid[24];
 415         const char *fieldsep = COLONSTR;
 416
 417         if (gr == NULL || len == NULL) {
 418                 errno = EINVAL;
 419                 return (-1);
 420         }
 421
 422         sprintf(grGid, "%ld", (long)gr->gr_gid);
 423
 424         need += strlen(gr->gr_name) + 1;
 425 #ifndef MISSING_GR_PASSWD
 426         need += strlen(gr->gr_passwd) + 1;
 427 #else
 428         need++;
 429 #endif
 430         need += strlen(grGid) + 1;
 431         need += joinlength(gr->gr_mem) + 1;
 432
 433         if (buffer == NULL) {
 434                 *len = need;
 435                 return (0);
 436         }
 437
 438         if (*buffer != NULL && need > *len) {
 439                 errno = EINVAL;
 440                 return (-1);
 441         }
 442
 443         if (*buffer == NULL) {
 444                 need += 2;              /*%< for CRLF */
 445                 *buffer = memget(need);
 446                 if (*buffer == NULL) {
 447                         errno = ENOMEM;
 448                         return (-1);
 449                 }
 450
 451                 *len = need;
 452         }
 453
 454         strcpy(*buffer, gr->gr_name);           strcat(*buffer, fieldsep);
 455 #ifndef MISSING_GR_PASSWD
 456         strcat(*buffer, gr->gr_passwd);
 457 #endif
 458         strcat(*buffer, fieldsep);
 459         strcat(*buffer, grGid);                 strcat(*buffer, fieldsep);
 460         joinarray(gr->gr_mem, *buffer, COMMA) ; strcat(*buffer, fieldsep);
 461
 462         return (0);
 463 }
 464
 465 /*%
 466  * int irp_unmarshall_gr(struct group *gr, char *buffer)
 467  *
 468  * notes: \li
 469  *
 470  *      See irpmarshall.h
 471  *
 472  * return: \li
 473  *
 474  *      0 on success and -1 on failure.
 475  *
 476  */
 477
 478 int
 479 irp_unmarshall_gr(struct group *gr, char *buffer) {
 480         char *p, *q;
 481         gid_t grgid;
 482         long t;
 483         char *name = NULL;
 484         char *pass = NULL;
 485         char **members = NULL;
 486         char tmpbuf[24];
 487         char *tb;
 488         char fieldsep = ':';
 489         int myerrno = EINVAL;
 490
 491         if (gr == NULL || buffer == NULL) {
 492                 errno = EINVAL;
 493                 return (-1);
 494         }
 495
 496         p = buffer;
 497
 498         /* gr_name field */
 499         name = NULL;
 500         if (getfield(&name, 0, &p, fieldsep) == NULL || strlen(name) == 0U) {
 501                 goto error;
 502         }
 503
 504
 505         /* gr_passwd field */
 506         pass = NULL;
 507         if (getfield(&pass, 0, &p, fieldsep) == NULL) {
 508                 goto error;
 509         }
 510
 511
 512         /* gr_gid field */
 513         tb = tmpbuf;
 514         if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
 515             strlen(tb) == 0U) {
 516                 goto error;
 517         }
 518         t = strtol(tmpbuf, &tb, 10);
 519         if (*tb) {
 520                 goto error;     /*%< junk in value */
 521         }
 522         grgid = (gid_t)t;
 523         if ((long) grgid != t) {        /*%< value must have been too big. */
 524                 goto error;
 525         }
 526
 527
 528         /* gr_mem field. Member names are separated by commas */
 529         q = strchr(p, fieldsep);
 530         if (q == NULL) {
 531                 goto error;
 532         }
 533         members = splitarray(p, q, COMMA);
 534         if (members == NULL) {
 535                 myerrno = errno;
 536                 goto error;
 537         }
 538         p = q + 1;
 539
 540
 541         gr->gr_name = name;
 542 #ifndef MISSING_GR_PASSWD
 543         gr->gr_passwd = pass;
 544 #endif
 545         gr->gr_gid = grgid;
 546         gr->gr_mem = members;
 547
 548         return (0);
 549
 550  error:
 551         errno = myerrno;
 552
 553         if (name != NULL) free(name);
 554         if (pass != NULL) free(pass);
 555
 556         return (-1);
 557 }
 558
 559
 560 /* ------------------------- struct group ------------------------- */
 561
 562
 563
 564
 565 /* +++++++++++++++++++++++++ struct servent +++++++++++++++++++++++++ */
 566
 567 /*%
 568  * int irp_marshall_sv(const struct servent *sv, char **buffer, size_t *len)
 569  *
 570  * notes: \li
 571  *
 572  *      See irpmarshall.h
 573  *
 574  * return: \li
 575  *
 576  *      0 on success, -1 on failure.
 577  *
 578  */
 579
 580 int
 581 irp_marshall_sv(const struct servent *sv, char **buffer, size_t *len) {
 582         size_t need = 1;        /*%< for null byte */
 583         char svPort[24];
 584         const char *fieldsep = COLONSTR;
 585         short realport;
 586
 587         if (sv == NULL || len == NULL) {
 588                 errno = EINVAL;
 589                 return (-1);
 590         }
 591
 592         /* the int s_port field is actually a short in network order. We
 593            want host order to make the marshalled data look correct */
 594         realport = ntohs((short)sv->s_port);
 595         sprintf(svPort, "%d", realport);
 596
 597         need += strlen(sv->s_name) + 1;
 598         need += joinlength(sv->s_aliases) + 1;
 599         need += strlen(svPort) + 1;
 600         need += strlen(sv->s_proto) + 1;
 601
 602         if (buffer == NULL) {
 603                 *len = need;
 604                 return (0);
 605         }
 606
 607         if (*buffer != NULL && need > *len) {
 608                 errno = EINVAL;
 609                 return (-1);
 610         }
 611
 612         if (*buffer == NULL) {
 613                 need += 2;              /*%< for CRLF */
 614                 *buffer = memget(need);
 615                 if (*buffer == NULL) {
 616                         errno = ENOMEM;
 617                         return (-1);
 618                 }
 619
 620                 *len = need;
 621         }
 622
 623         strcpy(*buffer, sv->s_name);            strcat(*buffer, fieldsep);
 624         joinarray(sv->s_aliases, *buffer, COMMA); strcat(*buffer, fieldsep);
 625         strcat(*buffer, svPort);                strcat(*buffer, fieldsep);
 626         strcat(*buffer, sv->s_proto);           strcat(*buffer, fieldsep);
 627
 628         return (0);
 629 }
 630
 631 /*%
 632  * int irp_unmarshall_sv(struct servent *sv, char *buffer)
 633  *
 634  * notes: \li
 635  *
 636  *      See irpmarshall.h
 637  *
 638  * return: \li
 639  *
 640  *      0 on success, -1 on failure.
 641  *
 642  */
 643
 644 int
 645 irp_unmarshall_sv(struct servent *sv, char *buffer) {
 646         char *p, *q;
 647         short svport;
 648         long t;
 649         char *name = NULL;
 650         char *proto = NULL;
 651         char **aliases = NULL;
 652         char tmpbuf[24];
 653         char *tb;
 654         char fieldsep = ':';
 655         int myerrno = EINVAL;
 656
 657         if (sv == NULL || buffer == NULL)
 658                 return (-1);
 659
 660         p = buffer;
 661
 662
 663         /* s_name field */
 664         name = NULL;
 665         if (getfield(&name, 0, &p, fieldsep) == NULL || strlen(name) == 0U) {
 666                 goto error;
 667         }
 668
 669
 670         /* s_aliases field */
 671         q = strchr(p, fieldsep);
 672         if (q == NULL) {
 673                 goto error;
 674         }
 675         aliases = splitarray(p, q, COMMA);
 676         if (aliases == NULL) {
 677                 myerrno = errno;
 678                 goto error;
 679         }
 680         p = q + 1;
 681
 682
 683         /* s_port field */
 684         tb = tmpbuf;
 685         if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
 686             strlen(tb) == 0U) {
 687                 goto error;
 688         }
 689         t = strtol(tmpbuf, &tb, 10);
 690         if (*tb) {
 691                 goto error;     /*%< junk in value */
 692         }
 693         svport = (short)t;
 694         if ((long) svport != t) {       /*%< value must have been too big. */
 695                 goto error;
 696         }
 697         svport = htons(svport);
 698
 699         /* s_proto field */
 700         proto = NULL;
 701         if (getfield(&proto, 0, &p, fieldsep) == NULL) {
 702                 goto error;
 703         }
 704
 705         sv->s_name = name;
 706         sv->s_aliases = aliases;
 707         sv->s_port = svport;
 708         sv->s_proto = proto;
 709
 710         return (0);
 711
 712  error:
 713         errno = myerrno;
 714
 715         if (name != NULL) free(name);
 716         if (proto != NULL) free(proto);
 717         free_array(aliases, 0);
 718
 719         return (-1);
 720 }
 721
 722
 723 /* ------------------------- struct servent ------------------------- */
 724
 725 /* +++++++++++++++++++++++++ struct protoent +++++++++++++++++++++++++ */
 726
 727 /*%
 728  * int irp_marshall_pr(struct protoent *pr, char **buffer, size_t *len)
 729  *
 730  * notes: \li
 731  *
 732  *      See irpmarshall.h
 733  *
 734  * return: \li
 735  *
 736  *      0 on success and -1 on failure.
 737  *
 738  */
 739
 740 int
 741 irp_marshall_pr(struct protoent *pr, char **buffer, size_t *len) {
 742         size_t need = 1;        /*%< for null byte */
 743         char prProto[24];
 744         const char *fieldsep = COLONSTR;
 745
 746         if (pr == NULL || len == NULL) {
 747                 errno = EINVAL;
 748                 return (-1);
 749         }
 750
 751         sprintf(prProto, "%d", (int)pr->p_proto);
 752
 753         need += strlen(pr->p_name) + 1;
 754         need += joinlength(pr->p_aliases) + 1;
 755         need += strlen(prProto) + 1;
 756
 757         if (buffer == NULL) {
 758                 *len = need;
 759                 return (0);
 760         }
 761
 762         if (*buffer != NULL && need > *len) {
 763                 errno = EINVAL;
 764                 return (-1);
 765         }
 766
 767         if (*buffer == NULL) {
 768                 need += 2;              /*%< for CRLF */
 769                 *buffer = memget(need);
 770                 if (*buffer == NULL) {
 771                         errno = ENOMEM;
 772                         return (-1);
 773                 }
 774
 775                 *len = need;
 776         }
 777
 778         strcpy(*buffer, pr->p_name);            strcat(*buffer, fieldsep);
 779         joinarray(pr->p_aliases, *buffer, COMMA); strcat(*buffer, fieldsep);
 780         strcat(*buffer, prProto);               strcat(*buffer, fieldsep);
 781
 782         return (0);
 783
 784 }
 785
 786 /*%
 787  * int irp_unmarshall_pr(struct protoent *pr, char *buffer)
 788  *
 789  * notes: \li
 790  *
 791  *      See irpmarshall.h
 792  *
 793  * return: \li
 794  *
 795  *      0 on success, -1 on failure
 796  *
 797  */
 798
 799 int irp_unmarshall_pr(struct protoent *pr, char *buffer) {
 800         char *p, *q;
 801         int prproto;
 802         long t;
 803         char *name = NULL;
 804         char **aliases = NULL;
 805         char tmpbuf[24];
 806         char *tb;
 807         char fieldsep = ':';
 808         int myerrno = EINVAL;
 809
 810         if (pr == NULL || buffer == NULL) {
 811                 errno = EINVAL;
 812                 return (-1);
 813         }
 814
 815         p = buffer;
 816
 817         /* p_name field */
 818         name = NULL;
 819         if (getfield(&name, 0, &p, fieldsep) == NULL || strlen(name) == 0U) {
 820                 goto error;
 821         }
 822
 823
 824         /* p_aliases field */
 825         q = strchr(p, fieldsep);
 826         if (q == NULL) {
 827                 goto error;
 828         }
 829         aliases = splitarray(p, q, COMMA);
 830         if (aliases == NULL) {
 831                 myerrno = errno;
 832                 goto error;
 833         }
 834         p = q + 1;
 835
 836
 837         /* p_proto field */
 838         tb = tmpbuf;
 839         if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
 840             strlen(tb) == 0U) {
 841                 goto error;
 842         }
 843         t = strtol(tmpbuf, &tb, 10);
 844         if (*tb) {
 845                 goto error;     /*%< junk in value */
 846         }
 847         prproto = (int)t;
 848         if ((long) prproto != t) {      /*%< value must have been too big. */
 849                 goto error;
 850         }
 851
 852         pr->p_name = name;
 853         pr->p_aliases = aliases;
 854         pr->p_proto = prproto;
 855
 856         return (0);
 857
 858  error:
 859         errno = myerrno;
 860
 861         if (name != NULL) free(name);
 862         free_array(aliases, 0);
 863
 864         return (-1);
 865 }
 866
 867 /* ------------------------- struct protoent ------------------------- */
 868
 869
 870
 871 /* +++++++++++++++++++++++++ struct hostent +++++++++++++++++++++++++ */
 872
 873 /*%
 874  * int irp_marshall_ho(struct hostent *ho, char **buffer, size_t *len)
 875  *
 876  * notes: \li
 877  *
 878  *      See irpmarshall.h.
 879  *
 880  * return: \li
 881  *
 882  *      0 on success, -1 on failure.
 883  *
 884  */
 885
 886 int
 887 irp_marshall_ho(struct hostent *ho, char **buffer, size_t *len) {
 888         size_t need = 1;        /*%< for null byte */
 889         char hoaddrtype[24];
 890         char holength[24];
 891         char **av;
 892         char *p;
 893         int addrlen;
 894         int malloced = 0;
 895         size_t remlen;
 896         const char *fieldsep = "@";
 897
 898         if (ho == NULL || len == NULL) {
 899                 errno = EINVAL;
 900                 return (-1);
 901         }
 902
 903         switch(ho->h_addrtype) {
 904         case AF_INET:
 905                 strcpy(hoaddrtype, "AF_INET");
 906                 break;
 907
 908         case AF_INET6:
 909                 strcpy(hoaddrtype, "AF_INET6");
 910                 break;
 911
 912         default:
 913                 errno = EINVAL;
 914                 return (-1);
 915         }
 916
 917         sprintf(holength, "%d", ho->h_length);
 918
 919         need += strlen(ho->h_name) + 1;
 920         need += joinlength(ho->h_aliases) + 1;
 921         need += strlen(hoaddrtype) + 1;
 922         need += strlen(holength) + 1;
 923
 924         /* we determine an upper bound on the string length needed, not an
 925            exact length. */
 926         addrlen = (ho->h_addrtype == AF_INET ? 16 : 46) ; /*%< XX other AF's?? */
 927         for (av = ho->h_addr_list; av != NULL && *av != NULL ; av++)
 928                 need += addrlen;
 929
 930         if (buffer == NULL) {
 931                 *len = need;
 932                 return (0);
 933         }
 934
 935         if (*buffer != NULL && need > *len) {
 936                 errno = EINVAL;
 937                 return (-1);
 938         }
 939
 940         if (*buffer == NULL) {
 941                 need += 2;              /*%< for CRLF */
 942                 *buffer = memget(need);
 943                 if (*buffer == NULL) {
 944                         errno = ENOMEM;
 945                         return (-1);
 946                 }
 947
 948                 *len = need;
 949                 malloced = 1;
 950         }
 951
 952         strcpy(*buffer, ho->h_name);            strcat(*buffer, fieldsep);
 953         joinarray(ho->h_aliases, *buffer, COMMA); strcat(*buffer, fieldsep);
 954         strcat(*buffer, hoaddrtype);            strcat(*buffer, fieldsep);
 955         strcat(*buffer, holength);              strcat(*buffer, fieldsep);
 956
 957         p = *buffer + strlen(*buffer);
 958         remlen = need - strlen(*buffer);
 959         for (av = ho->h_addr_list ; av != NULL && *av != NULL ; av++) {
 960                 if (inet_ntop(ho->h_addrtype, *av, p, remlen) == NULL) {
 961                         goto error;
 962                 }
 963                 if (*(av + 1) != NULL)
 964                         strcat(p, COMMASTR);
 965                 remlen -= strlen(p);
 966                 p += strlen(p);
 967         }
 968         strcat(*buffer, fieldsep);
 969
 970         return (0);
 971
 972  error:
 973         if (malloced) {
 974                 memput(*buffer, need);
 975         }
 976
 977         return (-1);
 978 }
 979
 980 /*%
 981  * int irp_unmarshall_ho(struct hostent *ho, char *buffer)
 982  *
 983  * notes: \li
 984  *
 985  *      See irpmarshall.h.
 986  *
 987  * return: \li
 988  *
 989  *      0 on success, -1 on failure.
 990  *
 991  */
 992
 993 int
 994 irp_unmarshall_ho(struct hostent *ho, char *buffer) {
 995         char *p, *q, *r;
 996         int hoaddrtype;
 997         int holength;
 998         long t;
 999         char *name;
1000         char **aliases = NULL;
1001         char **hohaddrlist = NULL;
1002         size_t hoaddrsize;
1003         char tmpbuf[24];
1004         char *tb;
1005         char **alist;
1006         int addrcount;
1007         char fieldsep = '@';
1008         int myerrno = EINVAL;
1009
1010         if (ho == NULL || buffer == NULL) {
1011                 errno = EINVAL;
1012                 return (-1);
1013         }
1014
1015         p = buffer;
1016
1017         /* h_name field */
1018         name = NULL;
1019         if (getfield(&name, 0, &p, fieldsep) == NULL || strlen(name) == 0U) {
1020                 goto error;
1021         }
1022
1023
1024         /* h_aliases field */
1025         q = strchr(p, fieldsep);
1026         if (q == NULL) {
1027                 goto error;
1028         }
1029         aliases = splitarray(p, q, COMMA);
1030         if (aliases == NULL) {
1031                 myerrno = errno;
1032                 goto error;
1033         }
1034         p = q + 1;
1035
1036
1037         /* h_addrtype field */
1038         tb = tmpbuf;
1039         if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
1040             strlen(tb) == 0U) {
1041                 goto error;
1042         }
1043         if (strcmp(tmpbuf, "AF_INET") == 0)
1044                 hoaddrtype = AF_INET;
1045         else if (strcmp(tmpbuf, "AF_INET6") == 0)
1046                 hoaddrtype = AF_INET6;
1047         else
1048                 goto error;
1049
1050
1051         /* h_length field */
1052         tb = tmpbuf;
1053         if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
1054             strlen(tb) == 0U) {
1055                 goto error;
1056         }
1057         t = strtol(tmpbuf, &tb, 10);
1058         if (*tb) {
1059                 goto error;     /*%< junk in value */
1060         }
1061         holength = (int)t;
1062         if ((long) holength != t) {     /*%< value must have been too big. */
1063                 goto error;
1064         }
1065
1066
1067         /* h_addr_list field */
1068         q = strchr(p, fieldsep);
1069         if (q == NULL)
1070                 goto error;
1071
1072         /* count how many addresss are in there */
1073         if (q > p + 1) {
1074                 for (addrcount = 1, r = p ; r != q ; r++) {
1075                         if (*r == COMMA)
1076                                 addrcount++;
1077                 }
1078         } else {
1079                 addrcount = 0;
1080         }
1081
1082         hoaddrsize = (addrcount + 1) * sizeof (char *);
1083         hohaddrlist = malloc(hoaddrsize);
1084         if (hohaddrlist == NULL) {
1085                 myerrno = ENOMEM;
1086                 goto error;
1087         }
1088
1089         memset(hohaddrlist, 0x0, hoaddrsize);
1090
1091         alist = hohaddrlist;
1092         for (t = 0, r = p ; r != q ; p = r + 1, t++) {
1093                 char saved;
1094                 while (r != q && *r != COMMA) r++;
1095                 saved = *r;
1096                 *r = 0x0;
1097
1098                 alist[t] = malloc(hoaddrtype == AF_INET ? 4 : 16);
1099                 if (alist[t] == NULL) {
1100                         myerrno = ENOMEM;
1101                         goto error;
1102                 }
1103
1104                 if (inet_pton(hoaddrtype, p, alist[t]) == -1)
1105                         goto error;
1106                 *r = saved;
1107         }
1108         alist[t] = NULL;
1109
1110         ho->h_name = name;
1111         ho->h_aliases = aliases;
1112         ho->h_addrtype = hoaddrtype;
1113         ho->h_length = holength;
1114         ho->h_addr_list = hohaddrlist;
1115
1116         return (0);
1117
1118  error:
1119         errno = myerrno;
1120
1121         if (name != NULL) free(name);
1122         free_array(hohaddrlist, 0);
1123         free_array(aliases, 0);
1124
1125         return (-1);
1126 }
1127
1128 /* ------------------------- struct hostent------------------------- */
1129
1130
1131
1132 /* +++++++++++++++++++++++++ struct netgrp +++++++++++++++++++++++++ */
1133
1134 /*%
1135  * int irp_marshall_ng(const char *host, const char *user,
1136  *                     const char *domain, char *buffer, size_t *len)
1137  *
1138  * notes: \li
1139  *
1140  *      See note for irp_marshall_ng_start
1141  *
1142  * return: \li
1143  *
1144  *      0 on success, 0 on failure.
1145  *
1146  */
1147
1148 int
1149 irp_marshall_ng(const char *host, const char *user, const char *domain,
1150                 char **buffer, size_t *len) {
1151         size_t need = 1; /*%< for nul byte */
1152         const char *fieldsep = ",";
1153
1154         if (len == NULL) {
1155                 errno = EINVAL;
1156                 return (-1);
1157         }
1158
1159         need += 4;                     /*%< two parens and two commas */
1160         need += (host == NULL ? 0 : strlen(host));
1161         need += (user == NULL ? 0 : strlen(user));
1162         need += (domain == NULL ? 0 : strlen(domain));
1163
1164         if (buffer == NULL) {
1165                 *len = need;
1166                 return (0);
1167         } else if (*buffer != NULL && need > *len) {
1168                 errno = EINVAL;
1169                 return (-1);
1170         }
1171
1172         if (*buffer == NULL) {
1173                 need += 2;              /*%< for CRLF */
1174                 *buffer = memget(need);
1175                 if (*buffer == NULL) {
1176                         errno = ENOMEM;
1177                         return (-1);
1178                 }
1179
1180                 *len = need;
1181         }
1182
1183         (*buffer)[0] = '(';
1184         (*buffer)[1] = '\0';
1185
1186         if (host != NULL)
1187                 strcat(*buffer, host);
1188         strcat(*buffer, fieldsep);
1189
1190         if (user != NULL)
1191                 strcat(*buffer, user);
1192         strcat(*buffer, fieldsep);
1193
1194         if (domain != NULL)
1195                 strcat(*buffer, domain);
1196         strcat(*buffer, ")");
1197
1198         return (0);
1199 }
1200
1201
1202
1203 /* ---------- */
1204
1205 /*%
1206  * int irp_unmarshall_ng(const char **host, const char **user,
1207  *                       const char **domain, char *buffer)
1208  *
1209  * notes: \li
1210  *
1211  *      Unpacks the BUFFER into 3 character arrays it allocates and assigns
1212  *      to *HOST, *USER and *DOMAIN. If any field of the value is empty,
1213  *      then the corresponding paramater value will be set to NULL.
1214  *
1215  * return: \li
1216  *
1217  *      0 on success and -1 on failure.
1218  */
1219
1220 int
1221 irp_unmarshall_ng(const char **hostp, const char **userp, const char **domainp,
1222                   char *buffer)
1223 {
1224         char *p, *q;
1225         char fieldsep = ',';
1226         int myerrno = EINVAL;
1227         char *host, *user, *domain;
1228
1229         if (userp == NULL || hostp == NULL ||
1230             domainp == NULL || buffer == NULL) {
1231                 errno = EINVAL;
1232                 return (-1);
1233         }
1234
1235         host = user = domain = NULL;
1236
1237         p = buffer;
1238         while (isspace((unsigned char)*p)) {
1239                 p++;
1240         }
1241         if (*p != '(') {
1242                 goto error;
1243         }
1244
1245         q = p + 1;
1246         while (*q && *q != fieldsep)
1247                 q++;
1248         if (!*q) {
1249                 goto error;
1250         } else if (q > p + 1) {
1251                 host = strndup(p, q - p);
1252         }
1253
1254         p = q + 1;
1255         if (!*p) {
1256                 goto error;
1257         } else if (*p != fieldsep) {
1258                 q = p + 1;
1259                 while (*q && *q != fieldsep)
1260                         q++;
1261                 if (!*q) {
1262                         goto error;
1263                 }
1264                 user = strndup(p, q - p);
1265         } else {
1266                 p++;
1267         }
1268
1269         if (!*p) {
1270                 goto error;
1271         } else if (*p != ')') {
1272                 q = p + 1;
1273                 while (*q && *q != ')')
1274                         q++;
1275                 if (!*q) {
1276                         goto error;
1277                 }
1278                 domain = strndup(p, q - p);
1279         }
1280         *hostp = host;
1281         *userp = user;
1282         *domainp = domain;
1283
1284         return (0);
1285
1286  error:
1287         errno = myerrno;
1288
1289         if (host != NULL) free(host);
1290         if (user != NULL) free(user);
1291
1292         return (-1);
1293 }
1294
1295 /* ------------------------- struct netgrp ------------------------- */
1296
1297
1298
1299
1300 /* +++++++++++++++++++++++++ struct nwent +++++++++++++++++++++++++ */
1301
1302 /*%
1303  * int irp_marshall_nw(struct nwent *ne, char **buffer, size_t *len)
1304  *
1305  * notes: \li
1306  *
1307  *      See at top.
1308  *
1309  * return: \li
1310  *
1311  *      0 on success and -1 on failure.
1312  *
1313  */
1314
1315 int
1316 irp_marshall_nw(struct nwent *ne, char **buffer, size_t *len) {
1317         size_t need = 1;        /*%< for null byte */
1318         char nAddrType[24];
1319         char nNet[MAXPADDRSIZE];
1320         const char *fieldsep = COLONSTR;
1321
1322         if (ne == NULL || len == NULL) {
1323                 return (-1);
1324         }
1325
1326         strcpy(nAddrType, ADDR_T_STR(ne->n_addrtype));
1327
1328         if (inet_net_ntop(ne->n_addrtype, ne->n_addr, ne->n_length,
1329                           nNet, sizeof nNet) == NULL) {
1330                 return (-1);
1331         }
1332
1333
1334         need += strlen(ne->n_name) + 1;
1335         need += joinlength(ne->n_aliases) + 1;
1336         need += strlen(nAddrType) + 1;
1337         need += strlen(nNet) + 1;
1338
1339         if (buffer == NULL) {
1340                 *len = need;
1341                 return (0);
1342         }
1343
1344         if (*buffer != NULL && need > *len) {
1345                 errno = EINVAL;
1346                 return (-1);
1347         }
1348
1349         if (*buffer == NULL) {
1350                 need += 2;              /*%< for CRLF */
1351                 *buffer = memget(need);
1352                 if (*buffer == NULL) {
1353                         errno = ENOMEM;
1354                         return (-1);
1355                 }
1356
1357                 *len = need;
1358         }
1359
1360         strcpy(*buffer, ne->n_name);            strcat(*buffer, fieldsep);
1361         joinarray(ne->n_aliases, *buffer, COMMA) ; strcat(*buffer, fieldsep);
1362         strcat(*buffer, nAddrType);             strcat(*buffer, fieldsep);
1363         strcat(*buffer, nNet);                  strcat(*buffer, fieldsep);
1364
1365         return (0);
1366 }
1367
1368 /*%
1369  * int irp_unmarshall_nw(struct nwent *ne, char *buffer)
1370  *
1371  * notes: \li
1372  *
1373  *      See note up top.
1374  *
1375  * return: \li
1376  *
1377  *      0 on success and -1 on failure.
1378  *
1379  */
1380
1381 int
1382 irp_unmarshall_nw(struct nwent *ne, char *buffer) {
1383         char *p, *q;
1384         int naddrtype;
1385         long nnet;
1386         int bits;
1387         char *name = NULL;
1388         char **aliases = NULL;
1389         char tmpbuf[24];
1390         char *tb;
1391         char fieldsep = ':';
1392         int myerrno = EINVAL;
1393
1394         if (ne == NULL || buffer == NULL) {
1395                 goto error;
1396         }
1397
1398         p = buffer;
1399
1400         /* n_name field */
1401         name = NULL;
1402         if (getfield(&name, 0, &p, fieldsep) == NULL || strlen(name) == 0U) {
1403                 goto error;
1404         }
1405
1406
1407         /* n_aliases field. Aliases are separated by commas */
1408         q = strchr(p, fieldsep);
1409         if (q == NULL) {
1410                 goto error;
1411         }
1412         aliases = splitarray(p, q, COMMA);
1413         if (aliases == NULL) {
1414                 myerrno = errno;
1415                 goto error;
1416         }
1417         p = q + 1;
1418
1419
1420         /* h_addrtype field */
1421         tb = tmpbuf;
1422         if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
1423             strlen(tb) == 0U) {
1424                 goto error;
1425         }
1426         if (strcmp(tmpbuf, "AF_INET") == 0)
1427                 naddrtype = AF_INET;
1428         else if (strcmp(tmpbuf, "AF_INET6") == 0)
1429                 naddrtype = AF_INET6;
1430         else
1431                 goto error;
1432
1433
1434         /* n_net field */
1435         tb = tmpbuf;
1436         if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
1437             strlen(tb) == 0U) {
1438                 goto error;
1439         }
1440         nnet = 0;
1441         bits = inet_net_pton(naddrtype, tmpbuf, &nnet, sizeof nnet);
1442         if (bits < 0) {
1443                 goto error;
1444         }
1445
1446         /* nnet = ntohl(nnet); */ /* keep in network order for nwent */
1447
1448         ne->n_name = name;
1449         ne->n_aliases = aliases;
1450         ne->n_addrtype = naddrtype;
1451         ne->n_length = bits;
1452         ne->n_addr = malloc(sizeof nnet);
1453         if (ne->n_addr == NULL) {
1454                 goto error;
1455         }
1456
1457         memcpy(ne->n_addr, &nnet, sizeof nnet);
1458
1459         return (0);
1460
1461  error:
1462         errno = myerrno;
1463
1464         if (name != NULL) free(name);
1465         free_array(aliases, 0);
1466
1467         return (-1);
1468 }
1469
1470
1471 /* ------------------------- struct nwent ------------------------- */
1472
1473
1474 /* +++++++++++++++++++++++++ struct netent +++++++++++++++++++++++++ */
1475
1476 /*%
1477  * int irp_marshall_ne(struct netent *ne, char **buffer, size_t *len)
1478  *
1479  * notes: \li
1480  *
1481  *      See at top.
1482  *
1483  * return: \li
1484  *
1485  *      0 on success and -1 on failure.
1486  *
1487  */
1488
1489 int
1490 irp_marshall_ne(struct netent *ne, char **buffer, size_t *len) {
1491         size_t need = 1;        /*%< for null byte */
1492         char nAddrType[24];
1493         char nNet[MAXPADDRSIZE];
1494         const char *fieldsep = COLONSTR;
1495         long nval;
1496
1497         if (ne == NULL || len == NULL) {
1498                 return (-1);
1499         }
1500
1501         strcpy(nAddrType, ADDR_T_STR(ne->n_addrtype));
1502
1503         nval = htonl(ne->n_net);
1504         if (inet_ntop(ne->n_addrtype, &nval, nNet, sizeof nNet) == NULL) {
1505                 return (-1);
1506         }
1507
1508         need += strlen(ne->n_name) + 1;
1509         need += joinlength(ne->n_aliases) + 1;
1510         need += strlen(nAddrType) + 1;
1511         need += strlen(nNet) + 1;
1512
1513         if (buffer == NULL) {
1514                 *len = need;
1515                 return (0);
1516         }
1517
1518         if (*buffer != NULL && need > *len) {
1519                 errno = EINVAL;
1520                 return (-1);
1521         }
1522
1523         if (*buffer == NULL) {
1524                 need += 2;              /*%< for CRLF */
1525                 *buffer = memget(need);
1526                 if (*buffer == NULL) {
1527                         errno = ENOMEM;
1528                         return (-1);
1529                 }
1530
1531                 *len = need;
1532         }
1533
1534         strcpy(*buffer, ne->n_name);            strcat(*buffer, fieldsep);
1535         joinarray(ne->n_aliases, *buffer, COMMA) ; strcat(*buffer, fieldsep);
1536         strcat(*buffer, nAddrType);             strcat(*buffer, fieldsep);
1537         strcat(*buffer, nNet);                  strcat(*buffer, fieldsep);
1538
1539         return (0);
1540 }
1541
1542 /*%
1543  * int irp_unmarshall_ne(struct netent *ne, char *buffer)
1544  *
1545  * notes: \li
1546  *
1547  *      See note up top.
1548  *
1549  * return: \li
1550  *
1551  *      0 on success and -1 on failure.
1552  *
1553  */
1554
1555 int
1556 irp_unmarshall_ne(struct netent *ne, char *buffer) {
1557         char *p, *q;
1558         int naddrtype;
1559         long nnet;
1560         int bits;
1561         char *name = NULL;
1562         char **aliases = NULL;
1563         char tmpbuf[24];
1564         char *tb;
1565         char fieldsep = ':';
1566         int myerrno = EINVAL;
1567
1568         if (ne == NULL || buffer == NULL) {
1569                 goto error;
1570         }
1571
1572         p = buffer;
1573
1574         /* n_name field */
1575         name = NULL;
1576         if (getfield(&name, 0, &p, fieldsep) == NULL || strlen(name) == 0U) {
1577                 goto error;
1578         }
1579
1580
1581         /* n_aliases field. Aliases are separated by commas */
1582         q = strchr(p, fieldsep);
1583         if (q == NULL) {
1584                 goto error;
1585         }
1586         aliases = splitarray(p, q, COMMA);
1587         if (aliases == NULL) {
1588                 myerrno = errno;
1589                 goto error;
1590         }
1591         p = q + 1;
1592
1593
1594         /* h_addrtype field */
1595         tb = tmpbuf;
1596         if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
1597             strlen(tb) == 0U) {
1598                 goto error;
1599         }
1600         if (strcmp(tmpbuf, "AF_INET") == 0)
1601                 naddrtype = AF_INET;
1602         else if (strcmp(tmpbuf, "AF_INET6") == 0)
1603                 naddrtype = AF_INET6;
1604         else
1605                 goto error;
1606
1607
1608         /* n_net field */
1609         tb = tmpbuf;
1610         if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
1611             strlen(tb) == 0U) {
1612                 goto error;
1613         }
1614         bits = inet_net_pton(naddrtype, tmpbuf, &nnet, sizeof nnet);
1615         if (bits < 0) {
1616                 goto error;
1617         }
1618         nnet = ntohl(nnet);
1619
1620         ne->n_name = name;
1621         ne->n_aliases = aliases;
1622         ne->n_addrtype = naddrtype;
1623         ne->n_net = nnet;
1624
1625         return (0);
1626
1627  error:
1628         errno = myerrno;
1629
1630         if (name != NULL) free(name);
1631         free_array(aliases, 0);
1632
1633         return (-1);
1634 }
1635
1636
1637 /* ------------------------- struct netent ------------------------- */
1638
1639
1640 /* =========================================================================== */
1641
1642 /*%
1643  * static char ** splitarray(const char *buffer, const char *buffend, char delim)
1644  *
1645  * notes: \li
1646  *
1647  *      Split a delim separated astring. Not allowed
1648  *      to have two delims next to each other. BUFFER points to begining of
1649  *      string, BUFFEND points to one past the end of the string
1650  *      (i.e. points at where the null byte would be if null
1651  *      terminated).
1652  *
1653  * return: \li
1654  *
1655  *      Returns a malloced array of pointers, each pointer pointing to a
1656  *      malloced string. If BUFEER is an empty string, then return values is
1657  *      array of 1 pointer that is NULL. Returns NULL on failure.
1658  *
1659  */
1660
1661 static char **
1662 splitarray(const char *buffer, const char *buffend, char delim) {
1663         const char *p, *q;
1664         int count = 0;
1665         char **arr = NULL;
1666         char **aptr;
1667
1668         if (buffend < buffer)
1669                 return (NULL);
1670         else if (buffend > buffer && *buffer == delim)
1671                 return (NULL);
1672         else if (buffend > buffer && *(buffend - 1) == delim)
1673                 return (NULL);
1674
1675         /* count the number of field and make sure none are empty */
1676         if (buffend > buffer + 1) {
1677                 for (count = 1, q = buffer ; q != buffend ; q++) {
1678                         if (*q == delim) {
1679                                 if (q > buffer && (*(q - 1) == delim)) {
1680                                         errno = EINVAL;
1681                                         return (NULL);
1682                                 }
1683                                 count++;
1684                         }
1685                 }
1686         }
1687
1688         if (count > 0) {
1689                 count++ ;               /*%< for NULL at end */
1690                 aptr = arr = malloc(count * sizeof (char *));
1691                 if (aptr == NULL) {
1692                          errno = ENOMEM;
1693                          return (NULL);
1694                  }
1695
1696                 memset(arr, 0x0, count * sizeof (char *));
1697                 for (p = buffer ; p < buffend ; p++) {
1698                         for (q = p ; *q != delim && q != buffend ; q++)
1699                                 /* nothing */;
1700                         *aptr = strndup(p, q - p);
1701
1702                         p = q;
1703                         aptr++;
1704                 }
1705                 *aptr = NULL;
1706         } else {
1707                 arr = malloc(sizeof (char *));
1708                 if (arr == NULL) {
1709                         errno = ENOMEM;
1710                         return (NULL);
1711                 }
1712
1713                 *arr = NULL;
1714         }
1715
1716         return (arr);
1717 }
1718
1719 /*%
1720  * static size_t joinlength(char * const *argv)
1721  *
1722  * return: \li
1723  *
1724  *      the number of bytes in all the arrays pointed at
1725  *      by argv, including their null bytes(which will usually be turned
1726  *      into commas).
1727  *
1728  *
1729  */
1730
1731 static size_t
1732 joinlength(char * const *argv) {
1733         int len = 0;
1734
1735         while (argv && *argv) {
1736                 len += (strlen(*argv) + 1);
1737                 argv++;
1738         }
1739
1740         return (len);
1741 }
1742
1743 /*%
1744  * int joinarray(char * const *argv, char *buffer, char delim)
1745  *
1746  * notes: \li
1747  *
1748  *      Copy all the ARGV strings into the end of BUFFER
1749  *      separating them with DELIM.  BUFFER is assumed to have
1750  *      enough space to hold everything and to be already null-terminated.
1751  *
1752  * return: \li
1753  *
1754  *      0 unless argv or buffer is NULL.
1755  *
1756  *
1757  */
1758
1759 static int
1760 joinarray(char * const *argv, char *buffer, char delim) {
1761         char * const *p;
1762         char sep[2];
1763
1764         if (argv == NULL || buffer == NULL) {
1765                 errno = EINVAL;
1766                 return (-1);
1767         }
1768
1769         sep[0] = delim;
1770         sep[1] = 0x0;
1771
1772         for (p = argv ; *p != NULL ; p++) {
1773                 strcat(buffer, *p);
1774                 if (*(p + 1) != NULL) {
1775                         strcat(buffer, sep);
1776                 }
1777         }
1778
1779         return (0);
1780 }
1781
1782 /*%
1783  * static char * getfield(char **res, size_t reslen, char **ptr, char delim)
1784  *
1785  * notes: \li
1786  *
1787  *      Stores in *RES, which is a buffer of length RESLEN, a
1788  *      copy of the bytes from *PTR up to and including the first
1789  *      instance of DELIM. If *RES is NULL, then it will be
1790  *      assigned a malloced buffer to hold the copy. *PTR is
1791  *      modified to point at the found delimiter.
1792  *
1793  * return: \li
1794  *
1795  *      If there was no delimiter, then NULL is returned,
1796  *      otherewise *RES is returned.
1797  *
1798  */
1799
1800 static char *
1801 getfield(char **res, size_t reslen, char **ptr, char delim) {
1802         char *q;
1803
1804         if (res == NULL || ptr == NULL || *ptr == NULL) {
1805                 errno = EINVAL;
1806                 return (NULL);
1807         }
1808
1809         q = strchr(*ptr, delim);
1810
1811         if (q == NULL) {
1812                 errno = EINVAL;
1813                 return (NULL);
1814         } else {
1815                 if (*res == NULL) {
1816                         *res = strndup(*ptr, q - *ptr);
1817                 } else {
1818                         if ((size_t)(q - *ptr + 1) > reslen) { /*%< to big for res */
1819                                 errno = EINVAL;
1820                                 return (NULL);
1821                         } else {
1822                                 strncpy(*res, *ptr, q - *ptr);
1823                                 (*res)[q - *ptr] = 0x0;
1824                         }
1825                 }
1826                 *ptr = q + 1;
1827         }
1828
1829         return (*res);
1830 }
1831
1832
1833
1834
1835
1836 #ifndef HAVE_STRNDUP
1837 /*
1838  * static char * strndup(const char *str, size_t len)
1839  *
1840  * notes: \li
1841  *
1842  *      like strdup, except do len bytes instead of the whole string. Always
1843  *      null-terminates.
1844  *
1845  * return: \li
1846  *
1847  *      The newly malloced string.
1848  *
1849  */
1850
1851 static char *
1852 strndup(const char *str, size_t len) {
1853         char *p = malloc(len + 1);
1854
1855         if (p == NULL)
1856                 return (NULL);
1857         strncpy(p, str, len);
1858         p[len] = 0x0;
1859         return (p);
1860 }
1861 #endif
1862
1863 #if WANT_MAIN
1864
1865 /*%
1866  * static int strcmp_nws(const char *a, const char *b)
1867  *
1868  * notes: \li
1869  *
1870  *      do a strcmp, except uneven lengths of whitespace compare the same
1871  *
1872  * return: \li
1873  *
1874  */
1875
1876 static int
1877 strcmp_nws(const char *a, const char *b) {
1878         while (*a && *b) {
1879                 if (isspace(*a) && isspace(*b)) {
1880                         do {
1881                                 a++;
1882                         } while (isspace(*a));
1883                         do {
1884                                 b++;
1885                         } while (isspace(*b));
1886                 }
1887                 if (*a < *b)
1888                         return (-1);
1889                 else if (*a > *b)
1890                         return (1);
1891
1892                 a++;
1893                 b++;;
1894         }
1895
1896         if (*a == *b)
1897                 return (0);
1898         else if (*a > *b)
1899                 return (1);
1900         else
1901                 return (-1);
1902 }
1903
1904 #endif
1905
1906 /*%
1907  * static void free_array(char **argv, size_t entries)
1908  *
1909  * notes: \li
1910  *
1911  *      Free argv and each of the pointers inside it. The end of
1912  *      the array is when a NULL pointer is found inside. If
1913  *      entries is > 0, then NULL pointers inside the array do
1914  *      not indicate the end of the array.
1915  *
1916  */
1917
1918 static void
1919 free_array(char **argv, size_t entries) {
1920         char **p = argv;
1921         int useEntries = (entries > 0U);
1922
1923         if (argv == NULL)
1924                 return;
1925
1926         while ((useEntries && entries > 0U) || *p) {
1927                 if (*p)
1928                         free(*p);
1929                 p++;
1930                 if (useEntries)
1931                         entries--;
1932         }
1933         free(argv);
1934 }
1935
1936
1937
1938
1939
1940 /* ************************************************** */
1941
1942 #if WANT_MAIN
1943
1944 /*% takes an option to indicate what sort of marshalling(read the code) and
1945    an argument. If the argument looks like a marshalled buffer(has a ':'
1946    embedded) then it's unmarshalled and the remarshalled and the new string
1947    is compared to the old one.
1948 */
1949
1950 int
1951 main(int argc, char **argv) {
1952         char buffer[1024];
1953         char *b = &buffer[0];
1954         size_t len = sizeof buffer;
1955         char option;
1956
1957         if (argc < 2 || argv[1][0] != '-')
1958                 exit(1);
1959
1960         option = argv[1][1];
1961         argv++;
1962         argc--;
1963
1964
1965 #if 0
1966         {
1967                 char buff[10];
1968                 char *p = argv[1], *q = &buff[0];
1969
1970                 while (getfield(&q, sizeof buff, &p, ':') != NULL) {
1971                         printf("field: \"%s\"\n", q);
1972                         p++;
1973                 }
1974                 printf("p is now \"%s\"\n", p);
1975         }
1976 #endif
1977
1978 #if 0
1979         {
1980                 char **x = splitarray(argv[1], argv[1] + strlen(argv[1]),
1981                                       argv[2][0]);
1982                 char **p;
1983
1984                 if (x == NULL)
1985                         printf("split failed\n");
1986
1987                 for (p = x ; p != NULL && *p != NULL ; p++) {
1988                         printf("\"%s\"\n", *p);
1989                 }
1990         }
1991 #endif
1992
1993 #if 1
1994         switch(option) {
1995         case 'n': {
1996                 struct nwent ne;
1997                 int i;
1998
1999                 if (strchr(argv[1], ':') != NULL) {
2000                         if (irp_unmarshall_nw(&ne, argv[1]) != 0) {
2001                                 printf("Unmarhsalling failed\n");
2002                                 exit(1);
2003                         }
2004
2005                         printf("Name: \"%s\"\n", ne.n_name);
2006                         printf("Aliases:");
2007                         for (i = 0 ; ne.n_aliases[i] != NULL ; i++)
2008                                 printf("\n\t\"%s\"", ne.n_aliases[i]);
2009                         printf("\nAddrtype: %s\n", ADDR_T_STR(ne.n_addrtype));
2010                         inet_net_ntop(ne.n_addrtype, ne.n_addr, ne.n_length,
2011                                       buffer, sizeof buffer);
2012                         printf("Net: \"%s\"\n", buffer);
2013                         *((long*)ne.n_addr) = htonl(*((long*)ne.n_addr));
2014                         inet_net_ntop(ne.n_addrtype, ne.n_addr, ne.n_length,
2015                                       buffer, sizeof buffer);
2016                         printf("Corrected Net: \"%s\"\n", buffer);
2017                 } else {
2018                         struct netent *np1 = getnetbyname(argv[1]);
2019                         ne.n_name = np1->n_name;
2020                         ne.n_aliases = np1->n_aliases;
2021                         ne.n_addrtype = np1->n_addrtype;
2022                         ne.n_addr = &np1->n_net;
2023                         ne.n_length = (IN_CLASSA(np1->n_net) ?
2024                                        8 :
2025                                        (IN_CLASSB(np1->n_net) ?
2026                                         16 :
2027                                         (IN_CLASSC(np1->n_net) ?
2028                                          24 : -1)));
2029                         np1->n_net = htonl(np1->n_net);
2030                         if (irp_marshall_nw(&ne, &b, &len) != 0) {
2031                                 printf("Marshalling failed\n");
2032                         }
2033                         printf("%s\n", b);
2034                 }
2035                 break;
2036         }
2037
2038
2039         case 'r': {
2040                 char **hosts, **users, **domains;
2041                 size_t entries;
2042                 int i;
2043                 char *buff;
2044                 size_t size;
2045                 char *ngname;
2046
2047                 if (strchr(argv[1], '(') != NULL) {
2048                         if (irp_unmarshall_ng(&ngname, &entries,
2049                                               &hosts, &users, &domains,
2050                                               argv[1]) != 0) {
2051                                 printf("unmarshall failed\n");
2052                                 exit(1);
2053                         }
2054
2055 #define STRVAL(x) (x == NULL ? "*" : x)
2056
2057                         printf("%s {\n", ngname);
2058                         for (i = 0 ; i < entries ; i++)
2059                                 printf("\t\"%s\" : \"%s\" : \"%s\"\n",
2060                                        STRVAL(hosts[i]),
2061                                        STRVAL(users[i]),
2062                                        STRVAL(domains[i]));
2063                         printf("}\n\n\n");
2064
2065
2066                         irp_marshall_ng_start(ngname, NULL, &size);
2067                         for (i = 0 ; i < entries ; i++)
2068                                 irp_marshall_ng_next(hosts[i], users[i],
2069                                                      domains[i], NULL, &size);
2070                         irp_marshall_ng_end(NULL, &size);
2071
2072                         buff = malloc(size);
2073
2074                         irp_marshall_ng_start(ngname, buff, &size);
2075                         for (i = 0 ; i < entries ; i++) {
2076                                 if (irp_marshall_ng_next(hosts[i], users[i],
2077                                                          domains[i], buff,
2078                                                          &size) != 0)
2079                                         printf("next marshalling failed.\n");
2080                         }
2081                         irp_marshall_ng_end(buff, &size);
2082
2083                         if (strcmp_nws(argv[1], buff) != 0) {
2084                                 printf("compare failed:\n\t%s\n\t%s\n",
2085                                        buffer, argv[1]);
2086                         } else {
2087                                 printf("compare ok\n");
2088                         }
2089                 } else {
2090                         char *h, *u, *d, *buff;
2091                         size_t size;
2092
2093                         /* run through two times. First to figure out how
2094                            much of a buffer we need. Second to do the
2095                            actual marshalling */
2096
2097                         setnetgrent(argv[1]);
2098                         irp_marshall_ng_start(argv[1], NULL, &size);
2099                         while (getnetgrent(&h, &u, &d) == 1)
2100                                 irp_marshall_ng_next(h, u, d, NULL, &size);
2101                         irp_marshall_ng_end(NULL, &size);
2102                         endnetgrent(argv[1]);
2103
2104                         buff = malloc(size);
2105
2106                         setnetgrent(argv[1]);
2107                         if (irp_marshall_ng_start(argv[1], buff, &size) != 0)
2108                                 printf("Marshalling start failed\n");
2109
2110                         while (getnetgrent(&h, &u, &d) == 1) {
2111                                 if (irp_marshall_ng_next(h, u, d, buff, &size)
2112                                     != 0) {
2113                                         printf("Marshalling failed\n");
2114                                 }
2115                         }
2116
2117                         irp_marshall_ng_end(buff, &size);
2118                         endnetgrent();
2119
2120                         printf("success: %s\n", buff);
2121                 }
2122                 break;
2123         }
2124
2125
2126
2127         case 'h': {
2128                 struct hostent he, *hp;
2129                 int i;
2130
2131
2132                 if (strchr(argv[1], '@') != NULL) {
2133                         if (irp_unmarshall_ho(&he, argv[1]) != 0) {
2134                                 printf("unmarshall failed\n");
2135                                 exit(1);
2136                         }
2137
2138                         printf("Host: \"%s\"\nAliases:", he.h_name);
2139                         for (i = 0 ; he.h_aliases[i] != NULL ; i++)
2140                                 printf("\n\t\t\"%s\"", he.h_aliases[i]);
2141                         printf("\nAddr Type: \"%s\"\n",
2142                                ADDR_T_STR(he.h_addrtype));
2143                         printf("Length: %d\nAddresses:", he.h_length);
2144                         for (i = 0 ; he.h_addr_list[i] != 0 ; i++) {
2145                                 inet_ntop(he.h_addrtype, he.h_addr_list[i],
2146                                           buffer, sizeof buffer);
2147                                 printf("\n\t\"%s\"\n", buffer);
2148                         }
2149                         printf("\n\n");
2150
2151                         irp_marshall_ho(&he, &b, &len);
2152                         if (strcmp(argv[1], buffer) != 0) {
2153                                 printf("compare failed:\n\t\"%s\"\n\t\"%s\"\n",
2154                                        buffer, argv[1]);
2155                         } else {
2156                                 printf("compare ok\n");
2157                         }
2158                 } else {
2159                         if ((hp = gethostbyname(argv[1])) == NULL) {
2160                                 perror("gethostbyname");
2161                                 printf("\"%s\"\n", argv[1]);
2162                                 exit(1);
2163                         }
2164
2165                         if (irp_marshall_ho(hp, &b, &len) != 0) {
2166                                 printf("irp_marshall_ho failed\n");
2167                                 exit(1);
2168                         }
2169
2170                         printf("success: \"%s\"\n", buffer);
2171                 }
2172                 break;
2173         }
2174
2175
2176         case 's': {
2177                 struct servent *sv;
2178                 struct servent sv1;
2179
2180                 if (strchr(argv[1], ':') != NULL) {
2181                         sv = &sv1;
2182                         memset(sv, 0xef, sizeof (struct servent));
2183                         if (irp_unmarshall_sv(sv, argv[1]) != 0) {
2184                                 printf("unmarshall failed\n");
2185
2186                         }
2187
2188                         irp_marshall_sv(sv, &b, &len);
2189                         if (strcmp(argv[1], buffer) != 0) {
2190                                 printf("compare failed:\n\t\"%s\"\n\t\"%s\"\n",
2191                                        buffer, argv[1]);
2192                         } else {
2193                                 printf("compare ok\n");
2194                         }
2195                 } else {
2196                         if ((sv = getservbyname(argv[1], argv[2])) == NULL) {
2197                                 perror("getservent");
2198                                 exit(1);
2199                         }
2200
2201                         if (irp_marshall_sv(sv, &b, &len) != 0) {
2202                                 printf("irp_marshall_sv failed\n");
2203                                 exit(1);
2204                         }
2205
2206                         printf("success: \"%s\"\n", buffer);
2207                 }
2208                 break;
2209         }
2210
2211         case 'g': {
2212                 struct group *gr;
2213                 struct group gr1;
2214
2215                 if (strchr(argv[1], ':') != NULL) {
2216                         gr = &gr1;
2217                         memset(gr, 0xef, sizeof (struct group));
2218                         if (irp_unmarshall_gr(gr, argv[1]) != 0) {
2219                                 printf("unmarshall failed\n");
2220
2221                         }
2222
2223                         irp_marshall_gr(gr, &b, &len);
2224                         if (strcmp(argv[1], buffer) != 0) {
2225                                 printf("compare failed:\n\t\"%s\"\n\t\"%s\"\n",
2226                                        buffer, argv[1]);
2227                         } else {
2228                                 printf("compare ok\n");
2229                         }
2230                 } else {
2231                         if ((gr = getgrnam(argv[1])) == NULL) {
2232                                 perror("getgrnam");
2233                                 exit(1);
2234                         }
2235
2236                         if (irp_marshall_gr(gr, &b, &len) != 0) {
2237                                 printf("irp_marshall_gr failed\n");
2238                                 exit(1);
2239                         }
2240
2241                         printf("success: \"%s\"\n", buffer);
2242                 }
2243                 break;
2244         }
2245
2246
2247         case 'p': {
2248                 struct passwd *pw;
2249                 struct passwd pw1;
2250
2251                 if (strchr(argv[1], ':') != NULL) {
2252                         pw = &pw1;
2253                         memset(pw, 0xef, sizeof (*pw));
2254                         if (irp_unmarshall_pw(pw, argv[1]) != 0) {
2255                                 printf("unmarshall failed\n");
2256                                 exit(1);
2257                         }
2258
2259                         printf("User: \"%s\"\nPasswd: \"%s\"\nUid: %ld\nGid: %ld\n",
2260                                pw->pw_name, pw->pw_passwd, (long)pw->pw_uid,
2261                                (long)pw->pw_gid);
2262                         printf("Class: \"%s\"\nChange: %ld\nGecos: \"%s\"\n",
2263                                pw->pw_class, (long)pw->pw_change, pw->pw_gecos);
2264                         printf("Shell: \"%s\"\nDirectory: \"%s\"\n",
2265                                pw->pw_shell, pw->pw_dir);
2266
2267                         pw = getpwnam(pw->pw_name);
2268                         irp_marshall_pw(pw, &b, &len);
2269                         if (strcmp(argv[1], buffer) != 0) {
2270                                 printf("compare failed:\n\t\"%s\"\n\t\"%s\"\n",
2271                                        buffer, argv[1]);
2272                         } else {
2273                                 printf("compare ok\n");
2274                         }
2275                 } else {
2276                         if ((pw = getpwnam(argv[1])) == NULL) {
2277                                 perror("getpwnam");
2278                                 exit(1);
2279                         }
2280
2281                         if (irp_marshall_pw(pw, &b, &len) != 0) {
2282                                 printf("irp_marshall_pw failed\n");
2283                                 exit(1);
2284                         }
2285
2286                         printf("success: \"%s\"\n", buffer);
2287                 }
2288                 break;
2289         }
2290
2291         default:
2292                 printf("Wrong option: %c\n", option);
2293                 break;
2294         }
2295
2296 #endif
2297
2298         return (0);
2299 }
2300
2301 #endif
2302
2303 /*! \file */