Beispiel #1
0
/*ARGSUSED*/
static int
_dns_initshells(void *rv, void *cb_data, va_list ap)
{
	char	  shellname[] = "shells-XXXXX";
	int	  hsindex, hpi, r;
	char	**hp;
	void	 *context;

	if (sl)
		sl_free(sl, 1);
	sl = sl_init();
	r = NS_UNAVAIL;
	if (hesiod_init(&context) == -1)
		return (r);

	for (hsindex = 0; ; hsindex++) {
		snprintf(shellname, sizeof(shellname)-1, "shells-%d", hsindex);
		hp = hesiod_resolve(context, shellname, "shells");
		if (hp == NULL) {
			if (errno == ENOENT) {
				if (hsindex == 0)
					r = NS_NOTFOUND;
				else
					r = NS_SUCCESS;
			}
			break;
		} else {
			for (hpi = 0; hp[hpi]; hpi++)
				sl_add(sl, hp[hpi]);
			free(hp);
		}
	}
	hesiod_end(context);
	return (r);
}
Beispiel #2
0
void *
_nss_hesiod_init (void)
{
  void *context;

  if (hesiod_init (&context) == -1)
    return NULL;

  /* Use the default (per-thread) resolver state.  */
  __hesiod_res_set (context, &_res, NULL);

  return context;
}
Beispiel #3
0
int
__grstart_dns(struct __grstate_dns *state)
{

	_DIAGASSERT(state != NULL);

	state->num = 0;
	if (state->context == NULL) {			/* setup Hesiod */
		if (hesiod_init(&state->context) == -1)
			return NS_UNAVAIL;
	}

	return NS_SUCCESS;
}
Beispiel #4
0
static char *
hesiod_get_pobox (const char **user)
{
    void *context;
    struct hesiod_postoffice *hpo;
    char *ret = NULL;

    if(hesiod_init (&context) != 0)
	err (1, "hesiod_init");

    hpo = hesiod_getmailhost (context, *user);
    if (hpo == NULL) {
	warn ("hesiod_getmailhost %s", *user);
    } else {
	if (strcasecmp(hpo->hesiod_po_type, "pop") != 0)
	    errx (1, "Unsupported po type %s", hpo->hesiod_po_type);

	ret = estrdup(hpo->hesiod_po_host);
	*user = estrdup(hpo->hesiod_po_name);
	hesiod_free_postoffice (context, hpo);
    }
    hesiod_end (context);
    return ret;
}
Beispiel #5
0
int 
main(int argc, char **argv)
{
	char  **list, **p, *bindname, *name, *type;
	int     lflag = 0, errflg = 0, bflag = 0, c;
	void   *context;

	while ((c = getopt(argc, argv, "lb")) != -1) {
		switch (c) {
		case 'l':
			lflag = 1;
			break;
		case 'b':
			bflag = 1;
			break;
		default:
			errflg++;
			break;
		}
	}
	if (argc - optind != 2 || errflg) {
		fprintf(stderr, "usage: hesinfo [-bl] name type\n");
		fprintf(stderr, "\t-l selects long format\n");
		fprintf(stderr, "\t-b also does hes_to_bind conversion\n");
		exit(2);
	}
	name = argv[optind];
	type = argv[optind + 1];

	if (hesiod_init(&context) < 0) {
		if (errno == ENOEXEC)
			warnx(
			    "hesiod_init: Invalid Hesiod configuration file.");
		else
			warn("hesiod_init");
	}
	/* Display bind name if requested. */
	if (bflag) {
		if (lflag)
			printf("hes_to_bind(%s, %s) expands to\n", name, type);
		bindname = hesiod_to_bind(context, name, type);
		if (!bindname) {
			if (lflag)
				printf("nothing\n");
			if (errno == ENOENT)
				warnx("hesiod_to_bind: Unknown rhs-extension.");
			else
				warn("hesiod_to_bind");
			exit(1);
		}
		printf("%s\n", bindname);
		free(bindname);
		if (lflag)
			printf("which ");
	}
	if (lflag)
		printf("resolves to\n");

	/* Do the hesiod resolve and check for errors. */
	list = hesiod_resolve(context, name, type);
	if (!list) {
		if (lflag)
			printf("nothing\n");
		if (errno == ENOENT)
			warnx("hesiod_resolve: Hesiod name not found.");
		else
			warn("hesiod_resolve");
		exit(1);
	}
	/* Display the results. */
	for (p = list; *p; p++)
		printf("%s\n", *p);

	hesiod_free_list(context, list);
	hesiod_end(context);
	exit(0);
}
Beispiel #6
0
/* Retrieve the user's hesiod groups and stuff them into *groups, with a
 * count in *ngroups.  Also put the user's primary gid into *primary_gid.
 * Return 0 on success and -1 on failure.
 */
static int retrieve_hesgroups(const char *username, struct hesgroup **groups,
			      int *ngroups, gid_t *primary_gid)
{
  char **grplistvec, **primarygidvec, *primary_name, buf[64], *p, *q;
  int n, len;
  struct hesgroup *hesgroups;
  struct passwd *pwd;
  void *hescontext;

  /* Look up the user's primary group in hesiod to retrieve the primary
   * group name.  Start by finding the gid. */
  pwd = al__getpwnam(username);
  if (!pwd)
    return -1;
  *primary_gid = pwd->pw_gid;
  al__free_passwd(pwd);

  /* Initialize the hesiod context. */
  if (hesiod_init(&hescontext) != 0)
    return -1;

  /* Now do the hesiod resolve.  If it fails with ENOENT, assume the user
   * has a local account and return no groups. */
  sprintf(buf, "%lu", (unsigned long) *primary_gid);
  primarygidvec = hesiod_resolve(hescontext, buf, "gid");
  if (!primarygidvec && errno == ENOENT)
    {
      *groups = NULL;
      *ngroups = 0;
      hesiod_end(hescontext);
      return 0;
    }
  if (!primarygidvec || !*primarygidvec || **primarygidvec == ':')
    {
      if (primarygidvec)
	hesiod_free_list(hescontext, primarygidvec);
      hesiod_end(hescontext);
      return -1;
    }

  /* Copy the name part into primary_name. */
  p = strchr(*primarygidvec, ':');
  len = (p) ? p - *primarygidvec : strlen(*primarygidvec);
  primary_name = malloc(len + 1);
  if (!primary_name)
    {
      hesiod_free_list(hescontext, primarygidvec);
      hesiod_end(hescontext);
      return -1;
    }
  memcpy(primary_name, *primarygidvec, len);
  primary_name[len] = 0;
  hesiod_free_list(hescontext, primarygidvec);

  /* Look up the Hesiod group list.  It's okay if there isn't one. */
  grplistvec = hesiod_resolve(hescontext, username, "grplist");
  if ((!grplistvec && errno != ENOENT) || (grplistvec && !*grplistvec))
    {
      if (grplistvec)
	hesiod_free_list(hescontext, grplistvec);
      hesiod_end(hescontext);
      free(primary_name);
      return -1;
    }

  /* Get a close upper bound on the number of group entries we'll need. */
  if (grplistvec)
    {
      n = 0;
      for (p = *grplistvec; *p; p++)
	{
	  if (*p == ':')
	    n++;
	}
      n = (n + 1) / 2 + 1;
    }
  else
    n = 1;

  /* Allocate memory. */
  hesgroups = malloc(n * sizeof(struct hesgroup));
  if (!hesgroups)
    {
      if (grplistvec)
	hesiod_free_list(hescontext, grplistvec);
      hesiod_end(hescontext);
      free(primary_name);
      return -1;
    }

  /* Start off the list with the primary gid. */
  hesgroups[0].name = primary_name;
  hesgroups[0].gid = *primary_gid;
  hesgroups[0].present = 0;
  n = 1;
  
  /* Now get the entries from grplistvec, if we got one. */
  p = (grplistvec) ? *grplistvec : NULL;
  while (p)
    {
      /* Find the end of the group name.  Stop if we hit the end, if we
       * have a zero-length group name, or if we have a non-numeric gid. */
      q = strchr(p, ':');
      if (!q || q == p || !isdigit((unsigned char)*(q + 1)))
	break;

      if (atoi(q + 1) >= MIN_HES_GROUP)
	{
	  hesgroups[n].name = malloc(q - p + 1);
	  if (!hesgroups[n].name)
	    {
	      free_hesgroups(hesgroups, n);
	      hesiod_free_list(hescontext, grplistvec);
	      hesiod_end(hescontext);
	      return -1;
	    }
	  memcpy(hesgroups[n].name, p, q - p);
	  hesgroups[n].name[q - p] = 0;
	  hesgroups[n].gid = atoi(q + 1);
	  hesgroups[n].present = 0;
	  n++;
	}
      p = strchr(q + 1, ':');
      if (p)
	p++;
    }

  /* Clean up allocated memory and return. */
  if (grplistvec)
    hesiod_free_list(hescontext, grplistvec);
  hesiod_end(hescontext);
  *ngroups = n;
  *groups = hesgroups;
  return 0;
}