nis/nis_clone.c

   1 /* Copyright (c) 1997 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1997.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, USA.  */
  19
  20 #include <string.h>
  21 #include <rpcsvc/nis.h>
  22 #include <rpcsvc/nislib.h>
  23
  24 directory_obj *
  25 nis_clone_directory (const directory_obj *src, directory_obj *dest)
  26 {
  27   directory_obj *res;
  28
  29   if (src == NULL)
  30     return NULL;
  31
  32   if (dest == NULL)
  33     {
  34       res = calloc (1, sizeof (directory_obj));
  35       if (res == NULL)
  36         return NULL;
  37     }
  38   else
  39     res = dest;
  40
  41   if (src->do_name)
  42     res->do_name = strdup (src->do_name);
  43   else
  44     res->do_name = NULL;
  45   res->do_type = src->do_type;
  46   if (src->do_servers.do_servers_len > 0)
  47     {
  48       size_t i;
  49
  50       res->do_servers.do_servers_len = src->do_servers.do_servers_len;
  51       if ((res->do_servers.do_servers_val =
  52            malloc (src->do_servers.do_servers_len * sizeof (nis_server)))
  53           == NULL)
  54         return NULL;
  55
  56       for (i = 0; i < src->do_servers.do_servers_len; ++i)
  57         {
  58           if (src->do_servers.do_servers_val[i].name != NULL)
  59             res->do_servers.do_servers_val[i].name =
  60               strdup (src->do_servers.do_servers_val[i].name);
  61           else
  62             res->do_servers.do_servers_val[i].name = NULL;
  63
  64           res->do_servers.do_servers_val[i].ep.ep_len =
  65             src->do_servers.do_servers_val[i].ep.ep_len;
  66           if (res->do_servers.do_servers_val[i].ep.ep_len > 0)
  67             {
  68               size_t j;
  69
  70               res->do_servers.do_servers_val[i].ep.ep_val =
  71                 malloc (src->do_servers.do_servers_val[i].ep.ep_len *
  72                         sizeof (endpoint));
  73               for (j = 0; j < res->do_servers.do_servers_val[i].ep.ep_len; ++j)
  74                 {
  75                   if (src->do_servers.do_servers_val[i].ep.ep_val[j].uaddr)
  76                     res->do_servers.do_servers_val[i].ep.ep_val[j].uaddr
  77                       = strdup (src->do_servers.do_servers_val[i].ep.ep_val[j].uaddr);
  78                   else
  79                     res->do_servers.do_servers_val[i].ep.ep_val[j].uaddr = NULL;
  80
  81                   if (src->do_servers.do_servers_val[i].ep.ep_val[j].family)
  82                     res->do_servers.do_servers_val[i].ep.ep_val[j].family
  83                       = strdup (src->do_servers.do_servers_val[i].ep.ep_val[j].family);
  84                   else
  85                     res->do_servers.do_servers_val[i].ep.ep_val[j].family = NULL;
  86
  87                   if (src->do_servers.do_servers_val[i].ep.ep_val[j].proto)
  88                     res->do_servers.do_servers_val[i].ep.ep_val[j].proto
  89                       = strdup (src->do_servers.do_servers_val[i].ep.ep_val[j].proto);
  90                   else
  91                     res->do_servers.do_servers_val[i].ep.ep_val[j].proto = NULL;
  92                 }
  93             }
  94           else
  95             {
  96               res->do_servers.do_servers_val[i].ep.ep_val = NULL;
  97             }
  98           res->do_servers.do_servers_val[i].key_type =
  99             src->do_servers.do_servers_val[i].key_type;
 100           res->do_servers.do_servers_val[i].pkey.n_len =
 101             src->do_servers.do_servers_val[i].pkey.n_len;
 102           if (res->do_servers.do_servers_val[i].pkey.n_len > 0)
 103             {
 104               res->do_servers.do_servers_val[i].pkey.n_bytes =
 105                 malloc (src->do_servers.do_servers_val[i].pkey.n_len);
 106               if (res->do_servers.do_servers_val[i].pkey.n_bytes == NULL)
 107                 return NULL;
 108               memcpy (res->do_servers.do_servers_val[i].pkey.n_bytes,
 109                       src->do_servers.do_servers_val[i].pkey.n_bytes,
 110                       src->do_servers.do_servers_val[i].pkey.n_len);
 111             }
 112           else
 113             res->do_servers.do_servers_val[i].pkey.n_bytes = NULL;
 114         }
 115     }
 116   else
 117     {
 118       res->do_servers.do_servers_len = 0;
 119       res->do_servers.do_servers_val = NULL;
 120     }
 121   res->do_ttl  = src->do_ttl;
 122   res->do_armask.do_armask_len = src->do_armask.do_armask_len;
 123   if (res->do_armask.do_armask_len > 0)
 124     {
 125       if ((res->do_armask.do_armask_val =
 126            malloc (src->do_armask.do_armask_len * sizeof (oar_mask))) == NULL)
 127         return NULL;
 128       memcpy (res->do_armask.do_armask_val, src->do_armask.do_armask_val,
 129               src->do_armask.do_armask_len * sizeof (oar_mask));
 130     }
 131   else
 132     {
 133       res->do_armask.do_armask_val = NULL;
 134     }
 135
 136   return res;
 137 }
 138
 139 group_obj *
 140 nis_clone_group (const group_obj *src, group_obj *dest)
 141 {
 142   size_t i;
 143   group_obj *res = NULL;
 144
 145   if (src == NULL)
 146     return NULL;
 147
 148   if (dest == NULL)
 149     {
 150       res = calloc (1, sizeof (group_obj));
 151       if (res == NULL)
 152         return NULL;
 153     }
 154   else
 155     res = dest;
 156
 157   res->gr_flags = src->gr_flags;
 158
 159   res->gr_members.gr_members_len = src->gr_members.gr_members_len;
 160   if (res->gr_members.gr_members_len > 0)
 161     {
 162       if (res->gr_members.gr_members_val == NULL)
 163         {
 164           res->gr_members.gr_members_val =
 165             malloc (res->gr_members.gr_members_len * sizeof (nis_name));
 166           if (res->gr_members.gr_members_val == NULL)
 167             return NULL;
 168         }
 169       for (i = 0; i < res->gr_members.gr_members_len; ++i)
 170         if (src->gr_members.gr_members_val[i] != NULL)
 171           res->gr_members.gr_members_val[i] =
 172             strdup (src->gr_members.gr_members_val[i]);
 173         else
 174           res->gr_members.gr_members_val[i] = NULL;
 175     }
 176
 177   return res;
 178 }
 179
 180 table_obj *
 181 nis_clone_table (const table_obj *src, table_obj *dest)
 182 {
 183   size_t i;
 184   table_obj *res = NULL;
 185
 186   if (src == NULL)
 187     return NULL;
 188
 189   if (dest == NULL)
 190     {
 191       res = calloc (1, sizeof (table_obj));
 192       if (res == NULL)
 193         return res;
 194     }
 195   else
 196     res = dest;
 197
 198   if (src->ta_type != NULL)
 199     {
 200       if ((res->ta_type = strdup (src->ta_type)) == NULL)
 201         return NULL;
 202     }
 203   else
 204     res->ta_type = NULL;
 205
 206   res->ta_maxcol = src->ta_maxcol;
 207   res->ta_sep = src->ta_sep;
 208   res->ta_cols.ta_cols_len = src->ta_cols.ta_cols_len;
 209   if (res->ta_cols.ta_cols_val == NULL)
 210     {
 211       res->ta_cols.ta_cols_val =
 212         malloc (src->ta_cols.ta_cols_len * sizeof (table_col));
 213       if (res->ta_cols.ta_cols_val == NULL)
 214         return NULL;
 215     }
 216   for (i = 0; i < res->ta_cols.ta_cols_len; i++)
 217     {
 218       if (src->ta_cols.ta_cols_val[i].tc_name == NULL)
 219         res->ta_cols.ta_cols_val[i].tc_name = NULL;
 220       else
 221         res->ta_cols.ta_cols_val[i].tc_name =
 222           strdup (src->ta_cols.ta_cols_val[i].tc_name);
 223       res->ta_cols.ta_cols_val[i].tc_flags =
 224         src->ta_cols.ta_cols_val[i].tc_flags;
 225       res->ta_cols.ta_cols_val[i].tc_rights =
 226         src->ta_cols.ta_cols_val[i].tc_rights;
 227     }
 228
 229   if (src->ta_path != NULL)
 230     {
 231       if ((res->ta_path = strdup (src->ta_path)) == NULL)
 232         return NULL;
 233     }
 234   else
 235     res->ta_path = NULL;
 236
 237   return res;
 238 }
 239
 240 entry_obj *
 241 nis_clone_entry (const entry_obj *src, entry_obj *dest)
 242 {
 243   size_t i;
 244   entry_obj *res = NULL;
 245
 246   if (src == NULL)
 247     return NULL;
 248
 249   if (dest == NULL)
 250     {
 251       res = calloc (1, sizeof (entry_obj));
 252       if (res == NULL)
 253         return NULL;
 254     }
 255   else
 256     res = dest;
 257
 258   if (src->en_type)
 259     res->en_type = strdup (src->en_type);
 260   else
 261     res->en_type = NULL;
 262
 263   res->en_cols.en_cols_len = src->en_cols.en_cols_len;
 264   if (res->en_cols.en_cols_val == NULL && src->en_cols.en_cols_len > 0)
 265     {
 266       res->en_cols.en_cols_val =
 267         malloc (src->en_cols.en_cols_len * sizeof (entry_col));
 268       if (res->en_cols.en_cols_val == NULL)
 269         return NULL;
 270     }
 271   for (i = 0; i < res->en_cols.en_cols_len; ++i)
 272     {
 273       res->en_cols.en_cols_val[i].ec_flags =
 274         src->en_cols.en_cols_val[i].ec_flags;
 275       res->en_cols.en_cols_val[i].ec_value.ec_value_len =
 276         src->en_cols.en_cols_val[i].ec_value.ec_value_len;
 277       if (res->en_cols.en_cols_val[i].ec_value.ec_value_val == NULL &&
 278           src->en_cols.en_cols_val[i].ec_value.ec_value_len > 0)
 279         res->en_cols.en_cols_val[i].ec_value.ec_value_val =
 280           malloc (src->en_cols.en_cols_val[i].ec_value.ec_value_len);
 281       memcpy (res->en_cols.en_cols_val[i].ec_value.ec_value_val,
 282               src->en_cols.en_cols_val[i].ec_value.ec_value_val,
 283               res->en_cols.en_cols_val[i].ec_value.ec_value_len);
 284     }
 285
 286   return res;
 287 }
 288
 289 nis_attr *
 290 nis_clone_nis_attr (const nis_attr *src, nis_attr *dest)
 291 {
 292   nis_attr *res = NULL;
 293
 294   if (src == NULL)
 295     return NULL;
 296
 297   if (dest == NULL)
 298     {
 299       res = calloc (1, sizeof (nis_attr));
 300       if (res == NULL)
 301         return NULL;
 302     }
 303   else
 304     res = dest;
 305
 306   if (src->zattr_ndx != NULL)
 307     {
 308       if ((res->zattr_ndx = strdup (src->zattr_ndx)) == NULL)
 309         return NULL;
 310     }
 311   else
 312     res->zattr_ndx = NULL;
 313
 314   res->zattr_val.zattr_val_len = src->zattr_val.zattr_val_len;
 315   if (res->zattr_val.zattr_val_val == NULL)
 316     {
 317       res->zattr_val.zattr_val_val =
 318         malloc (src->zattr_val.zattr_val_len);
 319       if (res->zattr_val.zattr_val_val == NULL)
 320         return NULL;
 321     }
 322   memcpy (res->zattr_val.zattr_val_val, src->zattr_val.zattr_val_val,
 323           src->zattr_val.zattr_val_len);
 324
 325   return res;
 326 }
 327
 328 static nis_attr *
 329 __nis_clone_attrs (const nis_attr *src, nis_attr *dest, u_int len)
 330 {
 331   unsigned int i;
 332   nis_attr *res;
 333
 334   if (len == 0)
 335     return dest;
 336
 337   if (dest == NULL)
 338     {
 339       res = calloc (len, sizeof (nis_attr));
 340       if (res == NULL)
 341         return NULL;
 342     }
 343   else
 344     res = dest;
 345
 346   for (i = 0; i < len; i++)
 347     nis_clone_nis_attr(&src[i], &res[i]);
 348
 349   return res;
 350 }
 351
 352 link_obj *
 353 nis_clone_link (const link_obj *src, link_obj *dest)
 354 {
 355   link_obj *res = NULL;
 356
 357   if (src == NULL)
 358     return NULL;
 359
 360   if (dest == NULL)
 361     {
 362       res = calloc (1, sizeof (link_obj));
 363       if (res == NULL)
 364         return NULL;
 365     }
 366   else
 367     res = dest;
 368
 369   res->li_rtype = src->li_rtype;
 370
 371   res->li_attrs.li_attrs_len = src->li_attrs.li_attrs_len;
 372   res->li_attrs.li_attrs_val =
 373     __nis_clone_attrs (src->li_attrs.li_attrs_val,
 374                        res->li_attrs.li_attrs_val,
 375                        src->li_attrs.li_attrs_len);
 376
 377   if ((res->li_name = strdup (src->li_name)) == NULL)
 378     return NULL;
 379
 380   return res;
 381 }
 382
 383 objdata *
 384 nis_clone_objdata (const objdata *src, objdata *dest)
 385 {
 386   objdata *res = NULL;
 387
 388   if (src == NULL)
 389     return NULL;
 390
 391   if (dest == NULL)
 392     {
 393       res = calloc (1, sizeof (objdata));
 394       if (res == NULL)
 395         return res;
 396     }
 397   else
 398     res = dest;
 399
 400   res->zo_type = src->zo_type;
 401
 402   switch (src->zo_type)
 403     {
 404     case BOGUS_OBJ:
 405       break;
 406     case NO_OBJ:
 407       break;
 408     case DIRECTORY_OBJ:
 409       if (nis_clone_directory (&src->objdata_u.di_data,
 410                                &res->objdata_u.di_data) == NULL)
 411         return NULL;
 412       break;
 413     case GROUP_OBJ:
 414       if (nis_clone_group (&src->objdata_u.gr_data,
 415                            &res->objdata_u.gr_data) == NULL)
 416         return NULL;
 417       break;
 418     case TABLE_OBJ:
 419       if (nis_clone_table (&src->objdata_u.ta_data,
 420                            &res->objdata_u.ta_data) == NULL)
 421         return NULL;
 422       break;
 423     case ENTRY_OBJ:
 424       if (nis_clone_entry (&src->objdata_u.en_data,
 425                            &res->objdata_u.en_data) == NULL)
 426         return NULL;
 427       break;
 428     case LINK_OBJ:
 429       if (nis_clone_link (&src->objdata_u.li_data,
 430                           &res->objdata_u.li_data) == NULL)
 431         return NULL;
 432       break;
 433     case PRIVATE_OBJ:
 434       res->objdata_u.po_data.po_data_len =
 435         src->objdata_u.po_data.po_data_len;
 436       if (src->objdata_u.po_data.po_data_val)
 437         {
 438           res->objdata_u.po_data.po_data_val =
 439             malloc (res->objdata_u.po_data.po_data_len);
 440           if (res->objdata_u.po_data.po_data_val == NULL)
 441             return NULL;
 442           memcpy (res->objdata_u.po_data.po_data_val,
 443                   src->objdata_u.po_data.po_data_val,
 444                   src->objdata_u.po_data.po_data_len);
 445           if (res->objdata_u.po_data.po_data_val == NULL)
 446             return NULL;
 447         }
 448       else
 449         {
 450           res->objdata_u.po_data.po_data_val = NULL;
 451           res->objdata_u.po_data.po_data_len = 0;
 452         }
 453       break;
 454     default:
 455       return NULL;
 456     }
 457
 458   return res;
 459 }
 460
 461 nis_object *
 462 nis_clone_object (const nis_object *src, nis_object *dest)
 463 {
 464   nis_object *res = NULL;
 465
 466   if (src == NULL)
 467     return NULL;
 468
 469   if (dest == NULL)
 470     {
 471       res = calloc (1, sizeof (nis_object));
 472       if (res == NULL)
 473         return NULL;
 474     }
 475   else
 476     res = dest;
 477
 478   res->zo_oid = src->zo_oid;
 479
 480   if ((res->zo_name = strdup (src->zo_name)) == NULL)
 481     return NULL;
 482   if ((res->zo_owner = strdup (src->zo_owner)) == NULL)
 483     return NULL;
 484   if ((res->zo_group = strdup (src->zo_group)) == NULL)
 485     return NULL;
 486   if ((res->zo_domain = strdup (src->zo_domain)) == NULL)
 487     return NULL;
 488
 489   res->zo_access = src->zo_access;
 490   res->zo_ttl = src->zo_ttl;
 491
 492   if (nis_clone_objdata (&src->zo_data, &res->zo_data) == NULL)
 493     return NULL;
 494
 495   return res;
 496 }
 497
 498 static nis_object *
 499 __nis_clone_objects (const nis_object *src, nis_object *dest, u_int len)
 500 {
 501   unsigned int i;
 502   nis_object *res;
 503
 504   if (len == 0)
 505     return dest;
 506
 507   if (dest == NULL)
 508     {
 509       res = calloc (len, sizeof (nis_object));
 510       if (res == NULL)
 511         return NULL;
 512     }
 513   else
 514     res = dest;
 515
 516   for (i = 0; i < len; ++i)
 517     nis_clone_object(&src[i], &res[i]);
 518
 519   return res;
 520 }
 521
 522 nis_result *
 523 nis_clone_result (const nis_result *src, nis_result *dest)
 524 {
 525   nis_result *res = NULL;
 526
 527   if (src == NULL)
 528     return NULL;
 529
 530   if (dest == NULL)
 531     {
 532       res = calloc (1, sizeof (nis_result));
 533       if (res == NULL)
 534         return NULL;
 535     }
 536   else
 537     res = dest;
 538
 539   res->status = src->status;
 540   res->objects.objects_len = src->objects.objects_len;
 541   res->objects.objects_val =
 542     __nis_clone_objects (src->objects.objects_val,
 543                          res->objects.objects_val,
 544                          src->objects.objects_len);
 545   res->zticks = src->zticks;
 546   res->dticks = src->dticks;
 547   res->aticks = src->aticks;
 548   res->cticks = src->cticks;
 549
 550   return res;
 551 }