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         calloc (1, 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 (src->li_name)
 378     {
 379       if ((res->li_name = strdup (src->li_name)) == NULL)
 380         return NULL;
 381     }
 382   else
 383     res->li_name = NULL;
 384
 385   return res;
 386 }
 387
 388 objdata *
 389 nis_clone_objdata (const objdata *src, objdata *dest)
 390 {
 391   objdata *res = NULL;
 392
 393   if (src == NULL)
 394     return NULL;
 395
 396   if (dest == NULL)
 397     {
 398       res = calloc (1, sizeof (objdata));
 399       if (res == NULL)
 400         return res;
 401     }
 402   else
 403     res = dest;
 404
 405   res->zo_type = src->zo_type;
 406
 407   switch (src->zo_type)
 408     {
 409     case BOGUS_OBJ:
 410       break;
 411     case NO_OBJ:
 412       break;
 413     case DIRECTORY_OBJ:
 414       if (nis_clone_directory (&src->objdata_u.di_data,
 415                                &res->objdata_u.di_data) == NULL)
 416         return NULL;
 417       break;
 418     case GROUP_OBJ:
 419       if (nis_clone_group (&src->objdata_u.gr_data,
 420                            &res->objdata_u.gr_data) == NULL)
 421         return NULL;
 422       break;
 423     case TABLE_OBJ:
 424       if (nis_clone_table (&src->objdata_u.ta_data,
 425                            &res->objdata_u.ta_data) == NULL)
 426         return NULL;
 427       break;
 428     case ENTRY_OBJ:
 429       if (nis_clone_entry (&src->objdata_u.en_data,
 430                            &res->objdata_u.en_data) == NULL)
 431         return NULL;
 432       break;
 433     case LINK_OBJ:
 434       if (nis_clone_link (&src->objdata_u.li_data,
 435                           &res->objdata_u.li_data) == NULL)
 436         return NULL;
 437       break;
 438     case PRIVATE_OBJ:
 439       res->objdata_u.po_data.po_data_len =
 440         src->objdata_u.po_data.po_data_len;
 441       if (src->objdata_u.po_data.po_data_val)
 442         {
 443           res->objdata_u.po_data.po_data_val =
 444             malloc (res->objdata_u.po_data.po_data_len);
 445           if (res->objdata_u.po_data.po_data_val == NULL)
 446             return NULL;
 447           memcpy (res->objdata_u.po_data.po_data_val,
 448                   src->objdata_u.po_data.po_data_val,
 449                   src->objdata_u.po_data.po_data_len);
 450           if (res->objdata_u.po_data.po_data_val == NULL)
 451             return NULL;
 452         }
 453       else
 454         {
 455           res->objdata_u.po_data.po_data_val = NULL;
 456           res->objdata_u.po_data.po_data_len = 0;
 457         }
 458       break;
 459     default:
 460       return NULL;
 461     }
 462
 463   return res;
 464 }
 465
 466 nis_object *
 467 nis_clone_object (const nis_object *src, nis_object *dest)
 468 {
 469   nis_object *res = NULL;
 470
 471   if (src == NULL)
 472     return NULL;
 473
 474   if (dest == NULL)
 475     {
 476       res = calloc (1, sizeof (nis_object));
 477       if (res == NULL)
 478         return NULL;
 479     }
 480   else
 481     res = dest;
 482
 483   res->zo_oid = src->zo_oid;
 484
 485   if (src->zo_name)
 486     {
 487       if ((res->zo_name = strdup (src->zo_name)) == NULL)
 488         return NULL;
 489     }
 490   else
 491     res->zo_name = NULL;
 492   if (src->zo_owner)
 493     {
 494       if ((res->zo_owner = strdup (src->zo_owner)) == NULL)
 495         return NULL;
 496     }
 497   else
 498     res->zo_owner = NULL;
 499   if (src->zo_group)
 500     {
 501       if ((res->zo_group = strdup (src->zo_group)) == NULL)
 502         return NULL;
 503     }
 504   else
 505     res->zo_group = NULL;
 506   if (src->zo_domain)
 507     {
 508       if ((res->zo_domain = strdup (src->zo_domain)) == NULL)
 509         return NULL;
 510     }
 511   else
 512     res->zo_domain = NULL;
 513   res->zo_access = src->zo_access;
 514   res->zo_ttl = src->zo_ttl;
 515
 516   if (nis_clone_objdata (&src->zo_data, &res->zo_data) == NULL)
 517     return NULL;
 518
 519   return res;
 520 }
 521
 522 static nis_object *
 523 __nis_clone_objects (const nis_object *src, nis_object *dest, u_int len)
 524 {
 525   unsigned int i;
 526   nis_object *res;
 527
 528   if (len == 0)
 529     return dest;
 530
 531   if (dest == NULL)
 532     {
 533       res = calloc (len, sizeof (nis_object));
 534       if (res == NULL)
 535         return NULL;
 536     }
 537   else
 538     res = dest;
 539
 540   for (i = 0; i < len; ++i)
 541     nis_clone_object(&src[i], &res[i]);
 542
 543   return res;
 544 }
 545
 546 nis_result *
 547 nis_clone_result (const nis_result *src, nis_result *dest)
 548 {
 549   nis_result *res = NULL;
 550
 551   if (src == NULL)
 552     return NULL;
 553
 554   if (dest == NULL)
 555     {
 556       res = calloc (1, sizeof (nis_result));
 557       if (res == NULL)
 558         return NULL;
 559     }
 560   else
 561     res = dest;
 562
 563   res->status = src->status;
 564   res->objects.objects_len = src->objects.objects_len;
 565   res->objects.objects_val =
 566     __nis_clone_objects (src->objects.objects_val,
 567                          res->objects.objects_val,
 568                          src->objects.objects_len);
 569   res->zticks = src->zticks;
 570   res->dticks = src->dticks;
 571   res->aticks = src->aticks;
 572   res->cticks = src->cticks;
 573
 574   return res;
 575 }