Back to index

glibc  2.9
Functions
hesiod.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

int hesiod_init (void **context)
void hesiod_end (void *context)
char * hesiod_to_bind (void *context, const char *name, const char *type)
char ** hesiod_resolve (void *context, const char *name, const char *type)
void hesiod_free_list (void *context, char **list)
struct __res_state__hesiod_res_get (void *context)
void __hesiod_res_set (void *context, struct __res_state *, void(*)(void *))

Function Documentation

struct __res_state* __hesiod_res_get ( void *  context) [read]

Definition at line 469 of file hesiod.c.

                                {
       struct hesiod_p *ctx = context;

       if (!ctx->res) {
              struct __res_state *res;
              res = (struct __res_state *)calloc(1, sizeof *res);
              if (res == NULL)
                     return (NULL);
              __hesiod_res_set(ctx, res, free);
       }

       return (ctx->res);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void __hesiod_res_set ( void *  context,
struct __res_state ,
void(*)(void *)   
)

Definition at line 484 of file hesiod.c.

                                          {
       struct hesiod_p *ctx = context;

       if (ctx->res && ctx->free_res) {
              res_nclose(ctx->res);
              (*ctx->free_res)(ctx->res);
       }

       ctx->res = res;
       ctx->free_res = free_res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void hesiod_end ( void *  context)

Definition at line 151 of file hesiod.c.

                          {
       struct hesiod_p *ctx = (struct hesiod_p *) context;
       int save_errno = errno;

       if (ctx->res)
              res_nclose(ctx->res);
       free(ctx->RHS);
       free(ctx->LHS);
       if (ctx->res && ctx->free_res)
              (*ctx->free_res)(ctx->res);
       free(ctx);
       __set_errno(save_errno);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void hesiod_free_list ( void *  context,
char **  list 
)

Definition at line 251 of file hesiod.c.

                                             {
       char **p;

       for (p = list; *p; p++)
              free(*p);
       free(list);
}

Here is the caller graph for this function:

int hesiod_init ( void **  context)

Definition at line 74 of file hesiod.c.

                            {
       struct hesiod_p *ctx;
       const char *configname;
       char *cp;

       ctx = malloc(sizeof(struct hesiod_p));
       if (ctx == 0)
              return (-1);

       ctx->LHS = NULL;
       ctx->RHS = NULL;
       ctx->res = NULL;
       /* Set default query classes. */
       ctx->classes[0] = C_IN;
       ctx->classes[1] = C_HS;

       configname = __secure_getenv("HESIOD_CONFIG");
       if (!configname)
         configname = _PATH_HESIOD_CONF;
       if (parse_config_file(ctx, configname) < 0) {
#ifdef DEF_RHS
              /*
               * Use compiled in defaults.
               */
              ctx->LHS = malloc(strlen(DEF_LHS)+1);
              ctx->RHS = malloc(strlen(DEF_RHS)+1);
              if (ctx->LHS == 0 || ctx->RHS == 0)
                     goto cleanup;
              strcpy(ctx->LHS, DEF_LHS);
              strcpy(ctx->RHS, DEF_RHS);
#else
              goto cleanup;
#endif
       }
       /*
        * The default RHS can be overridden by an environment
        * variable.
        */
       if ((cp = __secure_getenv("HES_DOMAIN")) != NULL) {
              free(ctx->RHS);
              ctx->RHS = malloc(strlen(cp)+2);
              if (!ctx->RHS)
                     goto cleanup;
              if (cp[0] == '.')
                     strcpy(ctx->RHS, cp);
              else {
                     ctx->RHS[0] = '.';
                     strcpy(ctx->RHS + 1, cp);
              }
       }

       /*
        * If there is no default hesiod realm set, we return an
        * error.
        */
       if (!ctx->RHS) {
              __set_errno(ENOEXEC);
              goto cleanup;
       }

#if 0
       if (res_ninit(ctx->res) < 0)
              goto cleanup;
#endif

       *context = ctx;
       return (0);

 cleanup:
       hesiod_end(ctx);
       return (-1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

char** hesiod_resolve ( void *  context,
const char *  name,
const char *  type 
)

Definition at line 228 of file hesiod.c.

                                                                  {
       struct hesiod_p *ctx = (struct hesiod_p *) context;
       char *bindname = hesiod_to_bind(context, name, type);
       char **retvec;

       if (bindname == NULL)
              return (NULL);
       if (init(ctx) == -1) {
              free(bindname);
              return (NULL);
       }

       retvec = get_txt_records(ctx, ctx->classes[0], bindname);

       if (retvec == NULL && (errno == ENOENT || errno == ECONNREFUSED) && ctx->classes[1])
              retvec = get_txt_records(ctx, ctx->classes[1], bindname);


       free(bindname);
       return (retvec);
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* hesiod_to_bind ( void *  context,
const char *  name,
const char *  type 
)

Definition at line 170 of file hesiod.c.

                                                                  {
       struct hesiod_p *ctx = (struct hesiod_p *) context;
       char *bindname;
       char **rhs_list = NULL;
       const char *RHS, *cp;
       char *endp;

       /* Decide what our RHS is, and set cp to the end of the actual name. */
       if ((cp = strchr(name, '@')) != NULL) {
              if (strchr(cp + 1, '.'))
                     RHS = cp + 1;
              else if ((rhs_list = hesiod_resolve(context, cp + 1,
                  "rhs-extension")) != NULL)
                     RHS = *rhs_list;
              else {
                     __set_errno(ENOENT);
                     return (NULL);
              }
       } else {
              RHS = ctx->RHS;
              cp = name + strlen(name);
       }

       /*
        * Allocate the space we need, including up to three periods and
        * the terminating NUL.
        */
       if ((bindname = malloc((cp - name) + strlen(type) + strlen(RHS) +
           (ctx->LHS ? strlen(ctx->LHS) : 0) + 4)) == NULL) {
              if (rhs_list)
                     hesiod_free_list(context, rhs_list);
              return NULL;
       }

       /* Now put together the DNS name. */
       endp = (char *) __mempcpy (bindname, name, cp - name);
       *endp++ = '.';
       endp = (char *) __stpcpy (endp, type);
       if (ctx->LHS) {
              if (ctx->LHS[0] != '.')
                     *endp++ = '.';
              endp = __stpcpy (endp, ctx->LHS);
       }
       if (RHS[0] != '.')
              *endp++ = '.';
       strcpy (endp, RHS);

       if (rhs_list)
              hesiod_free_list(context, rhs_list);

       return (bindname);
}

Here is the call graph for this function:

Here is the caller graph for this function: