1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 
  26 #include <string.h>
  27 #include "_libelf.h"
  28 #include "decl.h"
  29 #include "msg.h"
  30 
  31 
  32 /*
  33  * Find elf or it's class from a pointer to an Elf_Data struct.
  34  * Warning:  this Assumes that the Elf_Data is part of a libelf
  35  * Dnode structure, which is expected to be true for any Elf_Data
  36  * passed into libelf *except* for the xlatetof() and xlatetom() functions.
  37  */
  38 #define EDATA_CLASS(edata) \
  39         (((Dnode *)(edata))->db_scn->s_elf->ed_class)
  40 
  41 #define EDATA_ELF(edata) \
  42         (((Dnode *)(edata))->db_scn->s_elf)
  43 
  44 #define EDATA_SCN(edata) \
  45         (((Dnode *)(edata))->db_scn)
  46 
  47 #define EDATA_READLOCKS(edata) \
  48         READLOCKS(EDATA_ELF((edata)), EDATA_SCN((edata)))
  49 
  50 #define EDATA_READUNLOCKS(edata) \
  51         READUNLOCKS(EDATA_ELF((edata)), EDATA_SCN((edata)))
  52 
  53 
  54 size_t
  55 gelf_fsize(Elf * elf, Elf_Type type, size_t count, unsigned ver)
  56 {
  57         int class;
  58 
  59         if (elf == NULL)
  60                 return (0);
  61 
  62         class = gelf_getclass(elf);
  63         if (class == ELFCLASS32)
  64                 return (elf32_fsize(type, count, ver));
  65         else if (class == ELFCLASS64)
  66                 return (elf64_fsize(type, count, ver));
  67 
  68         _elf_seterr(EREQ_CLASS, 0);
  69         return (0);
  70 }
  71 
  72 
  73 int
  74 gelf_getclass(Elf *elf)
  75 {
  76         if (elf == NULL)
  77                 return (0);
  78 
  79         /*
  80          * Don't rely on the idents, a new ehdr doesn't have it!
  81          */
  82         return (elf->ed_class);
  83 }
  84 
  85 
  86 GElf_Ehdr *
  87 gelf_getehdr(Elf *elf, GElf_Ehdr *dst)
  88 {
  89         int class;
  90 
  91         if (elf == NULL)
  92                 return (NULL);
  93 
  94         class = gelf_getclass(elf);
  95         if (class == ELFCLASS32) {
  96                 Elf32_Ehdr * e          = elf32_getehdr(elf);
  97 
  98                 if (e == NULL)
  99                         return (NULL);
 100 
 101                 ELFRLOCK(elf);
 102                 (void) memcpy(dst->e_ident, e->e_ident, EI_NIDENT);
 103                 dst->e_type          = e->e_type;
 104                 dst->e_machine               = e->e_machine;
 105                 dst->e_version               = e->e_version;
 106                 dst->e_entry         = (Elf64_Addr)e->e_entry;
 107                 dst->e_phoff         = (Elf64_Off)e->e_phoff;
 108                 dst->e_shoff         = (Elf64_Off)e->e_shoff;
 109                 dst->e_flags         = e->e_flags;
 110                 dst->e_ehsize                = e->e_ehsize;
 111                 dst->e_phentsize     = e->e_phentsize;
 112                 dst->e_phnum         = e->e_phnum;
 113                 dst->e_shentsize     = e->e_shentsize;
 114                 dst->e_shnum         = e->e_shnum;
 115                 dst->e_shstrndx              = e->e_shstrndx;
 116                 ELFUNLOCK(elf);
 117 
 118                 return (dst);
 119         } else if (class == ELFCLASS64) {
 120                 Elf64_Ehdr * e          = elf64_getehdr(elf);
 121 
 122                 if (e == NULL)
 123                         return (NULL);
 124 
 125                 ELFRLOCK(elf);
 126                 *dst                    = *e;
 127                 ELFUNLOCK(elf);
 128 
 129                 return (dst);
 130         }
 131 
 132         _elf_seterr(EREQ_CLASS, 0);
 133         return (NULL);
 134 }
 135 
 136 
 137 int
 138 gelf_update_ehdr(Elf *elf, GElf_Ehdr *src)
 139 {
 140         int class;
 141 
 142         if (elf == NULL)
 143                 return (0);
 144 
 145         /*
 146          * In case elf isn't cooked.
 147          */
 148         class = gelf_getclass(elf);
 149         if (class == ELFCLASSNONE)
 150                 class = src->e_ident[EI_CLASS];
 151 
 152 
 153         if (class == ELFCLASS32) {
 154                 Elf32_Ehdr * d  = elf32_getehdr(elf);
 155 
 156                 if (d == NULL)
 157                         return (0);
 158 
 159                 ELFWLOCK(elf);
 160                 (void) memcpy(d->e_ident, src->e_ident, EI_NIDENT);
 161                 d->e_type    = src->e_type;
 162                 d->e_machine = src->e_machine;
 163                 d->e_version = src->e_version;
 164                 /* LINTED */
 165                 d->e_entry   = (Elf32_Addr)src->e_entry;
 166                 /* LINTED */
 167                 d->e_phoff   = (Elf32_Off)src->e_phoff;
 168                 /* LINTED */
 169                 d->e_shoff   = (Elf32_Off)src->e_shoff;
 170                 /* could memcpy the rest of these... */
 171                 d->e_flags   = src->e_flags;
 172                 d->e_ehsize  = src->e_ehsize;
 173                 d->e_phentsize       = src->e_phentsize;
 174                 d->e_phnum   = src->e_phnum;
 175                 d->e_shentsize       = src->e_shentsize;
 176                 d->e_shnum   = src->e_shnum;
 177                 d->e_shstrndx        = src->e_shstrndx;
 178                 ELFUNLOCK(elf);
 179 
 180                 return (1);
 181         } else if (class == ELFCLASS64) {
 182                 Elf64_Ehdr * d  = elf64_getehdr(elf);
 183 
 184                 if (d == NULL)
 185                         return (0);
 186 
 187                 ELFWLOCK(elf);
 188                 *d              = *(Elf64_Ehdr *)src;
 189                 ELFUNLOCK(elf);
 190 
 191                 return (1);
 192         }
 193 
 194         _elf_seterr(EREQ_CLASS, 0);
 195         return (0);
 196 }
 197 
 198 
 199 unsigned long
 200 gelf_newehdr(Elf *elf, int class)
 201 {
 202         if (elf == NULL)
 203                 return (0);
 204 
 205         if (class == ELFCLASS32)
 206                 return ((unsigned long)elf32_newehdr(elf));
 207         else if (class == ELFCLASS64)
 208                 return ((unsigned long)elf64_newehdr(elf));
 209 
 210         _elf_seterr(EREQ_CLASS, 0);
 211         return (0);
 212 }
 213 
 214 
 215 GElf_Phdr *
 216 gelf_getphdr(Elf *elf, int ndx, GElf_Phdr *dst)
 217 {
 218         int             class;
 219         size_t          phnum;
 220 
 221         if (elf == NULL)
 222                 return (NULL);
 223 
 224         if (elf_getphdrnum(elf, &phnum) == -1)
 225                 return (NULL);
 226 
 227         if (phnum <= ndx) {
 228                 _elf_seterr(EREQ_RAND, 0);
 229                 return (NULL);
 230         }
 231 
 232         class = gelf_getclass(elf);
 233         if ((class != ELFCLASS32) && (class != ELFCLASS64)) {
 234                 _elf_seterr(EREQ_CLASS, 0);
 235                 return (NULL);
 236         }
 237 
 238         if (class == ELFCLASS32) {
 239                 Elf32_Phdr *p   = &((Elf32_Phdr *)elf32_getphdr(elf))[ndx];
 240 
 241                 ELFRLOCK(elf);
 242                 dst->p_type  = p->p_type;
 243                 dst->p_flags = p->p_flags;
 244                 dst->p_offset        = (Elf64_Off)p->p_offset;
 245                 dst->p_vaddr = (Elf64_Addr)p->p_vaddr;
 246                 dst->p_paddr = (Elf64_Addr)p->p_paddr;
 247                 dst->p_filesz        = (Elf64_Xword)p->p_filesz;
 248                 dst->p_memsz = (Elf64_Xword)p->p_memsz;
 249                 dst->p_align = (Elf64_Xword)p->p_align;
 250                 ELFUNLOCK(elf);
 251         } else if (class == ELFCLASS64) {
 252                 Elf64_Phdr *phdrs = elf64_getphdr(elf);
 253                 ELFRLOCK(elf);
 254                 *dst = ((GElf_Phdr *)phdrs)[ndx];
 255                 ELFUNLOCK(elf);
 256         }
 257 
 258         return (dst);
 259 }
 260 
 261 
 262 int
 263 gelf_update_phdr(Elf *elf, int ndx, GElf_Phdr *src)
 264 {
 265         int             class;
 266         size_t          phnum;
 267 
 268         if (elf == NULL)
 269                 return (0);
 270 
 271         if (elf_getphdrnum(elf, &phnum) == -1)
 272                 return (NULL);
 273 
 274         if (phnum < ndx) {
 275                 _elf_seterr(EREQ_RAND, 0);
 276                 return (0);
 277         }
 278 
 279         class = gelf_getclass(elf);
 280         if (class == ELFCLASS32) {
 281                 Elf32_Phdr *dst = &((Elf32_Phdr *)elf32_getphdr(elf))[ndx];
 282                 ELFWLOCK(elf);
 283                 dst->p_type  = src->p_type;
 284                 dst->p_flags = src->p_flags;
 285                 /* LINTED */
 286                 dst->p_offset        = (Elf32_Off)src->p_offset;
 287                 /* LINTED */
 288                 dst->p_vaddr = (Elf32_Addr)src->p_vaddr;
 289                 /* LINTED */
 290                 dst->p_paddr = (Elf32_Addr)src->p_paddr;
 291                 /* LINTED */
 292                 dst->p_filesz        = (Elf32_Word)src->p_filesz;
 293                 /* LINTED */
 294                 dst->p_memsz = (Elf32_Word)src->p_memsz;
 295                 /* LINTED */
 296                 dst->p_align = (Elf32_Word)src->p_align;
 297                 ELFUNLOCK(elf);
 298         } else if (class == ELFCLASS64) {
 299                 Elf64_Phdr *dst = elf64_getphdr(elf);
 300                 ELFWLOCK(elf);
 301                 dst[ndx] = *(GElf_Phdr *)src;
 302                 ELFUNLOCK(elf);
 303         } else {
 304                 _elf_seterr(EREQ_CLASS, 0);
 305                 return (0);
 306         }
 307         return (1);
 308 }
 309 
 310 
 311 unsigned long
 312 gelf_newphdr(Elf *elf, size_t phnum)
 313 {
 314         int class;
 315 
 316         if (elf == NULL)
 317                 return (0);
 318 
 319         class = gelf_getclass(elf);
 320         if (class == ELFCLASS32)
 321                 return ((unsigned long)elf32_newphdr(elf, phnum));
 322         else if (class == ELFCLASS64)
 323                 return ((unsigned long)elf64_newphdr(elf, phnum));
 324 
 325         _elf_seterr(EREQ_CLASS, 0);
 326         return (0);
 327 }
 328 
 329 
 330 GElf_Shdr *
 331 gelf_getshdr(Elf_Scn *scn,  GElf_Shdr *dst)
 332 {
 333         if (scn == NULL)
 334                 return (NULL);
 335 
 336         if (scn->s_elf->ed_class == ELFCLASS32) {
 337                 Elf32_Shdr *s           = elf32_getshdr(scn);
 338 
 339                 if (s == NULL)
 340                         return (NULL);
 341 
 342                 READLOCKS(scn->s_elf, scn);
 343                 dst->sh_name         = s->sh_name;
 344                 dst->sh_type         = s->sh_type;
 345                 dst->sh_flags                = (Elf64_Xword)s->sh_flags;
 346                 dst->sh_addr         = (Elf64_Addr)s->sh_addr;
 347                 dst->sh_offset               = (Elf64_Off)s->sh_offset;
 348                 dst->sh_size         = (Elf64_Xword)s->sh_size;
 349                 dst->sh_link         = s->sh_link;
 350                 dst->sh_info         = s->sh_info;
 351                 dst->sh_addralign    = (Elf64_Xword)s->sh_addralign;
 352                 dst->sh_entsize              = (Elf64_Xword)s->sh_entsize;
 353                 READUNLOCKS(scn->s_elf, scn);
 354 
 355                 return (dst);
 356         } else if (scn->s_elf->ed_class == ELFCLASS64) {
 357                 Elf64_Shdr *s           = elf64_getshdr(scn);
 358 
 359                 if (s == NULL)
 360                         return (NULL);
 361 
 362                 READLOCKS(scn->s_elf, scn);
 363                 *dst                    = *(Elf64_Shdr *)s;
 364                 READUNLOCKS(scn->s_elf, scn);
 365 
 366                 return (dst);
 367         }
 368 
 369         _elf_seterr(EREQ_CLASS, 0);
 370         return (NULL);
 371 }
 372 
 373 
 374 int
 375 gelf_update_shdr(Elf_Scn *scn, GElf_Shdr *src)
 376 {
 377         if (scn == NULL)
 378                 return (0);
 379 
 380         if (scn->s_elf->ed_class == ELFCLASS32) {
 381                 Elf32_Shdr *dst = elf32_getshdr(scn);
 382 
 383                 if (dst == NULL)
 384                         return (0);
 385 
 386                 ELFWLOCK(scn->s_elf);
 387                 dst->sh_name         = src->sh_name;
 388                 dst->sh_type         = src->sh_type;
 389                 /* LINTED */
 390                 dst->sh_flags                = (Elf32_Word)src->sh_flags;
 391                 /* LINTED */
 392                 dst->sh_addr         = (Elf32_Addr)src->sh_addr;
 393                 /* LINTED */
 394                 dst->sh_offset               = (Elf32_Off) src->sh_offset;
 395                 /* LINTED */
 396                 dst->sh_size         = (Elf32_Word)src->sh_size;
 397                 dst->sh_link         = src->sh_link;
 398                 dst->sh_info         = src->sh_info;
 399                 /* LINTED */
 400                 dst->sh_addralign    = (Elf32_Word)src->sh_addralign;
 401                 /* LINTED */
 402                 dst->sh_entsize              = (Elf32_Word)src->sh_entsize;
 403 
 404                 ELFUNLOCK(scn->s_elf);
 405                 return (1);
 406         } else if (scn->s_elf->ed_class == ELFCLASS64) {
 407                 Elf64_Shdr * dst        = elf64_getshdr(scn);
 408 
 409                 if (dst == NULL)
 410                         return (0);
 411 
 412                 ELFWLOCK(scn->s_elf);
 413                 *dst                    = *(Elf64_Shdr *)src;
 414                 ELFUNLOCK(scn->s_elf);
 415                 return (1);
 416         }
 417 
 418         _elf_seterr(EREQ_CLASS, 0);
 419         return (0);
 420 }
 421 
 422 
 423 /*
 424  * gelf_xlatetof/gelf_xlatetom use 'elf' to find the class
 425  * because these are the odd case where the Elf_Data structs
 426  * might not have been allocated by libelf (and therefore
 427  * don't have Dnode's associated with them).
 428  */
 429 Elf_Data *
 430 gelf_xlatetof(Elf *elf, Elf_Data *dst, const Elf_Data *src, unsigned encode)
 431 {
 432         int class;
 433 
 434         if ((elf == NULL) || (dst == NULL) || (src == NULL))
 435                 return (NULL);
 436 
 437         class = gelf_getclass(elf);
 438         if (class == ELFCLASS32)
 439                 return (elf32_xlatetof(dst, src, encode));
 440         else if (class == ELFCLASS64)
 441                 return (elf64_xlatetof(dst, src, encode));
 442 
 443         _elf_seterr(EREQ_CLASS, 0);
 444         return (NULL);
 445 }
 446 
 447 
 448 Elf_Data *
 449 gelf_xlatetom(Elf *elf, Elf_Data *dst, const Elf_Data *src, unsigned encode)
 450 {
 451         int class;
 452 
 453         if ((elf == NULL) || (dst == NULL) || (src == NULL))
 454                 return (NULL);
 455 
 456         class = gelf_getclass(elf);
 457         if (class == ELFCLASS32)
 458                 return (elf32_xlatetom(dst, src, encode));
 459         else if (class == ELFCLASS64)
 460                 return (elf64_xlatetom(dst, src, encode));
 461 
 462         _elf_seterr(EREQ_CLASS, 0);
 463         return (NULL);
 464 }
 465 
 466 
 467 GElf_Sym *
 468 gelf_getsym(Elf_Data * data, int ndx, GElf_Sym * dst)
 469 {
 470         int     class;
 471         size_t  entsize;
 472 
 473         if (data == NULL)
 474                 return (NULL);
 475 
 476         class = EDATA_CLASS(data);
 477         if (class == ELFCLASS32)
 478                 entsize = sizeof (Elf32_Sym);
 479         else if (class == ELFCLASS64)
 480                 entsize = sizeof (GElf_Sym);
 481         else {
 482                 _elf_seterr(EREQ_CLASS, 0);
 483                 return (NULL);
 484         }
 485 
 486         EDATA_READLOCKS(data);
 487 
 488         if ((entsize * ndx) >= data->d_size) {
 489                 _elf_seterr(EREQ_RAND, 0);
 490                 dst = NULL;
 491         } else if (class == ELFCLASS32) {
 492                 Elf32_Sym       *s;
 493                 s               = &(((Elf32_Sym *)data->d_buf)[ndx]);
 494                 dst->st_name = s->st_name;
 495                 dst->st_value        = (Elf64_Addr)s->st_value;
 496                 dst->st_size = (Elf64_Xword)s->st_size;
 497                 dst->st_info = ELF64_ST_INFO(ELF32_ST_BIND(s->st_info),
 498                     ELF32_ST_TYPE(s->st_info));
 499                 dst->st_other        = s->st_other;
 500                 dst->st_shndx        = s->st_shndx;
 501         } else
 502                 *dst = ((GElf_Sym *)data->d_buf)[ndx];
 503 
 504         EDATA_READUNLOCKS(data);
 505         return (dst);
 506 }
 507 
 508 
 509 int
 510 gelf_update_sym(Elf_Data *dst, int ndx, GElf_Sym *src)
 511 {
 512         int     class, rc = 1;
 513         size_t  entsize;
 514 
 515         if (dst == NULL)
 516                 return (0);
 517 
 518         class = EDATA_CLASS(dst);
 519         if (class == ELFCLASS32)
 520                 entsize = sizeof (Elf32_Sym);
 521         else if (class == ELFCLASS64)
 522                 entsize = sizeof (GElf_Sym);
 523         else {
 524                 _elf_seterr(EREQ_CLASS, 0);
 525                 return (0);
 526         }
 527 
 528         ELFWLOCK(EDATA_ELF(dst));
 529 
 530         if ((entsize * ndx) >= dst->d_size) {
 531                 _elf_seterr(EREQ_RAND, 0);
 532                 rc = 0;
 533         } else if (class == ELFCLASS32) {
 534                 Elf32_Sym * d;
 535 
 536                 d               = &(((Elf32_Sym *)dst->d_buf)[ndx]);
 537                 d->st_name   = src->st_name;
 538                 /* LINTED */
 539                 d->st_value  = (Elf32_Addr)src->st_value;
 540                 /* LINTED */
 541                 d->st_size   = (Elf32_Word)src->st_size;
 542                 d->st_info   = ELF32_ST_INFO(ELF64_ST_BIND(src->st_info),
 543                     ELF64_ST_TYPE(src->st_info));
 544                 d->st_other  = src->st_other;
 545                 d->st_shndx  = src->st_shndx;
 546         } else
 547                 ((Elf64_Sym *)dst->d_buf)[ndx] = *((Elf64_Sym *)src);
 548 
 549         ELFUNLOCK(EDATA_ELF(dst));
 550         return (rc);
 551 }
 552 
 553 
 554 GElf_Syminfo *
 555 gelf_getsyminfo(Elf_Data *data, int ndx, GElf_Syminfo *dst)
 556 {
 557         int     class;
 558         size_t  entsize;
 559 
 560         if (data == NULL)
 561                 return (NULL);
 562 
 563         class = EDATA_CLASS(data);
 564         if (class == ELFCLASS32)
 565                 entsize = sizeof (Elf32_Syminfo);
 566         else if (class == ELFCLASS64)
 567                 entsize = sizeof (GElf_Syminfo);
 568         else {
 569                 _elf_seterr(EREQ_CLASS, 0);
 570                 return (NULL);
 571         }
 572         EDATA_READLOCKS(data);
 573 
 574         if ((entsize * ndx) >= data->d_size) {
 575                 _elf_seterr(EREQ_RAND, 0);
 576                 dst = NULL;
 577         } else if (class == ELFCLASS32) {
 578                 Elf32_Syminfo * si;
 579 
 580                 si              = &(((Elf32_Syminfo *)data->d_buf)[ndx]);
 581                 dst->si_boundto = si->si_boundto;
 582                 dst->si_flags        = si->si_flags;
 583         } else
 584                 *dst            = ((GElf_Syminfo *)data->d_buf)[ndx];
 585 
 586         EDATA_READUNLOCKS(data);
 587         return (dst);
 588 }
 589 
 590 int
 591 gelf_update_syminfo(Elf_Data *dst, int ndx, GElf_Syminfo *src)
 592 {
 593         int     class, rc = 1;
 594         size_t  entsize;
 595 
 596         if (dst == NULL)
 597                 return (0);
 598 
 599         class = EDATA_CLASS(dst);
 600         if (class == ELFCLASS32)
 601                 entsize = sizeof (Elf32_Syminfo);
 602         else if (class == ELFCLASS64)
 603                 entsize = sizeof (GElf_Syminfo);
 604         else {
 605                 _elf_seterr(EREQ_CLASS, 0);
 606                 return (0);
 607         }
 608         ELFWLOCK(EDATA_ELF(dst));
 609 
 610         if ((entsize * ndx) >= dst->d_size) {
 611                 _elf_seterr(EREQ_RAND, 0);
 612                 rc = 0;
 613         } else if (class == ELFCLASS32) {
 614                 Elf32_Syminfo * d       = &(((Elf32_Syminfo *)dst->d_buf)[ndx]);
 615                 d->si_boundto                = src->si_boundto;
 616                 d->si_flags          = src->si_flags;
 617         } else
 618                 ((Elf64_Syminfo *)dst->d_buf)[ndx] = *((Elf64_Syminfo *)src);
 619 
 620         ELFUNLOCK(EDATA_ELF(dst));
 621         return (rc);
 622 }
 623 
 624 GElf_Dyn *
 625 gelf_getdyn(Elf_Data *data, int ndx, GElf_Dyn *dst)
 626 {
 627         int     class;
 628         size_t  entsize;
 629 
 630         if (data == NULL)
 631                 return (NULL);
 632 
 633         class = EDATA_CLASS(data);
 634         if (class == ELFCLASS32)
 635                 entsize = sizeof (Elf32_Dyn);
 636         else if (class == ELFCLASS64)
 637                 entsize = sizeof (GElf_Dyn);
 638         else {
 639                 _elf_seterr(EREQ_CLASS, 0);
 640                 return (NULL);
 641         }
 642         EDATA_READLOCKS(data);
 643 
 644         if ((entsize * ndx) >= data->d_size) {
 645                 _elf_seterr(EREQ_RAND, 0);
 646                 dst = NULL;
 647         } else if (class == ELFCLASS32) {
 648                 Elf32_Dyn * d = &((Elf32_Dyn *)data->d_buf)[ndx];
 649 
 650                 dst->d_tag   = (Elf32_Sword)d->d_tag;
 651                 dst->d_un.d_val      = (Elf32_Word) d->d_un.d_val;
 652         } else
 653                 *dst = ((Elf64_Dyn *)data->d_buf)[ndx];
 654 
 655         EDATA_READUNLOCKS(data);
 656         return (dst);
 657 }
 658 
 659 
 660 int
 661 gelf_update_dyn(Elf_Data *dst, int ndx, GElf_Dyn *src)
 662 {
 663         int     class, rc = 1;
 664         size_t  entsize;
 665 
 666         if (dst == NULL)
 667                 return (0);
 668 
 669         class = EDATA_CLASS(dst);
 670         if (class == ELFCLASS32)
 671                 entsize = sizeof (Elf32_Dyn);
 672         else if (class == ELFCLASS64)
 673                 entsize = sizeof (GElf_Dyn);
 674         else {
 675                 _elf_seterr(EREQ_CLASS, 0);
 676                 return (0);
 677         }
 678         ELFWLOCK(EDATA_ELF(dst));
 679 
 680         if ((entsize * ndx) >= dst->d_size) {
 681                 _elf_seterr(EREQ_RAND, 0);
 682                 rc = 0;
 683         } else if (class == ELFCLASS32) {
 684                 Elf32_Dyn * d = &((Elf32_Dyn *)dst->d_buf)[ndx];
 685 
 686                 /* LINTED */
 687                 d->d_tag     = (Elf32_Word)src->d_tag;
 688                 /* LINTED */
 689                 d->d_un.d_val        = (Elf32_Word)src->d_un.d_val;
 690         } else
 691                 ((Elf64_Dyn *)dst->d_buf)[ndx] = *(Elf64_Dyn*)src;
 692 
 693         ELFUNLOCK(EDATA_ELF(dst));
 694         return (rc);
 695 }
 696 
 697 
 698 
 699 GElf_Sym *
 700 gelf_getsymshndx(Elf_Data *symdata, Elf_Data *shndxdata,
 701         int ndx, GElf_Sym *symptr, Elf32_Word *xshndx)
 702 {
 703         if (gelf_getsym(symdata, ndx, symptr) == 0)
 704                 return (NULL);
 705         if (shndxdata && xshndx) {
 706                 EDATA_READLOCKS(shndxdata);
 707                 if ((ndx * sizeof (Elf32_Word)) >= shndxdata->d_size) {
 708                         _elf_seterr(EREQ_RAND, 0);
 709                         EDATA_READUNLOCKS(shndxdata);
 710                         return (NULL);
 711                 }
 712                 *xshndx = (((Elf32_Word *)shndxdata->d_buf)[ndx]);
 713                 EDATA_READUNLOCKS(shndxdata);
 714         } else {
 715                 *xshndx = 0;
 716         }
 717         return (symptr);
 718 }
 719 
 720 int
 721 gelf_update_symshndx(Elf_Data *symdata, Elf_Data *shndxdata,
 722         int ndx, GElf_Sym *symptr, Elf32_Word xshndx)
 723 {
 724         if (gelf_update_sym(symdata, ndx, symptr) == 0)
 725                 return (0);
 726         if (shndxdata) {
 727                 ELFWLOCK(EDATA_ELF(shndxdata));
 728                 if ((ndx * sizeof (Elf32_Word)) >= shndxdata->d_size) {
 729                         _elf_seterr(EREQ_RAND, 0);
 730                         ELFUNLOCK(EDATA_ELF(shndxdata));
 731                         return (0);
 732                 }
 733                 ((Elf32_Word *)shndxdata->d_buf)[ndx] = xshndx;
 734                 ELFUNLOCK(EDATA_ELF(shndxdata));
 735         }
 736         return (1);
 737 }
 738 
 739 
 740 GElf_Move *
 741 gelf_getmove(Elf_Data *src, int ndx, GElf_Move *dst)
 742 {
 743         int     class;
 744         size_t  entsize;
 745 
 746         if (src == NULL)
 747                 return (NULL);
 748 
 749         class = EDATA_CLASS(src);
 750         if (class == ELFCLASS32)
 751                 entsize = sizeof (Elf32_Move);
 752         else if (class == ELFCLASS64)
 753                 entsize = sizeof (GElf_Move);
 754         else {
 755                 _elf_seterr(EREQ_CLASS, 0);
 756                 return (NULL);
 757         }
 758         EDATA_READLOCKS(src);
 759 
 760         if ((entsize * ndx) >= src->d_size) {
 761                 _elf_seterr(EREQ_RAND, 0);
 762                 dst = NULL;
 763         } else if (class == ELFCLASS32) {
 764                 Elf32_Move * m = &((Elf32_Move *)src->d_buf)[ndx];
 765 
 766                 dst->m_poffset = (Elf64_Word)m->m_poffset;
 767                 dst->m_repeat = (Elf64_Xword)m->m_repeat;
 768                 dst->m_stride = (Elf64_Half)m->m_stride;
 769                 dst->m_value = (Elf64_Xword)m->m_value;
 770                 dst->m_info = ELF64_M_INFO(ELF32_M_SYM(m->m_info),
 771                     ELF32_M_SIZE(m->m_info));
 772         } else {
 773                 *dst = ((Elf64_Move *)src->d_buf)[ndx];
 774         }
 775 
 776         EDATA_READUNLOCKS(src);
 777         return (dst);
 778 }
 779 
 780 int
 781 gelf_update_move(Elf_Data *dest, int ndx, GElf_Move *src)
 782 {
 783         int     class, rc = 1;
 784         size_t  entsize;
 785 
 786         if (dest == NULL)
 787                 return (0);
 788 
 789         class = EDATA_CLASS(dest);
 790         if (class == ELFCLASS32)
 791                 entsize = sizeof (Elf32_Move);
 792         else if (class == ELFCLASS64)
 793                 entsize = sizeof (GElf_Move);
 794         else {
 795                 _elf_seterr(EREQ_CLASS, 0);
 796                 return (0);
 797         }
 798         ELFWLOCK(EDATA_ELF(dest));
 799 
 800         if ((entsize * ndx) >= dest->d_size) {
 801                 _elf_seterr(EREQ_RAND, 0);
 802                 rc = 0;
 803         } else if (class == ELFCLASS32) {
 804                 Elf32_Move * m = &((Elf32_Move *)dest->d_buf)[ndx];
 805 
 806                 m->m_poffset = (Elf32_Word)src->m_poffset;
 807                 m->m_repeat = (Elf32_Half)src->m_repeat;
 808                 m->m_stride = (Elf32_Half)src->m_stride;
 809                 m->m_value = (Elf32_Lword)src->m_value;
 810                 m->m_info = (Elf32_Word)ELF32_M_INFO(ELF64_M_SYM(src->m_info),
 811                     ELF64_M_SIZE(src->m_info));
 812         } else {
 813                 ((Elf64_Move *)dest->d_buf)[ndx] = *(Elf64_Move *)src;
 814         }
 815 
 816         ELFUNLOCK(EDATA_ELF(dest));
 817         return (rc);
 818 }
 819 
 820 
 821 GElf_Rela *
 822 gelf_getrela(Elf_Data *src, int ndx, GElf_Rela *dst)
 823 {
 824         int     class;
 825         size_t  entsize;
 826 
 827         if (src == NULL)
 828                 return (NULL);
 829 
 830         class = EDATA_CLASS(src);
 831         if (class == ELFCLASS32)
 832                 entsize = sizeof (Elf32_Rela);
 833         else if (class == ELFCLASS64)
 834                 entsize = sizeof (GElf_Rela);
 835         else {
 836                 _elf_seterr(EREQ_CLASS, 0);
 837                 return (NULL);
 838         }
 839         EDATA_READLOCKS(src);
 840 
 841         if ((entsize * ndx) >= src->d_size) {
 842                 _elf_seterr(EREQ_RAND, 0);
 843                 dst = NULL;
 844         } else if (class == ELFCLASS32) {
 845                 Elf32_Rela * r = &((Elf32_Rela *)src->d_buf)[ndx];
 846 
 847                 dst->r_offset        = (GElf_Addr)r->r_offset;
 848                 dst->r_addend        = (GElf_Addr)r->r_addend;
 849 
 850                 /*
 851                  * Elf32 will never have the extra data field that
 852                  * Elf64's r_info field can have, so ignore it.
 853                  */
 854                 /* LINTED */
 855                 dst->r_info  = ELF64_R_INFO(
 856                     ELF32_R_SYM(r->r_info),
 857                     ELF32_R_TYPE(r->r_info));
 858         } else
 859                 *dst = ((Elf64_Rela *)src->d_buf)[ndx];
 860 
 861         EDATA_READUNLOCKS(src);
 862         return (dst);
 863 }
 864 
 865 
 866 int
 867 gelf_update_rela(Elf_Data *dst, int ndx, GElf_Rela *src)
 868 {
 869         int     class, rc = 1;
 870         size_t  entsize;
 871 
 872         if (dst == NULL)
 873                 return (0);
 874 
 875         class = EDATA_CLASS(dst);
 876         if (class == ELFCLASS32)
 877                 entsize = sizeof (Elf32_Rela);
 878         else if (class == ELFCLASS64)
 879                 entsize = sizeof (GElf_Rela);
 880         else {
 881                 _elf_seterr(EREQ_CLASS, 0);
 882                 return (0);
 883         }
 884         ELFWLOCK(EDATA_ELF(dst));
 885 
 886         if ((entsize * ndx) >= dst->d_size) {
 887                 _elf_seterr(EREQ_RAND, 0);
 888                 rc = 0;
 889         } else if (class == ELFCLASS32) {
 890                 Elf32_Rela * r = &((Elf32_Rela *)dst->d_buf)[ndx];
 891 
 892                 /* LINTED */
 893                 r->r_offset  = (Elf32_Addr) src->r_offset;
 894                 /* LINTED */
 895                 r->r_addend  = (Elf32_Sword)src->r_addend;
 896 
 897                 /*
 898                  * Elf32 will never have the extra data field that
 899                  * Elf64's r_info field can have, so ignore it.
 900                  */
 901                 /* LINTED */
 902                 r->r_info    = ELF32_R_INFO(ELF64_R_SYM(src->r_info),
 903                     ELF64_R_TYPE(src->r_info));
 904         } else {
 905                 ((Elf64_Rela *)dst->d_buf)[ndx] = *(Elf64_Rela *)src;
 906         }
 907 
 908         ELFUNLOCK(EDATA_ELF(dst));
 909 
 910         return (rc);
 911 }
 912 
 913 
 914 GElf_Rel *
 915 gelf_getrel(Elf_Data *src, int ndx, GElf_Rel *dst)
 916 {
 917         int     class;
 918         size_t  entsize;
 919 
 920         if (src == NULL)
 921                 return (NULL);
 922 
 923         class = EDATA_CLASS(src);
 924         if (class == ELFCLASS32)
 925                 entsize = sizeof (Elf32_Rel);
 926         else if (class == ELFCLASS64)
 927                 entsize = sizeof (GElf_Rel);
 928         else {
 929                 _elf_seterr(EREQ_CLASS, 0);
 930                 return (NULL);
 931         }
 932         EDATA_READLOCKS(src);
 933 
 934         if ((entsize * ndx) >= src->d_size) {
 935                 _elf_seterr(EREQ_RAND, 0);
 936                 dst = NULL;
 937         } else if (class == ELFCLASS32) {
 938                 Elf32_Rel * r = &((Elf32_Rel *)src->d_buf)[ndx];
 939 
 940                 dst->r_offset        = (GElf_Addr)r->r_offset;
 941 
 942                 /*
 943                  * Elf32 will never have the extra data field that
 944                  * Elf64's r_info field can have, so ignore it.
 945                  */
 946                 /* LINTED */
 947                 dst->r_info  = ELF64_R_INFO(ELF32_R_SYM(r->r_info),
 948                     ELF32_R_TYPE(r->r_info));
 949         } else
 950                 *dst = ((Elf64_Rel *)src->d_buf)[ndx];
 951 
 952         EDATA_READUNLOCKS(src);
 953         return (dst);
 954 }
 955 
 956 
 957 int
 958 gelf_update_rel(Elf_Data *dst, int ndx, GElf_Rel *src)
 959 {
 960         int     class, rc = 1;
 961         size_t  entsize;
 962 
 963         if (dst == NULL)
 964                 return (0);
 965 
 966         class = EDATA_CLASS(dst);
 967         if (class == ELFCLASS32)
 968                 entsize = sizeof (Elf32_Rel);
 969         else if (class == ELFCLASS64)
 970                 entsize = sizeof (GElf_Rel);
 971         else {
 972                 _elf_seterr(EREQ_CLASS, 0);
 973                 return (0);
 974         }
 975         ELFWLOCK(EDATA_ELF(dst));
 976 
 977         if ((entsize * ndx) >= dst->d_size) {
 978                 _elf_seterr(EREQ_RAND, 0);
 979                 rc = 0;
 980         } else if (class == ELFCLASS32) {
 981                 Elf32_Rel * r = &((Elf32_Rel *)dst->d_buf)[ndx];
 982 
 983                 /* LINTED */
 984                 r->r_offset  = (Elf32_Addr) src->r_offset;
 985 
 986                 /*
 987                  * Elf32 will never have the extra data field that
 988                  * Elf64's r_info field can have, so ignore it.
 989                  */
 990                 /* LINTED */
 991                 r->r_info    = ELF32_R_INFO(ELF64_R_SYM(src->r_info),
 992                     ELF64_R_TYPE(src->r_info));
 993 
 994         } else {
 995                 ((Elf64_Rel *)dst->d_buf)[ndx] = *(Elf64_Rel *)src;
 996         }
 997 
 998         ELFUNLOCK(EDATA_ELF(dst));
 999         return (rc);
1000 }
1001 
1002 long
1003 gelf_checksum(Elf *elf)
1004 {
1005         int class = gelf_getclass(elf);
1006 
1007         if (class == ELFCLASS32)
1008                 return (elf32_checksum(elf));
1009         else if (class == ELFCLASS64)
1010                 return (elf64_checksum(elf));
1011 
1012         _elf_seterr(EREQ_CLASS, 0);
1013         return (0);
1014 }
1015 
1016 GElf_Cap *
1017 gelf_getcap(Elf_Data *data, int ndx, GElf_Cap *dst)
1018 {
1019         int     class;
1020         size_t  entsize;
1021 
1022         if (data == NULL)
1023                 return (NULL);
1024 
1025         class = EDATA_CLASS(data);
1026         if (class == ELFCLASS32)
1027                 entsize = sizeof (Elf32_Cap);
1028         else if (class == ELFCLASS64)
1029                 entsize = sizeof (GElf_Cap);
1030         else {
1031                 _elf_seterr(EREQ_CLASS, 0);
1032                 return (NULL);
1033         }
1034 
1035         EDATA_READLOCKS(data);
1036 
1037         if ((entsize * ndx) >= data->d_size) {
1038                 _elf_seterr(EREQ_RAND, 0);
1039                 dst = NULL;
1040         } else if (class == ELFCLASS32) {
1041                 Elf32_Cap       *c = &(((Elf32_Cap *)data->d_buf)[ndx]);
1042 
1043                 dst->c_tag = (Elf64_Xword)c->c_tag;
1044                 dst->c_un.c_val = (Elf64_Xword)c->c_un.c_val;
1045         } else
1046                 *dst = ((GElf_Cap *)data->d_buf)[ndx];
1047 
1048         EDATA_READUNLOCKS(data);
1049         return (dst);
1050 }
1051 
1052 int
1053 gelf_update_cap(Elf_Data *dst, int ndx, GElf_Cap *src)
1054 {
1055         int     class, rc = 1;
1056         size_t  entsize;
1057 
1058         if (dst == NULL)
1059                 return (0);
1060 
1061         class = EDATA_CLASS(dst);
1062         if (class == ELFCLASS32)
1063                 entsize = sizeof (Elf32_Cap);
1064         else if (class == ELFCLASS64)
1065                 entsize = sizeof (GElf_Cap);
1066         else {
1067                 _elf_seterr(EREQ_CLASS, 0);
1068                 return (0);
1069         }
1070 
1071         ELFWLOCK(EDATA_ELF(dst));
1072 
1073         if ((entsize * ndx) >= dst->d_size) {
1074                 _elf_seterr(EREQ_RAND, 0);
1075                 rc = 0;
1076         } else if (class == ELFCLASS32) {
1077                 Elf32_Cap       *c = &(((Elf32_Cap *)dst->d_buf)[ndx]);
1078 
1079                 c->c_tag = (Elf32_Word)src->c_tag;
1080                 c->c_un.c_val = (Elf32_Word)src->c_un.c_val;
1081         } else
1082                 ((Elf64_Cap *)dst->d_buf)[ndx] = *((Elf64_Cap *)src);
1083 
1084         ELFUNLOCK(EDATA_ELF(dst));
1085         return (rc);
1086 }
1087 
1088 /*
1089  * If the specified object has a dynamic section, and that section
1090  * contains a DT_FLAGS_1 entry, then return the value of that entry.
1091  * Otherwise, return 0.
1092  */
1093 GElf_Xword
1094 _gelf_getdyndtflags_1(Elf *elf)
1095 {
1096         Elf_Scn *scn = NULL;
1097         Elf_Data *data;
1098         GElf_Shdr shdr;
1099         GElf_Dyn dyn;
1100         int i, n;
1101 
1102         while (scn = elf_nextscn(elf, scn)) {
1103                 if (gelf_getshdr(scn, &shdr) == NULL)
1104                         break;
1105                 if (shdr.sh_type != SHT_DYNAMIC)
1106                         continue;
1107                 if (data = elf_getdata(scn, NULL)) {
1108                         n = shdr.sh_size / shdr.sh_entsize;
1109                         for (i = 0; i < n; i++) {
1110                                 (void) gelf_getdyn(data, i, &dyn);
1111                                 if (dyn.d_tag == DT_FLAGS_1) {
1112                                         return (dyn.d_un.d_val);
1113                                 }
1114                         }
1115                 }
1116                 break;
1117         }
1118         return (0);
1119 }