qiurui
/
glibc
mirror of git://sourceware.org/git/glibc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update. 

1998-06-26  Thorsten Kukuk  <kukuk@vt.uni-paderborn.de>

	* nis/nis_call.c: Don't copy server structure.
	* nis/nis_intern.h: Remove unused entries.
	* nis/nis_table.c: Rewrite __create_ib_request.
This commit is contained in:
Ulrich Drepper 1998-06-26 22:47:20 +00:00
parent 026d50118f
commit d6db1d53b3
4 changed files with 160 additions and 266 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ChangeLog
View File

@ -1,3 +1,9 @@
1998-06-26 Thorsten Kukuk <kukuk@vt.uni-paderborn.de>
* nis/nis_call.c: Don't copy server structure.
* nis/nis_intern.h: Remove unused entries.
* nis/nis_table.c: Rewrite __create_ib_request.
1998-06-26 14:37 Ulrich Drepper <drepper@cygnus.com> 1998-06-26 14:37 Ulrich Drepper <drepper@cygnus.com>
* configure.in: Check for -fexceptions. * configure.in: Check for -fexceptions.

133
nis/nis_call.c
View File

@ -69,8 +69,6 @@ __bind_destroy (dir_binding *bind)
auth_destroy (bind->clnt->cl_auth); auth_destroy (bind->clnt->cl_auth);
clnt_destroy (bind->clnt); clnt_destroy (bind->clnt);
} }
free (bind->server_val);
free (bind);
} }
static nis_error static nis_error
@ -108,8 +106,7 @@ __bind_next (dir_binding *bind)
for (j = 0; j < bind->server_val[bind->server_used].ep.ep_len; ++j) for (j = 0; j < bind->server_val[bind->server_used].ep.ep_len; ++j)
if (strcmp (bind->server_val[bind->server_used].ep.ep_val[j].family, if (strcmp (bind->server_val[bind->server_used].ep.ep_val[j].family,
"inet") == 0) "inet") == 0)
if (strcmp (bind->server_val[bind->server_used].ep.ep_val[j].proto, if (bind->server_val[bind->server_used].ep.ep_val[j].proto[0] == '-')
"-") == 0)
{ {
bind->current_ep = j; bind->current_ep = j;
return NIS_SUCCESS; return NIS_SUCCESS;
@ -121,9 +118,7 @@ __bind_next (dir_binding *bind)
static nis_error static nis_error
__bind_connect (dir_binding *dbp) __bind_connect (dir_binding *dbp)
{ {
struct sockaddr_in check;
nis_server *serv; nis_server *serv;
int checklen;
if (dbp == NULL) if (dbp == NULL)
return NIS_FAIL; return NIS_FAIL;
@ -182,38 +177,17 @@ __bind_connect (dir_binding *dbp)
dbp->use_auth = TRUE; dbp->use_auth = TRUE;
} }
/* Get port for sanity checks later */
checklen = sizeof (struct sockaddr_in);
memset (&check, 0, checklen);
if (dbp->use_udp)
bind (dbp->socket, (struct sockaddr *)&check, checklen);
check.sin_family = AF_INET;
if (!getsockname (dbp->socket, (struct sockaddr *)&check, &checklen))
dbp->port = check.sin_port;
dbp->create = time (NULL);
return NIS_SUCCESS; return NIS_SUCCESS;
} }
static dir_binding * static nis_error
__bind_create (const nis_server *serv_val, u_int serv_len, u_long flags, __bind_create (dir_binding *dbp, const nis_server *serv_val, u_int serv_len,
cache2_info *cinfo) u_long flags, cache2_info *cinfo)
{ {
dir_binding *dbp; dbp->clnt = NULL;
u_int i;
dbp = calloc (1, sizeof (dir_binding));
if (dbp == NULL)
return NULL;
dbp->server_len = serv_len; dbp->server_len = serv_len;
dbp->server_val = calloc (1, sizeof (nis_server) * serv_len); dbp->server_val = (nis_server *)serv_val;
if (dbp->server_val == NULL)
{
free (dbp);
return NULL;
}
if (flags & USE_DGRAM) if (flags & USE_DGRAM)
dbp->use_udp = TRUE; dbp->use_udp = TRUE;
@ -233,54 +207,6 @@ __bind_create (const nis_server *serv_val, u_int serv_len, u_long flags,
/* We try the first server */ /* We try the first server */
dbp->trys = 1; dbp->trys = 1;
for (i = 0; i < serv_len; ++i)
{
if (serv_val[i].name != NULL)
dbp->server_val[i].name = strdup (serv_val[i].name);
dbp->server_val[i].ep.ep_len = serv_val[i].ep.ep_len;
if (dbp->server_val[i].ep.ep_len > 0)
{
unsigned long j;
dbp->server_val[i].ep.ep_val =
malloc (serv_val[i].ep.ep_len * sizeof (endpoint));
for (j = 0; j < dbp->server_val[i].ep.ep_len; ++j)
{
if (serv_val[i].ep.ep_val[j].uaddr)
dbp->server_val[i].ep.ep_val[j].uaddr =
strdup (serv_val[i].ep.ep_val[j].uaddr);
else
dbp->server_val[i].ep.ep_val[j].uaddr = NULL;
if (serv_val[i].ep.ep_val[j].family)
dbp->server_val[i].ep.ep_val[j].family =
strdup (serv_val[i].ep.ep_val[j].family);
else
dbp->server_val[i].ep.ep_val[j].family = NULL;
if (serv_val[i].ep.ep_val[j].proto)
dbp->server_val[i].ep.ep_val[j].proto =
strdup (serv_val[i].ep.ep_val[j].proto);
else
dbp->server_val[i].ep.ep_val[j].proto = NULL;
}
}
else
dbp->server_val[i].ep.ep_val = NULL;
dbp->server_val[i].key_type = serv_val[i].key_type;
dbp->server_val[i].pkey.n_len = serv_val[i].pkey.n_len;
if (serv_val[i].pkey.n_len > 0)
{
dbp->server_val[i].pkey.n_bytes =
malloc (serv_val[i].pkey.n_len);
if (dbp->server_val[i].pkey.n_bytes == NULL)
return NULL;
memcpy (dbp->server_val[i].pkey.n_bytes, serv_val[i].pkey.n_bytes,
serv_val[i].pkey.n_len);
}
else
dbp->server_val[i].pkey.n_bytes = NULL;
}
dbp->class = -1; dbp->class = -1;
if (cinfo != NULL && cinfo->server_used >= 0) if (cinfo != NULL && cinfo->server_used >= 0)
{ {
@ -291,10 +217,10 @@ __bind_create (const nis_server *serv_val, u_int serv_len, u_long flags,
else if (__nis_findfastest (dbp) < 1) else if (__nis_findfastest (dbp) < 1)
{ {
__bind_destroy (dbp); __bind_destroy (dbp);
return NULL; return NIS_NAMEUNREACHABLE;
} }
return dbp; return NIS_SUCCESS;
} }
nis_error nis_error
@ -304,19 +230,18 @@ __do_niscall2 (const nis_server *server, u_int server_len, u_long prog,
{ {
enum clnt_stat result; enum clnt_stat result;
nis_error retcode; nis_error retcode;
dir_binding *dbp; dir_binding dbp;
if (flags & MASTER_ONLY) if (flags & MASTER_ONLY)
server_len = 1; server_len = 1;
dbp = __bind_create (server, server_len, flags, cinfo); if (__bind_create (&dbp, server, server_len, flags, cinfo) != NIS_SUCCESS)
if (dbp == NULL)
return NIS_NAMEUNREACHABLE; return NIS_NAMEUNREACHABLE;
while (__bind_connect (dbp) != NIS_SUCCESS) while (__bind_connect (&dbp) != NIS_SUCCESS)
{ {
if (__bind_next (dbp) != NIS_SUCCESS) if (__bind_next (&dbp) != NIS_SUCCESS)
{ {
__bind_destroy (dbp); __bind_destroy (&dbp);
return NIS_NAMEUNREACHABLE; return NIS_NAMEUNREACHABLE;
} }
} }
@ -324,11 +249,11 @@ __do_niscall2 (const nis_server *server, u_int server_len, u_long prog,
do do
{ {
again: again:
result = clnt_call (dbp->clnt, prog, xargs, req, xres, resp, RPCTIMEOUT); result = clnt_call (dbp.clnt, prog, xargs, req, xres, resp, RPCTIMEOUT);
if (result != RPC_SUCCESS) if (result != RPC_SUCCESS)
{ {
__bind_destroy (dbp); __bind_destroy (&dbp);
retcode = NIS_RPCERROR; retcode = NIS_RPCERROR;
} }
else else
@ -339,7 +264,7 @@ __do_niscall2 (const nis_server *server, u_int server_len, u_long prog,
if ((((nis_result *)resp)->status == NIS_CBRESULTS) && if ((((nis_result *)resp)->status == NIS_CBRESULTS) &&
(cb != NULL)) (cb != NULL))
{ {
__nis_do_callback(dbp, &((nis_result *)resp)->cookie, cb); __nis_do_callback(&dbp, &((nis_result *)resp)->cookie, cb);
break; break;
} }
/* Yes, this is correct. If we doesn't have to start /* Yes, this is correct. If we doesn't have to start
@ -357,13 +282,13 @@ __do_niscall2 (const nis_server *server, u_int server_len, u_long prog,
(((nis_result *)resp)->status == NIS_NOSUCHNAME) || (((nis_result *)resp)->status == NIS_NOSUCHNAME) ||
(((nis_result *)resp)->status == NIS_NOT_ME)) (((nis_result *)resp)->status == NIS_NOT_ME))
{ {
if (__bind_next (dbp) == NIS_SUCCESS) if (__bind_next (&dbp) == NIS_SUCCESS)
{ {
while (__bind_connect (dbp) != NIS_SUCCESS) while (__bind_connect (&dbp) != NIS_SUCCESS)
{ {
if (__bind_next (dbp) != NIS_SUCCESS) if (__bind_next (&dbp) != NIS_SUCCESS)
{ {
__bind_destroy (dbp); __bind_destroy (&dbp);
return NIS_SUCCESS; return NIS_SUCCESS;
} }
} }
@ -378,13 +303,13 @@ __do_niscall2 (const nis_server *server, u_int server_len, u_long prog,
(((fd_result *)resp)->status == NIS_NOSUCHNAME) || (((fd_result *)resp)->status == NIS_NOSUCHNAME) ||
(((fd_result *)resp)->status == NIS_NOT_ME)) (((fd_result *)resp)->status == NIS_NOT_ME))
{ {
if (__bind_next (dbp) == NIS_SUCCESS) if (__bind_next (&dbp) == NIS_SUCCESS)
{ {
while (__bind_connect (dbp) != NIS_SUCCESS) while (__bind_connect (&dbp) != NIS_SUCCESS)
{ {
if (__bind_next (dbp) != NIS_SUCCESS) if (__bind_next (&dbp) != NIS_SUCCESS)
{ {
__bind_destroy (dbp); __bind_destroy (&dbp);
return NIS_SUCCESS; return NIS_SUCCESS;
} }
} }
@ -400,13 +325,13 @@ __do_niscall2 (const nis_server *server, u_int server_len, u_long prog,
(((log_result *)resp)->lr_status == NIS_NOSUCHNAME) || (((log_result *)resp)->lr_status == NIS_NOSUCHNAME) ||
(((log_result *)resp)->lr_status == NIS_NOT_ME)) (((log_result *)resp)->lr_status == NIS_NOT_ME))
{ {
if (__bind_next (dbp) == NIS_SUCCESS) if (__bind_next (&dbp) == NIS_SUCCESS)
{ {
while (__bind_connect (dbp) != NIS_SUCCESS) while (__bind_connect (&dbp) != NIS_SUCCESS)
{ {
if (__bind_next (dbp) != NIS_SUCCESS) if (__bind_next (&dbp) != NIS_SUCCESS)
{ {
__bind_destroy (dbp); __bind_destroy (&dbp);
return NIS_SUCCESS; return NIS_SUCCESS;
} }
} }
@ -419,7 +344,7 @@ __do_niscall2 (const nis_server *server, u_int server_len, u_long prog,
default: default:
break; break;
} }
__bind_destroy (dbp); __bind_destroy (&dbp);
retcode = NIS_SUCCESS; retcode = NIS_SUCCESS;
} }
} }

2
nis/nis_intern.h
View File

@ -36,10 +36,8 @@ struct dir_binding
bool_t master_only; /* Is only binded to the master */ bool_t master_only; /* Is only binded to the master */
bool_t use_auth; /* Do we use AUTH ? */ bool_t use_auth; /* Do we use AUTH ? */
bool_t use_udp; /* Do we use UDP ? */ bool_t use_udp; /* Do we use UDP ? */
time_t create; /* Binding creation time */
struct sockaddr_in addr; /* Server's IP address */ struct sockaddr_in addr; /* Server's IP address */
int socket; /* Server's local socket */ int socket; /* Server's local socket */
unsigned short port; /* Local port */
}; };
typedef struct dir_binding dir_binding; typedef struct dir_binding dir_binding;

285
nis/nis_table.c
View File

@ -23,138 +23,89 @@
#include "nis_xdr.h" #include "nis_xdr.h"
#include "nis_intern.h" #include "nis_intern.h"
static void
splitname (const_nis_name name, nis_name *ibr_name, int *srch_len, static struct ib_request *
nis_attr **srch_val) __create_ib_request (const_nis_name name, u_long flags)
{ {
char *cptr, *key, *val, *next; struct ib_request *ibreq = calloc (1, sizeof (ib_request));
int size; char buf[strlen (name) + 1];
nis_attr *search_val = NULL;
int search_len = 0;
char *cptr;
size_t size = 0;
if (name == NULL) ibreq->ibr_flags = flags;
return;
cptr = strdup (name); cptr = strcpy (buf, name);
if (srch_len)
*srch_len = 0;
if (srch_val)
*srch_val = NULL;
size = 0;
/* Not of "[key=value,key=value,...],foo.." format? */ /* Not of "[key=value,key=value,...],foo.." format? */
if (cptr[0] != '[') if (cptr[0] != '[')
{ {
*ibr_name = cptr; ibreq->ibr_name = strdup (cptr);
return; return ibreq;
} }
*ibr_name = strchr (cptr, ']'); /* "[key=value,...],foo" format */
if (*ibr_name == NULL || (*ibr_name)[1] != ',') ibreq->ibr_name = strchr (cptr, ']');
{ if (ibreq->ibr_name == NULL || ibreq->ibr_name[1] != ',')
free (cptr);
*ibr_name = NULL;
return;
}
*ibr_name[0] = '\0';
*ibr_name += 2;
*ibr_name = strdup (*ibr_name);
if (srch_len == NULL || srch_val == NULL)
{
free (cptr);
return;
}
key = (cptr) + 1;
do
{
next = strchr (key, ',');
if (next)
{
next[0] = '\0';
++next;
}
val = strchr (key, '=');
if (!val)
{
free (cptr);
*srch_val = malloc (sizeof (nis_attr));
if (*srch_val == NULL)
{
free (cptr);
free (*ibr_name);
*ibr_name = NULL;
return;
}
(*srch_val)[0].zattr_val.zattr_val_len = 0;
(*srch_val)[0].zattr_val.zattr_val_val = NULL;
return;
}
val[0] = '\0';
++val;
if ((*srch_len) + 1 >= size)
{
size += 10;
if (size == 10)
*srch_val = malloc (size * sizeof (char *));
else
*srch_val = realloc (val, size * sizeof (char *));
if (*srch_val == NULL)
{
free (cptr);
free (*ibr_name);
*ibr_name = NULL;
return;
}
}
(*srch_val)[*srch_len].zattr_ndx = strdup (key);
if (((*srch_val)[*srch_len].zattr_ndx) == NULL)
{
free (cptr);
free (*ibr_name);
*ibr_name = NULL;
return;
}
(*srch_val)[*srch_len].zattr_val.zattr_val_len = strlen (val) + 1;
(*srch_val)[*srch_len].zattr_val.zattr_val_val = strdup (val);
if ((*srch_val)[*srch_len].zattr_val.zattr_val_val == NULL)
{
free (cptr);
free (*ibr_name);
*ibr_name = NULL;
return;
}
++(*srch_len);
key = next;
}
while (next);
free (cptr);
}
static struct ib_request *
__create_ib_request (const_nis_name name, struct ib_request *ibreq,
u_long flags)
{
splitname (name, &ibreq->ibr_name, &ibreq->ibr_srch.ibr_srch_len,
&ibreq->ibr_srch.ibr_srch_val);
if (ibreq->ibr_name == NULL)
return NULL; return NULL;
ibreq->ibr_flags = flags; /* Check if we have an entry of "[key=value,],bar". If, remove the "," */
ibreq->ibr_obj.ibr_obj_len = 0; if (ibreq->ibr_name[-1] == ',')
ibreq->ibr_obj.ibr_obj_val = NULL; ibreq->ibr_name[-1] = '\0';
ibreq->ibr_cbhost.ibr_cbhost_len = 0; else
ibreq->ibr_cbhost.ibr_cbhost_val = NULL; ibreq->ibr_name[0] = '\0';
ibreq->ibr_bufsize = 0; ibreq->ibr_name += 2;
ibreq->ibr_cookie.n_len = 0; ibreq->ibr_name = strdup (ibreq->ibr_name);
ibreq->ibr_cookie.n_bytes = NULL;
++cptr; /* Remove "[" */
while (cptr != NULL && cptr[0] != '\0')
{
char *key = cptr;
char *val = strchr (cptr, '=');
cptr = strchr (key, ',');
if (cptr != NULL)
*cptr++ = '\0';
if (!val)
{
nis_free_request (ibreq);
return NULL;
}
*val++ = '\0';
if ((search_len + 1) >= size)
{
size += 1;
if (size == 1)
search_val = malloc (size * sizeof (nis_attr));
else
search_val = realloc (search_val, size * sizeof (nis_attr));
if (search_val == NULL)
{
nis_free_request (ibreq);
return NULL;
}
}
search_val[search_len].zattr_ndx = strdup (key);
if ((search_val[search_len].zattr_ndx) == NULL)
{
nis_free_request (ibreq);
return NULL;
}
search_val[search_len].zattr_val.zattr_val_len = strlen (val) + 1;
search_val[search_len].zattr_val.zattr_val_val = strdup (val);
if (search_val[search_len].zattr_val.zattr_val_val == NULL)
{
nis_free_request (ibreq);
return NULL;
}
++search_len;
}
ibreq->ibr_srch.ibr_srch_val = search_val;
ibreq->ibr_srch.ibr_srch_len = search_len;
return ibreq; return ibreq;
} }
@ -167,7 +118,7 @@ nis_list (const_nis_name name, u_long flags,
const void *userdata) const void *userdata)
{ {
nis_result *res = NULL; nis_result *res = NULL;
ib_request *ibreq = calloc (1, sizeof (ib_request)); ib_request *ibreq;
int status; int status;
int count_links = 0; /* We will only follow NIS_MAXLINKS links! */ int count_links = 0; /* We will only follow NIS_MAXLINKS links! */
int done = 0; int done = 0;
@ -180,13 +131,20 @@ nis_list (const_nis_name name, u_long flags,
if (res == NULL) if (res == NULL)
return NULL; return NULL;
if (__create_ib_request (name, ibreq, flags) == NULL) if (name == NULL)
{ {
NIS_RES_STATUS (res) = NIS_BADNAME; NIS_RES_STATUS (res) = NIS_BADNAME;
return res; return res;
} }
if (flags & EXPAND_NAME) if ((ibreq = __create_ib_request (name, flags)) == NULL)
{
NIS_RES_STATUS (res) = NIS_BADNAME;
return res;
}
if ((flags & EXPAND_NAME) &&
ibreq->ibr_name[strlen (ibreq->ibr_name) - 1] != '.')
{ {
names = nis_getnames (ibreq->ibr_name); names = nis_getnames (ibreq->ibr_name);
free (ibreq->ibr_name); free (ibreq->ibr_name);
@ -210,23 +168,23 @@ nis_list (const_nis_name name, u_long flags,
{ {
nis_result *lres; nis_result *lres;
u_long newflags = flags & ~FOLLOW_PATH & ~ALL_RESULTS; u_long newflags = flags & ~FOLLOW_PATH & ~ALL_RESULTS;
char table_path[NIS_MAXPATH + 1]; char table_path[NIS_MAXPATH + 3];
char *ntable, *p; char *ntable, *p;
u_long done = 0, failures = 0; u_long done = 0, failures = 0;
while (names[name_nr] != NULL && !done) while (names[name_nr] != NULL && !done)
{ {
lres = nis_lookup (names[name_nr], newflags); lres = nis_lookup (names[name_nr], newflags | NO_AUTHINFO);
if (lres == NULL || NIS_RES_STATUS (lres) != NIS_SUCCESS) if (lres == NULL || NIS_RES_STATUS (lres) != NIS_SUCCESS)
{ {
NIS_RES_STATUS (res) = NIS_RES_STATUS (lres); NIS_RES_STATUS (res) = NIS_RES_STATUS (lres);
nis_freeresult (lres); nis_freeresult (lres);
++name_nr; ++name_nr;
continue; continue;
} }
/* nis_lookup handles FOLLOW_LINKS, /* nis_lookup handles FOLLOW_LINKS,
so we must have a table object. */ so we must have a table object.*/
if (__type_of (NIS_RES_OBJECT (lres)) != NIS_TABLE_OBJ) if (__type_of (NIS_RES_OBJECT (lres)) != NIS_TABLE_OBJ)
{ {
nis_freeresult (lres); nis_freeresult (lres);
@ -235,8 +193,11 @@ nis_list (const_nis_name name, u_long flags,
} }
/* Save the path, discard everything else. */ /* Save the path, discard everything else. */
snprintf (table_path, NIS_MAXPATH, "%s:%s", names[name_nr], p = __stpncpy (table_path, names[name_nr], NIS_MAXPATH);
NIS_RES_OBJECT (lres)->TA_data.ta_path); *p++ = ':';
p = __stpncpy (p, NIS_RES_OBJECT (lres)->TA_data.ta_path,
NIS_MAXPATH - (p - table_path));
*p = '\0';
nis_freeresult (lres); nis_freeresult (lres);
free (res); free (res);
res = NULL; res = NULL;
@ -397,21 +358,22 @@ nis_add_entry (const_nis_name name, const nis_object *obj2, u_long flags)
nis_object obj; nis_object obj;
nis_result *res; nis_result *res;
nis_error status; nis_error status;
ib_request *ibreq = calloc (1, sizeof (ib_request)); ib_request *ibreq;
char buf1[strlen (name) + 20]; size_t namelen = strlen (name);
char buf4[strlen (name) + 20]; char buf1[namelen + 20];
char buf4[namelen + 20];
res = calloc (1, sizeof (nis_result)); res = calloc (1, sizeof (nis_result));
if (res == NULL) if (res == NULL)
return NULL; return NULL;
if (ibreq == NULL) if (name == NULL)
{ {
NIS_RES_STATUS (res) = NIS_NOMEMORY; NIS_RES_STATUS (res) = NIS_BADNAME;
return res; return res;
} }
if (__create_ib_request (name, ibreq, flags) == NULL) if ((ibreq = __create_ib_request (name, flags)) == NULL)
{ {
NIS_RES_STATUS (res) = NIS_BADNAME; NIS_RES_STATUS (res) = NIS_BADNAME;
return res; return res;
@ -456,13 +418,16 @@ nis_modify_entry (const_nis_name name, const nis_object *obj2, u_long flags)
nis_object obj; nis_object obj;
nis_result *res; nis_result *res;
nis_error status; nis_error status;
ib_request *ibreq = calloc (1, sizeof (ib_request)); ib_request *ibreq;
char buf1[strlen (name) + 20]; size_t namelen = strlen (name);
char buf4[strlen (name) + 20]; char buf1[namelen + 20];
char buf4[namelen + 20];
res = calloc (1, sizeof (nis_result)); res = calloc (1, sizeof (nis_result));
if (res == NULL)
return NULL;
if (__create_ib_request (name, ibreq, flags) == NULL) if (( ibreq =__create_ib_request (name, flags)) == NULL)
{ {
NIS_RES_STATUS (res) = NIS_BADNAME; NIS_RES_STATUS (res) = NIS_BADNAME;
return res; return res;
@ -505,20 +470,20 @@ nis_remove_entry (const_nis_name name, const nis_object *obj,
u_long flags) u_long flags)
{ {
nis_result *res; nis_result *res;
ib_request *ibreq = calloc (1, sizeof (ib_request)); ib_request *ibreq;
nis_error status; nis_error status;
res = calloc (1, sizeof (nis_result)); res = calloc (1, sizeof (nis_result));
if (res == NULL) if (res == NULL)
return NULL; return NULL;
if (ibreq == NULL) if (name == NULL)
{ {
NIS_RES_STATUS (res) = NIS_NOMEMORY; NIS_RES_STATUS (res) = NIS_BADNAME;
return res; return res;
} }
if (__create_ib_request (name, ibreq, flags) == NULL) if ((ibreq =__create_ib_request (name, flags)) == NULL)
{ {
NIS_RES_STATUS (res) = NIS_BADNAME; NIS_RES_STATUS (res) = NIS_BADNAME;
return res; return res;
@ -550,20 +515,20 @@ nis_result *
nis_first_entry (const_nis_name name) nis_first_entry (const_nis_name name)
{ {
nis_result *res; nis_result *res;
ib_request *ibreq = calloc (1, sizeof (ib_request)); ib_request *ibreq;
nis_error status; nis_error status;
res = calloc (1, sizeof (nis_result)); res = calloc (1, sizeof (nis_result));
if (res == NULL) if (res == NULL)
return NULL; return NULL;
if (ibreq == NULL) if (name == NULL)
{ {
NIS_RES_STATUS (res) = NIS_NOMEMORY; NIS_RES_STATUS (res) = NIS_BADNAME;
return res; return res;
} }
if (__create_ib_request (name, ibreq, 0) == NULL) if ((ibreq =__create_ib_request (name, 0)) == NULL)
{ {
NIS_RES_STATUS (res) = NIS_BADNAME; NIS_RES_STATUS (res) = NIS_BADNAME;
return res; return res;
@ -584,20 +549,20 @@ nis_result *
nis_next_entry (const_nis_name name, const netobj *cookie) nis_next_entry (const_nis_name name, const netobj *cookie)
{ {
nis_result *res; nis_result *res;
ib_request *ibreq = calloc (1, sizeof (ib_request)); ib_request *ibreq;
nis_error status; nis_error status;
res = calloc (1, sizeof (nis_result)); res = calloc (1, sizeof (nis_result));
if (res == NULL) if (res == NULL)
return NULL; return NULL;
if (ibreq == NULL) if (name == NULL)
{ {
NIS_RES_STATUS (res) = NIS_NOMEMORY; NIS_RES_STATUS (res) = NIS_BADNAME;
return res; return res;
} }
if (__create_ib_request (name, ibreq, 0) == NULL) if (( ibreq =__create_ib_request (name, 0)) == NULL)
{ {
NIS_RES_STATUS (res) = NIS_BADNAME; NIS_RES_STATUS (res) = NIS_BADNAME;
return res; return res;
@ -605,14 +570,7 @@ nis_next_entry (const_nis_name name, const netobj *cookie)
if (cookie != NULL) if (cookie != NULL)
{ {
ibreq->ibr_cookie.n_bytes = malloc (cookie->n_len); ibreq->ibr_cookie.n_bytes = cookie->n_bytes;
if (ibreq->ibr_cookie.n_bytes == NULL)
{
NIS_RES_STATUS (res) = NIS_NOMEMORY;
nis_free_request (ibreq);
return res;
}
memcpy (ibreq->ibr_cookie.n_bytes, cookie->n_bytes, cookie->n_len);
ibreq->ibr_cookie.n_len = cookie->n_len; ibreq->ibr_cookie.n_len = cookie->n_len;
} }
@ -622,6 +580,13 @@ nis_next_entry (const_nis_name name, const netobj *cookie)
(caddr_t) res, 0, NULL)) != NIS_SUCCESS) (caddr_t) res, 0, NULL)) != NIS_SUCCESS)
NIS_RES_STATUS (res) = status; NIS_RES_STATUS (res) = status;
if (cookie != NULL)
{
/* Don't give cookie free, it is not from us */
ibreq->ibr_cookie.n_bytes = NULL;
ibreq->ibr_cookie.n_len = 0;
}
nis_free_request (ibreq); nis_free_request (ibreq);
return res; return res;