nis_result * nis_add_entry (const_nis_name name, const nis_object *obj2, unsigned int flags) { nis_object obj; nis_result *res; nis_error status; ib_request *ibreq; size_t namelen = strlen (name); char buf1[namelen + 20]; char buf4[namelen + 20]; res = calloc (1, sizeof (nis_result)); if (res == NULL) return NULL; if (name == NULL) { NIS_RES_STATUS (res) = NIS_BADNAME; return res; } if ((ibreq = __create_ib_request (name, flags)) == NULL) { NIS_RES_STATUS (res) = NIS_BADNAME; return res; } memcpy (&obj, obj2, sizeof (nis_object)); if (obj.zo_name == NULL || strlen (obj.zo_name) == 0) obj.zo_name = nis_leaf_of_r (name, buf1, sizeof (buf1)); if (obj.zo_owner == NULL || strlen (obj.zo_owner) == 0) obj.zo_owner = nis_local_principal (); if (obj.zo_group == NULL || strlen (obj.zo_group) == 0) obj.zo_group = nis_local_group (); obj.zo_domain = nis_domain_of_r (name, buf4, sizeof (buf4)); ibreq->ibr_obj.ibr_obj_val = nis_clone_object (&obj, NULL); if (ibreq->ibr_obj.ibr_obj_val == NULL) { nis_free_request (ibreq); NIS_RES_STATUS (res) = NIS_NOMEMORY; return res; } ibreq->ibr_obj.ibr_obj_len = 1; if ((status = __do_niscall (ibreq->ibr_name, NIS_IBADD, (xdrproc_t) _xdr_ib_request, (caddr_t) ibreq, (xdrproc_t) _xdr_nis_result, (caddr_t) res, 0, NULL)) != NIS_SUCCESS) NIS_RES_STATUS (res) = status; nis_free_request (ibreq); return res; }
nis_result * nis_checkpoint (const_nis_name dirname) { nis_result *res; res = calloc (1, sizeof (nis_result)); if (res == NULL) return NULL; if (dirname != NULL) { nis_result *res2; u_int i; res2 = nis_lookup (dirname, EXPAND_NAME); if (NIS_RES_STATUS (res2) != NIS_SUCCESS) { free (res); return res2; } /* Check if obj is really a diryectory object */ if (__type_of (NIS_RES_OBJECT (res2)) != NIS_DIRECTORY_OBJ) { nis_freeresult (res2); NIS_RES_STATUS (res) = NIS_INVALIDOBJ; return res; } for (i = 0; i < NIS_RES_OBJECT (res2)->DI_data.do_servers.do_servers_len; ++i) { cp_result cpres; memset (&cpres, '\0', sizeof (cp_result)); if (__do_niscall2 (&NIS_RES_OBJECT(res2)->DI_data.do_servers.do_servers_val[i], 1, NIS_CHECKPOINT, (xdrproc_t) _xdr_nis_name, (caddr_t) &dirname, (xdrproc_t) _xdr_cp_result, (caddr_t) &cpres, 0, NULL) != NIS_SUCCESS) NIS_RES_STATUS (res) = NIS_RPCERROR; else { NIS_RES_STATUS (res) = cpres.cp_status; res->zticks += cpres.cp_zticks; res->dticks += cpres.cp_dticks; } } nis_freeresult (res2); } else NIS_RES_STATUS (res) = NIS_NOSUCHNAME; return res; }
nis_result * nis_next_entry (const_nis_name name, const netobj *cookie) { nis_result *res; ib_request *ibreq; nis_error status; res = calloc (1, sizeof (nis_result)); if (res == NULL) return NULL; if (name == NULL) { NIS_RES_STATUS (res) = NIS_BADNAME; return res; } ibreq = __create_ib_request (name, 0); if (ibreq == NULL) { NIS_RES_STATUS (res) = NIS_BADNAME; return res; } if (cookie != NULL) { ibreq->ibr_cookie.n_bytes = cookie->n_bytes; ibreq->ibr_cookie.n_len = cookie->n_len; } status = __do_niscall (ibreq->ibr_name, NIS_IBNEXT, (xdrproc_t) _xdr_ib_request, (caddr_t) ibreq, (xdrproc_t) _xdr_nis_result, (caddr_t) res, 0, NULL); if (status != NIS_SUCCESS) 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); return res; }
nis_result * nis_add (const_nis_name name, const nis_object *obj2) { nis_object obj; nis_result *res; nis_error status; struct ns_request req; size_t namelen = strlen (name); char buf1 [namelen + 20]; char buf4 [namelen + 20]; res = calloc (1, sizeof (nis_result)); if (res == NULL) return NULL; req.ns_name = (char *)name; memcpy (&obj, obj2, sizeof (nis_object)); if (obj.zo_name == NULL || obj.zo_name[0] == '\0') obj.zo_name = nis_leaf_of_r (name, buf1, sizeof (buf1)); if (obj.zo_owner == NULL || obj.zo_owner[0] == '\0') obj.zo_owner = nis_local_principal (); if (obj.zo_group == NULL || obj.zo_group[0] == '\0') obj.zo_group = nis_local_group (); obj.zo_domain = nis_domain_of_r (name, buf4, sizeof (buf4)); req.ns_object.ns_object_val = nis_clone_object (&obj, NULL); if (req.ns_object.ns_object_val == NULL) { NIS_RES_STATUS (res) = NIS_NOMEMORY; return res; } req.ns_object.ns_object_len = 1; status = __do_niscall (req.ns_object.ns_object_val[0].zo_domain, NIS_ADD, (xdrproc_t) _xdr_ns_request, (caddr_t) &req, (xdrproc_t) _xdr_nis_result, (caddr_t) res, MASTER_ONLY, NULL); if (status != NIS_SUCCESS) NIS_RES_STATUS (res) = status; nis_destroy_object (req.ns_object.ns_object_val); return res; }
static char * get_tablepath (char *name, dir_binding *bptr) { enum clnt_stat result; nis_result res; struct ns_request req; memset (&res, '\0', sizeof (res)); req.ns_name = name; req.ns_object.ns_object_len = 0; req.ns_object.ns_object_val = NULL; result = clnt_call (bptr->clnt, NIS_LOOKUP, (xdrproc_t) _xdr_ns_request, (caddr_t) &req, (xdrproc_t) _xdr_nis_result, (caddr_t) &res, RPCTIMEOUT); const char *cptr; if (result == RPC_SUCCESS && NIS_RES_STATUS (&res) == NIS_SUCCESS && __type_of (NIS_RES_OBJECT (&res)) == NIS_TABLE_OBJ) cptr = NIS_RES_OBJECT (&res)->TA_data.ta_path; else cptr = ""; char *str = strdup (cptr); if (result == RPC_SUCCESS) xdr_free ((xdrproc_t) _xdr_nis_result, (char *) &res); return str; }
nis_result * nis_remove (const_nis_name name, const nis_object *obj) { nis_result *res; nis_error status; struct ns_request req; res = calloc (1, sizeof (nis_result)); if (res == NULL) return NULL; req.ns_name = (char *)name; if (obj != NULL) { req.ns_object.ns_object_len = 1; req.ns_object.ns_object_val = nis_clone_object (obj, NULL); } else { req.ns_object.ns_object_len = 0; req.ns_object.ns_object_val = NULL; } if ((status = __do_niscall (name, NIS_REMOVE, (xdrproc_t) _xdr_ns_request, (caddr_t) &req, (xdrproc_t) _xdr_nis_result, (caddr_t) res, MASTER_ONLY, NULL)) != NIS_SUCCESS) NIS_RES_STATUS (res) = status; nis_destroy_object (req.ns_object.ns_object_val); return res; }
nis_error nis_destroygroup (const_nis_name group) { if (group != NULL && group[0] != '\0') { size_t grouplen = strlen (group); char buf[grouplen + 50]; char leafbuf[grouplen + 3]; char domainbuf[grouplen + 3]; nis_error status; nis_result *res; char *cp, *cp2; cp = stpcpy (buf, nis_leaf_of_r (group, leafbuf, sizeof (leafbuf) - 1)); cp = stpcpy (cp, ".groups_dir"); cp2 = nis_domain_of_r (group, domainbuf, sizeof (domainbuf) - 1); if (cp2 != NULL && cp2[0] != '\0') { *cp++ = '.'; stpcpy (cp, cp2); } res = nis_remove (buf, NULL); status = NIS_RES_STATUS (res); nis_freeresult (res); return status; } else return NIS_FAIL; }
nis_result * nis_remove_entry (const_nis_name name, const nis_object *obj, unsigned int flags) { nis_result *res; ib_request *ibreq; nis_error status; res = calloc (1, sizeof (nis_result)); if (res == NULL) return NULL; if (name == NULL) { NIS_RES_STATUS (res) = NIS_BADNAME; return res; } ibreq = __create_ib_request (name, flags); if (ibreq == NULL) { NIS_RES_STATUS (res) = NIS_BADNAME; return res; } if (obj != NULL) { ibreq->ibr_obj.ibr_obj_val = nis_clone_object (obj, NULL); if (ibreq->ibr_obj.ibr_obj_val == NULL) { nis_free_request (ibreq); NIS_RES_STATUS (res) = NIS_NOMEMORY; return res; } ibreq->ibr_obj.ibr_obj_len = 1; } if ((status = __do_niscall (ibreq->ibr_name, NIS_IBREMOVE, (xdrproc_t) _xdr_ib_request, (caddr_t) ibreq, (xdrproc_t) _xdr_nis_result, (caddr_t) res, 0, NULL)) != NIS_SUCCESS) NIS_RES_STATUS (res) = status; nis_free_request (ibreq); return res; }
void nis_print_result (const nis_result *res) { unsigned int i; printf (_("Status : %s\n"), nis_sperrno (NIS_RES_STATUS (res))); printf (_("Number of objects : %u\n"), res->objects.objects_len); for (i = 0; i < res->objects.objects_len; i++) { printf (_("Object #%d:\n"), i); nis_print_object (&res->objects.objects_val[i]); } }
nis_name nis_local_principal (void) { static char __principal[NIS_MAXNAMELEN + 1]; if (__principal[0] == '\0') { char buf[NIS_MAXNAMELEN + 1]; nis_result *res; uid_t uid = geteuid (); if (uid != 0) { int len = snprintf (buf, NIS_MAXNAMELEN - 1, "[auth_name=%d,auth_type=LOCAL],cred.org_dir.%s", uid, nis_local_directory ()); if (len >= NIS_MAXNAMELEN - 1) nobody: /* XXX The buffer is too small. Can this happen??? */ return strcpy (__principal, "nobody"); if (buf[len - 1] != '.') { buf[len++] = '.'; buf[len] = '\0'; } res = nis_list (buf, USE_DGRAM + NO_AUTHINFO + FOLLOW_LINKS + FOLLOW_PATH, NULL, NULL); if (res == NULL) goto nobody; if (NIS_RES_STATUS (res) == NIS_SUCCESS) { if (res->objects.objects_len > 1) { /* More than one principal with same uid? something wrong with cred table. Should be unique. Warn user and continue. */ printf (_("\ LOCAL entry for UID %d in directory %s not unique\n"), uid, nis_local_directory ()); } strcpy (__principal, ENTRY_VAL (res->objects.objects_val, 0)); nis_freeresult (res); return __principal; }
nis_result * nis_first_entry (const_nis_name name) { nis_result *res; ib_request *ibreq; nis_error status; res = calloc (1, sizeof (nis_result)); if (res == NULL) return NULL; if (name == NULL) { NIS_RES_STATUS (res) = NIS_BADNAME; return res; } ibreq = __create_ib_request (name, 0); if (ibreq == NULL) { NIS_RES_STATUS (res) = NIS_BADNAME; return res; } status = __do_niscall (ibreq->ibr_name, NIS_IBFIRST, (xdrproc_t) _xdr_ib_request, (caddr_t) ibreq, (xdrproc_t) _xdr_nis_result, (caddr_t) res, 0, NULL); if (status != NIS_SUCCESS) NIS_RES_STATUS (res) = status; nis_free_request (ibreq); return res; }
void nis_ping (const_nis_name dirname, unsigned int utime, const nis_object *dirobj) { nis_result *res = NULL; nis_object *obj; ping_args args; unsigned int i; if (dirname == NULL && dirobj == NULL) abort (); if (dirobj == NULL) { res = nis_lookup (dirname, MASTER_ONLY); if (res == NULL || NIS_RES_STATUS (res) != NIS_SUCCESS) { nis_freeresult (res); return; } obj = res->objects.objects_val; } else obj = (nis_object *) dirobj; /* Check if obj is really a diryectory object */ if (__type_of (obj) != NIS_DIRECTORY_OBJ) { nis_freeresult (res); return; } if (dirname == NULL) args.dir = obj->DI_data.do_name; else args.dir = (char *) dirname; args.stamp = utime; /* Send the ping only to replicas */ for (i = 1; i < obj->DI_data.do_servers.do_servers_len; ++i) __do_niscall2 (&obj->DI_data.do_servers.do_servers_val[i], 1, NIS_PING, (xdrproc_t) _xdr_ping_args, (caddr_t) &args, (xdrproc_t) xdr_void, (caddr_t) NULL, 0, NULL); nis_freeresult (res); }
nis_result * nis_lookup (const_nis_name name, const unsigned int flags) { nis_result *res = calloc (1, sizeof (nis_result)); struct ns_request req; nis_name *names; nis_error status; int link_first_try = 0; int count_links = 0; /* We will follow only 16 links in the deep */ int done = 0; int name_nr = 0; nis_name namebuf[2] = {NULL, NULL}; if (res == NULL) return NULL; if ((flags & EXPAND_NAME) && (name[strlen (name) - 1] != '.')) { names = nis_getnames (name); if (names == NULL) { NIS_RES_STATUS (res) = NIS_NAMEUNREACHABLE; return res; } } else { names = namebuf; names[0] = (nis_name)name; } req.ns_name = names[0]; while (!done) { dir_binding bptr; directory_obj *dir = NULL; req.ns_object.ns_object_len = 0; req.ns_object.ns_object_val = NULL; status = __nisfind_server (req.ns_name, &dir); if (status != NIS_SUCCESS) { NIS_RES_STATUS (res) = status; return res; } status = __nisbind_create (&bptr, dir->do_servers.do_servers_val, dir->do_servers.do_servers_len, flags); if (status != NIS_SUCCESS) { NIS_RES_STATUS (res) = status; nis_free_directory (dir); return res; } while (__nisbind_connect (&bptr) != NIS_SUCCESS) { if (__nisbind_next (&bptr) != NIS_SUCCESS) { __nisbind_destroy (&bptr); nis_free_directory (dir); NIS_RES_STATUS (res) = NIS_NAMEUNREACHABLE; return res; } } do { static struct timeval RPCTIMEOUT = {10, 0}; enum clnt_stat result; again: result = clnt_call (bptr.clnt, NIS_LOOKUP, (xdrproc_t) _xdr_ns_request, (caddr_t) &req, (xdrproc_t) _xdr_nis_result, (caddr_t) res, RPCTIMEOUT); if (result != RPC_SUCCESS) status = NIS_RPCERROR; else { status = NIS_SUCCESS; if (NIS_RES_STATUS (res) == NIS_SUCCESS) { if (__type_of(NIS_RES_OBJECT (res)) == NIS_LINK_OBJ && flags & FOLLOW_LINKS) /* We are following links */ { if (count_links) free (req.ns_name); /* if we hit the link limit, bail */ if (count_links > NIS_MAXLINKS) { NIS_RES_STATUS (res) = NIS_LINKNAMEERROR; break; } ++count_links; req.ns_name = strdup (NIS_RES_OBJECT (res)->LI_data.li_name); if (req.ns_name == NULL) return NULL; nis_freeresult (res); res = calloc (1, sizeof (nis_result)); if (res == NULL) { __nisbind_destroy (&bptr); return NULL; } link_first_try = 1; /* Try at first the old binding */ goto again; } } else if ((NIS_RES_STATUS (res) == NIS_SYSTEMERROR) || (NIS_RES_STATUS (res) == NIS_NOSUCHNAME) || (NIS_RES_STATUS (res) == NIS_NOT_ME)) { if (link_first_try) { __nisbind_destroy (&bptr); nis_free_directory (dir); if (__nisfind_server (req.ns_name, &dir) != NIS_SUCCESS) return res; if (__nisbind_create (&bptr, dir->do_servers.do_servers_val, dir->do_servers.do_servers_len, flags) != NIS_SUCCESS) { nis_free_directory (dir); return res; } } else if (__nisbind_next (&bptr) != NIS_SUCCESS) break; /* No more servers to search */ while (__nisbind_connect (&bptr) != NIS_SUCCESS) { if (__nisbind_next (&bptr) != NIS_SUCCESS) { __nisbind_destroy (&bptr); nis_free_directory (dir); return res; } } goto again; } break; } link_first_try = 0; /* Set it back */ } while ((flags & HARD_LOOKUP) && status == NIS_RPCERROR); __nisbind_destroy (&bptr); nis_free_directory (dir); if (status != NIS_SUCCESS) { NIS_RES_STATUS (res) = status; return res; } switch (NIS_RES_STATUS (res)) { case NIS_PARTIAL: case NIS_SUCCESS: case NIS_S_SUCCESS: case NIS_LINKNAMEERROR: /* We follow to max links */ case NIS_UNAVAIL: /* NIS+ is not installed, or all servers are down */ ++done; break; default: /* Try the next domainname if we don't follow a link */ if (count_links) { free (req.ns_name); NIS_RES_STATUS (res) = NIS_LINKNAMEERROR; ++done; break; } ++name_nr; if (names[name_nr] == NULL) { ++done; break; } req.ns_name = names[name_nr]; break; } } if (names != namebuf) nis_freenames (names); return res; }
static enum nss_status internal_nisplus_getgrent_r (struct group *gr, char *buffer, size_t buflen, int *errnop) { int parse_res = -1; enum nss_status retval = NSS_STATUS_SUCCESS; /* Get the next entry until we found a correct one. */ do { nis_error status; nis_result result; memset (&result, '\0', sizeof (result)); if (cursor.n_bytes == NULL) { if (ibreq == NULL) { retval = internal_setgrent (errnop); if (retval != NSS_STATUS_SUCCESS) return retval; } status = __do_niscall3 (&bptr, NIS_IBFIRST, (xdrproc_t) _xdr_ib_request, (caddr_t) ibreq, (xdrproc_t) _xdr_nis_result, (caddr_t) &result, 0, NULL); } else { ibreq->ibr_cookie.n_bytes = cursor.n_bytes; ibreq->ibr_cookie.n_len = cursor.n_len; status = __do_niscall3 (&bptr, NIS_IBNEXT, (xdrproc_t) _xdr_ib_request, (caddr_t) ibreq, (xdrproc_t) _xdr_nis_result, (caddr_t) &result, 0, NULL); ibreq->ibr_cookie.n_bytes = NULL; ibreq->ibr_cookie.n_len = 0; } if (status != NIS_SUCCESS) return niserr2nss (status); if (NIS_RES_STATUS (&result) == NIS_NOTFOUND) { /* No more entries on this server. This means we have to go to the next server on the path. */ status = __follow_path (&tablepath, &tableptr, ibreq, &bptr); if (status != NIS_SUCCESS) return niserr2nss (status); directory_obj *newdir = NULL; dir_binding newbptr; status = __prepare_niscall (ibreq->ibr_name, &newdir, &newbptr, 0); if (status != NIS_SUCCESS) return niserr2nss (status); nis_free_directory (dir); dir = newdir; __nisbind_destroy (&bptr); bptr = newbptr; xdr_free ((xdrproc_t) xdr_netobj, (char *) &result.cookie); result.cookie.n_bytes = NULL; result.cookie.n_len = 0; parse_res = 0; goto next; } else if (NIS_RES_STATUS (&result) != NIS_SUCCESS) return niserr2nss (NIS_RES_STATUS (&result)); parse_res = _nss_nisplus_parse_grent (&result, gr, buffer, buflen, errnop); if (__glibc_unlikely (parse_res == -1)) { *errnop = ERANGE; retval = NSS_STATUS_TRYAGAIN; goto freeres; } next: /* Free the old cursor. */ xdr_free ((xdrproc_t) xdr_netobj, (char *) &cursor); /* Remember the new one. */ cursor.n_bytes = result.cookie.n_bytes; cursor.n_len = result.cookie.n_len; /* Free the result structure. NB: we do not remove the cookie. */ result.cookie.n_bytes = NULL; result.cookie.n_len = 0; freeres: xdr_free ((xdrproc_t) _xdr_nis_result, (char *) &result); memset (&result, '\0', sizeof (result)); } while (!parse_res); return retval; }
nis_error nis_removemember (const_nis_name member, const_nis_name group) { if (group != NULL && group[0] != '\0') { size_t grouplen = strlen (group); char buf[grouplen + 14 + NIS_MAXNAMELEN]; char leafbuf[grouplen + 2]; char domainbuf[grouplen + 2]; nis_name *newmem; nis_result *res, *res2; nis_error status; char *cp, *cp2; unsigned long int i, j, k; cp = stpcpy (buf, nis_leaf_of_r (group, leafbuf, sizeof (leafbuf) - 1)); cp = stpcpy (cp, ".groups_dir"); cp2 = nis_domain_of_r (group, domainbuf, sizeof (domainbuf) - 1); if (cp2 != NULL && cp2[0] != '\0') { cp = stpcpy (cp, "."); stpcpy (cp, cp2); } res = nis_lookup (buf, FOLLOW_LINKS|EXPAND_NAME); if (res == NULL || NIS_RES_STATUS (res) != NIS_SUCCESS) { if (res) { status = NIS_RES_STATUS (res); nis_freeresult (res); } else return NIS_NOMEMORY; return status; } if ((res->objects.objects_len != 1) || (__type_of (NIS_RES_OBJECT (res)) != NIS_GROUP_OBJ)) { nis_freeresult (res); return NIS_INVALIDOBJ; } newmem = calloc (NIS_RES_OBJECT(res)->GR_data.gr_members.gr_members_len, sizeof (char *)); if (newmem == NULL) return NIS_NOMEMORY; k = NIS_RES_OBJECT (res)[0].GR_data.gr_members.gr_members_len; j = 0; for (i = 0; i < NIS_RES_OBJECT(res)->GR_data.gr_members.gr_members_len; ++i) { if (strcmp (NIS_RES_OBJECT(res)->GR_data.gr_members.gr_members_val[i], member) != 0) { newmem[j] = NIS_RES_OBJECT(res)->GR_data.gr_members.gr_members_val[i]; ++j; } else { free (NIS_RES_OBJECT(res)->GR_data.gr_members.gr_members_val[i]); --k; } } free (NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_val); newmem = realloc (newmem, k * sizeof (char*)); if (newmem == NULL) return NIS_NOMEMORY; NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_val = newmem; NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_len = k; cp = stpcpy (buf, NIS_RES_OBJECT (res)->zo_name); *cp++ = '.'; strncpy (cp, NIS_RES_OBJECT (res)->zo_domain, NIS_MAXNAMELEN); res2 = nis_modify (buf, NIS_RES_OBJECT (res)); status = NIS_RES_STATUS (res2); nis_freeresult (res); nis_freeresult (res2); return status; } else return NIS_FAIL; }
nis_result * nis_list (const_nis_name name, unsigned int flags, int (*callback) (const_nis_name name, const nis_object *object, const void *userdata), const void *userdata) { nis_result *res = malloc (sizeof (nis_result)); ib_request *ibreq; int status; enum clnt_stat clnt_status; int count_links = 0; /* We will only follow NIS_MAXLINKS links! */ int done = 0; nis_name *names; nis_name namebuf[2] = {NULL, NULL}; int name_nr = 0; nis_cb *cb = NULL; char *tableptr; char *tablepath = NULL; int first_try = 0; /* Do we try the old binding at first ? */ nis_result *allres = NULL; if (res == NULL) return NULL; if (name == NULL) { status = NIS_BADNAME; err_out: nis_freeresult (allres); memset (res, '\0', sizeof (nis_result)); NIS_RES_STATUS (res) = status; return res; } ibreq = __create_ib_request (name, flags); if (ibreq == NULL) { status = NIS_BADNAME; goto err_out; } if ((flags & EXPAND_NAME) && ibreq->ibr_name[strlen (ibreq->ibr_name) - 1] != '.') { names = nis_getnames (ibreq->ibr_name); free (ibreq->ibr_name); ibreq->ibr_name = NULL; if (names == NULL) { nis_free_request (ibreq); status = NIS_BADNAME; goto err_out; } ibreq->ibr_name = strdup (names[name_nr]); if (ibreq->ibr_name == NULL) { nis_freenames (names); nis_free_request (ibreq); status = NIS_NOMEMORY; goto err_out; } } else { names = namebuf; names[name_nr] = ibreq->ibr_name; } cb = NULL; while (!done) { dir_binding bptr; directory_obj *dir = NULL; memset (res, '\0', sizeof (nis_result)); status = __nisfind_server (ibreq->ibr_name, ibreq->ibr_srch.ibr_srch_val != NULL, &dir, &bptr, flags & ~MASTER_ONLY); if (status != NIS_SUCCESS) { NIS_RES_STATUS (res) = status; goto fail3; } while (__nisbind_connect (&bptr) != NIS_SUCCESS) if (__nisbind_next (&bptr) != NIS_SUCCESS) { NIS_RES_STATUS (res) = NIS_NAMEUNREACHABLE; goto fail; } if (callback != NULL) { assert (cb == NULL); cb = __nis_create_callback (callback, userdata, flags); ibreq->ibr_cbhost.ibr_cbhost_len = 1; ibreq->ibr_cbhost.ibr_cbhost_val = cb->serv; } again: clnt_status = clnt_call (bptr.clnt, NIS_IBLIST, (xdrproc_t) _xdr_ib_request, (caddr_t) ibreq, (xdrproc_t) _xdr_nis_result, (caddr_t) res, RPCTIMEOUT); if (clnt_status != RPC_SUCCESS) NIS_RES_STATUS (res) = NIS_RPCERROR; else switch (NIS_RES_STATUS (res)) { /* start switch */ case NIS_PARTIAL: case NIS_SUCCESS: case NIS_S_SUCCESS: if (__type_of (NIS_RES_OBJECT (res)) == NIS_LINK_OBJ && (flags & FOLLOW_LINKS)) /* We are following links. */ { free (ibreq->ibr_name); ibreq->ibr_name = NULL; /* If we hit the link limit, bail. */ if (count_links > NIS_MAXLINKS) { NIS_RES_STATUS (res) = NIS_LINKNAMEERROR; ++done; break; } ++count_links; ibreq->ibr_name = strdup (NIS_RES_OBJECT (res)->LI_data.li_name); if (ibreq->ibr_name == NULL) { NIS_RES_STATUS (res) = NIS_NOMEMORY; fail: __nisbind_destroy (&bptr); nis_free_directory (dir); fail3: free (tablepath); if (cb) { __nis_destroy_callback (cb); ibreq->ibr_cbhost.ibr_cbhost_len = 0; ibreq->ibr_cbhost.ibr_cbhost_val = NULL; } if (names != namebuf) nis_freenames (names); nis_free_request (ibreq); nis_freeresult (allres); return res; } if (NIS_RES_OBJECT (res)->LI_data.li_attrs.li_attrs_len) if (ibreq->ibr_srch.ibr_srch_len == 0) { ibreq->ibr_srch.ibr_srch_len = NIS_RES_OBJECT (res)->LI_data.li_attrs.li_attrs_len; ibreq->ibr_srch.ibr_srch_val = NIS_RES_OBJECT (res)->LI_data.li_attrs.li_attrs_val; } /* The following is a non-obvious optimization. A nis_freeresult call would call xdr_free as the following code. But it also would unnecessarily free the result structure. We avoid this here along with the necessary tests. */ xdr_free ((xdrproc_t) _xdr_nis_result, (char *)res); memset (res, '\0', sizeof (*res)); first_try = 1; /* Try at first the old binding */ goto again; } else if ((flags & FOLLOW_PATH) && NIS_RES_STATUS (res) == NIS_PARTIAL) { enum nis_error err = __follow_path (&tablepath, &tableptr, ibreq, &bptr); if (err != NIS_SUCCESS) { if (err == NIS_NOMEMORY) NIS_RES_STATUS (res) = err; ++done; } else { /* The following is a non-obvious optimization. A nis_freeresult call would call xdr_free as the following code. But it also would unnecessarily free the result structure. We avoid this here along with the necessary tests. */ xdr_free ((xdrproc_t) _xdr_nis_result, (char *) res); memset (res, '\0', sizeof (*res)); first_try = 1; goto again; } } else if ((flags & (FOLLOW_PATH | ALL_RESULTS)) == (FOLLOW_PATH | ALL_RESULTS)) { if (allres == NULL) { allres = res; res = malloc (sizeof (nis_result)); if (res == NULL) { res = allres; allres = NULL; NIS_RES_STATUS (res) = NIS_NOMEMORY; goto fail; } NIS_RES_STATUS (res) = NIS_RES_STATUS (allres); } else { nis_object *objects_val = realloc (NIS_RES_OBJECT (allres), (NIS_RES_NUMOBJ (allres) + NIS_RES_NUMOBJ (res)) * sizeof (nis_object)); if (objects_val == NULL) { NIS_RES_STATUS (res) = NIS_NOMEMORY; goto fail; } NIS_RES_OBJECT (allres) = objects_val; memcpy (NIS_RES_OBJECT (allres) + NIS_RES_NUMOBJ (allres), NIS_RES_OBJECT (res), NIS_RES_NUMOBJ (res) * sizeof (nis_object)); NIS_RES_NUMOBJ (allres) += NIS_RES_NUMOBJ (res); NIS_RES_NUMOBJ (res) = 0; free (NIS_RES_OBJECT (res)); NIS_RES_OBJECT (res) = NULL; NIS_RES_STATUS (allres) = NIS_RES_STATUS (res); xdr_free ((xdrproc_t) _xdr_nis_result, (char *) res); } enum nis_error err = __follow_path (&tablepath, &tableptr, ibreq, &bptr); if (err != NIS_SUCCESS) { /* Prepare for the nis_freeresult call. */ memset (res, '\0', sizeof (*res)); if (err == NIS_NOMEMORY) NIS_RES_STATUS (allres) = err; ++done; } } else ++done; break; case NIS_CBRESULTS: if (cb != NULL) { __nis_do_callback (&bptr, &res->cookie, cb); NIS_RES_STATUS (res) = cb->result; if (!(flags & ALL_RESULTS)) ++done; else { enum nis_error err = __follow_path (&tablepath, &tableptr, ibreq, &bptr); if (err != NIS_SUCCESS) { if (err == NIS_NOMEMORY) NIS_RES_STATUS (res) = err; ++done; } } } break; case NIS_SYSTEMERROR: case NIS_NOSUCHNAME: case NIS_NOT_ME: /* If we had first tried the old binding, do nothing, but get a new binding */ if (!first_try) { if (__nisbind_next (&bptr) != NIS_SUCCESS) { ++done; break; /* No more servers to search */ } while (__nisbind_connect (&bptr) != NIS_SUCCESS) { if (__nisbind_next (&bptr) != NIS_SUCCESS) { ++done; break; /* No more servers to search */ } } goto again; } break; default: if (!first_try) { /* Try the next domainname if we don't follow a link. */ free (ibreq->ibr_name); ibreq->ibr_name = NULL; if (count_links) { NIS_RES_STATUS (res) = NIS_LINKNAMEERROR; ++done; break; } ++name_nr; if (names[name_nr] == NULL) { ++done; break; } ibreq->ibr_name = strdup (names[name_nr]); if (ibreq->ibr_name == NULL) { NIS_RES_STATUS (res) = NIS_NOMEMORY; goto fail; } first_try = 1; /* Try old binding at first */ goto again; } break; } first_try = 0; if (cb) { __nis_destroy_callback (cb); ibreq->ibr_cbhost.ibr_cbhost_len = 0; ibreq->ibr_cbhost.ibr_cbhost_val = NULL; cb = NULL; } __nisbind_destroy (&bptr); nis_free_directory (dir); } free (tablepath); if (names != namebuf) nis_freenames (names); nis_free_request (ibreq); if (allres) { nis_freeresult (res); return allres; } return res; }
/* internal_nis_ismember () return codes: -1 principal is in -group 0 principal isn't in any group 1 pirncipal is in group */ static int internal_ismember (const_nis_name principal, const_nis_name group) { size_t grouplen = strlen (group); char buf[grouplen + 50]; char leafbuf[grouplen + 2]; char domainbuf[grouplen + 2]; nis_result *res; char *cp, *cp2; u_int i; cp = stpcpy (buf, nis_leaf_of_r (group, leafbuf, sizeof (leafbuf) - 1)); cp = stpcpy (cp, ".groups_dir"); cp2 = nis_domain_of_r (group, domainbuf, sizeof (domainbuf) - 1); if (cp2 != NULL && cp2[0] != '\0') { *cp++ = '.'; strcpy (cp, cp2); } res = nis_lookup (buf, EXPAND_NAME|FOLLOW_LINKS); if (res == NULL || NIS_RES_STATUS (res) != NIS_SUCCESS) { nis_freeresult (res); return 0; } if ((NIS_RES_NUMOBJ (res) != 1) || (__type_of (NIS_RES_OBJECT (res)) != NIS_GROUP_OBJ)) { nis_freeresult (res); return 0; } /* We search twice in the list, at first, if we have the name with a "-", then if without. "-member" has priority */ for (i = 0; i < NIS_RES_OBJECT(res)->GR_data.gr_members.gr_members_len; ++i) { cp = NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_val[i]; if (cp[0] == '-') { if (strcmp (&cp[1], principal) == 0) { nis_freeresult (res); return -1; } if (cp[1] == '@') switch (internal_ismember (principal, &cp[2])) { case -1: nis_freeresult (res); return -1; case 1: nis_freeresult (res); return 1; default: break; } else if (cp[1] == '*') { char buf1[strlen (principal) + 2]; char buf2[strlen (cp) + 2]; if (strcmp (nis_domain_of_r (principal, buf1, sizeof buf1), nis_domain_of_r (cp, buf2, sizeof buf2)) == 0) { nis_freeresult (res); return -1; } } } } for (i = 0; i < NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_len; ++i) { cp = NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_val[i]; if (cp[0] != '-') { if (strcmp (cp, principal) == 0) { nis_freeresult (res); return 1; } if (cp[0] == '@') switch (internal_ismember (principal, &cp[1])) { case -1: nis_freeresult (res); return -1; case 1: nis_freeresult (res); return 1; default: break; } else if (cp[0] == '*') { char buf1[strlen (principal) + 2]; char buf2[strlen (cp) + 2]; if (strcmp (nis_domain_of_r (principal, buf1, sizeof buf1), nis_domain_of_r (cp, buf2, sizeof buf2)) == 0) { nis_freeresult (res); return 1; } } } } nis_freeresult (res); return 0; }
void nis_print_group_entry (const_nis_name group) { if (group != NULL && group[0] != '\0') { size_t grouplen = strlen (group); char buf[grouplen + 50]; char leafbuf[grouplen + 3]; char domainbuf[grouplen + 3]; nis_result *res; char *cp, *cp2; u_int i; cp = stpcpy (buf, nis_leaf_of_r (group, leafbuf, sizeof (leafbuf) - 1)); cp = stpcpy (cp, ".groups_dir"); cp2 = nis_domain_of_r (group, domainbuf, sizeof (domainbuf) - 1); if (cp2 != NULL && cp2[0] != '\0') { *cp++ = '.'; stpcpy (cp, cp2); } res = nis_lookup (buf, FOLLOW_LINKS | EXPAND_NAME); if (res == NULL) return; if (NIS_RES_STATUS (res) != NIS_SUCCESS || NIS_RES_NUMOBJ (res) != 1 || __type_of (NIS_RES_OBJECT (res)) != NIS_GROUP_OBJ) { nis_freeresult (res); return; } char *mem_exp[NIS_RES_NUMOBJ (res)]; char *mem_imp[NIS_RES_NUMOBJ (res)]; char *mem_rec[NIS_RES_NUMOBJ (res)]; char *nomem_exp[NIS_RES_NUMOBJ (res)]; char *nomem_imp[NIS_RES_NUMOBJ (res)]; char *nomem_rec[NIS_RES_NUMOBJ (res)]; unsigned long mem_exp_cnt = 0, mem_imp_cnt = 0, mem_rec_cnt = 0; unsigned long nomem_exp_cnt = 0, nomem_imp_cnt = 0, nomem_rec_cnt = 0; for (i = 0; i < NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_len; ++i) { char *grmem = NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_val[i]; int neg = grmem[0] == '-'; switch (grmem[neg]) { case '*': if (neg) { nomem_imp[nomem_imp_cnt] = grmem; ++nomem_imp_cnt; } else { mem_imp[mem_imp_cnt] = grmem; ++mem_imp_cnt; } break; case '@': if (neg) { nomem_rec[nomem_rec_cnt] = grmem; ++nomem_rec_cnt; } else { mem_rec[mem_rec_cnt] = grmem; ++mem_rec_cnt; } break; default: if (neg) { nomem_exp[nomem_exp_cnt] = grmem; ++nomem_exp_cnt; } else { mem_exp[mem_exp_cnt] = grmem; ++mem_exp_cnt; } break; } } { char buf[strlen (NIS_RES_OBJECT (res)->zo_domain) + 10]; printf (_("Group entry for \"%s.%s\" group:\n"), NIS_RES_OBJECT (res)->zo_name, nis_domain_of_r (NIS_RES_OBJECT (res)->zo_domain, buf, strlen (NIS_RES_OBJECT (res)->zo_domain) + 10)); } if (mem_exp_cnt) { fputs (_(" Explicit members:\n"), stdout); for (i = 0; i < mem_exp_cnt; ++i) printf ("\t%s\n", mem_exp[i]); } else fputs (_(" No explicit members\n"), stdout); if (mem_imp_cnt) { fputs (_(" Implicit members:\n"), stdout); for (i = 0; i < mem_imp_cnt; ++i) printf ("\t%s\n", &mem_imp[i][2]); } else fputs (_(" No implicit members\n"), stdout); if (mem_rec_cnt) { fputs (_(" Recursive members:\n"), stdout); for (i = 0; i < mem_rec_cnt; ++i) printf ("\t%s\n", &mem_rec[i][1]); } else fputs (_(" No recursive members\n"), stdout); if (nomem_exp_cnt) { fputs (_(" Explicit nonmembers:\n"), stdout); for (i = 0; i < nomem_exp_cnt; ++i) printf ("\t%s\n", &nomem_exp[i][1]); } else fputs (_(" No explicit nonmembers\n"), stdout); if (nomem_imp_cnt) { fputs (_(" Implicit nonmembers:\n"), stdout); for (i = 0; i < nomem_imp_cnt; ++i) printf ("\t%s\n", &nomem_imp[i][3]); } else fputs (_(" No implicit nonmembers\n"), stdout); if (nomem_rec_cnt) { fputs (_(" Recursive nonmembers:\n"), stdout); for (i = 0; i < nomem_rec_cnt; ++i) printf ("\t%s=n", &nomem_rec[i][2]); } else fputs (_(" No recursive nonmembers\n"), stdout); nis_freeresult (res); } }
nis_error nis_addmember (const_nis_name member, const_nis_name group) { if (group != NULL && group[0] != '\0') { size_t grouplen = strlen (group); char buf[grouplen + 14 + NIS_MAXNAMELEN]; char domainbuf[grouplen + 2]; nis_result *res, *res2; nis_error status; char *cp, *cp2; cp = rawmemchr (nis_leaf_of_r (group, buf, sizeof (buf) - 1), '\0'); cp = stpcpy (cp, ".groups_dir"); cp2 = nis_domain_of_r (group, domainbuf, sizeof (domainbuf) - 1); if (cp2 != NULL && cp2[0] != '\0') { *cp++ = '.'; stpcpy (cp, cp2); } res = nis_lookup (buf, FOLLOW_LINKS | EXPAND_NAME); if (NIS_RES_STATUS (res) != NIS_SUCCESS) { status = NIS_RES_STATUS (res); nis_freeresult (res); return status; } if (NIS_RES_NUMOBJ (res) != 1 || __type_of (NIS_RES_OBJECT (res)) != NIS_GROUP_OBJ) { nis_freeresult (res); return NIS_INVALIDOBJ; } u_int gr_members_len = NIS_RES_OBJECT(res)->GR_data.gr_members.gr_members_len; nis_name *new_gr_members_val = realloc (NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_val, (gr_members_len + 1) * sizeof (nis_name)); if (new_gr_members_val == NULL) goto nomem_out; NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_val = new_gr_members_val; new_gr_members_val[gr_members_len] = strdup (member); if (new_gr_members_val[gr_members_len] == NULL) { nomem_out: nis_freeresult (res); return NIS_NOMEMORY; } ++NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_len; /* Check the buffer bounds are not exceeded. */ assert (strlen (NIS_RES_OBJECT(res)->zo_name) + 1 < grouplen + 14); cp = stpcpy (buf, NIS_RES_OBJECT(res)->zo_name); *cp++ = '.'; strncpy (cp, NIS_RES_OBJECT (res)->zo_domain, NIS_MAXNAMELEN); res2 = nis_modify (buf, NIS_RES_OBJECT (res)); status = NIS_RES_STATUS (res2); nis_freeresult (res); nis_freeresult (res2); return status; } else return NIS_FAIL; }
nis_error nis_creategroup (const_nis_name group, unsigned int flags) { if (group != NULL && group[0] != '\0') { size_t grouplen = strlen (group); char buf[grouplen + 50]; char leafbuf[grouplen + 2]; char domainbuf[grouplen + 2]; nis_error status; nis_result *res; char *cp, *cp2; nis_object *obj; cp = stpcpy (buf, nis_leaf_of_r (group, leafbuf, sizeof (leafbuf) - 1)); cp = stpcpy (cp, ".groups_dir"); cp2 = nis_domain_of_r (group, domainbuf, sizeof (domainbuf) - 1); if (cp2 != NULL && cp2[0] != '\0') { *cp++ = '.'; stpcpy (cp, cp2); } else return NIS_BADNAME; obj = calloc (1, sizeof (nis_object)); if (__builtin_expect (obj == NULL, 0)) return NIS_NOMEMORY; obj->zo_oid.ctime = obj->zo_oid.mtime = time (NULL); obj->zo_name = strdup (leafbuf); obj->zo_owner = __nis_default_owner (NULL); obj->zo_group = __nis_default_group (NULL); obj->zo_domain = strdup (domainbuf); if (obj->zo_name == NULL || obj->zo_owner == NULL || obj->zo_group == NULL || obj->zo_domain == NULL) { free (obj->zo_group); free (obj->zo_owner); free (obj->zo_name); free (obj); return NIS_NOMEMORY; } obj->zo_access = __nis_default_access (NULL, 0); obj->zo_ttl = 60 * 60; obj->zo_data.zo_type = NIS_GROUP_OBJ; obj->zo_data.objdata_u.gr_data.gr_flags = flags; obj->zo_data.objdata_u.gr_data.gr_members.gr_members_len = 0; obj->zo_data.objdata_u.gr_data.gr_members.gr_members_val = NULL; res = nis_add (buf, obj); nis_free_object (obj); if (res == NULL) return NIS_NOMEMORY; status = NIS_RES_STATUS (res); nis_freeresult (res); return status; } return NIS_FAIL; }
nis_error nis_addmember (const_nis_name member, const_nis_name group) { if (group != NULL && group[0] != '\0') { size_t grouplen = strlen (group); char buf[grouplen + 14 + NIS_MAXNAMELEN]; char leafbuf[grouplen + 2]; char domainbuf[grouplen + 2]; nis_result *res, *res2; nis_error status; char *cp, *cp2; cp = stpcpy (buf, nis_leaf_of_r (group, leafbuf, sizeof (leafbuf) - 1)); cp = stpcpy (cp, ".groups_dir"); cp2 = nis_domain_of_r (group, domainbuf, sizeof (domainbuf) - 1); if (cp2 != NULL && cp2[0] != '\0') { *cp++ = '.'; stpcpy (cp, cp2); } res = nis_lookup (buf, FOLLOW_LINKS|EXPAND_NAME); if (NIS_RES_STATUS (res) != NIS_SUCCESS) { status = NIS_RES_STATUS (res); nis_freeresult (res); return status; } if ((NIS_RES_NUMOBJ (res) != 1) || (__type_of (NIS_RES_OBJECT (res)) != NIS_GROUP_OBJ)) { nis_freeresult (res); return NIS_INVALIDOBJ; } NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_val = realloc (NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_val, (NIS_RES_OBJECT(res)->GR_data.gr_members.gr_members_len + 1) * sizeof (char *)); if (NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_val == NULL) goto nomem_out; NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_val[NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_len] = strdup (member); if (NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_val[NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_len] == NULL) { free (NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_val); nomem_out: nis_freeresult (res); return NIS_NOMEMORY; } ++NIS_RES_OBJECT (res)->GR_data.gr_members.gr_members_len; cp = stpcpy (buf, NIS_RES_OBJECT(res)->zo_name); *cp++ = '.'; strncpy (cp, NIS_RES_OBJECT (res)->zo_domain, NIS_MAXNAMELEN); res2 = nis_modify (buf, NIS_RES_OBJECT (res)); status = NIS_RES_STATUS (res2); nis_freeresult (res); nis_freeresult (res2); return status; } else return NIS_FAIL; }