diff options
Diffstat (limited to 'nis/nis_clone.c')
| -rw-r--r-- | nis/nis_clone.c | 551 |
1 files changed, 551 insertions, 0 deletions
diff --git a/nis/nis_clone.c b/nis/nis_clone.c new file mode 100644 index 0000000000..860abb386c --- /dev/null +++ b/nis/nis_clone.c @@ -0,0 +1,551 @@ +/* Copyright (c) 1997 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1997. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with the GNU C Library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#include <string.h> +#include <rpcsvc/nis.h> +#include <rpcsvc/nislib.h> + +directory_obj * +nis_clone_directory (const directory_obj *src, directory_obj *dest) +{ + directory_obj *res; + + if (src == NULL) + return NULL; + + if (dest == NULL) + { + res = calloc (1, sizeof (directory_obj)); + if (res == NULL) + return NULL; + } + else + res = dest; + + if (src->do_name) + res->do_name = strdup (src->do_name); + else + res->do_name = NULL; + res->do_type = src->do_type; + if (src->do_servers.do_servers_len > 0) + { + size_t i; + + res->do_servers.do_servers_len = src->do_servers.do_servers_len; + if ((res->do_servers.do_servers_val = + malloc (src->do_servers.do_servers_len * sizeof (nis_server))) + == NULL) + return NULL; + + for (i = 0; i < src->do_servers.do_servers_len; ++i) + { + if (src->do_servers.do_servers_val[i].name != NULL) + res->do_servers.do_servers_val[i].name = + strdup (src->do_servers.do_servers_val[i].name); + else + res->do_servers.do_servers_val[i].name = NULL; + + res->do_servers.do_servers_val[i].ep.ep_len = + src->do_servers.do_servers_val[i].ep.ep_len; + if (res->do_servers.do_servers_val[i].ep.ep_len > 0) + { + size_t j; + + res->do_servers.do_servers_val[i].ep.ep_val = + malloc (src->do_servers.do_servers_val[i].ep.ep_len * + sizeof (endpoint)); + for (j = 0; j < res->do_servers.do_servers_val[i].ep.ep_len; ++j) + { + if (src->do_servers.do_servers_val[i].ep.ep_val[j].uaddr) + res->do_servers.do_servers_val[i].ep.ep_val[j].uaddr + = strdup (src->do_servers.do_servers_val[i].ep.ep_val[j].uaddr); + else + res->do_servers.do_servers_val[i].ep.ep_val[j].uaddr = NULL; + + if (src->do_servers.do_servers_val[i].ep.ep_val[j].family) + res->do_servers.do_servers_val[i].ep.ep_val[j].family + = strdup (src->do_servers.do_servers_val[i].ep.ep_val[j].family); + else + res->do_servers.do_servers_val[i].ep.ep_val[j].family = NULL; + + if (src->do_servers.do_servers_val[i].ep.ep_val[j].proto) + res->do_servers.do_servers_val[i].ep.ep_val[j].proto + = strdup (src->do_servers.do_servers_val[i].ep.ep_val[j].proto); + else + res->do_servers.do_servers_val[i].ep.ep_val[j].proto = NULL; + } + } + else + { + res->do_servers.do_servers_val[i].ep.ep_val = NULL; + } + res->do_servers.do_servers_val[i].key_type = + src->do_servers.do_servers_val[i].key_type; + res->do_servers.do_servers_val[i].pkey.n_len = + src->do_servers.do_servers_val[i].pkey.n_len; + if (res->do_servers.do_servers_val[i].pkey.n_len > 0) + { + res->do_servers.do_servers_val[i].pkey.n_bytes = + malloc (src->do_servers.do_servers_val[i].pkey.n_len); + if (res->do_servers.do_servers_val[i].pkey.n_bytes == NULL) + return NULL; + memcpy (res->do_servers.do_servers_val[i].pkey.n_bytes, + src->do_servers.do_servers_val[i].pkey.n_bytes, + src->do_servers.do_servers_val[i].pkey.n_len); + } + else + res->do_servers.do_servers_val[i].pkey.n_bytes = NULL; + } + } + else + { + res->do_servers.do_servers_len = 0; + res->do_servers.do_servers_val = NULL; + } + res->do_ttl = src->do_ttl; + res->do_armask.do_armask_len = src->do_armask.do_armask_len; + if (res->do_armask.do_armask_len > 0) + { + if ((res->do_armask.do_armask_val = + malloc (src->do_armask.do_armask_len * sizeof (oar_mask))) == NULL) + return NULL; + memcpy (res->do_armask.do_armask_val, src->do_armask.do_armask_val, + src->do_armask.do_armask_len * sizeof (oar_mask)); + } + else + { + res->do_armask.do_armask_val = NULL; + } + + return res; +} + +group_obj * +nis_clone_group (const group_obj *src, group_obj *dest) +{ + size_t i; + group_obj *res = NULL; + + if (src == NULL) + return NULL; + + if (dest == NULL) + { + res = calloc (1, sizeof (group_obj)); + if (res == NULL) + return NULL; + } + else + res = dest; + + res->gr_flags = src->gr_flags; + + res->gr_members.gr_members_len = src->gr_members.gr_members_len; + if (res->gr_members.gr_members_len > 0) + { + if (res->gr_members.gr_members_val == NULL) + { + res->gr_members.gr_members_val = + malloc (res->gr_members.gr_members_len * sizeof (nis_name)); + if (res->gr_members.gr_members_val == NULL) + return NULL; + } + for (i = 0; i < res->gr_members.gr_members_len; ++i) + if (src->gr_members.gr_members_val[i] != NULL) + res->gr_members.gr_members_val[i] = + strdup (src->gr_members.gr_members_val[i]); + else + res->gr_members.gr_members_val[i] = NULL; + } + + return res; +} + +table_obj * +nis_clone_table (const table_obj *src, table_obj *dest) +{ + size_t i; + table_obj *res = NULL; + + if (src == NULL) + return NULL; + + if (dest == NULL) + { + res = calloc (1, sizeof (table_obj)); + if (res == NULL) + return res; + } + else + res = dest; + + if (src->ta_type != NULL) + { + if ((res->ta_type = strdup (src->ta_type)) == NULL) + return NULL; + } + else + res->ta_type = NULL; + + res->ta_maxcol = src->ta_maxcol; + res->ta_sep = src->ta_sep; + res->ta_cols.ta_cols_len = src->ta_cols.ta_cols_len; + if (res->ta_cols.ta_cols_val == NULL) + { + res->ta_cols.ta_cols_val = + malloc (src->ta_cols.ta_cols_len * sizeof (table_col)); + if (res->ta_cols.ta_cols_val == NULL) + return NULL; + } + for (i = 0; i < res->ta_cols.ta_cols_len; i++) + { + if (src->ta_cols.ta_cols_val[i].tc_name == NULL) + res->ta_cols.ta_cols_val[i].tc_name = NULL; + else + res->ta_cols.ta_cols_val[i].tc_name = + strdup (src->ta_cols.ta_cols_val[i].tc_name); + res->ta_cols.ta_cols_val[i].tc_flags = + src->ta_cols.ta_cols_val[i].tc_flags; + res->ta_cols.ta_cols_val[i].tc_rights = + src->ta_cols.ta_cols_val[i].tc_rights; + } + + if (src->ta_path != NULL) + { + if ((res->ta_path = strdup (src->ta_path)) == NULL) + return NULL; + } + else + res->ta_path = NULL; + + return res; +} + +entry_obj * +nis_clone_entry (const entry_obj *src, entry_obj *dest) +{ + size_t i; + entry_obj *res = NULL; + + if (src == NULL) + return NULL; + + if (dest == NULL) + { + res = calloc (1, sizeof (entry_obj)); + if (res == NULL) + return NULL; + } + else + res = dest; + + if (src->en_type) + res->en_type = strdup (src->en_type); + else + res->en_type = NULL; + + res->en_cols.en_cols_len = src->en_cols.en_cols_len; + if (res->en_cols.en_cols_val == NULL && src->en_cols.en_cols_len > 0) + { + res->en_cols.en_cols_val = + malloc (src->en_cols.en_cols_len * sizeof (entry_col)); + if (res->en_cols.en_cols_val == NULL) + return NULL; + } + for (i = 0; i < res->en_cols.en_cols_len; ++i) + { + res->en_cols.en_cols_val[i].ec_flags = + src->en_cols.en_cols_val[i].ec_flags; + res->en_cols.en_cols_val[i].ec_value.ec_value_len = + src->en_cols.en_cols_val[i].ec_value.ec_value_len; + if (res->en_cols.en_cols_val[i].ec_value.ec_value_val == NULL && + src->en_cols.en_cols_val[i].ec_value.ec_value_len > 0) + res->en_cols.en_cols_val[i].ec_value.ec_value_val = + malloc (src->en_cols.en_cols_val[i].ec_value.ec_value_len); + memcpy (res->en_cols.en_cols_val[i].ec_value.ec_value_val, + src->en_cols.en_cols_val[i].ec_value.ec_value_val, + res->en_cols.en_cols_val[i].ec_value.ec_value_len); + } + + return res; +} + +nis_attr * +nis_clone_nis_attr (const nis_attr *src, nis_attr *dest) +{ + nis_attr *res = NULL; + + if (src == NULL) + return NULL; + + if (dest == NULL) + { + res = calloc (1, sizeof (nis_attr)); + if (res == NULL) + return NULL; + } + else + res = dest; + + if (src->zattr_ndx != NULL) + { + if ((res->zattr_ndx = strdup (src->zattr_ndx)) == NULL) + return NULL; + } + else + res->zattr_ndx = NULL; + + res->zattr_val.zattr_val_len = src->zattr_val.zattr_val_len; + if (res->zattr_val.zattr_val_val == NULL) + { + res->zattr_val.zattr_val_val = + malloc (src->zattr_val.zattr_val_len); + if (res->zattr_val.zattr_val_val == NULL) + return NULL; + } + memcpy (res->zattr_val.zattr_val_val, src->zattr_val.zattr_val_val, + src->zattr_val.zattr_val_len); + + return res; +} + +static nis_attr * +__nis_clone_attrs (const nis_attr *src, nis_attr *dest, u_int len) +{ + unsigned int i; + nis_attr *res; + + if (len == 0) + return dest; + + if (dest == NULL) + { + res = calloc (len, sizeof (nis_attr)); + if (res == NULL) + return NULL; + } + else + res = dest; + + for (i = 0; i < len; i++) + nis_clone_nis_attr(&src[i], &res[i]); + + return res; +} + +link_obj * +nis_clone_link (const link_obj *src, link_obj *dest) +{ + link_obj *res = NULL; + + if (src == NULL) + return NULL; + + if (dest == NULL) + { + res = calloc (1, sizeof (link_obj)); + if (res == NULL) + return NULL; + } + else + res = dest; + + res->li_rtype = src->li_rtype; + + res->li_attrs.li_attrs_len = src->li_attrs.li_attrs_len; + res->li_attrs.li_attrs_val = + __nis_clone_attrs (src->li_attrs.li_attrs_val, + res->li_attrs.li_attrs_val, + src->li_attrs.li_attrs_len); + + if ((res->li_name = strdup (src->li_name)) == NULL) + return NULL; + + return res; +} + +objdata * +nis_clone_objdata (const objdata *src, objdata *dest) +{ + objdata *res = NULL; + + if (src == NULL) + return NULL; + + if (dest == NULL) + { + res = calloc (1, sizeof (objdata)); + if (res == NULL) + return res; + } + else + res = dest; + + res->zo_type = src->zo_type; + + switch (src->zo_type) + { + case BOGUS_OBJ: + break; + case NO_OBJ: + break; + case DIRECTORY_OBJ: + if (nis_clone_directory (&src->objdata_u.di_data, + &res->objdata_u.di_data) == NULL) + return NULL; + break; + case GROUP_OBJ: + if (nis_clone_group (&src->objdata_u.gr_data, + &res->objdata_u.gr_data) == NULL) + return NULL; + break; + case TABLE_OBJ: + if (nis_clone_table (&src->objdata_u.ta_data, + &res->objdata_u.ta_data) == NULL) + return NULL; + break; + case ENTRY_OBJ: + if (nis_clone_entry (&src->objdata_u.en_data, + &res->objdata_u.en_data) == NULL) + return NULL; + break; + case LINK_OBJ: + if (nis_clone_link (&src->objdata_u.li_data, + &res->objdata_u.li_data) == NULL) + return NULL; + break; + case PRIVATE_OBJ: + res->objdata_u.po_data.po_data_len = + src->objdata_u.po_data.po_data_len; + if (src->objdata_u.po_data.po_data_val) + { + res->objdata_u.po_data.po_data_val = + malloc (res->objdata_u.po_data.po_data_len); + if (res->objdata_u.po_data.po_data_val == NULL) + return NULL; + memcpy (res->objdata_u.po_data.po_data_val, + src->objdata_u.po_data.po_data_val, + src->objdata_u.po_data.po_data_len); + if (res->objdata_u.po_data.po_data_val == NULL) + return NULL; + } + else + { + res->objdata_u.po_data.po_data_val = NULL; + res->objdata_u.po_data.po_data_len = 0; + } + break; + default: + return NULL; + } + + return res; +} + +nis_object * +nis_clone_object (const nis_object *src, nis_object *dest) +{ + nis_object *res = NULL; + + if (src == NULL) + return NULL; + + if (dest == NULL) + { + res = calloc (1, sizeof (nis_object)); + if (res == NULL) + return NULL; + } + else + res = dest; + + res->zo_oid = src->zo_oid; + + if ((res->zo_name = strdup (src->zo_name)) == NULL) + return NULL; + if ((res->zo_owner = strdup (src->zo_owner)) == NULL) + return NULL; + if ((res->zo_group = strdup (src->zo_group)) == NULL) + return NULL; + if ((res->zo_domain = strdup (src->zo_domain)) == NULL) + return NULL; + + res->zo_access = src->zo_access; + res->zo_ttl = src->zo_ttl; + + if (nis_clone_objdata (&src->zo_data, &res->zo_data) == NULL) + return NULL; + + return res; +} + +static nis_object * +__nis_clone_objects (const nis_object *src, nis_object *dest, u_int len) +{ + unsigned int i; + nis_object *res; + + if (len == 0) + return dest; + + if (dest == NULL) + { + res = calloc (len, sizeof (nis_object)); + if (res == NULL) + return NULL; + } + else + res = dest; + + for (i = 0; i < len; ++i) + nis_clone_object(&src[i], &res[i]); + + return res; +} + +nis_result * +nis_clone_result (const nis_result *src, nis_result *dest) +{ + nis_result *res = NULL; + + if (src == NULL) + return NULL; + + if (dest == NULL) + { + res = calloc (1, sizeof (nis_result)); + if (res == NULL) + return NULL; + } + else + res = dest; + + res->status = src->status; + res->objects.objects_len = src->objects.objects_len; + res->objects.objects_val = + __nis_clone_objects (src->objects.objects_val, + res->objects.objects_val, + src->objects.objects_len); + res->zticks = src->zticks; + res->dticks = src->dticks; + res->aticks = src->aticks; + res->cticks = src->cticks; + + return res; +} |