contrib/bind-9.5.2/lib/bind/irs/irpmarshall.c

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