/* $NetBSD: irpmarshall.c,v 1.1.1.2 2012/09/09 16:07:57 christos Exp $ */
/*
* Copyright(c) 1989, 1993, 1995
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
* Portions Copyright (c) 1996 by Internet Software Consortium.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#if defined(LIBC_SCCS) && !defined(lint)
static const char rcsid[] = "Id: irpmarshall.c,v 1.7 2006/03/09 23:57:56 marka Exp ";
#endif /* LIBC_SCCS and not lint */
#if 0
Check values are in approrpriate endian order.
Double check memory allocations on unmarhsalling
#endif
/* Extern */
#include "port_before.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <arpa/nameser.h>
#include <stdio.h>
#include <ctype.h>
#include <pwd.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <utmp.h>
#include <unistd.h>
#include <assert.h>
#include <errno.h>
#include <irs.h>
#include <isc/memcluster.h>
#include <isc/irpmarshall.h>
#include "port_after.h"
#ifndef HAVE_STRNDUP
static char *strndup(const char *str, size_t len);
#endif
static char **splitarray(const char *buffer, const char *buffend, char delim);
static int joinarray(char * const * argv, char *buffer, char delim);
static char *getfield(char **res, size_t reslen, char **buffer, char delim);
static size_t joinlength(char * const *argv);
static void free_array(char **argv, size_t entries);
#define ADDR_T_STR(x) (x == AF_INET ? "AF_INET" :\
(x == AF_INET6 ? "AF_INET6" : "UNKNOWN"))
#define MAXPADDRSIZE (sizeof "255.255.255.255" + 1)
static char COMMA = ',';
static const char *COMMASTR = ",";
static const char *COLONSTR = ":";
/* See big comment at bottom of irpmarshall.h for description. */
#ifdef WANT_IRS_PW
/* +++++++++++++++++++++++++ struct passwd +++++++++++++++++++++++++ */
/*%
* int irp_marshall_pw(const struct passwd *pw, char **buffer, size_t *len)
*
* notes: \li
*
* See irpmarshall.h
*
* return: \li
*
* 0 on sucess, -1 on failure.
*
*/
int
irp_marshall_pw(const struct passwd *pw, char **buffer, size_t *len) {
size_t need = 1 ; /*%< for null byte */
char pwUid[24];
char pwGid[24];
char pwChange[24];
char pwExpire[24];
const char *pwClass;
const char *fieldsep = COLONSTR;
if (pw == NULL || len == NULL) {
errno = EINVAL;
return (-1);
}
sprintf(pwUid, "%ld", (long)pw->pw_uid);
sprintf(pwGid, "%ld", (long)pw->pw_gid);
#ifdef HAVE_PW_CHANGE
sprintf(pwChange, "%ld", (long)pw->pw_change);
#else
pwChange[0] = '0';
pwChange[1] = '\0';
#endif
#ifdef HAVE_PW_EXPIRE
sprintf(pwExpire, "%ld", (long)pw->pw_expire);
#else
pwExpire[0] = '0';
pwExpire[1] = '\0';
#endif
#ifdef HAVE_PW_CLASS
pwClass = pw->pw_class;
#else
pwClass = "";
#endif
need += strlen(pw->pw_name) + 1; /*%< one for fieldsep */
need += strlen(pw->pw_passwd) + 1;
need += strlen(pwUid) + 1;
need += strlen(pwGid) + 1;
need += strlen(pwClass) + 1;
need += strlen(pwChange) + 1;
need += strlen(pwExpire) + 1;
need += strlen(pw->pw_gecos) + 1;
need += strlen(pw->pw_dir) + 1;
need += strlen(pw->pw_shell) + 1;
if (buffer == NULL) {
*len = need;
return (0);
}
if (*buffer != NULL && need > *len) {
errno = EINVAL;
return (-1);
}
if (*buffer == NULL) {
need += 2; /*%< for CRLF */
*buffer = memget(need);
if (*buffer == NULL) {
errno = ENOMEM;
return (-1);
}
*len = need;
}
strcpy(*buffer, pw->pw_name); strcat(*buffer, fieldsep);
strcat(*buffer, pw->pw_passwd); strcat(*buffer, fieldsep);
strcat(*buffer, pwUid); strcat(*buffer, fieldsep);
strcat(*buffer, pwGid); strcat(*buffer, fieldsep);
strcat(*buffer, pwClass); strcat(*buffer, fieldsep);
strcat(*buffer, pwChange); strcat(*buffer, fieldsep);
strcat(*buffer, pwExpire); strcat(*buffer, fieldsep);
strcat(*buffer, pw->pw_gecos); strcat(*buffer, fieldsep);
strcat(*buffer, pw->pw_dir); strcat(*buffer, fieldsep);
strcat(*buffer, pw->pw_shell); strcat(*buffer, fieldsep);
return (0);
}
/*%
* int irp_unmarshall_pw(struct passwd *pw, char *buffer)
*
* notes: \li
*
* See irpmarshall.h
*
* return: \li
*
* 0 on success, -1 on failure
*
*/
int
irp_unmarshall_pw(struct passwd *pw, char *buffer) {
char *name, *pass, *class, *gecos, *dir, *shell;
uid_t pwuid;
gid_t pwgid;
time_t pwchange;
time_t pwexpire;
char *p;
long t;
char tmpbuf[24];
char *tb = &tmpbuf[0];
char fieldsep = ':';
int myerrno = EINVAL;
name = pass = class = gecos = dir = shell = NULL;
p = buffer;
/* pw_name field */
name = NULL;
if (getfield(&name, 0, &p, fieldsep) == NULL || strlen(name) == 0) {
goto error;
}
/* pw_passwd field */
pass = NULL;
if (getfield(&pass, 0, &p, fieldsep) == NULL) { /*%< field can be empty */
goto error;
}
/* pw_uid field */
tb = tmpbuf;
if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
strlen(tb) == 0) {
goto error;
}
t = strtol(tmpbuf, &tb, 10);
if (*tb) {
goto error; /*%< junk in value */
}
pwuid = (uid_t)t;
if ((long) pwuid != t) { /*%< value must have been too big. */
goto error;
}
/* pw_gid field */
tb = tmpbuf;
if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
strlen(tb) == 0) {
goto error;
}
t = strtol(tmpbuf, &tb, 10);
if (*tb) {
goto error; /*%< junk in value */
}
pwgid = (gid_t)t;
if ((long)pwgid != t) { /*%< value must have been too big. */
goto error;
}
/* pw_class field */
class = NULL;
if (getfield(&class, 0, &p, fieldsep) == NULL) {
goto error;
}
/* pw_change field */
tb = tmpbuf;
if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
strlen(tb) == 0) {
goto error;
}
t = strtol(tmpbuf, &tb, 10);
if (*tb) {
goto error; /*%< junk in value */
}
pwchange = (time_t)t;
if ((long)pwchange != t) { /*%< value must have been too big. */
goto error;
}
/* pw_expire field */
tb = tmpbuf;
if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
strlen(tb) == 0) {
goto error;
}
t = strtol(tmpbuf, &tb, 10);
if (*tb) {
goto error; /*%< junk in value */
}
pwexpire = (time_t)t;
if ((long) pwexpire != t) { /*%< value must have been too big. */
goto error;
}
/* pw_gecos field */
gecos = NULL;
if (getfield(&gecos, 0, &p, fieldsep) == NULL) {
goto error;
}
/* pw_dir field */
dir = NULL;
if (getfield(&dir, 0, &p, fieldsep) == NULL) {
goto error;
}
/* pw_shell field */
shell = NULL;
if (getfield(&shell, 0, &p, fieldsep) == NULL) {
goto error;
}
pw->pw_name = name;
pw->pw_passwd = pass;
pw->pw_uid = pwuid;
pw->pw_gid = pwgid;
pw->pw_gecos = gecos;
pw->pw_dir = dir;
pw->pw_shell = shell;
#ifdef HAVE_PW_CHANGE
pw->pw_change = pwchange;
#endif
#ifdef HAVE_PW_CLASS
pw->pw_class = class;
#endif
#ifdef HAVE_PW_EXPIRE
pw->pw_expire = pwexpire;
#endif
return (0);
error:
errno = myerrno;
if (name != NULL) free(name);
if (pass != NULL) free(pass);
if (gecos != NULL) free(gecos);
if (dir != NULL) free(dir);
if (shell != NULL) free(shell);
return (-1);
}
/* ------------------------- struct passwd ------------------------- */
#endif /* WANT_IRS_PW */
/* +++++++++++++++++++++++++ struct group +++++++++++++++++++++++++ */
/*%
* int irp_marshall_gr(const struct group *gr, char **buffer, size_t *len)
*
* notes: \li
*
* See irpmarshall.h.
*
* return: \li
*
* 0 on success, -1 on failure
*/
int
irp_marshall_gr(const struct group *gr, char **buffer, size_t *len) {
size_t need = 1; /*%< for null byte */
char grGid[24];
const char *fieldsep = COLONSTR;
if (gr == NULL || len == NULL) {
errno = EINVAL;
return (-1);
}
sprintf(grGid, "%ld", (long)gr->gr_gid);
need += strlen(gr->gr_name) + 1;
#ifndef MISSING_GR_PASSWD
need += strlen(gr->gr_passwd) + 1;
#else
need++;
#endif
need += strlen(grGid) + 1;
need += joinlength(gr->gr_mem) + 1;
if (buffer == NULL) {
*len = need;
return (0);
}
if (*buffer != NULL && need > *len) {
errno = EINVAL;
return (-1);
}
if (*buffer == NULL) {
need += 2; /*%< for CRLF */
*buffer = memget(need);
if (*buffer == NULL) {
errno = ENOMEM;
return (-1);
}
*len = need;
}
strcpy(*buffer, gr->gr_name); strcat(*buffer, fieldsep);
#ifndef MISSING_GR_PASSWD
strcat(*buffer, gr->gr_passwd);
#endif
strcat(*buffer, fieldsep);
strcat(*buffer, grGid); strcat(*buffer, fieldsep);
joinarray(gr->gr_mem, *buffer, COMMA) ; strcat(*buffer, fieldsep);
return (0);
}
/*%
* int irp_unmarshall_gr(struct group *gr, char *buffer)
*
* notes: \li
*
* See irpmarshall.h
*
* return: \li
*
* 0 on success and -1 on failure.
*
*/
int
irp_unmarshall_gr(struct group *gr, char *buffer) {
char *p, *q;
gid_t grgid;
long t;
char *name = NULL;
char *pass = NULL;
char **members = NULL;
char tmpbuf[24];
char *tb;
char fieldsep = ':';
int myerrno = EINVAL;
if (gr == NULL || buffer == NULL) {
errno = EINVAL;
return (-1);
}
p = buffer;
/* gr_name field */
name = NULL;
if (getfield(&name, 0, &p, fieldsep) == NULL || strlen(name) == 0U) {
goto error;
}
/* gr_passwd field */
pass = NULL;
if (getfield(&pass, 0, &p, fieldsep) == NULL) {
goto error;
}
/* gr_gid field */
tb = tmpbuf;
if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
strlen(tb) == 0U) {
goto error;
}
t = strtol(tmpbuf, &tb, 10);
if (*tb) {
goto error; /*%< junk in value */
}
grgid = (gid_t)t;
if ((long) grgid != t) { /*%< value must have been too big. */
goto error;
}
/* gr_mem field. Member names are separated by commas */
q = strchr(p, fieldsep);
if (q == NULL) {
goto error;
}
members = splitarray(p, q, COMMA);
if (members == NULL) {
myerrno = errno;
goto error;
}
p = q + 1;
gr->gr_name = name;
#ifndef MISSING_GR_PASSWD
gr->gr_passwd = pass;
#endif
gr->gr_gid = grgid;
gr->gr_mem = members;
return (0);
error:
errno = myerrno;
if (name != NULL) free(name);
if (pass != NULL) free(pass);
return (-1);
}
/* ------------------------- struct group ------------------------- */
/* +++++++++++++++++++++++++ struct servent +++++++++++++++++++++++++ */
/*%
* int irp_marshall_sv(const struct servent *sv, char **buffer, size_t *len)
*
* notes: \li
*
* See irpmarshall.h
*
* return: \li
*
* 0 on success, -1 on failure.
*
*/
int
irp_marshall_sv(const struct servent *sv, char **buffer, size_t *len) {
size_t need = 1; /*%< for null byte */
char svPort[24];
const char *fieldsep = COLONSTR;
short realport;
if (sv == NULL || len == NULL) {
errno = EINVAL;
return (-1);
}
/* the int s_port field is actually a short in network order. We
want host order to make the marshalled data look correct */
realport = ntohs((short)sv->s_port);
sprintf(svPort, "%d", realport);
need += strlen(sv->s_name) + 1;
need += joinlength(sv->s_aliases) + 1;
need += strlen(svPort) + 1;
need += strlen(sv->s_proto) + 1;
if (buffer == NULL) {
*len = need;
return (0);
}
if (*buffer != NULL && need > *len) {
errno = EINVAL;
return (-1);
}
if (*buffer == NULL) {
need += 2; /*%< for CRLF */
*buffer = memget(need);
if (*buffer == NULL) {
errno = ENOMEM;
return (-1);
}
*len = need;
}
strcpy(*buffer, sv->s_name); strcat(*buffer, fieldsep);
joinarray(sv->s_aliases, *buffer, COMMA); strcat(*buffer, fieldsep);
strcat(*buffer, svPort); strcat(*buffer, fieldsep);
strcat(*buffer, sv->s_proto); strcat(*buffer, fieldsep);
return (0);
}
/*%
* int irp_unmarshall_sv(struct servent *sv, char *buffer)
*
* notes: \li
*
* See irpmarshall.h
*
* return: \li
*
* 0 on success, -1 on failure.
*
*/
int
irp_unmarshall_sv(struct servent *sv, char *buffer) {
char *p, *q;
short svport;
long t;
char *name = NULL;
char *proto = NULL;
char **aliases = NULL;
char tmpbuf[24];
char *tb;
char fieldsep = ':';
int myerrno = EINVAL;
if (sv == NULL || buffer == NULL)
return (-1);
p = buffer;
/* s_name field */
name = NULL;
if (getfield(&name, 0, &p, fieldsep) == NULL || strlen(name) == 0U) {
goto error;
}
/* s_aliases field */
q = strchr(p, fieldsep);
if (q == NULL) {
goto error;
}
aliases = splitarray(p, q, COMMA);
if (aliases == NULL) {
myerrno = errno;
goto error;
}
p = q + 1;
/* s_port field */
tb = tmpbuf;
if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
strlen(tb) == 0U) {
goto error;
}
t = strtol(tmpbuf, &tb, 10);
if (*tb) {
goto error; /*%< junk in value */
}
svport = (short)t;
if ((long) svport != t) { /*%< value must have been too big. */
goto error;
}
svport = htons(svport);
/* s_proto field */
proto = NULL;
if (getfield(&proto, 0, &p, fieldsep) == NULL) {
goto error;
}
sv->s_name = name;
sv->s_aliases = aliases;
sv->s_port = svport;
sv->s_proto = proto;
return (0);
error:
errno = myerrno;
if (name != NULL) free(name);
if (proto != NULL) free(proto);
free_array(aliases, 0);
return (-1);
}
/* ------------------------- struct servent ------------------------- */
/* +++++++++++++++++++++++++ struct protoent +++++++++++++++++++++++++ */
/*%
* int irp_marshall_pr(struct protoent *pr, char **buffer, size_t *len)
*
* notes: \li
*
* See irpmarshall.h
*
* return: \li
*
* 0 on success and -1 on failure.
*
*/
int
irp_marshall_pr(struct protoent *pr, char **buffer, size_t *len) {
size_t need = 1; /*%< for null byte */
char prProto[24];
const char *fieldsep = COLONSTR;
if (pr == NULL || len == NULL) {
errno = EINVAL;
return (-1);
}
sprintf(prProto, "%d", (int)pr->p_proto);
need += strlen(pr->p_name) + 1;
need += joinlength(pr->p_aliases) + 1;
need += strlen(prProto) + 1;
if (buffer == NULL) {
*len = need;
return (0);
}
if (*buffer != NULL && need > *len) {
errno = EINVAL;
return (-1);
}
if (*buffer == NULL) {
need += 2; /*%< for CRLF */
*buffer = memget(need);
if (*buffer == NULL) {
errno = ENOMEM;
return (-1);
}
*len = need;
}
strcpy(*buffer, pr->p_name); strcat(*buffer, fieldsep);
joinarray(pr->p_aliases, *buffer, COMMA); strcat(*buffer, fieldsep);
strcat(*buffer, prProto); strcat(*buffer, fieldsep);
return (0);
}
/*%
* int irp_unmarshall_pr(struct protoent *pr, char *buffer)
*
* notes: \li
*
* See irpmarshall.h
*
* return: \li
*
* 0 on success, -1 on failure
*
*/
int irp_unmarshall_pr(struct protoent *pr, char *buffer) {
char *p, *q;
int prproto;
long t;
char *name = NULL;
char **aliases = NULL;
char tmpbuf[24];
char *tb;
char fieldsep = ':';
int myerrno = EINVAL;
if (pr == NULL || buffer == NULL) {
errno = EINVAL;
return (-1);
}
p = buffer;
/* p_name field */
name = NULL;
if (getfield(&name, 0, &p, fieldsep) == NULL || strlen(name) == 0U) {
goto error;
}
/* p_aliases field */
q = strchr(p, fieldsep);
if (q == NULL) {
goto error;
}
aliases = splitarray(p, q, COMMA);
if (aliases == NULL) {
myerrno = errno;
goto error;
}
p = q + 1;
/* p_proto field */
tb = tmpbuf;
if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
strlen(tb) == 0U) {
goto error;
}
t = strtol(tmpbuf, &tb, 10);
if (*tb) {
goto error; /*%< junk in value */
}
prproto = (int)t;
if ((long) prproto != t) { /*%< value must have been too big. */
goto error;
}
pr->p_name = name;
pr->p_aliases = aliases;
pr->p_proto = prproto;
return (0);
error:
errno = myerrno;
if (name != NULL) free(name);
free_array(aliases, 0);
return (-1);
}
/* ------------------------- struct protoent ------------------------- */
/* +++++++++++++++++++++++++ struct hostent +++++++++++++++++++++++++ */
/*%
* int irp_marshall_ho(struct hostent *ho, char **buffer, size_t *len)
*
* notes: \li
*
* See irpmarshall.h.
*
* return: \li
*
* 0 on success, -1 on failure.
*
*/
int
irp_marshall_ho(struct hostent *ho, char **buffer, size_t *len) {
size_t need = 1; /*%< for null byte */
char hoaddrtype[24];
char holength[24];
char **av;
char *p;
int addrlen;
int malloced = 0;
size_t remlen;
const char *fieldsep = "@";
if (ho == NULL || len == NULL) {
errno = EINVAL;
return (-1);
}
switch(ho->h_addrtype) {
case AF_INET:
strcpy(hoaddrtype, "AF_INET");
break;
case AF_INET6:
strcpy(hoaddrtype, "AF_INET6");
break;
default:
errno = EINVAL;
return (-1);
}
sprintf(holength, "%d", ho->h_length);
need += strlen(ho->h_name) + 1;
need += joinlength(ho->h_aliases) + 1;
need += strlen(hoaddrtype) + 1;
need += strlen(holength) + 1;
/* we determine an upper bound on the string length needed, not an
exact length. */
addrlen = (ho->h_addrtype == AF_INET ? 16 : 46) ; /*%< XX other AF's?? */
for (av = ho->h_addr_list; av != NULL && *av != NULL ; av++)
need += addrlen;
if (buffer == NULL) {
*len = need;
return (0);
}
if (*buffer != NULL && need > *len) {
errno = EINVAL;
return (-1);
}
if (*buffer == NULL) {
need += 2; /*%< for CRLF */
*buffer = memget(need);
if (*buffer == NULL) {
errno = ENOMEM;
return (-1);
}
*len = need;
malloced = 1;
}
strcpy(*buffer, ho->h_name); strcat(*buffer, fieldsep);
joinarray(ho->h_aliases, *buffer, COMMA); strcat(*buffer, fieldsep);
strcat(*buffer, hoaddrtype); strcat(*buffer, fieldsep);
strcat(*buffer, holength); strcat(*buffer, fieldsep);
p = *buffer + strlen(*buffer);
remlen = need - strlen(*buffer);
for (av = ho->h_addr_list ; av != NULL && *av != NULL ; av++) {
if (inet_ntop(ho->h_addrtype, *av, p, remlen) == NULL) {
goto error;
}
if (*(av + 1) != NULL)
strcat(p, COMMASTR);
remlen -= strlen(p);
p += strlen(p);
}
strcat(*buffer, fieldsep);
return (0);
error:
if (malloced) {
memput(*buffer, need);
}
return (-1);
}
/*%
* int irp_unmarshall_ho(struct hostent *ho, char *buffer)
*
* notes: \li
*
* See irpmarshall.h.
*
* return: \li
*
* 0 on success, -1 on failure.
*
*/
int
irp_unmarshall_ho(struct hostent *ho, char *buffer) {
char *p, *q, *r;
int hoaddrtype;
int holength;
long t;
char *name;
char **aliases = NULL;
char **hohaddrlist = NULL;
size_t hoaddrsize;
char tmpbuf[24];
char *tb;
char **alist;
int addrcount;
char fieldsep = '@';
int myerrno = EINVAL;
if (ho == NULL || buffer == NULL) {
errno = EINVAL;
return (-1);
}
p = buffer;
/* h_name field */
name = NULL;
if (getfield(&name, 0, &p, fieldsep) == NULL || strlen(name) == 0U) {
goto error;
}
/* h_aliases field */
q = strchr(p, fieldsep);
if (q == NULL) {
goto error;
}
aliases = splitarray(p, q, COMMA);
if (aliases == NULL) {
myerrno = errno;
goto error;
}
p = q + 1;
/* h_addrtype field */
tb = tmpbuf;
if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
strlen(tb) == 0U) {
goto error;
}
if (strcmp(tmpbuf, "AF_INET") == 0)
hoaddrtype = AF_INET;
else if (strcmp(tmpbuf, "AF_INET6") == 0)
hoaddrtype = AF_INET6;
else
goto error;
/* h_length field */
tb = tmpbuf;
if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
strlen(tb) == 0U) {
goto error;
}
t = strtol(tmpbuf, &tb, 10);
if (*tb) {
goto error; /*%< junk in value */
}
holength = (int)t;
if ((long) holength != t) { /*%< value must have been too big. */
goto error;
}
/* h_addr_list field */
q = strchr(p, fieldsep);
if (q == NULL)
goto error;
/* count how many addresss are in there */
if (q > p + 1) {
for (addrcount = 1, r = p ; r != q ; r++) {
if (*r == COMMA)
addrcount++;
}
} else {
addrcount = 0;
}
hoaddrsize = (addrcount + 1) * sizeof (char *);
hohaddrlist = malloc(hoaddrsize);
if (hohaddrlist == NULL) {
myerrno = ENOMEM;
goto error;
}
memset(hohaddrlist, 0x0, hoaddrsize);
alist = hohaddrlist;
for (t = 0, r = p ; r != q ; p = r + 1, t++) {
char saved;
while (r != q && *r != COMMA) r++;
saved = *r;
*r = 0x0;
alist[t] = malloc(hoaddrtype == AF_INET ? 4 : 16);
if (alist[t] == NULL) {
myerrno = ENOMEM;
goto error;
}
if (inet_pton(hoaddrtype, p, alist[t]) == -1)
goto error;
*r = saved;
}
alist[t] = NULL;
ho->h_name = name;
ho->h_aliases = aliases;
ho->h_addrtype = hoaddrtype;
ho->h_length = holength;
ho->h_addr_list = hohaddrlist;
return (0);
error:
errno = myerrno;
if (name != NULL) free(name);
free_array(hohaddrlist, 0);
free_array(aliases, 0);
return (-1);
}
/* ------------------------- struct hostent------------------------- */
/* +++++++++++++++++++++++++ struct netgrp +++++++++++++++++++++++++ */
/*%
* int irp_marshall_ng(const char *host, const char *user,
* const char *domain, char *buffer, size_t *len)
*
* notes: \li
*
* See note for irp_marshall_ng_start
*
* return: \li
*
* 0 on success, 0 on failure.
*
*/
int
irp_marshall_ng(const char *host, const char *user, const char *domain,
char **buffer, size_t *len) {
size_t need = 1; /*%< for nul byte */
const char *fieldsep = ",";
if (len == NULL) {
errno = EINVAL;
return (-1);
}
need += 4; /*%< two parens and two commas */
need += (host == NULL ? 0 : strlen(host));
need += (user == NULL ? 0 : strlen(user));
need += (domain == NULL ? 0 : strlen(domain));
if (buffer == NULL) {
*len = need;
return (0);
} else if (*buffer != NULL && need > *len) {
errno = EINVAL;
return (-1);
}
if (*buffer == NULL) {
need += 2; /*%< for CRLF */
*buffer = memget(need);
if (*buffer == NULL) {
errno = ENOMEM;
return (-1);
}
*len = need;
}
(*buffer)[0] = '(';
(*buffer)[1] = '\0';
if (host != NULL)
strcat(*buffer, host);
strcat(*buffer, fieldsep);
if (user != NULL)
strcat(*buffer, user);
strcat(*buffer, fieldsep);
if (domain != NULL)
strcat(*buffer, domain);
strcat(*buffer, ")");
return (0);
}
/* ---------- */
/*%
* int irp_unmarshall_ng(const char **host, const char **user,
* const char **domain, char *buffer)
*
* notes: \li
*
* Unpacks the BUFFER into 3 character arrays it allocates and assigns
* to *HOST, *USER and *DOMAIN. If any field of the value is empty,
* then the corresponding paramater value will be set to NULL.
*
* return: \li
*
* 0 on success and -1 on failure.
*/
int
irp_unmarshall_ng(const char **hostp, const char **userp, const char **domainp,
char *buffer)
{
char *p, *q;
char fieldsep = ',';
int myerrno = EINVAL;
char *host, *user, *domain;
if (userp == NULL || hostp == NULL ||
domainp == NULL || buffer == NULL) {
errno = EINVAL;
return (-1);
}
host = user = domain = NULL;
p = buffer;
while (isspace((unsigned char)*p)) {
p++;
}
if (*p != '(') {
goto error;
}
q = p + 1;
while (*q && *q != fieldsep)
q++;
if (!*q) {
goto error;
} else if (q > p + 1) {
host = strndup(p, q - p);
}
p = q + 1;
if (!*p) {
goto error;
} else if (*p != fieldsep) {
q = p + 1;
while (*q && *q != fieldsep)
q++;
if (!*q) {
goto error;
}
user = strndup(p, q - p);
} else {
p++;
}
if (!*p) {
goto error;
} else if (*p != ')') {
q = p + 1;
while (*q && *q != ')')
q++;
if (!*q) {
goto error;
}
domain = strndup(p, q - p);
}
*hostp = host;
*userp = user;
*domainp = domain;
return (0);
error:
errno = myerrno;
if (host != NULL) free(host);
if (user != NULL) free(user);
return (-1);
}
/* ------------------------- struct netgrp ------------------------- */
/* +++++++++++++++++++++++++ struct nwent +++++++++++++++++++++++++ */
/*%
* int irp_marshall_nw(struct nwent *ne, char **buffer, size_t *len)
*
* notes: \li
*
* See at top.
*
* return: \li
*
* 0 on success and -1 on failure.
*
*/
int
irp_marshall_nw(struct nwent *ne, char **buffer, size_t *len) {
size_t need = 1; /*%< for null byte */
char nAddrType[24];
char nNet[MAXPADDRSIZE];
const char *fieldsep = COLONSTR;
if (ne == NULL || len == NULL) {
return (-1);
}
strcpy(nAddrType, ADDR_T_STR(ne->n_addrtype));
if (inet_net_ntop(ne->n_addrtype, ne->n_addr, ne->n_length,
nNet, sizeof nNet) == NULL) {
return (-1);
}
need += strlen(ne->n_name) + 1;
need += joinlength(ne->n_aliases) + 1;
need += strlen(nAddrType) + 1;
need += strlen(nNet) + 1;
if (buffer == NULL) {
*len = need;
return (0);
}
if (*buffer != NULL && need > *len) {
errno = EINVAL;
return (-1);
}
if (*buffer == NULL) {
need += 2; /*%< for CRLF */
*buffer = memget(need);
if (*buffer == NULL) {
errno = ENOMEM;
return (-1);
}
*len = need;
}
strcpy(*buffer, ne->n_name); strcat(*buffer, fieldsep);
joinarray(ne->n_aliases, *buffer, COMMA) ; strcat(*buffer, fieldsep);
strcat(*buffer, nAddrType); strcat(*buffer, fieldsep);
strcat(*buffer, nNet); strcat(*buffer, fieldsep);
return (0);
}
/*%
* int irp_unmarshall_nw(struct nwent *ne, char *buffer)
*
* notes: \li
*
* See note up top.
*
* return: \li
*
* 0 on success and -1 on failure.
*
*/
int
irp_unmarshall_nw(struct nwent *ne, char *buffer) {
char *p, *q;
int naddrtype;
long nnet;
int bits;
char *name = NULL;
char **aliases = NULL;
char tmpbuf[24];
char *tb;
char fieldsep = ':';
int myerrno = EINVAL;
if (ne == NULL || buffer == NULL) {
goto error;
}
p = buffer;
/* n_name field */
name = NULL;
if (getfield(&name, 0, &p, fieldsep) == NULL || strlen(name) == 0U) {
goto error;
}
/* n_aliases field. Aliases are separated by commas */
q = strchr(p, fieldsep);
if (q == NULL) {
goto error;
}
aliases = splitarray(p, q, COMMA);
if (aliases == NULL) {
myerrno = errno;
goto error;
}
p = q + 1;
/* h_addrtype field */
tb = tmpbuf;
if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
strlen(tb) == 0U) {
goto error;
}
if (strcmp(tmpbuf, "AF_INET") == 0)
naddrtype = AF_INET;
else if (strcmp(tmpbuf, "AF_INET6") == 0)
naddrtype = AF_INET6;
else
goto error;
/* n_net field */
tb = tmpbuf;
if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
strlen(tb) == 0U) {
goto error;
}
nnet = 0;
bits = inet_net_pton(naddrtype, tmpbuf, &nnet, sizeof nnet);
if (bits < 0) {
goto error;
}
/* nnet = ntohl(nnet); */ /* keep in network order for nwent */
ne->n_name = name;
ne->n_aliases = aliases;
ne->n_addrtype = naddrtype;
ne->n_length = bits;
ne->n_addr = malloc(sizeof nnet);
if (ne->n_addr == NULL) {
goto error;
}
memcpy(ne->n_addr, &nnet, sizeof nnet);
return (0);
error:
errno = myerrno;
if (name != NULL) free(name);
free_array(aliases, 0);
return (-1);
}
/* ------------------------- struct nwent ------------------------- */
/* +++++++++++++++++++++++++ struct netent +++++++++++++++++++++++++ */
/*%
* int irp_marshall_ne(struct netent *ne, char **buffer, size_t *len)
*
* notes: \li
*
* See at top.
*
* return: \li
*
* 0 on success and -1 on failure.
*
*/
int
irp_marshall_ne(struct netent *ne, char **buffer, size_t *len) {
size_t need = 1; /*%< for null byte */
char nAddrType[24];
char nNet[MAXPADDRSIZE];
const char *fieldsep = COLONSTR;
long nval;
if (ne == NULL || len == NULL) {
return (-1);
}
strcpy(nAddrType, ADDR_T_STR(ne->n_addrtype));
nval = htonl(ne->n_net);
if (inet_ntop(ne->n_addrtype, &nval, nNet, sizeof nNet) == NULL) {
return (-1);
}
need += strlen(ne->n_name) + 1;
need += joinlength(ne->n_aliases) + 1;
need += strlen(nAddrType) + 1;
need += strlen(nNet) + 1;
if (buffer == NULL) {
*len = need;
return (0);
}
if (*buffer != NULL && need > *len) {
errno = EINVAL;
return (-1);
}
if (*buffer == NULL) {
need += 2; /*%< for CRLF */
*buffer = memget(need);
if (*buffer == NULL) {
errno = ENOMEM;
return (-1);
}
*len = need;
}
strcpy(*buffer, ne->n_name); strcat(*buffer, fieldsep);
joinarray(ne->n_aliases, *buffer, COMMA) ; strcat(*buffer, fieldsep);
strcat(*buffer, nAddrType); strcat(*buffer, fieldsep);
strcat(*buffer, nNet); strcat(*buffer, fieldsep);
return (0);
}
/*%
* int irp_unmarshall_ne(struct netent *ne, char *buffer)
*
* notes: \li
*
* See note up top.
*
* return: \li
*
* 0 on success and -1 on failure.
*
*/
int
irp_unmarshall_ne(struct netent *ne, char *buffer) {
char *p, *q;
int naddrtype;
long nnet;
int bits;
char *name = NULL;
char **aliases = NULL;
char tmpbuf[24];
char *tb;
char fieldsep = ':';
int myerrno = EINVAL;
if (ne == NULL || buffer == NULL) {
goto error;
}
p = buffer;
/* n_name field */
name = NULL;
if (getfield(&name, 0, &p, fieldsep) == NULL || strlen(name) == 0U) {
goto error;
}
/* n_aliases field. Aliases are separated by commas */
q = strchr(p, fieldsep);
if (q == NULL) {
goto error;
}
aliases = splitarray(p, q, COMMA);
if (aliases == NULL) {
myerrno = errno;
goto error;
}
p = q + 1;
/* h_addrtype field */
tb = tmpbuf;
if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
strlen(tb) == 0U) {
goto error;
}
if (strcmp(tmpbuf, "AF_INET") == 0)
naddrtype = AF_INET;
else if (strcmp(tmpbuf, "AF_INET6") == 0)
naddrtype = AF_INET6;
else
goto error;
/* n_net field */
tb = tmpbuf;
if (getfield(&tb, sizeof tmpbuf, &p, fieldsep) == NULL ||
strlen(tb) == 0U) {
goto error;
}
bits = inet_net_pton(naddrtype, tmpbuf, &nnet, sizeof nnet);
if (bits < 0) {
goto error;
}
nnet = ntohl(nnet);
ne->n_name = name;
ne->n_aliases = aliases;
ne->n_addrtype = naddrtype;
ne->n_net = nnet;
return (0);
error:
errno = myerrno;
if (name != NULL) free(name);
free_array(aliases, 0);
return (-1);
}
/* ------------------------- struct netent ------------------------- */
/* =========================================================================== */
/*%
* static char ** splitarray(const char *buffer, const char *buffend, char delim)
*
* notes: \li
*
* Split a delim separated astring. Not allowed
* to have two delims next to each other. BUFFER points to begining of
* string, BUFFEND points to one past the end of the string
* (i.e. points at where the null byte would be if null
* terminated).
*
* return: \li
*
* Returns a malloced array of pointers, each pointer pointing to a
* malloced string. If BUFEER is an empty string, then return values is
* array of 1 pointer that is NULL. Returns NULL on failure.
*
*/
static char **
splitarray(const char *buffer, const char *buffend, char delim) {
const char *p, *q;
int count = 0;
char **arr = NULL;
char **aptr;
if (buffend < buffer)
return (NULL);
else if (buffend > buffer && *buffer == delim)
return (NULL);
else if (buffend > buffer && *(buffend - 1) == delim)
return (NULL);
/* count the number of field and make sure none are empty */
if (buffend > buffer + 1) {
for (count = 1, q = buffer ; q != buffend ; q++) {
if (*q == delim) {
if (q > buffer && (*(q - 1) == delim)) {
errno = EINVAL;
return (NULL);
}
count++;
}
}
}
if (count > 0) {
count++ ; /*%< for NULL at end */
aptr = arr = malloc(count * sizeof (char *));
if (aptr == NULL) {
errno = ENOMEM;
return (NULL);
}
memset(arr, 0x0, count * sizeof (char *));
for (p = buffer ; p < buffend ; p++) {
for (q = p ; *q != delim && q != buffend ; q++)
/* nothing */;
*aptr = strndup(p, q - p);
p = q;
aptr++;
}
*aptr = NULL;
} else {
arr = malloc(sizeof (char *));
if (arr == NULL) {
errno = ENOMEM;
return (NULL);
}
*arr = NULL;
}
return (arr);
}
/*%
* static size_t joinlength(char * const *argv)
*
* return: \li
*
* the number of bytes in all the arrays pointed at
* by argv, including their null bytes(which will usually be turned
* into commas).
*
*
*/
static size_t
joinlength(char * const *argv) {
int len = 0;
while (argv && *argv) {
len += (strlen(*argv) + 1);
argv++;
}
return (len);
}
/*%
* int joinarray(char * const *argv, char *buffer, char delim)
*
* notes: \li
*
* Copy all the ARGV strings into the end of BUFFER
* separating them with DELIM. BUFFER is assumed to have
* enough space to hold everything and to be already null-terminated.
*
* return: \li
*
* 0 unless argv or buffer is NULL.
*
*
*/
static int
joinarray(char * const *argv, char *buffer, char delim) {
char * const *p;
char sep[2];
if (argv == NULL || buffer == NULL) {
errno = EINVAL;
return (-1);
}
sep[0] = delim;
sep[1] = 0x0;
for (p = argv ; *p != NULL ; p++) {
strcat(buffer, *p);
if (*(p + 1) != NULL) {
strcat(buffer, sep);
}
}
return (0);
}
/*%
* static char * getfield(char **res, size_t reslen, char **ptr, char delim)
*
* notes: \li
*
* Stores in *RES, which is a buffer of length RESLEN, a
* copy of the bytes from *PTR up to and including the first
* instance of DELIM. If *RES is NULL, then it will be
* assigned a malloced buffer to hold the copy. *PTR is
* modified to point at the found delimiter.
*
* return: \li
*
* If there was no delimiter, then NULL is returned,
* otherewise *RES is returned.
*
*/
static char *
getfield(char **res, size_t reslen, char **ptr, char delim) {
char *q;
if (res == NULL || ptr == NULL || *ptr == NULL) {
errno = EINVAL;
return (NULL);
}
q = strchr(*ptr, delim);
if (q == NULL) {
errno = EINVAL;
return (NULL);
} else {
if (*res == NULL) {
*res = strndup(*ptr, q - *ptr);
} else {
if ((size_t)(q - *ptr + 1) > reslen) { /*%< to big for res */
errno = EINVAL;
return (NULL);
} else {
strncpy(*res, *ptr, q - *ptr);
(*res)[q - *ptr] = 0x0;
}
}
*ptr = q + 1;
}
return (*res);
}
#ifndef HAVE_STRNDUP
/*
* static char * strndup(const char *str, size_t len)
*
* notes: \li
*
* like strdup, except do len bytes instead of the whole string. Always
* null-terminates.
*
* return: \li
*
* The newly malloced string.
*
*/
static char *
strndup(const char *str, size_t len) {
char *p = malloc(len + 1);
if (p == NULL)
return (NULL);
strncpy(p, str, len);
p[len] = 0x0;
return (p);
}
#endif
#if WANT_MAIN
/*%
* static int strcmp_nws(const char *a, const char *b)
*
* notes: \li
*
* do a strcmp, except uneven lengths of whitespace compare the same
*
* return: \li
*
*/
static int
strcmp_nws(const char *a, const char *b) {
while (*a && *b) {
if (isspace(*a) && isspace(*b)) {
do {
a++;
} while (isspace(*a));
do {
b++;
} while (isspace(*b));
}
if (*a < *b)
return (-1);
else if (*a > *b)
return (1);
a++;
b++;;
}
if (*a == *b)
return (0);
else if (*a > *b)
return (1);
else
return (-1);
}
#endif
/*%
* static void free_array(char **argv, size_t entries)
*
* notes: \li
*
* Free argv and each of the pointers inside it. The end of
* the array is when a NULL pointer is found inside. If
* entries is > 0, then NULL pointers inside the array do
* not indicate the end of the array.
*
*/
static void
free_array(char **argv, size_t entries) {
char **p = argv;
int useEntries = (entries > 0U);
if (argv == NULL)
return;
while ((useEntries && entries > 0U) || *p) {
if (*p)
free(*p);
p++;
if (useEntries)
entries--;
}
free(argv);
}
/* ************************************************** */
#if WANT_MAIN
/*% takes an option to indicate what sort of marshalling(read the code) and
an argument. If the argument looks like a marshalled buffer(has a ':'
embedded) then it's unmarshalled and the remarshalled and the new string
is compared to the old one.
*/
int
main(int argc, char **argv) {
char buffer[1024];
char *b = &buffer[0];
size_t len = sizeof buffer;
char option;
if (argc < 2 || argv[1][0] != '-')
exit(1);
option = argv[1][1];
argv++;
argc--;
#if 0
{
char buff[10];
char *p = argv[1], *q = &buff[0];
while (getfield(&q, sizeof buff, &p, ':') != NULL) {
printf("field: \"%s\"\n", q);
p++;
}
printf("p is now \"%s\"\n", p);
}
#endif
#if 0
{
char **x = splitarray(argv[1], argv[1] + strlen(argv[1]),
argv[2][0]);
char **p;
if (x == NULL)
printf("split failed\n");
for (p = x ; p != NULL && *p != NULL ; p++) {
printf("\"%s\"\n", *p);
}
}
#endif
#if 1
switch(option) {
case 'n': {
struct nwent ne;
int i;
if (strchr(argv[1], ':') != NULL) {
if (irp_unmarshall_nw(&ne, argv[1]) != 0) {
printf("Unmarhsalling failed\n");
exit(1);
}
printf("Name: \"%s\"\n", ne.n_name);
printf("Aliases:");
for (i = 0 ; ne.n_aliases[i] != NULL ; i++)
printf("\n\t\"%s\"", ne.n_aliases[i]);
printf("\nAddrtype: %s\n", ADDR_T_STR(ne.n_addrtype));
inet_net_ntop(ne.n_addrtype, ne.n_addr, ne.n_length,
buffer, sizeof buffer);
printf("Net: \"%s\"\n", buffer);
*((long*)ne.n_addr) = htonl(*((long*)ne.n_addr));
inet_net_ntop(ne.n_addrtype, ne.n_addr, ne.n_length,
buffer, sizeof buffer);
printf("Corrected Net: \"%s\"\n", buffer);
} else {
struct netent *np1 = getnetbyname(argv[1]);
ne.n_name = np1->n_name;
ne.n_aliases = np1->n_aliases;
ne.n_addrtype = np1->n_addrtype;
ne.n_addr = &np1->n_net;
ne.n_length = (IN_CLASSA(np1->n_net) ?
8 :
(IN_CLASSB(np1->n_net) ?
16 :
(IN_CLASSC(np1->n_net) ?
24 : -1)));
np1->n_net = htonl(np1->n_net);
if (irp_marshall_nw(&ne, &b, &len) != 0) {
printf("Marshalling failed\n");
}
printf("%s\n", b);
}
break;
}
case 'r': {
char **hosts, **users, **domains;
size_t entries;
int i;
char *buff;
size_t size;
char *ngname;
if (strchr(argv[1], '(') != NULL) {
if (irp_unmarshall_ng(&ngname, &entries,
&hosts, &users, &domains,
argv[1]) != 0) {
printf("unmarshall failed\n");
exit(1);
}
#define STRVAL(x) (x == NULL ? "*" : x)
printf("%s {\n", ngname);
for (i = 0 ; i < entries ; i++)
printf("\t\"%s\" : \"%s\" : \"%s\"\n",
STRVAL(hosts[i]),
STRVAL(users[i]),
STRVAL(domains[i]));
printf("}\n\n\n");
irp_marshall_ng_start(ngname, NULL, &size);
for (i = 0 ; i < entries ; i++)
irp_marshall_ng_next(hosts[i], users[i],
domains[i], NULL, &size);
irp_marshall_ng_end(NULL, &size);
buff = malloc(size);
irp_marshall_ng_start(ngname, buff, &size);
for (i = 0 ; i < entries ; i++) {
if (irp_marshall_ng_next(hosts[i], users[i],
domains[i], buff,
&size) != 0)
printf("next marshalling failed.\n");
}
irp_marshall_ng_end(buff, &size);
if (strcmp_nws(argv[1], buff) != 0) {
printf("compare failed:\n\t%s\n\t%s\n",
buffer, argv[1]);
} else {
printf("compare ok\n");
}
} else {
char *h, *u, *d, *buff;
size_t size;
/* run through two times. First to figure out how
much of a buffer we need. Second to do the
actual marshalling */
setnetgrent(argv[1]);
irp_marshall_ng_start(argv[1], NULL, &size);
while (getnetgrent(&h, &u, &d) == 1)
irp_marshall_ng_next(h, u, d, NULL, &size);
irp_marshall_ng_end(NULL, &size);
endnetgrent(argv[1]);
buff = malloc(size);
setnetgrent(argv[1]);
if (irp_marshall_ng_start(argv[1], buff, &size) != 0)
printf("Marshalling start failed\n");
while (getnetgrent(&h, &u, &d) == 1) {
if (irp_marshall_ng_next(h, u, d, buff, &size)
!= 0) {
printf("Marshalling failed\n");
}
}
irp_marshall_ng_end(buff, &size);
endnetgrent();
printf("success: %s\n", buff);
}
break;
}
case 'h': {
struct hostent he, *hp;
int i;
if (strchr(argv[1], '@') != NULL) {
if (irp_unmarshall_ho(&he, argv[1]) != 0) {
printf("unmarshall failed\n");
exit(1);
}
printf("Host: \"%s\"\nAliases:", he.h_name);
for (i = 0 ; he.h_aliases[i] != NULL ; i++)
printf("\n\t\t\"%s\"", he.h_aliases[i]);
printf("\nAddr Type: \"%s\"\n",
ADDR_T_STR(he.h_addrtype));
printf("Length: %d\nAddresses:", he.h_length);
for (i = 0 ; he.h_addr_list[i] != 0 ; i++) {
inet_ntop(he.h_addrtype, he.h_addr_list[i],
buffer, sizeof buffer);
printf("\n\t\"%s\"\n", buffer);
}
printf("\n\n");
irp_marshall_ho(&he, &b, &len);
if (strcmp(argv[1], buffer) != 0) {
printf("compare failed:\n\t\"%s\"\n\t\"%s\"\n",
buffer, argv[1]);
} else {
printf("compare ok\n");
}
} else {
if ((hp = gethostbyname(argv[1])) == NULL) {
perror("gethostbyname");
printf("\"%s\"\n", argv[1]);
exit(1);
}
if (irp_marshall_ho(hp, &b, &len) != 0) {
printf("irp_marshall_ho failed\n");
exit(1);
}
printf("success: \"%s\"\n", buffer);
}
break;
}
case 's': {
struct servent *sv;
struct servent sv1;
if (strchr(argv[1], ':') != NULL) {
sv = &sv1;
memset(sv, 0xef, sizeof (struct servent));
if (irp_unmarshall_sv(sv, argv[1]) != 0) {
printf("unmarshall failed\n");
}
irp_marshall_sv(sv, &b, &len);
if (strcmp(argv[1], buffer) != 0) {
printf("compare failed:\n\t\"%s\"\n\t\"%s\"\n",
buffer, argv[1]);
} else {
printf("compare ok\n");
}
} else {
if ((sv = getservbyname(argv[1], argv[2])) == NULL) {
perror("getservent");
exit(1);
}
if (irp_marshall_sv(sv, &b, &len) != 0) {
printf("irp_marshall_sv failed\n");
exit(1);
}
printf("success: \"%s\"\n", buffer);
}
break;
}
case 'g': {
struct group *gr;
struct group gr1;
if (strchr(argv[1], ':') != NULL) {
gr = &gr1;
memset(gr, 0xef, sizeof (struct group));
if (irp_unmarshall_gr(gr, argv[1]) != 0) {
printf("unmarshall failed\n");
}
irp_marshall_gr(gr, &b, &len);
if (strcmp(argv[1], buffer) != 0) {
printf("compare failed:\n\t\"%s\"\n\t\"%s\"\n",
buffer, argv[1]);
} else {
printf("compare ok\n");
}
} else {
if ((gr = getgrnam(argv[1])) == NULL) {
perror("getgrnam");
exit(1);
}
if (irp_marshall_gr(gr, &b, &len) != 0) {
printf("irp_marshall_gr failed\n");
exit(1);
}
printf("success: \"%s\"\n", buffer);
}
break;
}
case 'p': {
struct passwd *pw;
struct passwd pw1;
if (strchr(argv[1], ':') != NULL) {
pw = &pw1;
memset(pw, 0xef, sizeof (*pw));
if (irp_unmarshall_pw(pw, argv[1]) != 0) {
printf("unmarshall failed\n");
exit(1);
}
printf("User: \"%s\"\nPasswd: \"%s\"\nUid: %ld\nGid: %ld\n",
pw->pw_name, pw->pw_passwd, (long)pw->pw_uid,
(long)pw->pw_gid);
printf("Class: \"%s\"\nChange: %ld\nGecos: \"%s\"\n",
pw->pw_class, (long)pw->pw_change, pw->pw_gecos);
printf("Shell: \"%s\"\nDirectory: \"%s\"\n",
pw->pw_shell, pw->pw_dir);
pw = getpwnam(pw->pw_name);
irp_marshall_pw(pw, &b, &len);
if (strcmp(argv[1], buffer) != 0) {
printf("compare failed:\n\t\"%s\"\n\t\"%s\"\n",
buffer, argv[1]);
} else {
printf("compare ok\n");
}
} else {
if ((pw = getpwnam(argv[1])) == NULL) {
perror("getpwnam");
exit(1);
}
if (irp_marshall_pw(pw, &b, &len) != 0) {
printf("irp_marshall_pw failed\n");
exit(1);
}
printf("success: \"%s\"\n", buffer);
}
break;
}
default:
printf("Wrong option: %c\n", option);
break;
}
#endif
return (0);
}
#endif
/*! \file */
