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           if ((res->gr_members.gr_members_val =
 165                malloc (res->gr_members.gr_members_len * sizeof (nis_name))) == NULL)
 166             return NULL;
 167         }
 168       for (i = 0; i < res->gr_members.gr_members_len; ++i)
 169         if (src->gr_members.gr_members_val[i] != NULL)
 170           res->gr_members.gr_members_val[i] =
 171             strdup (src->gr_members.gr_members_val[i]);
 172         else
 173           res->gr_members.gr_members_val[i] = NULL;
 174     }
 175
 176   return res;
 177 }
 178
 179 table_obj *
 180 nis_clone_table (const table_obj *src, table_obj *dest)
 181 {
 182   size_t i;
 183   table_obj *res = NULL;
 184
 185   if (src == NULL)
 186     return NULL;
 187
 188   if (dest == NULL)
 189     {
 190       res = calloc (1, sizeof (table_obj));
 191       if (res == NULL)
 192         return res;
 193     }
 194   else
 195     res = dest;
 196
 197   if (src->ta_type != NULL)
 198     {
 199       if ((res->ta_type = strdup (src->ta_type)) == NULL)
 200         return NULL;
 201     }
 202   else
 203     res->ta_type = NULL;
 204
 205   res->ta_maxcol = src->ta_maxcol;
 206   res->ta_sep = src->ta_sep;
 207   res->ta_cols.ta_cols_len = src->ta_cols.ta_cols_len;
 208   if (res->ta_cols.ta_cols_val == NULL)
 209     {
 210       if ((res->ta_cols.ta_cols_val =
 211            calloc (1, src->ta_cols.ta_cols_len * sizeof (table_col))) == NULL)
 212         return NULL;
 213     }
 214   for (i = 0; i < res->ta_cols.ta_cols_len; i++)
 215     {
 216       if (src->ta_cols.ta_cols_val[i].tc_name == NULL)
 217         res->ta_cols.ta_cols_val[i].tc_name = NULL;
 218       else
 219         res->ta_cols.ta_cols_val[i].tc_name =
 220           strdup (src->ta_cols.ta_cols_val[i].tc_name);
 221       res->ta_cols.ta_cols_val[i].tc_flags =
 222         src->ta_cols.ta_cols_val[i].tc_flags;
 223       res->ta_cols.ta_cols_val[i].tc_rights =
 224         src->ta_cols.ta_cols_val[i].tc_rights;
 225     }
 226
 227   if (src->ta_path != NULL)
 228     {
 229       if ((res->ta_path = strdup (src->ta_path)) == NULL)
 230         return NULL;
 231     }
 232   else
 233     res->ta_path = NULL;
 234
 235   return res;
 236 }
 237
 238 entry_obj *
 239 nis_clone_entry (const entry_obj *src, entry_obj *dest)
 240 {
 241   size_t i;
 242   entry_obj *res = NULL;
 243
 244   if (src == NULL)
 245     return NULL;
 246
 247   if (dest == NULL)
 248     {
 249       res = calloc (1, sizeof (entry_obj));
 250       if (res == NULL)
 251         return NULL;
 252     }
 253   else
 254     res = dest;
 255
 256   if (src->en_type)
 257     res->en_type = strdup (src->en_type);
 258   else
 259     res->en_type = NULL;
 260
 261   res->en_cols.en_cols_len = src->en_cols.en_cols_len;
 262   if (res->en_cols.en_cols_val == NULL && src->en_cols.en_cols_len > 0)
 263     {
 264       res->en_cols.en_cols_val =
 265         calloc (1, src->en_cols.en_cols_len * sizeof (entry_col));
 266       if (res->en_cols.en_cols_val == NULL)
 267         return NULL;
 268     }
 269   for (i = 0; i < res->en_cols.en_cols_len; ++i)
 270     {
 271       res->en_cols.en_cols_val[i].ec_flags =
 272         src->en_cols.en_cols_val[i].ec_flags;
 273       res->en_cols.en_cols_val[i].ec_value.ec_value_len =
 274         src->en_cols.en_cols_val[i].ec_value.ec_value_len;
 275       if (res->en_cols.en_cols_val[i].ec_value.ec_value_val == NULL &&
 276           src->en_cols.en_cols_val[i].ec_value.ec_value_len > 0)
 277         res->en_cols.en_cols_val[i].ec_value.ec_value_val =
 278           malloc (src->en_cols.en_cols_val[i].ec_value.ec_value_len);
 279       memcpy (res->en_cols.en_cols_val[i].ec_value.ec_value_val,
 280               src->en_cols.en_cols_val[i].ec_value.ec_value_val,
 281               res->en_cols.en_cols_val[i].ec_value.ec_value_len);
 282     }
 283
 284   return res;
 285 }
 286
 287 nis_attr *
 288 nis_clone_nis_attr (const nis_attr *src, nis_attr *dest)
 289 {
 290   nis_attr *res = NULL;
 291
 292   if (src == NULL)
 293     return NULL;
 294
 295   if (dest == NULL)
 296     {
 297       res = calloc (1, sizeof (nis_attr));
 298       if (res == NULL)
 299         return NULL;
 300     }
 301   else
 302     res = dest;
 303
 304   if (src->zattr_ndx != NULL)
 305     {
 306       if ((res->zattr_ndx = strdup (src->zattr_ndx)) == NULL)
 307         return NULL;
 308     }
 309   else
 310     res->zattr_ndx = NULL;
 311
 312   res->zattr_val.zattr_val_len = src->zattr_val.zattr_val_len;
 313   if (res->zattr_val.zattr_val_len > 0)
 314     {
 315       if (res->zattr_val.zattr_val_val == NULL)
 316         {
 317           if ((res->zattr_val.zattr_val_val =
 318                calloc (1, src->zattr_val.zattr_val_len)) == NULL)
 319             return NULL;
 320         }
 321       memcpy (res->zattr_val.zattr_val_val, src->zattr_val.zattr_val_val,
 322               src->zattr_val.zattr_val_len);
 323     }
 324   else
 325     res->zattr_val.zattr_val_val = NULL;
 326   return res;
 327 }
 328
 329 static nis_attr *
 330 __nis_clone_attrs (const nis_attr *src, nis_attr *dest, u_int len)
 331 {
 332   unsigned int i;
 333   nis_attr *res;
 334
 335   if (len == 0)
 336     return dest;
 337
 338   if (dest == NULL)
 339     {
 340       res = calloc (len, sizeof (nis_attr));
 341       if (res == NULL)
 342         return NULL;
 343     }
 344   else
 345     res = dest;
 346
 347   for (i = 0; i < len; i++)
 348     nis_clone_nis_attr(&src[i], &res[i]);
 349
 350   return res;
 351 }
 352
 353 link_obj *
 354 nis_clone_link (const link_obj *src, link_obj *dest)
 355 {
 356   link_obj *res = NULL;
 357
 358   if (src == NULL)
 359     return NULL;
 360
 361   if (dest == NULL)
 362     {
 363       res = calloc (1, sizeof (link_obj));
 364       if (res == NULL)
 365         return NULL;
 366     }
 367   else
 368     res = dest;
 369
 370   res->li_rtype = src->li_rtype;
 371
 372   res->li_attrs.li_attrs_len = src->li_attrs.li_attrs_len;
 373   res->li_attrs.li_attrs_val =
 374     __nis_clone_attrs (src->li_attrs.li_attrs_val,
 375                        res->li_attrs.li_attrs_val,
 376                        src->li_attrs.li_attrs_len);
 377
 378   if (src->li_name)
 379     {
 380       if ((res->li_name = strdup (src->li_name)) == NULL)
 381         return NULL;
 382     }
 383   else
 384     res->li_name = NULL;
 385
 386   return res;
 387 }
 388
 389 objdata *
 390 nis_clone_objdata (const objdata *src, objdata *dest)
 391 {
 392   objdata *res = NULL;
 393
 394   if (src == NULL)
 395     return NULL;
 396
 397   if (dest == NULL)
 398     {
 399       res = calloc (1, sizeof (objdata));
 400       if (res == NULL)
 401         return res;
 402     }
 403   else
 404     res = dest;
 405
 406   res->zo_type = src->zo_type;
 407
 408   switch (src->zo_type)
 409     {
 410     case BOGUS_OBJ:
 411       break;
 412     case NO_OBJ:
 413       break;
 414     case DIRECTORY_OBJ:
 415       if (nis_clone_directory (&src->objdata_u.di_data,
 416                                &res->objdata_u.di_data) == NULL)
 417         return NULL;
 418       break;
 419     case GROUP_OBJ:
 420       if (nis_clone_group (&src->objdata_u.gr_data,
 421                            &res->objdata_u.gr_data) == NULL)
 422         return NULL;
 423       break;
 424     case TABLE_OBJ:
 425       if (nis_clone_table (&src->objdata_u.ta_data,
 426                            &res->objdata_u.ta_data) == NULL)
 427         return NULL;
 428       break;
 429     case ENTRY_OBJ:
 430       if (nis_clone_entry (&src->objdata_u.en_data,
 431                            &res->objdata_u.en_data) == NULL)
 432         return NULL;
 433       break;
 434     case LINK_OBJ:
 435       if (nis_clone_link (&src->objdata_u.li_data,
 436                           &res->objdata_u.li_data) == NULL)
 437         return NULL;
 438       break;
 439     case PRIVATE_OBJ:
 440       res->objdata_u.po_data.po_data_len =
 441         src->objdata_u.po_data.po_data_len;
 442       if (src->objdata_u.po_data.po_data_val)
 443         {
 444           if ((res->objdata_u.po_data.po_data_val =
 445                malloc (res->objdata_u.po_data.po_data_len)) == 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         }
 451       else
 452         {
 453           res->objdata_u.po_data.po_data_val = NULL;
 454           res->objdata_u.po_data.po_data_len = 0;
 455         }
 456       break;
 457     default:
 458       return NULL;
 459     }
 460
 461   return res;
 462 }
 463
 464 nis_object *
 465 nis_clone_object (const nis_object *src, nis_object *dest)
 466 {
 467   nis_object *res = NULL;
 468
 469   if (src == NULL)
 470     return NULL;
 471
 472   if (dest == NULL)
 473     {
 474       res = calloc (1, sizeof (nis_object));
 475       if (res == NULL)
 476         return NULL;
 477     }
 478   else
 479     res = dest;
 480
 481   res->zo_oid = src->zo_oid;
 482
 483   if (src->zo_name)
 484     {
 485       if ((res->zo_name = strdup (src->zo_name)) == NULL)
 486         return NULL;
 487     }
 488   else
 489     res->zo_name = NULL;
 490   if (src->zo_owner)
 491     {
 492       if ((res->zo_owner = strdup (src->zo_owner)) == NULL)
 493         return NULL;
 494     }
 495   else
 496     res->zo_owner = NULL;
 497   if (src->zo_group)
 498     {
 499       if ((res->zo_group = strdup (src->zo_group)) == NULL)
 500         return NULL;
 501     }
 502   else
 503     res->zo_group = NULL;
 504   if (src->zo_domain)
 505     {
 506       if ((res->zo_domain = strdup (src->zo_domain)) == NULL)
 507         return NULL;
 508     }
 509   else
 510     res->zo_domain = NULL;
 511   res->zo_access = src->zo_access;
 512   res->zo_ttl = src->zo_ttl;
 513
 514   if (nis_clone_objdata (&src->zo_data, &res->zo_data) == NULL)
 515     return NULL;
 516
 517   return res;
 518 }
 519
 520 static nis_object *
 521 __nis_clone_objects (const nis_object *src, nis_object *dest, u_int len)
 522 {
 523   unsigned int i;
 524   nis_object *res;
 525
 526   if (len == 0)
 527     return dest;
 528
 529   if (dest == NULL)
 530     {
 531       res = calloc (len, sizeof (nis_object));
 532       if (res == NULL)
 533         return NULL;
 534     }
 535   else
 536     res = dest;
 537
 538   for (i = 0; i < len; ++i)
 539     nis_clone_object(&src[i], &res[i]);
 540
 541   return res;
 542 }
 543
 544 nis_result *
 545 nis_clone_result (const nis_result *src, nis_result *dest)
 546 {
 547   nis_result *res = NULL;
 548
 549   if (src == NULL)
 550     return NULL;
 551
 552   if (dest == NULL)
 553     {
 554       res = calloc (1, sizeof (nis_result));
 555       if (res == NULL)
 556         return NULL;
 557     }
 558   else
 559     res = dest;
 560
 561   res->status = src->status;
 562   res->objects.objects_len = src->objects.objects_len;
 563   res->objects.objects_val =
 564     __nis_clone_objects (src->objects.objects_val,
 565                          res->objects.objects_val,
 566                          src->objects.objects_len);
 567   res->zticks = src->zticks;
 568   res->dticks = src->dticks;
 569   res->aticks = src->aticks;
 570   res->cticks = src->cticks;
 571
 572   return res;
 573 }