/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * tpcom: Threaded Print Comment
 *
 * tpcom is a threaded version of the pcom program.  It will create
 * a new thread for each new ELF descriptor that it examines.  It
 * will then examine each elf descriptor and print the .comment section
 * if found.
 *
 * This program demonstrates that libelf is MT-Safe and the usage
 * of elf_begin(ELF_C_READ).
 */

#include <stdio.h>
#include <libelf.h>
#include <gelf.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <thread.h>


#define NUMLWPS         32              /* arbitrary number of LWPS */

static const char *CommentStr = ".comment";

/*
 * arguments to be passed into process_elf().
 */
typedef struct {
        Elf     *pe_elf;
        char    *pe_file;               /* elf member name */
        int     pe_fd;
        short   pe_member;              /* is this an archive member? */
} pe_args;


static mutex_t  printlock = DEFAULTMUTEX;       /* printlock used to */
                                                /* group output */
                                                /* of comment sections */

static void
print_comment(Elf *elf, const char *file)
{
        Elf_Scn         *scn = NULL;
        GElf_Shdr       shdr;
        Elf_Data        *data;
        size_t          shstrndx;

        if (elf_getshdrstrndx(elf, &shstrndx) == -1) {
                (void) fprintf(stderr, "%s: elf_getshdrstrndx() failed: %s\n",
                    file, elf_errmsg(0));
                return;
        }

        while ((scn = elf_nextscn(elf, scn)) != NULL) {
                /*
                 * Do a string compare to examine each section header
                 * to see if it is a ".comment" section.  If it is then
                 * this is the section we want to process.
                 */
                if (gelf_getshdr(scn, &shdr) == NULL) {
                        (void) fprintf(stderr, "%s: elf_getshdr() failed: %s\n",
                            file, elf_errmsg(0));
                        return;
                }

                if (strcmp(CommentStr, elf_strptr(elf, shstrndx,
                    shdr.sh_name)) == 0) {
                        int     i;
                        char    *ptr;

                        (void) mutex_lock(&printlock);
                        (void) printf("%s .comment:\n", file);

                        /*
                         * Get the data associated with the .comment
                         * section.
                         */
                        if ((data = elf_getdata(scn, NULL)) == NULL) {
                                (void) fprintf(stderr,
                                    "%s: elf_getdata() failed: %s\n",
                                    file, elf_errmsg(0));
                                (void) mutex_unlock(&printlock);
                                return;
                        }
                        /*
                         * Data in a .comment section is a list of 'null'
                         * terminated strings.  The following will print
                         * one string per line.
                         */
                        for (i = 0, ptr = (char *)data->d_buf;
                            i < data->d_size; i++)
                                if (ptr[i]) {
                                        (void) puts(&ptr[i]);
                                        i += strlen(&ptr[i]);
                                }
                        (void) putchar('\n');
                        (void) mutex_unlock(&printlock);
                }
        }

}

static void
process_elf(pe_args *pep)
{
        Elf_Cmd cmd;
        Elf     *_elf;

        switch (elf_kind(pep->pe_elf)) {
        case ELF_K_ELF:
                print_comment(pep->pe_elf, pep->pe_file);
                break;
        case ELF_K_AR:
                cmd = ELF_C_READ;
                while ((_elf = elf_begin(pep->pe_fd, cmd,
                    pep->pe_elf)) != NULL) {
                        Elf_Arhdr       *arhdr;
                        pe_args         *_pep;
                        int             rc;

                        if ((arhdr = elf_getarhdr(_elf)) == NULL) {
                                (void) fprintf(stderr,
                                    "%s: elf_getarhdr() failed: %s\n",
                                    pep->pe_file, elf_errmsg(0));
                        }
                        cmd = elf_next(_elf);
                        _pep = malloc(sizeof (pe_args));
                        _pep->pe_elf = _elf;
                        _pep->pe_file = malloc(strlen(pep->pe_file) +
                            strlen(arhdr->ar_name) + 5);
                        (void) sprintf(_pep->pe_file,
                            "%s(%s)", pep->pe_file, arhdr->ar_name);
                        _pep->pe_fd = pep->pe_fd;
                        _pep->pe_member = 1;

                        if ((rc = thr_create(NULL, 0,
                            (void *(*)(void *))process_elf,
                            (void *)_pep, THR_DETACHED, 0)) != 0) {
                                (void) fprintf(stderr,
                                    "thr_create() failed, rc = %d\n", rc);
                        }
                }
                break;
        default:
                if (!pep->pe_member) {
                        (void) mutex_lock(&printlock);
                        (void) fprintf(stderr,
                            "%s: unexpected elf_kind(): 0x%x\n",
                            pep->pe_file, elf_kind(pep->pe_elf));
                        (void) mutex_unlock(&printlock);
                }
        }

        (void) elf_end(pep->pe_elf);
        if (pep->pe_member)
                free(pep->pe_file);
        free(pep);
        thr_exit(0);
}

int
main(int argc, char ** argv)
{
        int     i;

        if (argc < 2) {
                (void) printf("usage: %s elf_file ...\n", argv[0]);
                return (1);
        }

        /*
         * Initialize the elf library, must be called before elf_begin()
         * can be called.
         */
        if (elf_version(EV_CURRENT) == EV_NONE) {
                (void) fprintf(stderr,
                    "elf_version() failed: %s\n", elf_errmsg(0));
                return (1);
        }

        /*
         * create an arbitrary number of LWP's to run the
         * threads that will be created.
         */
        if (thr_setconcurrency(NUMLWPS) != 0) {
                (void) fprintf(stderr, "thread setconcurrency failed\n");
                return (1);
        }

        for (i = 1; i < argc; i++) {
                int     fd;
                Elf     *elf;
                pe_args *pep;
                int     rc;
                char    *elf_fname;

                elf_fname = argv[i];

                if ((fd = open(elf_fname, O_RDONLY)) == -1) {
                        perror("open");
                        continue;
                }

                /*
                 * Attempt to open an Elf descriptor Read/Write
                 * for each file.
                 */
                if ((elf = elf_begin(fd, ELF_C_READ, 0)) == NULL) {
                        (void) mutex_lock(&printlock);
                        (void) fprintf(stderr, "elf_begin() failed: %s\n",
                            elf_errmsg(0));
                        (void) mutex_unlock(&printlock);
                        (void) close(fd);
                        continue;
                }
                pep = malloc(sizeof (pe_args));
                pep->pe_elf = elf;
                pep->pe_file = elf_fname;
                pep->pe_fd = fd;
                pep->pe_member = 0;
                if ((rc = thr_create(NULL, 0, (void *(*)(void *))process_elf,
                    (void *)pep, THR_DETACHED, 0)) != 0) {
                        (void) mutex_lock(&printlock);
                        (void) fprintf(stderr,
                            "thr_create() failed with code: %d\n", rc);
                        (void) mutex_unlock(&printlock);
                        return (1);
                }
        }

        thr_exit(0);
        return (0);
}