summaryrefslogtreecommitdiffhomepage
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/arbits/output/pe_ar_list_members.c388
-rw-r--r--src/arbits/output/pe_ar_print_members.c181
-rw-r--r--src/arbits/pe_archive_meta.c888
-rw-r--r--src/arbits/pe_armap_bsd_32.c157
-rw-r--r--src/arbits/pe_armap_bsd_64.c174
-rw-r--r--src/arbits/pe_armap_sysv_32.c120
-rw-r--r--src/arbits/pe_armap_sysv_64.c128
-rw-r--r--src/cmds/pe_cmd_ar.c134
-rw-r--r--src/cmds/pe_cmd_perk.c97
-rw-r--r--src/driver/pe_amain.c102
-rw-r--r--src/driver/pe_driver_ctx.c414
-rw-r--r--src/driver/pe_unit_ctx.c159
-rw-r--r--src/hexdump/pe_hexdump_coff_image_hdr.c (renamed from src/hdrdump/pe_hdrdump_coff_image_hdr.c)4
-rw-r--r--src/hexdump/pe_hexdump_coff_object_hdr.c (renamed from src/hdrdump/pe_hdrdump_coff_object_hdr.c)4
-rw-r--r--src/hexdump/pe_hexdump_coff_opt_hdr.c (renamed from src/hdrdump/pe_hdrdump_coff_opt_hdr.c)12
-rw-r--r--src/hexdump/pe_hexdump_export_hdr.c (renamed from src/hdrdump/pe_hdrdump_export_hdr.c)4
-rw-r--r--src/hexdump/pe_hexdump_image_dos_hdr.c (renamed from src/hdrdump/pe_hdrdump_image_dos_hdr.c)4
-rw-r--r--src/hexdump/pe_hexdump_import_tbl.c (renamed from src/hdrdump/pe_hdrdump_import_tbl.c)8
-rw-r--r--src/hexdump/pe_hexdump_sec_tbl.c (renamed from src/hdrdump/pe_hdrdump_sec_tbl.c)8
-rw-r--r--src/info/pe_info_get_image_abi.c (renamed from src/info/pe_get_image_abi.c)2
-rw-r--r--src/info/pe_info_get_image_framework.c (renamed from src/info/pe_get_image_framework.c)2
-rw-r--r--src/info/pe_info_get_image_subsystem.c (renamed from src/info/pe_get_image_subsystem.c)2
-rw-r--r--src/info/pe_info_get_image_subtype.c (renamed from src/info/pe_get_image_subtype.c)2
-rw-r--r--src/internal/perk_ar_impl.h116
-rw-r--r--src/internal/perk_dprintf_impl.c4
-rw-r--r--src/internal/perk_driver_impl.h30
-rw-r--r--src/internal/perk_errinfo_impl.c3
-rw-r--r--src/internal/perk_hexdump_impl.c (renamed from src/internal/perk_hdrdump_impl.c)9
-rw-r--r--src/internal/perk_hexdump_impl.h (renamed from src/internal/perk_hdrdump_impl.h)0
-rw-r--r--src/internal/perk_synopsis_impl.h46
-rw-r--r--src/internal/perk_visibility_impl.h26
-rw-r--r--src/logic/pe_image_meta_data.c (renamed from src/logic/pe_get_image_meta.c)43
-rw-r--r--src/logic/pe_image_raw_data.c (renamed from src/logic/pe_map_raw_image.c)4
-rw-r--r--src/output/pe_output_error.c15
-rw-r--r--src/output/pe_output_image_category.c8
-rw-r--r--src/output/pe_output_mdso_libraries.c16
-rw-r--r--src/skin/pe_skin_ar.c35
-rw-r--r--src/skin/pe_skin_default.c47
-rw-r--r--src/skin/pe_skin_perk.c55
39 files changed, 3174 insertions, 277 deletions
diff --git a/src/arbits/output/pe_ar_list_members.c b/src/arbits/output/pe_ar_list_members.c
new file mode 100644
index 0000000..3e0aaa4
--- /dev/null
+++ b/src/arbits/output/pe_ar_list_members.c
@@ -0,0 +1,388 @@
+/***************************************************************/
+/* perk: PE Resource Kit */
+/* Copyright (C) 2015--2025 SysDeer Technologies, LLC */
+/* Released under GPLv2 and GPLv3; see COPYING.PERK. */
+/***************************************************************/
+
+#include <time.h>
+#include <locale.h>
+#include <inttypes.h>
+#include <perk/perk.h>
+#include <perk/perk_output.h>
+#include "perk_driver_impl.h"
+#include "perk_dprintf_impl.h"
+#include "perk_errinfo_impl.h"
+#include "perk_ar_impl.h"
+
+#define PERK_PRETTY_FLAGS (PERK_PRETTY_YAML \
+ | PERK_PRETTY_POSIX \
+ | PERK_PRETTY_HEXDATA)
+
+#define PPRIU64 "%"PRIu64
+
+const char pe_ar_perm_strs[8][4] = {
+ {'-','-','-','\0'},
+ {'-','-','x','\0'},
+ {'-','w','-','\0'},
+ {'-','w','x','\0'},
+ {'r','-','-','\0'},
+ {'r','-','x','\0'},
+ {'r','w','-','\0'},
+ {'r','w','x','\0'}
+};
+
+static unsigned pe_ar_output_decimal_len_from_val(size_t val, unsigned min)
+{
+ unsigned ret;
+
+ for (ret=0; val; ret++)
+ val /= 10;
+
+ return (ret > min) ? ret : min;
+}
+
+static void pe_ar_member_not_found(
+ const struct pe_archive_meta * meta,
+ const char * name)
+{
+ const struct pe_driver_ctx * dctx;
+ int fderr;
+
+ dctx = (pe_archive_meta_ictx(meta))->dctx;
+
+ if ((fderr = pe_driver_fderr(dctx)) >= 0)
+ pe_dprintf(
+ fderr,
+ "%s: error: member '%s' was not found in the current archive\n",
+ dctx->program,name);
+}
+
+static struct ar_meta_member_info * pe_ar_get_member_info(
+ const struct pe_archive_meta * meta,
+ const char * name)
+{
+ struct ar_meta_member_info ** memberp;
+ const char * slash;
+
+ if ((slash = strrchr(name,'/')))
+ name = ++slash;
+
+ for (memberp=meta->a_memberv; *memberp; memberp++)
+ if (!strcmp(memberp[0]->ar_file_header.ar_member_name,name))
+ return *memberp;
+
+ pe_ar_member_not_found(meta,name);
+
+ return 0;
+}
+
+static int pe_ar_member_in_members(
+ struct ar_meta_member_info * minfo,
+ const char ** members)
+{
+ const char ** pname;
+
+ for (pname=members; *pname; pname++)
+ if (!strcmp(*pname,minfo->ar_file_header.ar_member_name))
+ return 1;
+
+ return 0;
+}
+
+static int pe_ar_list_one_member_posix(
+ int fdout,
+ struct ar_meta_member_info * minfo)
+{
+ return pe_dprintf(
+ fdout,"%s\n",
+ minfo->ar_file_header.ar_member_name);
+}
+
+static int pe_ar_list_one_member_posix_verbose(
+ int fdout,
+ struct ar_meta_member_info * minfo,
+ const char * fmtstr,
+ locale_t arlocale)
+{
+ unsigned ownerbits;
+ unsigned groupbits;
+ unsigned worldbits;
+ time_t artimeval;
+ struct tm artimeloc;
+ char artimestr[64] = {0};
+
+ ownerbits = (minfo->ar_file_header.ar_file_mode & 0700) >> 6;
+ groupbits = (minfo->ar_file_header.ar_file_mode & 0070) >> 3;
+ worldbits = (minfo->ar_file_header.ar_file_mode & 0007);
+ artimeval = minfo->ar_file_header.ar_time_date_stamp;
+
+ if (localtime_r(&artimeval,&artimeloc))
+ strftime_l(
+ artimestr,sizeof(artimestr),
+ "%b %e %H:%M %Y",&artimeloc,
+ arlocale);
+
+ return pe_dprintf(
+ fdout,fmtstr,
+ pe_ar_perm_strs[ownerbits],
+ pe_ar_perm_strs[groupbits],
+ pe_ar_perm_strs[worldbits],
+ minfo->ar_file_header.ar_uid,
+ minfo->ar_file_header.ar_gid,
+ minfo->ar_object_size,
+ artimestr,
+ minfo->ar_file_header.ar_member_name);
+}
+
+static int pe_ar_list_members_posix(
+ const struct pe_driver_ctx * dctx,
+ const struct pe_archive_meta * meta,
+ const struct pe_fd_ctx * fdctx,
+ const char ** members)
+{
+ struct ar_meta_member_info ** memberp;
+ struct ar_meta_member_info * minfo;
+ const char ** pname;
+ int fdout;
+ size_t testval;
+ size_t sizelen;
+ size_t uidlen;
+ size_t gidlen;
+ locale_t arloc;
+ char fmtstr[64];
+
+ fdout = fdctx->fdout;
+ arloc = 0;
+
+ if (dctx->cctx->fmtflags & PERK_PRETTY_VERBOSE) {
+ for (sizelen=0,memberp=meta->a_memberv; *memberp; memberp++)
+ if ((testval = memberp[0]->ar_object_size) > sizelen)
+ if (!members || pe_ar_member_in_members(*memberp,members))
+ sizelen = testval;
+
+ for (uidlen=0,memberp=meta->a_memberv; *memberp; memberp++)
+ if ((testval = memberp[0]->ar_file_header.ar_uid) > uidlen)
+ if (!members || pe_ar_member_in_members(*memberp,members))
+ uidlen = testval;
+
+ for (gidlen=0,memberp=meta->a_memberv; *memberp; memberp++)
+ if ((testval = memberp[0]->ar_file_header.ar_gid) > gidlen)
+ if (!members || pe_ar_member_in_members(*memberp,members))
+ gidlen = testval;
+
+ sizelen = pe_ar_output_decimal_len_from_val(sizelen,6);
+ uidlen = pe_ar_output_decimal_len_from_val(uidlen,1);
+ gidlen = pe_ar_output_decimal_len_from_val(gidlen,1);
+ arloc = newlocale(LC_ALL,setlocale(LC_ALL,0),0);
+
+ sprintf(
+ fmtstr,
+ "%%s%%s%%s "
+ "%%" PPRIU64 "u"
+ "/%%-" PPRIU64 "u "
+ "%%" PPRIU64 "u "
+ "%%s "
+ "%%s\n",
+ uidlen,
+ gidlen,
+ sizelen);
+ }
+
+ for (pname=members; pname && *pname; pname++) {
+ if ((minfo = pe_ar_get_member_info(meta,*pname))) {
+ switch (minfo->ar_member_attr) {
+ case AR_MEMBER_ATTR_ARMAP:
+ case AR_MEMBER_ATTR_LINKINFO:
+ case AR_MEMBER_ATTR_NAMESTRS:
+ break;
+
+ default:
+ if (arloc) {
+ if (pe_ar_list_one_member_posix_verbose(
+ fdout,minfo,fmtstr,arloc) < 0)
+ return PERK_SYSTEM_ERROR(dctx);
+ } else {
+ if (pe_ar_list_one_member_posix(
+ fdout,minfo) < 0)
+ return PERK_SYSTEM_ERROR(dctx);
+ }
+ }
+ }
+ }
+
+ for (memberp=meta->a_memberv; !members && *memberp; memberp++) {
+ switch ((*memberp)->ar_member_attr) {
+ case AR_MEMBER_ATTR_ARMAP:
+ case AR_MEMBER_ATTR_LINKINFO:
+ case AR_MEMBER_ATTR_NAMESTRS:
+ break;
+
+ default:
+ if (arloc) {
+ if (pe_ar_list_one_member_posix_verbose(
+ fdout,*memberp,fmtstr,arloc) < 0)
+ return PERK_SYSTEM_ERROR(dctx);
+ } else {
+ if (pe_ar_list_one_member_posix(
+ fdout,*memberp) < 0)
+ return PERK_SYSTEM_ERROR(dctx);
+ }
+ }
+ }
+
+ if (arloc)
+ freelocale(arloc);
+
+ return 0;
+}
+
+static int pe_ar_list_one_member_yaml(
+ int fdout,
+ struct ar_meta_member_info * minfo)
+{
+ return pe_dprintf(
+ fdout,
+ " - [ member: %s ]\n",
+ minfo->ar_file_header.ar_member_name);
+}
+
+static int pe_ar_list_one_member_yaml_verbose(
+ int fdout,
+ struct ar_meta_member_info * minfo,
+ locale_t arlocale)
+{
+ time_t artimeval;
+ struct tm artimeloc;
+ char artimestr[64] = {0};
+
+ artimeval = minfo->ar_file_header.ar_time_date_stamp;
+
+ if (localtime_r(&artimeval,&artimeloc))
+ strftime_l(
+ artimestr,sizeof(artimestr),
+ "%Y/%m/%d @ %H:%M",&artimeloc,
+ arlocale);
+
+ return pe_dprintf(
+ fdout,
+ " - Member:\n"
+ " - [ name: " "%s" " ]\n"
+ " - [ timestamp: " "%s" " ]\n"
+ " - [ filesize: " PPRIU64 " ]\n"
+ " - [ uid: " "%d" " ]\n"
+ " - [ gid: " "%d" " ]\n"
+ " - [ mode: " "%d" " ]\n\n",
+ minfo->ar_file_header.ar_member_name,
+ artimestr,
+ minfo->ar_object_size,
+ minfo->ar_file_header.ar_uid,
+ minfo->ar_file_header.ar_gid,
+ minfo->ar_file_header.ar_file_mode);
+}
+
+static int pe_ar_list_members_yaml(
+ const struct pe_driver_ctx * dctx,
+ const struct pe_archive_meta * meta,
+ const struct pe_fd_ctx * fdctx,
+ const char ** members)
+{
+ struct ar_meta_member_info ** memberp;
+ struct ar_meta_member_info * minfo;
+ const char ** pname;
+ int fdout;
+ locale_t arloc;
+
+ fdout = fdctx->fdout;
+ arloc = 0;
+
+ if (dctx->cctx->fmtflags & PERK_PRETTY_VERBOSE) {
+ arloc = newlocale(LC_ALL,setlocale(LC_ALL,0),0);
+ }
+
+ if (pe_dprintf(fdctx->fdout," - Members:\n") < 0)
+ return PERK_SYSTEM_ERROR(dctx);
+
+ for (pname=members; pname && *pname; pname++) {
+ if ((minfo = pe_ar_get_member_info(meta,*pname))) {
+ switch (minfo->ar_member_attr) {
+ case AR_MEMBER_ATTR_ARMAP:
+ case AR_MEMBER_ATTR_LINKINFO:
+ case AR_MEMBER_ATTR_NAMESTRS:
+ break;
+
+ default:
+ if (arloc) {
+ if (pe_ar_list_one_member_yaml_verbose(
+ fdout,minfo,arloc) < 0)
+ return PERK_SYSTEM_ERROR(dctx);
+ } else {
+ if (pe_ar_list_one_member_yaml(
+ fdout,minfo) < 0)
+ return PERK_SYSTEM_ERROR(dctx);
+ }
+ }
+ }
+ }
+
+ for (memberp=meta->a_memberv; !members && *memberp; memberp++) {
+ switch ((*memberp)->ar_member_attr) {
+ case AR_MEMBER_ATTR_ARMAP:
+ case AR_MEMBER_ATTR_LINKINFO:
+ case AR_MEMBER_ATTR_NAMESTRS:
+ break;
+
+ default:
+ if (arloc) {
+ if (pe_ar_list_one_member_yaml_verbose(
+ fdout,*memberp,arloc) < 0)
+ return PERK_SYSTEM_ERROR(dctx);
+ } else {
+ if (pe_ar_list_one_member_yaml(
+ fdout,*memberp) < 0)
+ return PERK_SYSTEM_ERROR(dctx);
+ }
+ }
+ }
+
+ if (arloc)
+ freelocale(arloc);
+
+ return 0;
+}
+
+int pe_ar_list_members(const struct pe_archive_meta * meta, const char ** members)
+{
+ const struct pe_driver_ctx * dctx;
+ struct pe_fd_ctx fdctx;
+
+ const char ** pmember;
+
+ dctx = (pe_archive_meta_ictx(meta))->dctx;
+
+ if (pe_lib_get_driver_fdctx(dctx,&fdctx) < 0)
+ return PERK_NESTED_ERROR(dctx);
+
+ if (members && !members[0])
+ members = 0;
+
+ if (!meta->a_memberv) {
+ for (pmember=members; pmember && *pmember; pmember++)
+ pe_ar_member_not_found(meta,*pmember);
+
+ return members ? 1 : 0;
+ }
+
+ switch (dctx->cctx->fmtflags & PERK_PRETTY_FLAGS) {
+ case PERK_PRETTY_YAML:
+ return pe_ar_list_members_yaml(
+ dctx,meta,&fdctx,members);
+
+ case PERK_PRETTY_POSIX:
+ return pe_ar_list_members_posix(
+ dctx,meta,&fdctx,members);
+
+ default:
+ return pe_ar_list_members_posix(
+ dctx,meta,&fdctx,members);
+ }
+}
diff --git a/src/arbits/output/pe_ar_print_members.c b/src/arbits/output/pe_ar_print_members.c
new file mode 100644
index 0000000..3bdf539
--- /dev/null
+++ b/src/arbits/output/pe_ar_print_members.c
@@ -0,0 +1,181 @@
+/***************************************************************/
+/* perk: PE Resource Kit */
+/* Copyright (C) 2015--2025 SysDeer Technologies, LLC */
+/* Released under GPLv2 and GPLv3; see COPYING.PERK. */
+/***************************************************************/
+
+#include <perk/perk.h>
+#include <perk/perk_output.h>
+#include "perk_driver_impl.h"
+#include "perk_dprintf_impl.h"
+#include "perk_errinfo_impl.h"
+#include "perk_ar_impl.h"
+
+static void pe_ar_member_not_found(
+ const struct pe_archive_meta * meta,
+ const char * name)
+{
+ const struct pe_driver_ctx * dctx;
+ int fderr;
+
+ dctx = (pe_archive_meta_ictx(meta))->dctx;
+
+ if ((fderr = pe_driver_fderr(dctx)) >= 0)
+ pe_dprintf(
+ fderr,
+ "%s: error: member '%s' was not found in the current archive\n",
+ dctx->program,name);
+}
+
+static struct ar_meta_member_info * pe_ar_get_member_info(
+ const struct pe_archive_meta * meta,
+ const char * name)
+{
+ struct ar_meta_member_info ** memberp;
+ const char * slash;
+
+ if ((slash = strrchr(name,'/')))
+ name = ++slash;
+
+ for (memberp=meta->a_memberv; *memberp; memberp++)
+ if (!strcmp(memberp[0]->ar_file_header.ar_member_name,name))
+ return *memberp;
+
+ pe_ar_member_not_found(meta,name);
+
+ return 0;
+}
+
+static int pe_ar_print_one_member_posix(
+ int fdout,
+ const struct pe_driver_ctx * dctx,
+ struct ar_meta_member_info * minfo)
+{
+ ssize_t ret;
+ size_t cnt;
+ const char * ch;
+
+ ret = 0;
+ cnt = minfo->ar_file_header.ar_file_size;
+ ch = minfo->ar_object_data;
+
+ for (; cnt && ret>=0; ) {
+ ch += ret;
+ cnt -= ret;
+
+ ret = write(fdout,ch,cnt);
+
+ while ((ret < 0) && (errno == EINTR))
+ ret = write(fdout,ch,cnt);
+ }
+
+ if (ret < 0)
+ return PERK_SYSTEM_ERROR(dctx);
+
+ return 0;
+}
+
+static int pe_ar_print_one_member_posix_verbose(
+ int fdout,
+ const struct pe_driver_ctx * dctx,
+ struct ar_meta_member_info * minfo,
+ const char * aname)
+{
+ const char * name = aname ? aname : minfo->ar_file_header.ar_member_name;
+
+ if (pe_dprintf(fdout,"\n<%s>\n\n",name) < 0)
+ return PERK_SYSTEM_ERROR(dctx);
+
+ if (pe_ar_print_one_member_posix(fdout,dctx,minfo) < 0)
+ return PERK_NESTED_ERROR(dctx);
+
+ return 0;
+}
+
+static int pe_ar_print_members_posix(
+ const struct pe_driver_ctx * dctx,
+ const struct pe_archive_meta * meta,
+ const struct pe_fd_ctx * fdctx,
+ const char ** members)
+{
+ struct ar_meta_member_info ** memberp;
+ struct ar_meta_member_info * minfo;
+ const char ** pname;
+ int fdout;
+ bool fname;
+
+ fdout = fdctx->fdout;
+ fname = dctx->cctx->fmtflags & PERK_PRETTY_VERBOSE;
+
+ for (pname=members; pname && *pname; pname++) {
+ if ((minfo = pe_ar_get_member_info(meta,*pname))) {
+ switch (minfo->ar_member_attr) {
+ case AR_MEMBER_ATTR_ARMAP:
+ case AR_MEMBER_ATTR_LINKINFO:
+ case AR_MEMBER_ATTR_NAMESTRS:
+ break;
+
+ default:
+ if (fname) {
+ if (pe_ar_print_one_member_posix_verbose(
+ fdout,dctx,minfo,*pname) < 0)
+ return PERK_NESTED_ERROR(dctx);
+ } else {
+ if (pe_ar_print_one_member_posix(
+ fdout,dctx,minfo) < 0)
+ return PERK_NESTED_ERROR(dctx);
+ }
+ }
+ }
+ }
+
+ for (memberp=meta->a_memberv; !members && *memberp; memberp++) {
+ switch ((*memberp)->ar_member_attr) {
+ case AR_MEMBER_ATTR_ARMAP:
+ case AR_MEMBER_ATTR_LINKINFO:
+ case AR_MEMBER_ATTR_NAMESTRS:
+ break;
+
+ default:
+ if (fname) {
+ if (pe_ar_print_one_member_posix_verbose(
+ fdout,dctx,*memberp,0) < 0)
+ return PERK_NESTED_ERROR(dctx);
+ } else {
+ if (pe_ar_print_one_member_posix(
+ fdout,dctx,*memberp) < 0)
+ return PERK_NESTED_ERROR(dctx);
+ }
+ }
+ }
+
+ return 0;
+}
+
+int pe_ar_print_members(const struct pe_archive_meta * meta, const char ** members)
+{
+ const struct pe_driver_ctx * dctx;
+ struct pe_fd_ctx fdctx;
+
+ const char ** pmember;
+
+ dctx = (pe_archive_meta_ictx(meta))->dctx;
+
+ if (pe_lib_get_driver_fdctx(dctx,&fdctx) < 0)
+ return PERK_NESTED_ERROR(dctx);
+
+ if (members && !members[0])
+ members = 0;
+
+ if (!meta->a_memberv) {
+ for (pmember=members; pmember && *pmember; pmember++)
+ pe_ar_member_not_found(meta,*pmember);
+
+ return members ? 1 : 0;
+ }
+
+ if (pe_ar_print_members_posix(dctx,meta,&fdctx,members) < 0)
+ return PERK_NESTED_ERROR(dctx);
+
+ return 0;
+}
diff --git a/src/arbits/pe_archive_meta.c b/src/arbits/pe_archive_meta.c
new file mode 100644
index 0000000..f5fcf0d
--- /dev/null
+++ b/src/arbits/pe_archive_meta.c
@@ -0,0 +1,888 @@
+/***************************************************************/
+/* perk: PE Resource Kit */
+/* Copyright (C) 2015--2025 SysDeer Technologies, LLC */
+/* Released under GPLv2 and GPLv3; see COPYING.PERK. */
+/***************************************************************/
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+
+#include <perk/perk.h>
+#include <perk/perk_arbits.h>
+#include "perk_ar_impl.h"
+#include "perk_driver_impl.h"
+#include "perk_errinfo_impl.h"
+#include "perk_visibility_impl.h"
+
+/* transient header info vector */
+struct ar_header_info {
+ struct ar_raw_file_header * phdr;
+ uint32_t attr;
+};
+
+static const char ar_signature[] = AR_SIGNATURE;
+
+static int pe_ar_free_archive_meta_impl(struct pe_archive_meta_impl * meta, int ret)
+{
+ if (meta) {
+ if (meta->armaps.armap_symrefs_32)
+ free(meta->armaps.armap_symrefs_32);
+
+ if (meta->armaps.armap_symrefs_64)
+ free(meta->armaps.armap_symrefs_64);
+
+ if (meta->hdrinfov)
+ free(meta->hdrinfov);
+
+ if (meta->namestrs)
+ free(meta->namestrs);
+
+ if (meta->syminfo)
+ free(meta->syminfo);
+
+ if (meta->syminfv)
+ free(meta->syminfv);
+
+ if (meta->memberv)
+ free(meta->memberv);
+
+ if (meta->offsetv)
+ free(meta->offsetv);
+
+ if (meta->members)
+ free(meta->members);
+
+ if (meta->symstrv)
+ free(meta->symstrv);
+
+ if (meta->mapstrv)
+ free(meta->mapstrv);
+
+ if (meta->nminfo)
+ (void)0;
+
+ free(meta);
+ }
+
+ return ret;
+}
+
+
+static int pe_ar_read_octal(const char * mark, int len, uint32_t * dec)
+{
+ int i;
+ uint64_t res;
+
+ for (; len && (mark[len-1]==AR_DEC_PADDING); )
+ len--;
+
+ for (i=0,res=0; i<len; i++) {
+ if ((mark[i] >= '0') && (mark[i] <= '7')) {
+ res *= 8;
+ res += (mark[i] - '0');
+ } else {
+ return -1;
+ }
+ }
+
+ *dec = res;
+
+ return 0;
+}
+
+static int pe_ar_read_decimal_64(const char * mark, int len, uint64_t * dec)
+{
+ int i;
+ uint64_t res;
+
+ for (; len && (mark[len-1]==AR_DEC_PADDING); )
+ len--;
+
+ for (i=0,res=0; i<len; i++) {
+ if ((mark[i] >= '0') && (mark[i] <= '9')) {
+ res *= 10;
+ res += (mark[i] - '0');
+ } else {
+ return -1;
+ }
+ }
+
+ *dec = res;
+
+ return 0;
+}
+
+static int pe_ar_read_decimal_32(const char * mark, int len, uint32_t * dec)
+{
+ uint64_t res;
+
+ if (pe_ar_read_decimal_64(mark,len,&res) < 0)
+ return -1;
+
+ *dec = res;
+
+ return 0;
+}
+
+static uint32_t pe_ar_get_member_attr(struct ar_meta_member_info * m)
+{
+ const char * hdrname;
+ uint32_t hdrattr;
+ const char * data;
+ const char * data_cap;
+ const unsigned char * udata;
+ unsigned char uch;
+ const size_t siglen = sizeof(struct ar_raw_signature);
+
+ hdrname = m->ar_file_header.ar_member_name;
+ hdrattr = m->ar_file_header.ar_header_attr;
+
+ data = m->ar_object_data;
+ data_cap = &data[m->ar_file_header.ar_file_size];
+
+ if (hdrattr & AR_HEADER_ATTR_SYSV) {
+ /* long names member? */
+ if ((hdrname[0] == '/') && (hdrname[1] == '/'))
+ return AR_MEMBER_ATTR_NAMESTRS;
+
+ /* mips 64-bit armap member? */
+ else if (!strncmp(hdrname,"/SYM64/",7))
+ return AR_MEMBER_ATTR_ARMAP;
+
+ /* armap member? */
+ else if (hdrname[0] == '/' && (hdrname[1] == '\0'))
+ return AR_MEMBER_ATTR_ARMAP;
+
+ /* nested archive? */
+ else if (m->ar_file_header.ar_file_size >= siglen)
+ if (!strncmp(data,ar_signature,siglen))
+ return AR_MEMBER_ATTR_ARCHIVE;
+
+ } else if (hdrattr & AR_HEADER_ATTR_BSD) {
+ if (!strcmp(hdrname,"__.SYMDEF"))
+ return AR_MEMBER_ATTR_ARMAP;
+
+ else if (!strcmp(hdrname,"__.SYMDEF SORTED"))
+ return AR_MEMBER_ATTR_ARMAP;
+
+ else if (!strcmp(hdrname,"__.SYMDEF_64"))
+ return AR_MEMBER_ATTR_ARMAP;
+
+ else if (!strcmp(hdrname,"__.SYMDEF_64 SORTED"))
+ return AR_MEMBER_ATTR_ARMAP;
+ }
+
+ /* ascii only data? */
+ for (; data<data_cap; ) {
+ if ((uch = *data) >= 0x80)
+ break;
+
+ data++;
+ }
+
+ if (data == data_cap)
+ return AR_MEMBER_ATTR_ASCII;
+
+ data = m->ar_object_data;
+ udata = (unsigned char *)data;
+
+ /* elf object? [quick and dirty] */
+ if (m->ar_file_header.ar_file_size >= 5)
+ if ((udata[0] == 0x7f)
+ && (udata[1] == 'E')
+ && (udata[2] == 'L')
+ && (udata[3] == 'F'))
+ if ((m->ar_object_attr = AR_OBJECT_ATTR_ELF))
+ return AR_MEMBER_ATTR_OBJECT;
+
+ /* coff i386 object? [quick and dirty] */
+ if (m->ar_file_header.ar_file_size >= 2)
+ if ((udata[0] == 0x4c) && (udata[1] == 0x01))
+ if ((m->ar_object_attr = AR_OBJECT_ATTR_COFF))
+ return AR_MEMBER_ATTR_OBJECT;
+
+ /* coff x86_64 object? [quick and dirty] */
+ if (m->ar_file_header.ar_file_size >= 2)
+ if ((udata[0] == 0x64) && (udata[1] == 0x86))
+ if ((m->ar_object_attr = AR_OBJECT_ATTR_COFF))
+ return AR_MEMBER_ATTR_OBJECT;
+
+ /* big endian 32-bit macho object? [quick and dirty] */
+ if (m->ar_file_header.ar_file_size >= 4)
+ if ((udata[0] == 0xfe) && (udata[1] == 0xed))
+ if ((udata[2] == 0xfa) && (udata[3] == 0xce))
+ if ((m->ar_object_attr = AR_OBJECT_ATTR_MACHO))
+ return AR_MEMBER_ATTR_OBJECT;
+
+ /* big endian 64-bit macho object? [quick and dirty] */
+ if (m->ar_file_header.ar_file_size >= 4)
+ if ((udata[0] == 0xfe) && (udata[1] == 0xed))
+ if ((udata[2] == 0xfa) && (udata[3] == 0xcf))
+ if ((m->ar_object_attr = AR_OBJECT_ATTR_MACHO))
+ return AR_MEMBER_ATTR_OBJECT;
+
+ /* little endian 32-bit macho object? [quick and dirty] */
+ if (m->ar_file_header.ar_file_size >= 4)
+ if ((udata[3] == 0xfe) && (udata[2] == 0xed))
+ if ((udata[1] == 0xfa) && (udata[0] == 0xce))
+ if ((m->ar_object_attr = AR_OBJECT_ATTR_MACHO))
+ return AR_MEMBER_ATTR_OBJECT;
+
+ /* little endian 64-bit macho object? [quick and dirty] */
+ if (m->ar_file_header.ar_file_size >= 4)
+ if ((udata[3] == 0xfe) && (udata[2] == 0xed))
+ if ((udata[1] == 0xfa) && (udata[0] == 0xcf))
+ if ((m->ar_object_attr = AR_OBJECT_ATTR_MACHO))
+ return AR_MEMBER_ATTR_OBJECT;
+
+ /* all other */
+ return AR_MEMBER_ATTR_DEFAULT;
+}
+
+static int pe_ar_parse_primary_armap(
+ const struct pe_driver_ctx * dctx,
+ struct pe_archive_meta_impl * m)
+
+{
+ struct ar_meta_member_info * memberp;
+ const char * hdrname;
+ uint32_t hdrattr;
+
+ memberp = m->memberv[0];
+ hdrname = memberp->ar_file_header.ar_member_name;
+ hdrattr = memberp->ar_file_header.ar_header_attr;
+
+ if (!(memberp->ar_member_attr & AR_MEMBER_ATTR_ARMAP))
+ return 0;
+
+ if (hdrattr & AR_HEADER_ATTR_SYSV) {
+ /* mips 64-bit armap member? */
+ if (!strncmp(hdrname,"/SYM64/",7))
+ return pe_ar_parse_primary_armap_sysv_64(
+ dctx,m);
+
+ /* sysv 32-bit armap member */
+ return pe_ar_parse_primary_armap_sysv_32(
+ dctx,m);
+
+ } else if (hdrattr & AR_HEADER_ATTR_BSD) {
+ if (!strcmp(hdrname,"__.SYMDEF"))
+ return pe_ar_parse_primary_armap_bsd_32(
+ dctx,m);
+
+ else if (!strcmp(hdrname,"__.SYMDEF SORTED"))
+ return pe_ar_parse_primary_armap_bsd_32(
+ dctx,m);
+
+ else if (!strcmp(hdrname,"__.SYMDEF_64"))
+ return pe_ar_parse_primary_armap_bsd_64(
+ dctx,m);
+
+ else if (!strcmp(hdrname,"__.SYMDEF_64 SORTED"))
+ return pe_ar_parse_primary_armap_bsd_64(
+ dctx,m);
+ }
+
+ return PERK_CUSTOM_ERROR(dctx,PERK_ERR_FLOW_ERROR);
+}
+
+perk_hidden struct ar_meta_member_info * pe_archive_member_from_offset(
+ struct pe_archive_meta_impl * meta,
+ off_t offset)
+{
+ intptr_t l,r,m;
+ off_t * offsetv;
+
+ l = 0;
+ r = meta->nentries - 1;
+
+ offsetv = meta->offsetv;
+
+ while (l != r) {
+ m = (l + r) / 2;
+ m += (l + r) % 2;
+
+ if (offsetv[m] > offset) {
+ r = --m;
+ } else {
+ l = m;
+ }
+ }
+
+ return (offsetv[l] == offset) ? meta->memberv[l] : 0;
+}
+
+int pe_ar_get_archive_meta(
+ const struct pe_driver_ctx * dctx,
+ const struct pe_raw_archive * archive,
+ struct pe_archive_meta ** meta)
+{
+ const char * mark;
+ const char * cap;
+ struct pe_archive_meta_impl * m;
+ const char * slash;
+ const char * ch;
+ const char * fldcap;
+ size_t nelements;
+ uint64_t nentries;
+ uint64_t nmembers;
+ uint64_t stblsize;
+ uint64_t filesize;
+ uint64_t namelen;
+ uint64_t nameoff;
+ uint32_t attr;
+ void * s_addr;
+ void * m_addr;
+ const char * s_ptr;
+ const char * m_ptr;
+ struct ar_raw_file_header * arhdr;
+ struct ar_raw_file_header * arlongnames;
+ struct ar_meta_member_info * memberp;
+ char * longnamep;
+ size_t idx;
+ struct ar_meta_armap_ref_32 * symrefs_32;
+ struct ar_meta_armap_ref_64 * symrefs_64;
+ struct ar_header_info * hdrinfov;
+ struct ar_header_info * hdrinfov_cap;
+ struct ar_header_info * hdrinfov_next;
+ struct ar_header_info hdrinfobuf[AR_STACK_VECTOR_ELEMENTS];
+
+ /* init */
+ hdrinfov = hdrinfobuf;
+ hdrinfov_cap = &hdrinfobuf[AR_STACK_VECTOR_ELEMENTS];
+ nelements = AR_STACK_VECTOR_ELEMENTS;
+
+ memset(hdrinfobuf,0,sizeof(hdrinfobuf));
+
+ mark = archive->map_addr;
+ cap = &mark[archive->map_size];
+
+ /* preliminary validation */
+ if (archive->map_size < sizeof(struct ar_raw_signature))
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_SIGNATURE);
+
+ else if (strncmp(mark,ar_signature,sizeof(struct ar_raw_signature)))
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_SIGNATURE);
+
+ /* alloc */
+ if (!(m = calloc(1,sizeof(*m))))
+ return PERK_SYSTEM_ERROR(dctx);
+
+ /* associated driver context */
+ m->dctx = dctx;
+
+ /* archive map info */
+ m->armeta.r_archive.map_addr = archive->map_addr;
+ m->armeta.r_archive.map_size = archive->map_size;
+
+ /* archive signature */
+ m->armeta.r_signature = (struct ar_raw_signature *)mark;
+ m->armeta.m_signature = (struct ar_meta_signature *)ar_signature;
+
+ /* signature only? */
+ if (archive->map_size == sizeof(struct ar_raw_signature)) {
+ *meta = &m->armeta;
+ return 0;
+ }
+
+ mark += sizeof(struct ar_raw_signature);
+
+ /* only trailing null characters past the signature? */
+ if (cap < &mark[sizeof(*arhdr)])
+ for (ch=mark; ch<cap; ch++)
+ if (*ch)
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_HEADER));
+
+ /* count entries, calculate string table size */
+ for (nentries=0,stblsize=0,arlongnames=0; mark<cap; nentries++) {
+ arhdr = (struct ar_raw_file_header *)mark;
+
+ /* file size */
+ if ((pe_ar_read_decimal_64(
+ arhdr->ar_file_size,
+ sizeof(arhdr->ar_file_size),
+ &filesize)) < 0)
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_HEADER));
+
+ mark += sizeof(struct ar_raw_file_header);
+
+ /* stblsize, member name type */
+ fldcap = &arhdr->ar_file_id[sizeof(arhdr->ar_file_id)];
+
+ /* sysv long names table? */
+ if ((arhdr->ar_file_id[0] == '/') && (arhdr->ar_file_id[1] == '/')) {
+ for (ch=&arhdr->ar_file_id[2]; ch<fldcap; ch++)
+ if (*ch != AR_DEC_PADDING)
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_HEADER));
+
+ if (pe_ar_read_decimal_64(
+ arhdr->ar_file_size,
+ sizeof(arhdr->ar_file_size),
+ &namelen) < 0)
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_HEADER));
+
+
+ /* duplicate long names member? */
+ if (arlongnames)
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_DUPLICATE_LONG_NAMES));
+
+ attr = AR_HEADER_ATTR_FILE_ID | AR_HEADER_ATTR_SYSV;
+
+ stblsize++;
+ stblsize++;
+ stblsize++;
+
+ stblsize += namelen;
+
+ arlongnames = arhdr;
+
+ /* the /SYM64/ string must be special cased, also below when it gets copied */
+ } else if (!strncmp(arhdr->ar_file_id,"/SYM64/",7)) {
+ for (ch=&arhdr->ar_file_id[7]; ch<fldcap; ch++)
+ if (*ch != AR_DEC_PADDING)
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_HEADER));
+
+ attr = AR_HEADER_ATTR_FILE_ID | AR_HEADER_ATTR_SYSV;
+ stblsize += 8;
+
+ /* sysv armap member or sysv long name reference? */
+ } else if (arhdr->ar_file_id[0] == '/') {
+ if (pe_ar_read_decimal_64(
+ &arhdr->ar_file_id[1],
+ sizeof(arhdr->ar_file_id)-1,
+ &nameoff) < 0)
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_HEADER));
+
+ if (arhdr->ar_file_id[1] == AR_DEC_PADDING) {
+ attr = AR_HEADER_ATTR_FILE_ID | AR_HEADER_ATTR_SYSV;
+ stblsize++;
+ stblsize++;
+ } else {
+ attr = AR_HEADER_ATTR_NAME_REF | AR_HEADER_ATTR_SYSV;
+ }
+
+ /* bsd long name reference? */
+ } else if ((arhdr->ar_file_id[0] == '#')
+ && (arhdr->ar_file_id[1] == '1')
+ && (arhdr->ar_file_id[2] == '/')) {
+ if (pe_ar_read_decimal_64(
+ &arhdr->ar_file_id[3],
+ sizeof(arhdr->ar_file_id)-3,
+ &namelen) < 0)
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_HEADER));
+
+ attr = AR_HEADER_ATTR_NAME_REF | AR_HEADER_ATTR_BSD;
+
+ stblsize += namelen + 1;
+
+ /* must be either a sysv short member name, or a (legacy) bsd short name */
+ } else {
+ for (ch=arhdr->ar_file_id,slash=0; (ch<fldcap) && !slash; ch++)
+ if (*ch == '/')
+ slash = ch;
+
+ if (slash) {
+ attr = AR_HEADER_ATTR_FILE_ID | AR_HEADER_ATTR_SYSV;
+ stblsize += (slash - arhdr->ar_file_id) + 1;
+ } else {
+ attr = AR_HEADER_ATTR_FILE_ID | AR_HEADER_ATTR_BSD;
+ stblsize += sizeof(arhdr->ar_file_id) + 1;
+ }
+
+ for (; ch<fldcap; )
+ if (*ch++ != AR_DEC_PADDING)
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_HEADER));
+
+ }
+
+ /* truncated data? */
+ if (cap < &mark[filesize])
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_TRUNCATED_DATA));
+
+ /* ar member alignment */
+ filesize += 1;
+ filesize |= 1;
+ filesize ^= 1;
+
+ mark += filesize;
+
+ /* only trailing null characters past the signature? */
+ if (cap < &mark[sizeof(*arhdr)])
+ for (; mark<cap; )
+ if (*mark++)
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_HEADER));
+
+ /* transient header info vector */
+ if (&hdrinfov[nentries] == hdrinfov_cap) {
+ nelements = (nelements == AR_STACK_VECTOR_ELEMENTS)
+ ? (nelements << 4) : (nelements << 1);
+
+ if (!(hdrinfov_next = calloc(nelements,sizeof(*hdrinfov))))
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_TRUNCATED_DATA));
+
+ for (idx=0; idx<nentries; idx++) {
+ hdrinfov_next[idx].phdr = hdrinfov[idx].phdr;
+ hdrinfov_next[idx].attr = hdrinfov[idx].attr;
+ };
+
+ if (hdrinfov != hdrinfobuf)
+ free(hdrinfov);
+
+ hdrinfov = hdrinfov_next;
+ hdrinfov_cap = &hdrinfov_next[nelements];
+ m->hdrinfov = hdrinfov;
+ }
+
+ hdrinfov[nentries].phdr = arhdr;
+ hdrinfov[nentries].attr = attr;
+ }
+
+ /* allocate name strings, member vector */
+ if (!(m->namestrs = calloc(1,stblsize)))
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_SYSTEM_ERROR(dctx));
+
+ if (!(m->offsetv = calloc(nentries+1,sizeof(*m->offsetv))))
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_SYSTEM_ERROR(dctx));
+
+ if (!(m->memberv = calloc(nentries+1,sizeof(*m->memberv))))
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_SYSTEM_ERROR(dctx));
+
+ if (!(m->members = calloc(nentries,sizeof(*m->members))))
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_SYSTEM_ERROR(dctx));
+
+ /* archive signature reference */
+ s_addr = archive->map_addr;
+ s_ptr = s_addr;
+
+ /* iterate, store meta data in library-friendly form */
+ for (idx=0,longnamep=m->namestrs; idx<nentries; idx++) {
+ arhdr = hdrinfov[idx].phdr;
+ attr = hdrinfov[idx].attr;
+
+ m_addr = arhdr;
+ m_ptr = m_addr;
+
+ memberp = &m->members[idx];
+ m->offsetv[idx] = m_ptr - s_ptr;
+ m->memberv[idx] = memberp;
+
+ memberp->ar_file_header.ar_header_attr = attr;
+
+ pe_ar_read_decimal_64(
+ arhdr->ar_time_date_stamp,
+ sizeof(arhdr->ar_time_date_stamp),
+ &memberp->ar_file_header.ar_time_date_stamp);
+
+ pe_ar_read_decimal_32(
+ arhdr->ar_uid,
+ sizeof(arhdr->ar_uid),
+ &memberp->ar_file_header.ar_uid);
+
+ pe_ar_read_decimal_32(
+ arhdr->ar_gid,
+ sizeof(arhdr->ar_gid),
+ &memberp->ar_file_header.ar_gid);
+
+ pe_ar_read_octal(
+ arhdr->ar_file_mode,
+ sizeof(arhdr->ar_file_mode),
+ &memberp->ar_file_header.ar_file_mode);
+
+ pe_ar_read_decimal_64(
+ arhdr->ar_file_size,
+ sizeof(arhdr->ar_file_size),
+ &memberp->ar_file_header.ar_file_size);
+
+ memberp->ar_file_header.ar_member_name = longnamep;
+
+ if (attr == (AR_HEADER_ATTR_FILE_ID | AR_HEADER_ATTR_SYSV)) {
+ if ((arhdr->ar_file_id[0] == '/') && (arhdr->ar_file_id[1] == '/')) {
+ *longnamep++ = '/';
+ *longnamep++ = '/';
+ longnamep++;
+
+ } else if ((arhdr->ar_file_id[0] == '/') && (arhdr->ar_file_id[1] == 'S')) {
+ *longnamep++ = '/';
+ *longnamep++ = 'S';
+ *longnamep++ = 'Y';
+ *longnamep++ = 'M';
+ *longnamep++ = '6';
+ *longnamep++ = '4';
+ *longnamep++ = '/';
+ longnamep++;
+
+ } else if (arhdr->ar_file_id[0] == '/') {
+ *longnamep++ = '/';
+ longnamep++;
+
+ } else {
+ ch = arhdr->ar_file_id;
+
+ for (; (*ch != '/'); )
+ *longnamep++ = *ch++;
+
+ longnamep++;
+ }
+
+ } else if (attr == (AR_HEADER_ATTR_FILE_ID | AR_HEADER_ATTR_BSD)) {
+ ch = arhdr->ar_file_id;
+ fldcap = &ch[sizeof(arhdr->ar_file_id)];
+
+ for (; (ch<fldcap) && (*ch != AR_DEC_PADDING); )
+ *longnamep++ = *ch++;
+
+ longnamep++;
+
+ } else if (attr == (AR_HEADER_ATTR_NAME_REF | AR_HEADER_ATTR_SYSV)) {
+ pe_ar_read_decimal_64(
+ &arhdr->ar_file_id[1],
+ sizeof(arhdr->ar_file_id) - 1,
+ &nameoff);
+
+ ch = arlongnames->ar_file_id;
+ ch += sizeof(*arlongnames);
+ ch += nameoff;
+
+ for (; *ch && (*ch != '/') && (*ch != AR_OBJ_PADDING); )
+ *longnamep++ = *ch++;
+
+ longnamep++;
+
+ } else if (attr == (AR_HEADER_ATTR_NAME_REF | AR_HEADER_ATTR_BSD)) {
+ pe_ar_read_decimal_64(
+ &arhdr->ar_file_id[3],
+ sizeof(arhdr->ar_file_id) - 3,
+ &namelen);
+
+ mark = arhdr->ar_file_id;
+ mark += sizeof(*arhdr);
+
+ memcpy(longnamep,mark,namelen);
+
+ longnamep += namelen;
+ longnamep++;
+ }
+
+ /* member raw header, object size, object data */
+ mark = arhdr->ar_file_id;
+ mark += sizeof(*arhdr);
+ namelen = 0;
+
+ if (attr == (AR_HEADER_ATTR_NAME_REF | AR_HEADER_ATTR_BSD)) {
+ pe_ar_read_decimal_64(
+ &arhdr->ar_file_id[3],
+ sizeof(arhdr->ar_file_id)-3,
+ &namelen);
+
+ namelen += 1;
+ namelen |= 1;
+ namelen ^= 1;
+
+ mark += namelen;
+ };
+
+ memberp->ar_member_data = arhdr;
+ memberp->ar_object_data = (void *)mark;
+ memberp->ar_object_size = memberp->ar_file_header.ar_file_size - namelen;
+
+ /* member attribute */
+ memberp->ar_member_attr = pe_ar_get_member_attr(memberp);
+
+ /* pe/coff second linker member? */
+ if ((idx == 1) && (memberp->ar_member_attr == AR_MEMBER_ATTR_ARMAP))
+ if (hdrinfov[0].attr & AR_HEADER_ATTR_SYSV)
+ if (m->members[0].ar_member_attr == AR_MEMBER_ATTR_ARMAP)
+ if (attr & AR_HEADER_ATTR_SYSV)
+ memberp->ar_member_attr = AR_MEMBER_ATTR_LINKINFO;
+
+ /* armap member must be the first */
+ if ((memberp->ar_member_attr == AR_MEMBER_ATTR_ARMAP) && (idx > 0)) {
+ if (m->members[0].ar_member_attr == AR_MEMBER_ATTR_ARMAP)
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_DUPLICATE_ARMAP_MEMBER));
+
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_MISPLACED_ARMAP_MEMBER));
+ }
+ }
+
+ /* number of archive members, including internal ones */
+ m->nentries = nentries;
+
+ /* primary armap (first linker member) */
+ if (pe_ar_parse_primary_armap(dctx,m) < 0)
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_NESTED_ERROR(dctx));
+
+ for (idx=0,ch=m->symstrs; idx<m->armaps.armap_nsyms; idx++) {
+ m->symstrv[idx] = ch;
+ ch += strlen(ch);
+ ch++;
+ }
+
+ if (m->armaps.armap_common_32.ar_member) {
+ symrefs_32 = m->armaps.armap_symrefs_32;
+
+ for (idx=0; idx<m->armaps.armap_nsyms; idx++) {
+ if (m->armaps.armap_common_32.ar_armap_attr & AR_ARMAP_ATTR_SYSV)
+ symrefs_32[idx].ar_name_offset = m->symstrv[idx] - m->symstrv[0];
+
+ if (!pe_archive_member_from_offset(m,symrefs_32[idx].ar_member_offset))
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_MEMBER_OFFSET));
+
+ if (symrefs_32[idx].ar_name_offset) {
+ ch = &m->symstrs[symrefs_32[idx].ar_name_offset];
+
+ if ((ch > m->symstrv[m->armaps.armap_nsyms - 1]) || *--ch)
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_NAME_OFFSET));
+ }
+
+ }
+ }
+
+ if (m->armaps.armap_common_64.ar_member) {
+ symrefs_64 = m->armaps.armap_symrefs_64;
+
+ for (idx=0; idx<m->armaps.armap_nsyms; idx++) {
+ if (m->armaps.armap_common_64.ar_armap_attr & AR_ARMAP_ATTR_SYSV)
+ symrefs_64[idx].ar_name_offset = m->symstrv[idx] - m->symstrv[0];
+
+ if (!pe_archive_member_from_offset(m,symrefs_64[idx].ar_member_offset))
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_MEMBER_OFFSET));
+
+ if (symrefs_64[idx].ar_name_offset) {
+ ch = &m->symstrs[symrefs_64[idx].ar_name_offset];
+
+ if ((ch > m->symstrv[m->armaps.armap_nsyms - 1]) || *--ch)
+ return pe_ar_free_archive_meta_impl(
+ m,PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_NAME_OFFSET));
+ }
+
+ }
+ }
+
+ /* number of public archive members */
+ for (idx=0,nmembers=0; idx<nentries; idx++) {
+ switch (m->memberv[idx]->ar_member_attr) {
+ case AR_MEMBER_ATTR_ARMAP:
+ case AR_MEMBER_ATTR_LINKINFO:
+ case AR_MEMBER_ATTR_NAMESTRS:
+ break;
+
+ default:
+ nmembers++;
+ }
+ }
+
+ if (m->armaps.armap_common_32.ar_member)
+ m->armaps.armap_common_32.ar_num_of_members = nmembers;
+
+ if (m->armaps.armap_common_64.ar_member)
+ m->armaps.armap_common_64.ar_num_of_members = nmembers;
+
+ /* pe/coff armap attributes (second linker member) */
+ (void)m->armeta.a_armap_pecoff;
+
+ /* reference to the long names member */
+ if (arlongnames)
+ for (idx=0; idx<nentries && !m->armeta.a_arref_longnames; idx++)
+ if (m->memberv[idx]->ar_member_data == arlongnames)
+ m->armeta.a_arref_longnames = m->memberv[idx];
+
+ /* common binary format (information only) */
+ for (idx=0,nmembers=0; idx<nentries; idx++) {
+ if (m->memberv[idx]->ar_member_attr == AR_MEMBER_ATTR_OBJECT) {
+ if (m->ofmtattr && (m->ofmtattr != m->memberv[idx]->ar_object_attr)) {
+ m->ofmtattr = 0;
+ idx = nentries;
+ } else if (!m->ofmtattr) {
+ m->ofmtattr = m->memberv[idx]->ar_object_attr;
+ }
+ }
+ }
+
+ /* member vector */
+ m->armeta.a_memberv = m->memberv;
+
+ /* all done */
+ if (m->hdrinfov) {
+ free(m->hdrinfov);
+ m->hdrinfov = 0;
+ }
+
+ *meta = &m->armeta;
+
+ return 0;
+}
+
+void pe_ar_free_archive_meta(struct pe_archive_meta * meta)
+{
+ struct pe_archive_meta_impl * m;
+
+ if (meta) {
+ m = pe_archive_meta_ictx(meta);
+ pe_ar_free_archive_meta_impl(m,0);
+ }
+}
diff --git a/src/arbits/pe_armap_bsd_32.c b/src/arbits/pe_armap_bsd_32.c
new file mode 100644
index 0000000..fdbc3a0
--- /dev/null
+++ b/src/arbits/pe_armap_bsd_32.c
@@ -0,0 +1,157 @@
+/***************************************************************/
+/* perk: PE Resource Kit */
+/* Copyright (C) 2015--2025 SysDeer Technologies, LLC */
+/* Released under GPLv2 and GPLv3; see COPYING.PERK. */
+/***************************************************************/
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <perk/perk.h>
+#include <perk/perk_arbits.h>
+#include "perk_ar_impl.h"
+#include "perk_driver_impl.h"
+#include "perk_errinfo_impl.h"
+#include "perk_visibility_impl.h"
+
+perk_hidden int pe_ar_parse_primary_armap_bsd_32(
+ const struct pe_driver_ctx * dctx,
+ struct pe_archive_meta_impl * m)
+
+{
+ struct ar_raw_armap_bsd_32 * armap;
+ struct ar_meta_member_info * memberp;
+ struct ar_meta_armap_common_32 *armapref;
+ struct ar_meta_armap_ref_32 * symrefs;
+ uint32_t idx;
+ uint32_t uref;
+ uint32_t attr;
+ uint32_t nsyms;
+ uint32_t nstrs;
+ uint32_t sizeofrefs_le;
+ uint32_t sizeofrefs_be;
+ uint32_t sizeofrefs;
+ uint32_t sizeofstrs;
+ const char * ch;
+ const char * cap;
+ unsigned char * uch;
+ unsigned char (*mark)[0x04];
+
+ armap = &m->armaps.armap_bsd_32;
+ memberp = m->memberv[0];
+
+ mark = memberp->ar_object_data;
+
+ armap->ar_size_of_refs = mark;
+ uch = *mark++;
+
+ armap->ar_first_name_offset = mark;
+
+ sizeofrefs_le = (uch[3] << 24) + (uch[2] << 16) + (uch[1] << 8) + uch[0];
+ sizeofrefs_be = (uch[0] << 24) + (uch[1] << 16) + (uch[2] << 8) + uch[3];
+
+ if (sizeofrefs_le < memberp->ar_object_size - sizeof(*mark)) {
+ sizeofrefs = sizeofrefs_le;
+ attr = AR_ARMAP_ATTR_LE_32;
+
+ } else if (sizeofrefs_be < memberp->ar_object_size - sizeof(*mark)) {
+ sizeofrefs = sizeofrefs_be;
+ attr = AR_ARMAP_ATTR_BE_32;
+ } else {
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_SIZE_OF_REFS);
+ }
+
+ nsyms = sizeofrefs / sizeof(struct ar_raw_armap_ref_32);
+ mark += (sizeofrefs / sizeof(*mark));
+
+ armap->ar_size_of_strs = mark;
+ uch = *mark++;
+
+ sizeofstrs = (attr == AR_ARMAP_ATTR_LE_32)
+ ? (uch[3] << 24) + (uch[2] << 16) + (uch[1] << 8) + uch[0]
+ : (uch[0] << 24) + (uch[1] << 16) + (uch[2] << 8) + uch[3];
+
+ if (sizeofstrs > memberp->ar_object_size - 2*sizeof(*mark) - sizeofrefs)
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_SIZE_OF_STRS);
+
+ m->symstrs = (const char *)mark;
+
+ cap = m->symstrs;
+ cap += sizeofstrs;
+
+ if ((cap == m->symstrs) && nsyms)
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_STRING_TABLE);
+
+ if (nsyms && !m->symstrs[0])
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_STRING_TABLE);
+
+ for (ch=&m->symstrs[1],nstrs=0; ch<cap; ch++) {
+ if (!ch[0] && !ch[-1] && (nstrs < nsyms))
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_STRING_TABLE);
+
+ if (!ch[0] && ch[-1] && (nstrs < nsyms))
+ nstrs++;
+ }
+
+ if (nstrs != nsyms)
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_STRING_TABLE);
+
+ if (!(m->symstrv = calloc(nsyms + 1,sizeof(const char *))))
+ return PERK_SYSTEM_ERROR(dctx);
+
+ if (!(m->armaps.armap_symrefs_32 = calloc(nsyms + 1,sizeof(*symrefs))))
+ return PERK_SYSTEM_ERROR(dctx);
+
+ mark = armap->ar_first_name_offset;
+ symrefs = m->armaps.armap_symrefs_32;
+
+ for (idx=0; idx<nsyms; idx++) {
+ uch = *mark++;
+
+ uref = (attr == AR_ARMAP_ATTR_BE_32)
+ ? (uch[0] << 24) + (uch[1] << 16) + (uch[2] << 8) + uch[3]
+ : (uch[3] << 24) + (uch[2] << 16) + (uch[1] << 8) + uch[0];
+
+ symrefs[idx].ar_name_offset = uref;
+
+ uch = *mark++;
+
+ uref = (attr == AR_ARMAP_ATTR_BE_32)
+ ? (uch[0] << 24) + (uch[1] << 16) + (uch[2] << 8) + uch[3]
+ : (uch[3] << 24) + (uch[2] << 16) + (uch[1] << 8) + uch[0];
+
+ symrefs[idx].ar_member_offset = uref;
+ }
+
+ armap->ar_string_table = m->symstrv;
+
+ armapref = &m->armaps.armap_common_32;
+ armapref->ar_member = memberp;
+ armapref->ar_symrefs = symrefs;
+ armapref->ar_armap_bsd = armap;
+ armapref->ar_armap_attr = AR_ARMAP_ATTR_BSD | attr;
+ armapref->ar_num_of_symbols = nsyms;
+ armapref->ar_size_of_refs = sizeofrefs;
+ armapref->ar_size_of_strs = sizeofstrs;
+ armapref->ar_string_table = m->symstrs;
+
+ m->armaps.armap_nsyms = nsyms;
+
+ m->armeta.a_armap_primary.ar_armap_common_32 = armapref;
+
+ return 0;
+}
diff --git a/src/arbits/pe_armap_bsd_64.c b/src/arbits/pe_armap_bsd_64.c
new file mode 100644
index 0000000..fc61eb2
--- /dev/null
+++ b/src/arbits/pe_armap_bsd_64.c
@@ -0,0 +1,174 @@
+/***************************************************************/
+/* perk: PE Resource Kit */
+/* Copyright (C) 2015--2025 SysDeer Technologies, LLC */
+/* Released under GPLv2 and GPLv3; see COPYING.PERK. */
+/***************************************************************/
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <perk/perk.h>
+#include <perk/perk_arbits.h>
+#include "perk_ar_impl.h"
+#include "perk_driver_impl.h"
+#include "perk_errinfo_impl.h"
+#include "perk_visibility_impl.h"
+
+perk_hidden int pe_ar_parse_primary_armap_bsd_64(
+ const struct pe_driver_ctx * dctx,
+ struct pe_archive_meta_impl * m)
+{
+ struct ar_raw_armap_bsd_64 * armap;
+ struct ar_meta_member_info * memberp;
+ struct ar_meta_armap_common_64 *armapref;
+ struct ar_meta_armap_ref_64 * symrefs;
+ uint64_t idx;
+ uint64_t uref_hi;
+ uint64_t uref_lo;
+ uint32_t attr;
+ uint64_t u64_lo;
+ uint64_t u64_hi;
+ uint64_t nsyms;
+ uint64_t nstrs;
+ uint64_t sizeofrefs_le;
+ uint64_t sizeofrefs_be;
+ uint64_t sizeofrefs;
+ uint64_t sizeofstrs;
+ const char * ch;
+ const char * cap;
+ unsigned char * uch;
+ unsigned char (*mark)[0x08];
+
+ armap = &m->armaps.armap_bsd_64;
+ memberp = m->memberv[0];
+
+ mark = memberp->ar_object_data;
+
+ armap->ar_size_of_refs = mark;
+ uch = *mark++;
+
+ armap->ar_first_name_offset = mark;
+
+ u64_lo = (uch[3] << 24) + (uch[2] << 16) + (uch[1] << 8) + uch[0];
+ u64_hi = (uch[7] << 24) + (uch[6] << 16) + (uch[5] << 8) + uch[4];
+
+ sizeofrefs_le = u64_lo + (u64_hi << 32);
+
+ u64_hi = (uch[0] << 24) + (uch[1] << 16) + (uch[2] << 8) + uch[3];
+ u64_lo = (uch[4] << 24) + (uch[5] << 16) + (uch[6] << 8) + uch[7];
+
+ sizeofrefs_be = (u64_hi << 32) + u64_lo;
+
+ if (sizeofrefs_le < memberp->ar_object_size - sizeof(*mark)) {
+ sizeofrefs = sizeofrefs_le;
+ attr = AR_ARMAP_ATTR_LE_64;
+
+ } else if (sizeofrefs_be < memberp->ar_object_size - sizeof(*mark)) {
+ sizeofrefs = sizeofrefs_be;
+ attr = AR_ARMAP_ATTR_BE_64;
+ } else {
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_SIZE_OF_REFS);
+ }
+
+ nsyms = sizeofrefs / sizeof(struct ar_raw_armap_ref_64);
+ mark += (sizeofrefs / sizeof(*mark));
+
+ armap->ar_size_of_strs = mark;
+ uch = *mark++;
+
+ if (attr == AR_ARMAP_ATTR_LE_64) {
+ u64_lo = (uch[3] << 24) + (uch[2] << 16) + (uch[1] << 8) + uch[0];
+ u64_hi = (uch[7] << 24) + (uch[6] << 16) + (uch[5] << 8) + uch[4];
+ } else {
+ u64_hi = (uch[0] << 24) + (uch[1] << 16) + (uch[2] << 8) + uch[3];
+ u64_lo = (uch[4] << 24) + (uch[5] << 16) + (uch[6] << 8) + uch[7];
+ }
+
+ sizeofstrs = u64_lo + (u64_hi << 32);
+ m->symstrs = (const char *)mark;
+
+ cap = m->symstrs;
+ cap += sizeofstrs;
+
+ if ((cap == m->symstrs) && nsyms)
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_STRING_TABLE);
+
+ if (nsyms && !m->symstrs[0])
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_STRING_TABLE);
+
+ for (ch=&m->symstrs[1],nstrs=0; ch<cap; ch++) {
+ if (!ch[0] && !ch[-1] && (nstrs < nsyms))
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_STRING_TABLE);
+
+ if (!ch[0] && ch[-1] && (nstrs < nsyms))
+ nstrs++;
+ }
+
+ if (nstrs != nsyms)
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_STRING_TABLE);
+
+ if (!(m->symstrv = calloc(nsyms + 1,sizeof(const char *))))
+ return PERK_SYSTEM_ERROR(dctx);
+
+ if (!(m->armaps.armap_symrefs_64 = calloc(nsyms + 1,sizeof(*symrefs))))
+ return PERK_SYSTEM_ERROR(dctx);
+
+ mark = armap->ar_first_name_offset;
+ symrefs = m->armaps.armap_symrefs_64;
+
+ for (idx=0; idx<nsyms; idx++) {
+ uch = *mark++;
+
+ if (attr == AR_ARMAP_ATTR_BE_64) {
+ uref_hi = (uch[0] << 24) + (uch[1] << 16) + (uch[2] << 8) + uch[3];
+ uref_lo = (uch[4] << 24) + (uch[5] << 16) + (uch[6] << 8) + uch[7];
+ } else {
+ uref_lo = (uch[3] << 24) + (uch[2] << 16) + (uch[1] << 8) + uch[0];
+ uref_hi = (uch[7] << 24) + (uch[6] << 16) + (uch[5] << 8) + uch[4];
+ }
+
+ symrefs[idx].ar_name_offset = (uref_hi << 32) + uref_lo;
+
+ uch = *mark++;
+
+ if (attr == AR_ARMAP_ATTR_BE_64) {
+ uref_hi = (uch[0] << 24) + (uch[1] << 16) + (uch[2] << 8) + uch[3];
+ uref_lo = (uch[4] << 24) + (uch[5] << 16) + (uch[6] << 8) + uch[7];
+ } else {
+ uref_lo = (uch[3] << 24) + (uch[2] << 16) + (uch[1] << 8) + uch[0];
+ uref_hi = (uch[7] << 24) + (uch[6] << 16) + (uch[5] << 8) + uch[4];
+ }
+
+ symrefs[idx].ar_member_offset = (uref_hi << 32) + uref_lo;
+ }
+
+ armap->ar_string_table = m->symstrv;
+
+ armapref = &m->armaps.armap_common_64;
+ armapref->ar_member = memberp;
+ armapref->ar_symrefs = symrefs;
+ armapref->ar_armap_bsd = armap;
+ armapref->ar_armap_attr = AR_ARMAP_ATTR_BSD | attr;
+ armapref->ar_num_of_symbols = nsyms;
+ armapref->ar_size_of_refs = sizeofrefs;
+ armapref->ar_size_of_strs = sizeofstrs;
+ armapref->ar_string_table = m->symstrs;
+
+ m->armaps.armap_nsyms = nsyms;
+
+ m->armeta.a_armap_primary.ar_armap_common_64 = armapref;
+
+ return 0;
+}
diff --git a/src/arbits/pe_armap_sysv_32.c b/src/arbits/pe_armap_sysv_32.c
new file mode 100644
index 0000000..91fd5ec
--- /dev/null
+++ b/src/arbits/pe_armap_sysv_32.c
@@ -0,0 +1,120 @@
+/***************************************************************/
+/* perk: PE Resource Kit */
+/* Copyright (C) 2015--2025 SysDeer Technologies, LLC */
+/* Released under GPLv2 and GPLv3; see COPYING.PERK. */
+/***************************************************************/
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <perk/perk.h>
+#include <perk/perk_arbits.h>
+#include "perk_ar_impl.h"
+#include "perk_driver_impl.h"
+#include "perk_errinfo_impl.h"
+#include "perk_visibility_impl.h"
+
+perk_hidden int pe_ar_parse_primary_armap_sysv_32(
+ const struct pe_driver_ctx * dctx,
+ struct pe_archive_meta_impl * m)
+{
+ struct ar_raw_armap_sysv_32 * armap;
+ struct ar_meta_member_info * memberp;
+ struct ar_meta_armap_common_32 *armapref;
+ struct ar_meta_armap_ref_32 * symrefs;
+ uint32_t idx;
+ uint32_t uref;
+ uint32_t nsyms;
+ uint32_t nstrs;
+ const char * ch;
+ const char * cap;
+ unsigned char * uch;
+ unsigned char (*mark)[0x04];
+
+ armap = &m->armaps.armap_sysv_32;
+ memberp = m->memberv[0];
+
+ mark = memberp->ar_object_data;
+
+ armap->ar_num_of_syms = mark;
+ uch = *mark++;
+
+ armap->ar_first_ref_offset = mark;
+
+ nsyms = (uch[0] << 24) + (uch[1] << 16) + (uch[2] << 8) + uch[3];
+ mark += nsyms;
+
+ if (memberp->ar_object_size < (sizeof(*mark) + (nsyms * sizeof(*mark))))
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_NUMBER_OF_SYMS);
+
+ m->symstrs = (const char *)mark;
+
+ cap = memberp->ar_object_data;
+ cap += memberp->ar_object_size;
+
+ if ((cap == m->symstrs) && nsyms)
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_STRING_TABLE);
+
+ if (nsyms && !m->symstrs[0])
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_STRING_TABLE);
+
+ for (ch=&m->symstrs[1],nstrs=0; ch<cap; ch++) {
+ if (!ch[0] && !ch[-1] && (nstrs < nsyms))
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_STRING_TABLE);
+
+ if (!ch[0] && ch[-1])
+ nstrs++;
+ }
+
+ if (nstrs != nsyms)
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_STRING_TABLE);
+
+ if (cap[-1])
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_STRING_TABLE);
+
+ if (!(m->symstrv = calloc(nsyms + 1,sizeof(const char *))))
+ return PERK_SYSTEM_ERROR(dctx);
+
+ if (!(m->armaps.armap_symrefs_32 = calloc(nsyms + 1,sizeof(*symrefs))))
+ return PERK_SYSTEM_ERROR(dctx);
+
+ mark = armap->ar_first_ref_offset;
+ symrefs = m->armaps.armap_symrefs_32;
+
+ for (idx=0,uch=*mark; idx<nsyms; idx++,uch=*++mark) {
+ uref = (uch[0] << 24) + (uch[1] << 16) + (uch[2] << 8) + uch[3];
+ symrefs[idx].ar_member_offset = uref;
+ }
+
+ armap->ar_string_table = m->symstrv;
+
+ armapref = &m->armaps.armap_common_32;
+ armapref->ar_member = memberp;
+ armapref->ar_symrefs = symrefs;
+ armapref->ar_armap_sysv = armap;
+ armapref->ar_armap_attr = AR_ARMAP_ATTR_SYSV | AR_ARMAP_ATTR_BE_32;
+ armapref->ar_num_of_symbols = nsyms;
+ armapref->ar_size_of_refs = nsyms * sizeof(*mark);
+ armapref->ar_size_of_strs = cap - m->symstrs;
+ armapref->ar_string_table = m->symstrs;
+
+ m->armaps.armap_nsyms = nsyms;
+
+ m->armeta.a_armap_primary.ar_armap_common_32 = armapref;
+
+ return 0;
+}
diff --git a/src/arbits/pe_armap_sysv_64.c b/src/arbits/pe_armap_sysv_64.c
new file mode 100644
index 0000000..f46a4b7
--- /dev/null
+++ b/src/arbits/pe_armap_sysv_64.c
@@ -0,0 +1,128 @@
+/***************************************************************/
+/* perk: PE Resource Kit */
+/* Copyright (C) 2015--2025 SysDeer Technologies, LLC */
+/* Released under GPLv2 and GPLv3; see COPYING.PERK. */
+/***************************************************************/
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <perk/perk.h>
+#include <perk/perk_arbits.h>
+#include "perk_ar_impl.h"
+#include "perk_driver_impl.h"
+#include "perk_errinfo_impl.h"
+#include "perk_visibility_impl.h"
+
+perk_hidden int pe_ar_parse_primary_armap_sysv_64(
+ const struct pe_driver_ctx * dctx,
+ struct pe_archive_meta_impl * m)
+{
+ struct ar_raw_armap_sysv_64 * armap;
+ struct ar_meta_member_info * memberp;
+ struct ar_meta_armap_common_64 *armapref;
+ struct ar_meta_armap_ref_64 * symrefs;
+ uint64_t idx;
+ uint64_t uref_hi;
+ uint64_t uref_lo;
+ uint64_t nsyms_hi;
+ uint64_t nsyms_lo;
+ uint64_t nsyms;
+ uint64_t nstrs;
+ const char * ch;
+ const char * cap;
+ unsigned char * uch;
+ unsigned char (*mark)[0x08];
+
+ armap = &m->armaps.armap_sysv_64;
+ memberp = m->memberv[0];
+
+ mark = memberp->ar_object_data;
+
+ armap->ar_num_of_syms = mark;
+ uch = *mark++;
+
+ armap->ar_first_ref_offset = mark;
+
+ nsyms_hi = (uch[0] << 24) + (uch[1] << 16) + (uch[2] << 8) + uch[3];
+ nsyms_lo = (uch[4] << 24) + (uch[5] << 16) + (uch[6] << 8) + uch[7];
+
+ nsyms = (nsyms_hi << 32) + nsyms_lo;
+ mark += nsyms;
+
+ if (memberp->ar_object_size < (sizeof(*mark) + (nsyms * sizeof(*mark))))
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_NUMBER_OF_SYMS);
+
+ m->symstrs = (const char *)mark;
+
+ cap = memberp->ar_object_data;
+ cap += memberp->ar_object_size;
+
+ if ((cap == m->symstrs) && nsyms)
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_STRING_TABLE);
+
+ if (nsyms && !m->symstrs[0])
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_STRING_TABLE);
+
+ for (ch=&m->symstrs[1],nstrs=0; ch<cap; ch++) {
+ if (!ch[0] && !ch[-1] && (nstrs < nsyms))
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_STRING_TABLE);
+
+ if (!ch[0] && ch[-1])
+ nstrs++;
+ }
+
+ if (nstrs != nsyms)
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_STRING_TABLE);
+
+ if (cap[-1])
+ return PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_AR_INVALID_ARMAP_STRING_TABLE);
+
+ if (!(m->symstrv = calloc(nsyms + 1,sizeof(const char *))))
+ return PERK_SYSTEM_ERROR(dctx);
+
+ if (!(m->armaps.armap_symrefs_64 = calloc(nsyms + 1,sizeof(*symrefs))))
+ return PERK_SYSTEM_ERROR(dctx);
+
+ mark = armap->ar_first_ref_offset;
+ symrefs = m->armaps.armap_symrefs_64;
+
+ for (idx=0,uch=*mark; idx<nsyms; idx++,uch=*++mark) {
+ uref_hi = (uch[0] << 24) + (uch[1] << 16) + (uch[2] << 8) + uch[3];
+ uref_lo = (uch[4] << 24) + (uch[5] << 16) + (uch[6] << 8) + uch[7];
+
+ symrefs[idx].ar_member_offset = (uref_hi << 32) + uref_lo;
+ }
+
+ armap->ar_string_table = m->symstrv;
+
+ armapref = &m->armaps.armap_common_64;
+ armapref->ar_member = memberp;
+ armapref->ar_symrefs = symrefs;
+ armapref->ar_armap_sysv = armap;
+ armapref->ar_armap_attr = AR_ARMAP_ATTR_SYSV | AR_ARMAP_ATTR_BE_64;
+ armapref->ar_num_of_symbols = nsyms;
+ armapref->ar_size_of_refs = nsyms * sizeof(*mark);
+ armapref->ar_size_of_strs = cap - m->symstrs;
+ armapref->ar_string_table = m->symstrs;
+
+ m->armaps.armap_nsyms = nsyms;
+
+ m->armeta.a_armap_primary.ar_armap_common_64 = armapref;
+
+ return 0;
+}
diff --git a/src/cmds/pe_cmd_ar.c b/src/cmds/pe_cmd_ar.c
new file mode 100644
index 0000000..97e94c7
--- /dev/null
+++ b/src/cmds/pe_cmd_ar.c
@@ -0,0 +1,134 @@
+/***************************************************************/
+/* perk: PE Resource Kit */
+/* Copyright (C) 2015--2025 SysDeer Technologies, LLC */
+/* Released under GPLv2 and GPLv3; see COPYING.PERK. */
+/***************************************************************/
+
+#include <perk/perk.h>
+#include "perk_driver_impl.h"
+#include "perk_errinfo_impl.h"
+#include "perk_ar_impl.h"
+
+int pe_ar_list_members(const struct pe_archive_meta *, const char **);
+
+static int pe_cmd_ar_perform_unit_actions(
+ const struct pe_driver_ctx * dctx,
+ const char * arname,
+ const char ** members,
+ uint64_t action)
+{
+ struct pe_unit_ctx * arctx = 0;
+ int (*pe_ar_fn)(const struct pe_archive_meta *,const char **);
+
+ if (action == PERK_DRIVER_AR_LIST_MEMBERS) {
+ pe_ar_fn = pe_ar_list_members;
+
+ } else if (action == PERK_DRIVER_AR_PRINT_MEMBERS) {
+ pe_ar_fn = pe_ar_print_members;
+
+ } else {
+ return 0;
+ }
+
+ if (pe_lib_get_unit_ctx(dctx,arname,&arctx) < 0)
+ return PERK_NESTED_ERROR(dctx);
+
+ if (arctx->armeta == 0)
+ return PERK_CUSTOM_ERROR(dctx,
+ PERK_ERR_AR_NON_ARCHIVE_IMAGE);
+
+ if (pe_ar_fn(arctx->armeta,members) < 0) {
+ pe_lib_free_unit_ctx(arctx);
+ return PERK_NESTED_ERROR(dctx);
+ }
+
+ pe_lib_free_unit_ctx(arctx);
+
+ return 0;
+}
+
+static int pe_cmd_ar_verify_cmdline(
+ const struct pe_driver_ctx * dctx,
+ uint64_t flags,
+ const char * posname,
+ const char * arname,
+ const char ** members)
+{
+ uint64_t action;
+ uint64_t poscmd;
+ uint64_t vercmd;
+
+ action = (flags & AR_ACTION_MASK);
+ poscmd = (flags & AR_POSNAME_MASK);
+ vercmd = (flags & PERK_DRIVER_VERSION);
+
+ if (vercmd && !posname && !arname && !members)
+ return 0;
+
+ switch (action) {
+ case 0:
+ return PERK_CUSTOM_ERROR(dctx,
+ PERK_ERR_AR_MISSING_ACTION);
+
+ case PERK_DRIVER_AR_LIST_MEMBERS:
+ case PERK_DRIVER_AR_DELETE_MEMBERS:
+ case PERK_DRIVER_AR_APPEND_MEMBERS:
+ case PERK_DRIVER_AR_EXTRACT_MEMBERS:
+ case PERK_DRIVER_AR_PRINT_MEMBERS:
+ if (poscmd || posname)
+ return PERK_CUSTOM_ERROR(dctx,
+ PERK_ERR_AR_INVALID_ANCHORS);
+
+ break;
+
+ case AR_UPDATE_MASK:
+ case PERK_DRIVER_AR_REPLACE_MEMBERS:
+ case PERK_DRIVER_AR_MOVE_MEMBERS:
+ switch (poscmd) {
+ case 0:
+ if (posname)
+ return PERK_CUSTOM_ERROR(dctx,
+ PERK_ERR_AR_MISSING_ANCHOR);
+ break;
+
+ case PERK_DRIVER_AR_POSITION_AFTER:
+ case PERK_DRIVER_AR_POSITION_BEFORE:
+ if (!posname)
+ return PERK_CUSTOM_ERROR(dctx,
+ PERK_ERR_AR_NULL_POSNAME);
+ break;
+
+ default:
+ return PERK_CUSTOM_ERROR(dctx,
+ PERK_ERR_AR_MULTIPLE_ANCHORS);
+ }
+
+ default:
+ return PERK_CUSTOM_ERROR(dctx,
+ PERK_ERR_AR_MULTIPLE_ACTIONS);
+ }
+
+ if (!arname)
+ return PERK_CUSTOM_ERROR(dctx,
+ PERK_ERR_AR_NULL_ARNAME);
+
+ return 0;
+}
+
+int pe_cmd_ar(
+ const struct pe_driver_ctx * dctx,
+ uint64_t flags,
+ const char * posname,
+ const char * arname,
+ const char ** members)
+{
+ uint64_t action = (flags & AR_ACTION_MASK);
+
+ if (pe_cmd_ar_verify_cmdline(dctx,flags,posname,arname,members) < 0)
+ return PERK_NESTED_ERROR(dctx);
+
+ if (pe_cmd_ar_perform_unit_actions(dctx,arname,members,action) < 0)
+ return PERK_NESTED_ERROR(dctx);
+
+ return 0;
+}
diff --git a/src/cmds/pe_cmd_perk.c b/src/cmds/pe_cmd_perk.c
new file mode 100644
index 0000000..6fe6112
--- /dev/null
+++ b/src/cmds/pe_cmd_perk.c
@@ -0,0 +1,97 @@
+/***************************************************************/
+/* perk: PE Resource Kit */
+/* Copyright (C) 2015--2025 SysDeer Technologies, LLC */
+/* Released under GPLv2 and GPLv3; see COPYING.PERK. */
+/***************************************************************/
+
+#include <stdio.h>
+#include <unistd.h>
+#include <perk/perk.h>
+#include <perk/perk_output.h>
+#include "perk_driver_impl.h"
+#include "perk_dprintf_impl.h"
+
+static void pe_perform_hdrdump_actions(
+ const struct pe_driver_ctx * dctx,
+ const struct pe_image_meta * meta)
+{
+ if (dctx->cctx->hdrdump & PERK_HDRDUMP_IMAGE_DOS_HEADER)
+ pe_hexdump_image_dos_hdr(dctx,meta);
+
+ if (dctx->cctx->hdrdump & PERK_HDRDUMP_COFF_IMAGE_HEADER)
+ pe_hexdump_coff_image_hdr(dctx,meta);
+
+ if (dctx->cctx->hdrdump & PERK_HDRDUMP_COFF_OBJECT_HEADER)
+ pe_hexdump_coff_object_hdr(dctx,meta);
+
+ if (dctx->cctx->hdrdump & PERK_HDRDUMP_COFF_OPT_HEADER)
+ pe_hexdump_coff_opt_hdr(dctx,meta);
+
+ if (dctx->cctx->hdrdump & PERK_HDRDUMP_SECTION_TABLE)
+ pe_hexdump_sec_tbl(dctx,meta);
+
+ if (dctx->cctx->hdrdump & PERK_HDRDUMP_EXPORT_HEADER)
+ pe_hexdump_export_hdr(dctx,meta);
+
+ if (dctx->cctx->hdrdump & PERK_HDRDUMP_IMPORT_TABLE)
+ pe_hexdump_import_tbl(dctx,meta);
+}
+
+static void pe_perform_unit_actions_impl(
+ const struct pe_driver_ctx * dctx,
+ const struct pe_image_meta * meta)
+{
+ uint64_t flags = dctx->cctx->fmtflags;
+
+ if (flags & PERK_OUTPUT_IMAGE_CATEGORY)
+ pe_output_image_category(dctx,meta);
+
+ if (flags & PERK_OUTPUT_IMAGE_SECTIONS)
+ pe_output_image_sections(dctx,meta);
+
+ if (flags & PERK_OUTPUT_IMAGE_SYMBOLS)
+ pe_output_image_symbols(dctx,meta);
+
+ if (flags & PERK_OUTPUT_IMAGE_STRINGS)
+ pe_output_image_strings(dctx,meta);
+
+ if (flags & PERK_OUTPUT_EXPORT_SYMS)
+ pe_output_export_symbols(dctx,meta);
+
+ if ((flags & PERK_OUTPUT_IMPORT_LIBS) || (flags & PERK_OUTPUT_IMPORT_SYMS))
+ pe_output_import_libraries(dctx,meta);
+
+ if ((flags & PERK_OUTPUT_MDSO_LIBS) || (flags & PERK_OUTPUT_MDSO_SYMS))
+ pe_output_mdso_libraries(dctx,meta);
+
+ if (dctx->cctx->hdrdump)
+ pe_perform_hdrdump_actions(dctx,meta);
+}
+
+static void pe_perform_unit_actions(
+ const struct pe_driver_ctx * dctx,
+ const struct pe_unit_ctx * uctx)
+{
+ const struct pe_image_meta ** objmeta;
+
+ if (uctx->meta)
+ pe_perform_unit_actions_impl(dctx,uctx->meta);
+
+ if ((objmeta = uctx->objmeta))
+ for (; *objmeta; )
+ pe_perform_unit_actions_impl(dctx,*objmeta++);
+}
+
+int pe_cmd_perk(const struct pe_driver_ctx * dctx, const char * path)
+{
+ int ret;
+ struct pe_unit_ctx * uctx;
+
+ if ((ret = pe_lib_get_unit_ctx(dctx,path,&uctx)) < 0)
+ return ret;
+
+ pe_perform_unit_actions(dctx,uctx);
+ pe_lib_free_unit_ctx(uctx);
+
+ return 0;
+}
diff --git a/src/driver/pe_amain.c b/src/driver/pe_amain.c
index 286e111..a766dba 100644
--- a/src/driver/pe_amain.c
+++ b/src/driver/pe_amain.c
@@ -10,13 +10,15 @@
#include <perk/perk_output.h>
#include "perk_driver_impl.h"
#include "perk_dprintf_impl.h"
+#include "perk_ar_impl.h"
#ifndef PERK_DRIVER_FLAGS
#define PERK_DRIVER_FLAGS PERK_DRIVER_VERBOSITY_ERRORS \
- | PERK_DRIVER_VERBOSITY_USAGE
+ | PERK_DRIVER_VERBOSITY_UTILITY \
+ | PERK_DRIVER_AR_OBJECT_VECTOR
#endif
-static const char vermsg[] = "%s%s%s (git://midipix.org/perk): "
+static const char vermsg[] = "%s%s%s (https://git.foss21.org/perk): "
"version %s%d.%d.%d%s.\n"
"[commit reference: %s%s%s]\n";
@@ -48,67 +50,10 @@ static ssize_t pe_version(struct pe_driver_ctx * dctx, int fdout)
verclr[4],verinfo->commit,verclr[5]);
}
-static void pe_perform_hdrdump_actions(
- const struct pe_driver_ctx * dctx,
- struct pe_unit_ctx * uctx)
-{
- if (dctx->cctx->hdrdump & PERK_HDRDUMP_IMAGE_DOS_HEADER)
- pe_hdrdump_image_dos_hdr(dctx,uctx->meta);
-
- if (dctx->cctx->hdrdump & PERK_HDRDUMP_COFF_IMAGE_HEADER)
- pe_hdrdump_coff_image_hdr(dctx,uctx->meta);
-
- if (dctx->cctx->hdrdump & PERK_HDRDUMP_COFF_OBJECT_HEADER)
- pe_hdrdump_coff_object_hdr(dctx,uctx->meta);
-
- if (dctx->cctx->hdrdump & PERK_HDRDUMP_COFF_OPT_HEADER)
- pe_hdrdump_coff_opt_hdr(dctx,uctx->meta);
-
- if (dctx->cctx->hdrdump & PERK_HDRDUMP_SECTION_TABLE)
- pe_hdrdump_sec_tbl(dctx,uctx->meta);
-
- if (dctx->cctx->hdrdump & PERK_HDRDUMP_EXPORT_HEADER)
- pe_hdrdump_export_hdr(dctx,uctx->meta);
-
- if (dctx->cctx->hdrdump & PERK_HDRDUMP_IMPORT_TABLE)
- pe_hdrdump_import_tbl(dctx,uctx->meta);
-}
-
-static void pe_perform_unit_actions(
- const struct pe_driver_ctx * dctx,
- struct pe_unit_ctx * uctx)
-{
- uint64_t flags = dctx->cctx->fmtflags;
-
- if (flags & PERK_OUTPUT_IMAGE_CATEGORY)
- pe_output_image_category(dctx,uctx->meta);
-
- if (flags & PERK_OUTPUT_IMAGE_SECTIONS)
- pe_output_image_sections(dctx,uctx->meta);
-
- if (flags & PERK_OUTPUT_IMAGE_SYMBOLS)
- pe_output_image_symbols(dctx,uctx->meta);
-
- if (flags & PERK_OUTPUT_IMAGE_STRINGS)
- pe_output_image_strings(dctx,uctx->meta);
-
- if (flags & PERK_OUTPUT_EXPORT_SYMS)
- pe_output_export_symbols(dctx,uctx->meta);
-
- if ((flags & PERK_OUTPUT_IMPORT_LIBS) || (flags & PERK_OUTPUT_IMPORT_SYMS))
- pe_output_import_libraries(dctx,uctx->meta);
-
- if ((flags & PERK_OUTPUT_MDSO_LIBS) || (flags & PERK_OUTPUT_MDSO_SYMS))
- pe_output_mdso_libraries(dctx,uctx->meta);
-
- if (dctx->cctx->hdrdump)
- pe_perform_hdrdump_actions(dctx,uctx);
-}
-
static int pe_exit(struct pe_driver_ctx * dctx, int ret)
{
pe_output_error_vector(dctx);
- pe_free_driver_ctx(dctx);
+ pe_lib_free_driver_ctx(dctx);
return ret;
}
@@ -118,13 +63,16 @@ int pe_main(char ** argv, char ** envp, const struct pe_fd_ctx * fdctx)
int fdout;
uint64_t flags;
struct pe_driver_ctx * dctx;
- struct pe_unit_ctx * uctx;
const char ** unit;
+ const char * posname;
+ const char * arname;
+ const char ** arfiles;
+ uint64_t arflags;
flags = PERK_DRIVER_FLAGS;
fdout = fdctx ? fdctx->fdout : STDOUT_FILENO;
- if ((ret = pe_get_driver_ctx(argv,envp,flags,fdctx,&dctx)))
+ if ((ret = pe_lib_get_driver_ctx(argv,envp,flags,fdctx,&dctx)))
return (ret == PERK_USAGE)
? !argv || !argv[0] || !argv[1]
: PERK_ERROR;
@@ -133,11 +81,31 @@ int pe_main(char ** argv, char ** envp, const struct pe_fd_ctx * fdctx)
if ((pe_version(dctx,fdout)) < 0)
return pe_exit(dctx,PERK_ERROR);
- for (unit=dctx->units; *unit; unit++) {
- if (!(pe_get_unit_ctx(dctx,*unit,&uctx))) {
- pe_perform_unit_actions(dctx,uctx);
- pe_free_unit_ctx(uctx);
- }
+ switch (dctx->cctx->cmd) {
+ case PERK_CMD_PERK:
+ for (unit=dctx->units; *unit; unit++)
+ pe_cmd_perk(dctx,*unit);
+ break;
+
+ case PERK_CMD_AR:
+ arflags = dctx->cctx->drvflags;
+
+ if (arflags & AR_POSNAME_MASK) {
+ posname = dctx->units[0];
+ arname = posname ? dctx->units[1] : 0;
+ arfiles = arname ? &dctx->units[2] : 0;
+ } else {
+ posname = 0;
+ arname = dctx->units[0];
+ arfiles = arname ? &dctx->units[1] : 0;
+ }
+
+ pe_cmd_ar(dctx,arflags,posname,arname,arfiles);
+
+ break;
+
+ default:
+ break;
}
return pe_exit(dctx,dctx->errv[0] ? PERK_ERROR : PERK_OK);
diff --git a/src/driver/pe_driver_ctx.c b/src/driver/pe_driver_ctx.c
index 9955548..11c2e27 100644
--- a/src/driver/pe_driver_ctx.c
+++ b/src/driver/pe_driver_ctx.c
@@ -14,6 +14,7 @@
#include <perk/perk_output.h>
#include "perk_version.h"
#include "perk_driver_impl.h"
+#include "perk_synopsis_impl.h"
#include "argv/argv.h"
/* package info */
@@ -24,6 +25,19 @@ static const struct pe_source_version pe_src_version = {
PERK_GIT_VERSION
};
+/* perk command names */
+static const char * const perk_cmd_name[PERK_CMD_CAP] = {
+ [PERK_CMD_PERK] = "perk",
+ [PERK_CMD_AR] = "ar",
+};
+
+/* perk command options */
+static const struct argv_option * perk_cmd_options[PERK_CMD_CAP] = {
+ [PERK_CMD_DEFAULT] = pe_default_options,
+ [PERK_CMD_PERK] = pe_perk_options,
+ [PERK_CMD_AR] = pe_ar_options,
+};
+
/* default fd context */
static const struct pe_fd_ctx pe_default_fdctx = {
.fdin = STDIN_FILENO,
@@ -62,13 +76,40 @@ static int pe_driver_usage(
const char * program,
const char * arg,
const struct argv_option ** optv,
- struct argv_meta * meta)
+ struct argv_meta * meta,
+ const char * cmdarg,
+ enum pe_cmd cmd)
{
- char header[512];
-
- snprintf(header,sizeof(header),
- "Usage: %s [options] <file>...\n" "Options:\n",
- program);
+ char header [2048];
+ char cmdname[128];
+
+ snprintf(cmdname,sizeof(cmdname),"%s%s%s",
+ program,
+ cmdarg ? " --cmd=" : "",
+ cmdarg ? perk_cmd_name[cmd] : "");
+
+ switch (cmd) {
+ case PERK_CMD_AR:
+ snprintf(header,sizeof(header),
+ PERK_AR_CMD_SYNOPSIS,
+ cmdname,cmdname,cmdname,cmdname,
+ cmdname,cmdname,cmdname,cmdname,
+ cmdname,cmdname,cmdname,cmdname,
+ cmdname,cmdname,cmdname);
+ break;
+
+ case PERK_CMD_PERK:
+ snprintf(header,sizeof(header),
+ PERK_PERK_CMD_SYNOPSIS,
+ cmdname,cmdname,cmdname);
+ break;
+
+ default:
+ snprintf(header,sizeof(header),
+ PERK_DEFAULT_CMD_SYNOPSIS,
+ program,program,program,program);
+ break;
+ }
argv_usage(fdout,header,optv,arg);
argv_free(meta);
@@ -113,157 +154,354 @@ static struct pe_driver_ctx_impl * pe_driver_ctx_alloc(
return &ictx->ctx;
}
-static int pe_get_driver_ctx_fail(struct argv_meta * meta)
+static int pe_cmd_from_program(const char * program)
{
- argv_free(meta);
- return -1;
-}
+ const char * dot;
+ const char * hyphen;
+ const char * mark;
-int pe_get_driver_ctx(
- char ** argv,
- char ** envp,
- uint32_t flags,
- const struct pe_fd_ctx * fdctx,
- struct pe_driver_ctx ** pctx)
-{
- struct pe_driver_ctx_impl * ctx;
- struct pe_common_ctx cctx;
- const struct argv_option * optv[PERK_OPTV_ELEMENTS];
- struct argv_meta * meta;
- struct argv_entry * entry;
- size_t nunits;
- const char * program;
- const char * pretty;
+ dot = strrchr(program,'.');
+ hyphen = strrchr(program,'-');
- (void)envp;
+ if (hyphen > dot)
+ mark = ++hyphen;
+ else if (dot > hyphen)
+ mark = ++dot;
+ else
+ mark = program;
- if (!fdctx)
- fdctx = &pe_default_fdctx;
+ if (!strcmp(mark,"perk")) {
+ return PERK_CMD_PERK;
- argv_optv_init(pe_default_options,optv);
+ } else if (!strcmp(mark,"ar")) {
+ return PERK_CMD_AR;
- if (!(meta = argv_get(
- argv,optv,
- pe_argv_flags(flags),
- fdctx->fderr)))
- return -1;
+ } else {
+ return PERK_CMD_DEFAULT;
+ }
+}
- pretty = 0;
- nunits = 0;
- program = argv_program_name(argv[0]);
- memset(&cctx,0,sizeof(cctx));
- cctx.drvflags = flags;
+static int pe_cctx_update(
+ const char * program,
+ const struct argv_option ** optv,
+ struct argv_meta * meta,
+ const struct pe_fd_ctx * fdctx,
+ struct pe_common_ctx * cctx,
+ size_t * nunits,
+ const char * cmdarg)
+{
+ struct argv_entry * entry;
+ const char * pretty;
- if (!argv[1] && (flags & PERK_DRIVER_VERBOSITY_USAGE))
- return pe_driver_usage(
- fdctx->fderr,
- program,
- 0,optv,meta);
+ pretty = 0;
/* get options, count units */
for (entry=meta->entries; entry->fopt || entry->arg; entry++) {
if (entry->fopt) {
switch (entry->tag) {
case TAG_HELP:
- if (flags & PERK_DRIVER_VERBOSITY_USAGE)
+ return pe_driver_usage(
+ fdctx->fdout,
+ program,entry->arg,
+ optv,0,cmdarg,cctx->cmd);
+ break;
+
+ case TAG_CMD:
+ if (*nunits)
return pe_driver_usage(
- fdctx->fdout,
- program,entry->arg,
- optv,meta);
+ fdctx->fderr,
+ program,0,
+ optv,0,cmdarg,cctx->cmd);
+
+ cctx->cmd = pe_cmd_from_program(entry->arg);
+ cmdarg = entry->arg;
break;
case TAG_VERSION:
- cctx.drvflags |= PERK_DRIVER_VERSION;
+ cctx->drvflags |= PERK_DRIVER_VERSION;
break;
case TAG_PRETTY:
pretty = entry->arg;
break;
+ case TAG_VERBOSE:
+ cctx->fmtflags |= PERK_PRETTY_VERBOSE;
+ break;
+
case TAG_CATEGORY:
- cctx.fmtflags |= PERK_OUTPUT_IMAGE_CATEGORY;
+ cctx->fmtflags |= PERK_OUTPUT_IMAGE_CATEGORY;
break;
case TAG_SECTIONS:
- cctx.fmtflags |= PERK_OUTPUT_IMAGE_SECTIONS;
+ cctx->fmtflags |= PERK_OUTPUT_IMAGE_SECTIONS;
break;
case TAG_SYMBOLS:
- cctx.fmtflags |= PERK_OUTPUT_IMAGE_SYMBOLS;
+ cctx->fmtflags |= PERK_OUTPUT_IMAGE_SYMBOLS;
break;
case TAG_STRINGS:
- cctx.fmtflags |= PERK_OUTPUT_IMAGE_STRINGS;
+ cctx->fmtflags |= PERK_OUTPUT_IMAGE_STRINGS;
break;
case TAG_EXPSYMS:
- cctx.fmtflags |= PERK_OUTPUT_EXPORT_SYMS;
+ cctx->fmtflags |= PERK_OUTPUT_EXPORT_SYMS;
break;
case TAG_IMPLIBS:
- cctx.fmtflags |= PERK_OUTPUT_IMPORT_LIBS;
+ cctx->fmtflags |= PERK_OUTPUT_IMPORT_LIBS;
break;
case TAG_IMPSYMS:
- cctx.fmtflags |= PERK_OUTPUT_IMPORT_SYMS;
+ cctx->fmtflags |= PERK_OUTPUT_IMPORT_SYMS;
break;
case TAG_DSOLIBS:
- cctx.fmtflags |= PERK_OUTPUT_MDSO_LIBS;
+ cctx->fmtflags |= PERK_OUTPUT_MDSO_LIBS;
break;
case TAG_DSOSYMS:
- cctx.fmtflags |= PERK_OUTPUT_MDSO_SYMS;
+ cctx->fmtflags |= PERK_OUTPUT_MDSO_SYMS;
break;
case TAG_HDRDUMP:
if (!entry->arg) {
- cctx.hdrdump = 0;
- cctx.hdrdump = ~cctx.hdrdump;
+ cctx->hdrdump = 0;
+ cctx->hdrdump = ~cctx->hdrdump;
} else if (!strcmp(entry->arg,"dos")) {
- cctx.hdrdump = PERK_HDRDUMP_IMAGE_DOS_HEADER;
+ cctx->hdrdump = PERK_HDRDUMP_IMAGE_DOS_HEADER;
} else if (!strcmp(entry->arg,"image.dos")) {
- cctx.hdrdump = PERK_HDRDUMP_IMAGE_DOS_HEADER;
+ cctx->hdrdump = PERK_HDRDUMP_IMAGE_DOS_HEADER;
} else if (!strcmp(entry->arg,"coff")) {
- cctx.hdrdump = PERK_HDRDUMP_COFF_IMAGE_HEADER;
- cctx.hdrdump |= PERK_HDRDUMP_COFF_OBJECT_HEADER;
- cctx.hdrdump |= PERK_HDRDUMP_COFF_OPT_HEADER;
+ cctx->hdrdump = PERK_HDRDUMP_COFF_IMAGE_HEADER;
+ cctx->hdrdump |= PERK_HDRDUMP_COFF_OBJECT_HEADER;
+ cctx->hdrdump |= PERK_HDRDUMP_COFF_OPT_HEADER;
} else if (!strcmp(entry->arg,"coff.image")) {
- cctx.hdrdump = PERK_HDRDUMP_COFF_IMAGE_HEADER;
+ cctx->hdrdump = PERK_HDRDUMP_COFF_IMAGE_HEADER;
} else if (!strcmp(entry->arg,"coff.obj")) {
- cctx.hdrdump = PERK_HDRDUMP_COFF_OBJECT_HEADER;
+ cctx->hdrdump = PERK_HDRDUMP_COFF_OBJECT_HEADER;
} else if (!strcmp(entry->arg,"coff.object")) {
- cctx.hdrdump = PERK_HDRDUMP_COFF_OBJECT_HEADER;
+ cctx->hdrdump = PERK_HDRDUMP_COFF_OBJECT_HEADER;
} else if (!strcmp(entry->arg,"coff.opt")) {
- cctx.hdrdump = PERK_HDRDUMP_COFF_OPT_HEADER;
+ cctx->hdrdump = PERK_HDRDUMP_COFF_OPT_HEADER;
} else if (!strcmp(entry->arg,"coff.optional")) {
- cctx.hdrdump = PERK_HDRDUMP_COFF_OPT_HEADER;
+ cctx->hdrdump = PERK_HDRDUMP_COFF_OPT_HEADER;
} else if (!strcmp(entry->arg,"sectbl")) {
- cctx.hdrdump = PERK_HDRDUMP_SECTION_TABLE;
+ cctx->hdrdump = PERK_HDRDUMP_SECTION_TABLE;
} else if (!strcmp(entry->arg,"section.table")) {
- cctx.hdrdump = PERK_HDRDUMP_SECTION_TABLE;
+ cctx->hdrdump = PERK_HDRDUMP_SECTION_TABLE;
} else if (!strcmp(entry->arg,"exphdr")) {
- cctx.hdrdump = PERK_HDRDUMP_EXPORT_HEADER;
+ cctx->hdrdump = PERK_HDRDUMP_EXPORT_HEADER;
} else if (!strcmp(entry->arg,"export.header")) {
- cctx.hdrdump = PERK_HDRDUMP_EXPORT_HEADER;
+ cctx->hdrdump = PERK_HDRDUMP_EXPORT_HEADER;
} else if (!strcmp(entry->arg,"imptbl")) {
- cctx.hdrdump = PERK_HDRDUMP_IMPORT_TABLE;
+ cctx->hdrdump = PERK_HDRDUMP_IMPORT_TABLE;
} else if (!strcmp(entry->arg,"import.table")) {
- cctx.hdrdump = PERK_HDRDUMP_IMPORT_TABLE;
+ cctx->hdrdump = PERK_HDRDUMP_IMPORT_TABLE;
}
break;
+
+ /*---ar---*/
+ case TAG_AR_LIST_MEMBERS:
+ cctx->drvflags |= PERK_DRIVER_AR_LIST_MEMBERS;
+ break;
+
+ case TAG_AR_PRINT_MEMBERS:
+ cctx->drvflags |= PERK_DRIVER_AR_PRINT_MEMBERS;
+ break;
+ }
+ } else {
+ (*nunits)++;
+ }
+ }
+
+ if (pretty && !strcmp(pretty,"yaml")) {
+ cctx->fmtflags |= PERK_PRETTY_YAML;
+
+ } else if (pretty && !strcmp(pretty,"posix")) {
+ cctx->fmtflags |= PERK_PRETTY_POSIX;
+
+ } else if (pretty && !strcmp(pretty,"hexdata")) {
+ cctx->fmtflags |= PERK_PRETTY_HEXDATA;
+
+ } else if (pretty && !strcmp(pretty,"dlltool")) {
+ cctx->fmtflags |= PERK_PRETTY_DLLTOOL;
+ }
+
+ return 0;
+}
+
+static int pe_lib_get_driver_ctx_fail(struct argv_meta * meta)
+{
+ argv_free(meta);
+ return -1;
+}
+
+int pe_lib_get_driver_ctx(
+ char ** argv,
+ char ** envp,
+ uint32_t flags,
+ const struct pe_fd_ctx * fdctx,
+ struct pe_driver_ctx ** pctx)
+{
+ struct pe_driver_ctx_impl * ctx;
+ struct pe_common_ctx cctx;
+ const struct argv_option * optv[PERK_OPTV_ELEMENTS];
+ struct argv_meta * meta;
+ size_t nunits;
+ const char * program;
+ const char * cmdarg;
+ char ** parg;
+ char ** pargcap;
+ char ** cmdargv;
+ char * cmdmark;
+ char stckarg[64];
+ struct argv_ctx actx = {ARGV_VERBOSITY_NONE,
+ ARGV_MODE_SCAN,
+ 0,0,0,0,0,0,0,0};
+
+
+ (void)envp;
+
+ /* fdctx */
+ if (!fdctx)
+ fdctx = &pe_default_fdctx;
+
+ /* cctx */
+ memset(&cctx,0,sizeof(cctx));
+
+ program = argv_program_name(argv[0]);\
+ cctx.cmd = pe_cmd_from_program(program);
+ cctx.drvflags = flags;
+ nunits = 0;
+ cmdarg = 0;
+
+ /* missing arguments? */
+ argv_optv_init(perk_cmd_options[cctx.cmd],optv);
+
+ if (!argv[1] && (flags & PERK_DRIVER_VERBOSITY_UTILITY))
+ return pe_driver_usage(
+ fdctx->fderr,
+ program,0,
+ optv,0,0,cctx.cmd);
+
+ /* historic ar usage (vector will be cloned, so stack var is fine) */
+ if (cctx.cmd == PERK_CMD_AR) {
+ if (argv && argv[0] && argv[1] && (argv[1][0] != '-')) {
+ if (strlen(argv[1]) < (sizeof(stckarg) - 1)) {
+ stckarg[0] = '-';
+ strcpy(&stckarg[1],argv[1]);
+ argv[1] = stckarg;
}
- } else
- nunits++;
+ }
+ }
+
+ /* initial argv scan: ... --cmd=xxx ... */
+ argv_scan(argv,optv,&actx,0);
+
+ /* position of last base perk argument */
+ if (actx.erridx && actx.unitidx)
+ pargcap = &argv[actx.unitidx];
+
+ else if (actx.erridx)
+ pargcap = &argv[actx.erridx];
+
+ else
+ for (pargcap=argv; *pargcap; pargcap++)
+ (void)0;
+
+ /* scan for --cmd */
+ for (parg=argv, cmdargv=0; (parg<pargcap) && !cmdargv; parg++) {
+ if (!strcmp(*parg,"--cmd") && parg[1]) {
+ cmdargv = &parg[2];
+ cmdmark = parg[2];
+ cmdarg = parg[1];
+ } else if (!strncmp(*parg,"--cmd=",6)) {
+ cmdargv = &parg[1];
+ cmdmark = parg[1];
+ cmdarg = &parg[0][6];
+ }
+ }
+
+ /* invalid perk arguments? */
+ if (!actx.erridx) {
+ (void)0;
+
+ } else if (&argv[actx.erridx] >= cmdargv) {
+ (void)0;
+
+ } else {
+ if (flags & PERK_DRIVER_VERBOSITY_ERRORS)
+ argv_get(
+ argv,optv,
+ ARGV_VERBOSITY_ERRORS,
+ fdctx->fderr);
+ return -1;
+ }
+
+ /* process argv entries preceding --cmd */
+ if (cmdargv) {
+ *cmdargv = 0;
+
+ if (!(meta = argv_get(
+ argv,optv,
+ pe_argv_flags(flags),
+ fdctx->fderr)))
+ return -1;
+
+ if (pe_cctx_update(
+ program,optv,meta,
+ fdctx,&cctx,&nunits,
+ cmdarg)) {
+ argv_free(meta);
+ return -1;
+ }
+
+ argv_free(meta);
+
+ *cmdargv-- = cmdmark;
+ *cmdargv = argv[0];
+ argv = cmdargv;
+ }
+
+ /* set option vector by command */
+ if (cctx.cmd == PERK_CMD_DEFAULT) {
+ argv_optv_init(pe_default_options,optv);
+
+ } else if (cctx.cmd == PERK_CMD_PERK) {
+ argv_optv_init(pe_perk_options,optv);
+
+ } else if (cctx.cmd == PERK_CMD_AR) {
+ argv_optv_init(pe_ar_options,optv);
+ }
+
+ /* process the selected tool's command-line arguments */
+ if (!(meta = argv_get(
+ argv,optv,
+ pe_argv_flags(flags),
+ fdctx->fderr)))
+ return -1;
+
+ if (pe_cctx_update(
+ program,optv,meta,
+ fdctx,&cctx,&nunits,
+ cmdarg)) {
+ argv_free(meta);
+ return -1;
}
- if (pretty && !strcmp(pretty,"yaml"))
- cctx.fmtflags |= PERK_PRETTY_YAML;
- else if (pretty && !strcmp(pretty,"dlltool"))
- cctx.fmtflags |= PERK_PRETTY_DLLTOOL;
+ /* utility mode and no action to take? */
+ if (cctx.drvflags & PERK_DRIVER_VERBOSITY_UTILITY)
+ if (!nunits && !(cctx.drvflags & PERK_DRIVER_VERSION))
+ return pe_driver_usage(
+ fdctx->fdout,
+ program,0,optv,meta,
+ cmdarg,cctx.cmd);
+ /* context allocation */
if (!(ctx = pe_driver_ctx_alloc(meta,fdctx,&cctx,nunits)))
- return pe_get_driver_ctx_fail(meta);
+ return pe_lib_get_driver_ctx_fail(meta);
ctx->ctx.program = program;
ctx->ctx.cctx = &ctx->cctx;
@@ -272,13 +510,13 @@ int pe_get_driver_ctx(
return PERK_OK;
}
-static void pe_free_driver_ctx_impl(struct pe_driver_ctx_alloc * ictx)
+static void pe_lib_free_driver_ctx_impl(struct pe_driver_ctx_alloc * ictx)
{
argv_free(ictx->meta);
free(ictx);
}
-void pe_free_driver_ctx(struct pe_driver_ctx * ctx)
+void pe_lib_free_driver_ctx(struct pe_driver_ctx * ctx)
{
struct pe_driver_ctx_alloc * ictx;
uintptr_t addr;
@@ -287,7 +525,7 @@ void pe_free_driver_ctx(struct pe_driver_ctx * ctx)
addr = (uintptr_t)ctx - offsetof(struct pe_driver_ctx_impl,ctx);
addr = addr - offsetof(struct pe_driver_ctx_alloc,ctx);
ictx = (struct pe_driver_ctx_alloc *)addr;
- pe_free_driver_ctx_impl(ictx);
+ pe_lib_free_driver_ctx_impl(ictx);
}
}
@@ -296,7 +534,7 @@ const struct pe_source_version * pe_source_version(void)
return &pe_src_version;
}
-int pe_get_driver_fdctx(
+int pe_lib_get_driver_fdctx(
const struct pe_driver_ctx * dctx,
struct pe_fd_ctx * fdctx)
{
@@ -314,7 +552,7 @@ int pe_get_driver_fdctx(
return 0;
}
-int pe_set_driver_fdctx(
+int pe_lib_set_driver_fdctx(
struct pe_driver_ctx * dctx,
const struct pe_fd_ctx * fdctx)
{
diff --git a/src/driver/pe_unit_ctx.c b/src/driver/pe_unit_ctx.c
index 5333a2d..b165226 100644
--- a/src/driver/pe_unit_ctx.c
+++ b/src/driver/pe_unit_ctx.c
@@ -11,27 +11,136 @@
#include <sys/mman.h>
#include <perk/perk.h>
+#include <perk/perk_arbits.h>
+#include "perk_ar_impl.h"
#include "perk_driver_impl.h"
#include "perk_errinfo_impl.h"
-static int pe_free_unit_ctx_impl(struct pe_unit_ctx_impl * ctx, int ret)
+static int pe_lib_free_unit_ctx_impl(struct pe_unit_ctx_impl * ctx, int ret)
{
+ struct pe_image_meta ** pmeta;
if (ctx) {
- pe_free_image_meta(ctx->meta);
- pe_unmap_raw_image(&ctx->map);
+ for (pmeta=ctx->objmeta; pmeta && *pmeta; pmeta++)
+ pe_meta_free_image_meta(*pmeta);
+
+ pe_ar_free_archive_meta(ctx->armeta);
+ pe_meta_free_image_meta(ctx->meta);
+ pe_raw_unmap_raw_image(&ctx->map);
+ free(ctx->usrobjmeta);
+ free(ctx->objmeta);
free(ctx);
}
return ret;
}
-int pe_get_unit_ctx(
+static int pe_lib_create_object_vector_or_verify_archive(
+ const struct pe_driver_ctx * dctx,
+ struct pe_unit_ctx_impl * ctx)
+{
+ struct pe_archive_meta * actx;
+ struct pe_archive_meta_impl * ictx;
+ struct pe_driver_ctx_impl * idctx;
+ bool fvector;
+ bool fstrict;
+ bool fpurearch;
+ struct pe_image_meta * meta;
+ struct pe_image_meta ** objmeta;
+ const struct pe_image_meta ** usrobjmeta;
+ size_t veclen;
+ struct pe_raw_image map;
+ struct ar_meta_member_info ** pmember;
+ struct pe_error_info ** errinfp;
+ enum pe_abi m_abi;
+ enum pe_subtype m_subtype;
+
+ fvector = (dctx->cctx->drvflags & PERK_DRIVER_AR_OBJECT_VECTOR);
+ fstrict = (dctx->cctx->drvflags & PERK_DRIVER_AR_STRICT_PE);
+ fpurearch = (dctx->cctx->drvflags & PERK_DRIVER_AR_STRICT_PE_ARCH);
+
+ if (!fvector && !fstrict && !fpurearch)
+ return 0;
+
+ actx = ctx->armeta;
+ ictx = pe_archive_meta_ictx(actx);
+ idctx = pe_get_driver_ictx(dctx);
+ veclen = ictx->nentries + 1;
+
+ if (fvector && !(ctx->objmeta = calloc(veclen,sizeof(meta))))
+ return PERK_BUFFER_ERROR(dctx);
+
+ if (fvector && !(ctx->usrobjmeta = calloc(veclen,sizeof(*usrobjmeta))))
+ return PERK_BUFFER_ERROR(dctx);
+
+ if (!actx->a_memberv)
+ return 0;
+
+ objmeta = ctx->objmeta;
+ usrobjmeta = ctx->usrobjmeta;
+
+ for (pmember=actx->a_memberv; *pmember; pmember++) {
+ errinfp = idctx->errinfp;
+
+ switch (pmember[0]->ar_member_attr) {
+ case AR_MEMBER_ATTR_ARCHIVE:
+ return PERK_CUSTOM_ERROR(dctx,
+ PERK_ERR_AR_NESTED_ARCHIVE);
+
+ case AR_MEMBER_ATTR_ARMAP:
+ case AR_MEMBER_ATTR_NAMESTRS:
+ case AR_MEMBER_ATTR_LINKINFO:
+ break;
+
+ default:
+ map.map_addr = pmember[0]->ar_object_data;
+ map.map_size = pmember[0]->ar_object_size;
+
+ if (!pe_meta_get_image_meta(dctx,&map,&meta)) {
+ if (fpurearch && (objmeta == ctx->objmeta)) {
+ m_abi = meta->m_abi;
+ m_subtype = meta->m_subtype;
+
+ } else if (fpurearch) {
+ if ((meta->m_abi != m_abi) || (meta->m_subtype != m_subtype))
+ return PERK_CUSTOM_ERROR(dctx,
+ PERK_ERR_AR_MIXED_PE_MEMBERS);
+ }
+
+ if (fvector) {
+ *objmeta++ = meta;
+ *usrobjmeta++ = meta;
+ } else {
+ pe_meta_free_image_meta(meta);
+ };
+
+
+ } else if (fstrict || fpurearch) {
+ return PERK_CUSTOM_ERROR(dctx,
+ PERK_ERR_AR_NON_PE_MEMBERS);
+
+ } else {
+ idctx->errinfp = errinfp;
+
+ for (; *errinfp; )
+ *errinfp++ = 0;
+ }
+
+ break;
+ }
+ }
+
+ return 0;
+}
+
+int pe_lib_get_unit_ctx(
const struct pe_driver_ctx * dctx,
const char * path,
struct pe_unit_ctx ** pctx)
{
struct pe_unit_ctx_impl * ctx;
int prot;
+ char * mark;
+ size_t siglen;
if (!dctx)
return PERK_CUSTOM_ERROR(
@@ -43,28 +152,48 @@ int pe_get_unit_ctx(
pe_driver_set_ectx(
dctx,0,path);
- prot = (dctx->cctx->actflags & PERK_ACTION_MAP_READWRITE)
+ prot = (dctx->cctx->drvflags & PERK_DRIVER_MAP_WRITE_ACCESS)
? PROT_READ | PROT_WRITE
: PROT_READ;
- if (pe_map_raw_image(dctx,-1,path,prot,&ctx->map))
- return pe_free_unit_ctx_impl(ctx,
+ if (pe_raw_map_raw_image(dctx,-1,path,prot,&ctx->map))
+ return pe_lib_free_unit_ctx_impl(ctx,
PERK_NESTED_ERROR(dctx));
- if (pe_get_image_meta(dctx,&ctx->map,&ctx->meta))
- return pe_free_unit_ctx_impl(ctx,
+ if (ctx->map.map_size < (siglen = sizeof(struct ar_raw_signature)))
+ return pe_lib_free_unit_ctx_impl(ctx,
+ PERK_CUSTOM_ERROR(
+ dctx,
+ PERK_ERR_INVALID_IMAGE));
+
+ if (!strncmp((mark = ctx->map.map_addr),AR_SIGNATURE,siglen)) {
+ ctx->armap.map_addr = ctx->map.map_addr;
+ ctx->armap.map_size = ctx->map.map_size;
+
+ if (pe_ar_get_archive_meta(dctx,&ctx->armap,&ctx->armeta))
+ return pe_lib_free_unit_ctx_impl(ctx,
+ PERK_NESTED_ERROR(dctx));
+
+ if (pe_lib_create_object_vector_or_verify_archive(dctx,ctx) < 0)
+ return pe_lib_free_unit_ctx_impl(ctx,
+ PERK_NESTED_ERROR(dctx));
+
+ } else if (pe_meta_get_image_meta(dctx,&ctx->map,&ctx->meta)) {
+ return pe_lib_free_unit_ctx_impl(ctx,
PERK_NESTED_ERROR(dctx));
+ }
- ctx->path = path;
- ctx->uctx.path = &ctx->path;
- ctx->uctx.map = &ctx->map;
- ctx->uctx.meta = ctx->meta;
+ ctx->path = path;
+ ctx->uctx.path = &ctx->path;
+ ctx->uctx.meta = ctx->meta;
+ ctx->uctx.armeta = ctx->armeta;
+ ctx->uctx.objmeta = ctx->usrobjmeta;
*pctx = &ctx->uctx;
return 0;
}
-void pe_free_unit_ctx(struct pe_unit_ctx * ctx)
+void pe_lib_free_unit_ctx(struct pe_unit_ctx * ctx)
{
struct pe_unit_ctx_impl * ictx;
uintptr_t addr;
@@ -72,6 +201,6 @@ void pe_free_unit_ctx(struct pe_unit_ctx * ctx)
if (ctx) {
addr = (uintptr_t)ctx - offsetof(struct pe_unit_ctx_impl,uctx);
ictx = (struct pe_unit_ctx_impl *)addr;
- pe_free_unit_ctx_impl(ictx,0);
+ pe_lib_free_unit_ctx_impl(ictx,0);
}
}
diff --git a/src/hdrdump/pe_hdrdump_coff_image_hdr.c b/src/hexdump/pe_hexdump_coff_image_hdr.c
index 3ce0e2c..c52d8d7 100644
--- a/src/hdrdump/pe_hdrdump_coff_image_hdr.c
+++ b/src/hexdump/pe_hexdump_coff_image_hdr.c
@@ -11,7 +11,7 @@
#include <perk/perk_structs.h>
#include <perk/perk_output.h>
#include "perk_driver_impl.h"
-#include "perk_hdrdump_impl.h"
+#include "perk_hexdump_impl.h"
#include "perk_dprintf_impl.h"
#include "perk_errinfo_impl.h"
@@ -19,7 +19,7 @@
#define PE_RAW_STRUCT coff_image_hdr
#define PE_OUTPUT(x) PE_OUTPUT_TABLE(x)
-int pe_hdrdump_coff_image_hdr(
+int pe_hexdump_coff_image_hdr(
const struct pe_driver_ctx * dctx,
const struct pe_image_meta * meta)
{
diff --git a/src/hdrdump/pe_hdrdump_coff_object_hdr.c b/src/hexdump/pe_hexdump_coff_object_hdr.c
index 0011a34..083d85d 100644
--- a/src/hdrdump/pe_hdrdump_coff_object_hdr.c
+++ b/src/hexdump/pe_hexdump_coff_object_hdr.c
@@ -11,7 +11,7 @@
#include <perk/perk_structs.h>
#include <perk/perk_output.h>
#include "perk_driver_impl.h"
-#include "perk_hdrdump_impl.h"
+#include "perk_hexdump_impl.h"
#include "perk_dprintf_impl.h"
#include "perk_errinfo_impl.h"
@@ -19,7 +19,7 @@
#define PE_RAW_STRUCT coff_object_hdr
#define PE_OUTPUT(x) PE_OUTPUT_TABLE(x)
-int pe_hdrdump_coff_object_hdr(
+int pe_hexdump_coff_object_hdr(
const struct pe_driver_ctx * dctx,
const struct pe_image_meta * meta)
{
diff --git a/src/hdrdump/pe_hdrdump_coff_opt_hdr.c b/src/hexdump/pe_hexdump_coff_opt_hdr.c
index fbec549..e6a1e5f 100644
--- a/src/hdrdump/pe_hdrdump_coff_opt_hdr.c
+++ b/src/hexdump/pe_hexdump_coff_opt_hdr.c
@@ -11,7 +11,7 @@
#include <perk/perk_structs.h>
#include <perk/perk_output.h>
#include "perk_driver_impl.h"
-#include "perk_hdrdump_impl.h"
+#include "perk_hexdump_impl.h"
#include "perk_dprintf_impl.h"
#include "perk_errinfo_impl.h"
@@ -19,7 +19,7 @@
#define PE_RAW_STRUCT opt_hdr_32
#define PE_OUTPUT(x) PE_OUTPUT_TABLE(x)
-static int pe_hdrdump_opt_hdr_32(
+static int pe_hexdump_opt_hdr_32(
const struct pe_driver_ctx * dctx,
const struct pe_image_meta * meta)
{
@@ -109,7 +109,7 @@ static int pe_hdrdump_opt_hdr_32(
#define PE_RAW_STRUCT opt_hdr_64
#define PE_OUTPUT(x) PE_OUTPUT_TABLE(x)
-static int pe_hdrdump_opt_hdr_64(
+static int pe_hexdump_opt_hdr_64(
const struct pe_driver_ctx * dctx,
const struct pe_image_meta * meta)
{
@@ -190,7 +190,7 @@ static int pe_hdrdump_opt_hdr_64(
return 0;
}
-int pe_hdrdump_coff_opt_hdr(
+int pe_hexdump_coff_opt_hdr(
const struct pe_driver_ctx * dctx,
const struct pe_image_meta * meta)
{
@@ -199,10 +199,10 @@ int pe_hdrdump_coff_opt_hdr(
switch (pe_image_bits(meta)) {
case 32:
- return pe_hdrdump_opt_hdr_32(dctx,meta);
+ return pe_hexdump_opt_hdr_32(dctx,meta);
case 64:
- return pe_hdrdump_opt_hdr_64(dctx,meta);
+ return pe_hexdump_opt_hdr_64(dctx,meta);
default:
return PERK_CUSTOM_ERROR(
diff --git a/src/hdrdump/pe_hdrdump_export_hdr.c b/src/hexdump/pe_hexdump_export_hdr.c
index a413097..d1e3a33 100644
--- a/src/hdrdump/pe_hdrdump_export_hdr.c
+++ b/src/hexdump/pe_hexdump_export_hdr.c
@@ -11,7 +11,7 @@
#include <perk/perk_structs.h>
#include <perk/perk_output.h>
#include "perk_driver_impl.h"
-#include "perk_hdrdump_impl.h"
+#include "perk_hexdump_impl.h"
#include "perk_dprintf_impl.h"
#include "perk_errinfo_impl.h"
@@ -19,7 +19,7 @@
#define PE_RAW_STRUCT export_hdr
#define PE_OUTPUT(x) PE_OUTPUT_TABLE(x)
-int pe_hdrdump_export_hdr(
+int pe_hexdump_export_hdr(
const struct pe_driver_ctx * dctx,
const struct pe_image_meta * meta)
{
diff --git a/src/hdrdump/pe_hdrdump_image_dos_hdr.c b/src/hexdump/pe_hexdump_image_dos_hdr.c
index c290079..9579279 100644
--- a/src/hdrdump/pe_hdrdump_image_dos_hdr.c
+++ b/src/hexdump/pe_hexdump_image_dos_hdr.c
@@ -11,7 +11,7 @@
#include <perk/perk_structs.h>
#include <perk/perk_output.h>
#include "perk_driver_impl.h"
-#include "perk_hdrdump_impl.h"
+#include "perk_hexdump_impl.h"
#include "perk_dprintf_impl.h"
#include "perk_errinfo_impl.h"
@@ -19,7 +19,7 @@
#define PE_RAW_STRUCT image_dos_hdr
#define PE_OUTPUT(x) PE_OUTPUT_TABLE(x)
-int pe_hdrdump_image_dos_hdr(
+int pe_hexdump_image_dos_hdr(
const struct pe_driver_ctx * dctx,
const struct pe_image_meta * meta)
{
diff --git a/src/hdrdump/pe_hdrdump_import_tbl.c b/src/hexdump/pe_hexdump_import_tbl.c
index f7cdb24..41c7fe9 100644
--- a/src/hdrdump/pe_hdrdump_import_tbl.c
+++ b/src/hexdump/pe_hexdump_import_tbl.c
@@ -11,7 +11,7 @@
#include <perk/perk_structs.h>
#include <perk/perk_output.h>
#include "perk_driver_impl.h"
-#include "perk_hdrdump_impl.h"
+#include "perk_hexdump_impl.h"
#include "perk_dprintf_impl.h"
#include "perk_errinfo_impl.h"
@@ -19,7 +19,7 @@
#define PE_RAW_STRUCT import_hdr
#define PE_OUTPUT(x) PE_OUTPUT_TABLE(x)
-static int pe_hdrdump_import_hdr_impl(
+static int pe_hexdump_import_hdr_impl(
const struct pe_driver_ctx * dctx,
const struct pe_image_meta * meta,
int32_t idx)
@@ -92,7 +92,7 @@ static int pe_hdrdump_import_hdr_impl(
return 0;
}
-int pe_hdrdump_import_tbl(
+int pe_hexdump_import_tbl(
const struct pe_driver_ctx * dctx,
const struct pe_image_meta * meta)
{
@@ -102,7 +102,7 @@ int pe_hdrdump_import_tbl(
return 0;
for (idx=0; idx<=meta->m_stats.t_nimplibs; idx++)
- if (pe_hdrdump_import_hdr_impl(dctx,meta,idx) < 0)
+ if (pe_hexdump_import_hdr_impl(dctx,meta,idx) < 0)
return PERK_NESTED_ERROR(dctx);
return 0;
diff --git a/src/hdrdump/pe_hdrdump_sec_tbl.c b/src/hexdump/pe_hexdump_sec_tbl.c
index 8379d6d..a9c74b0 100644
--- a/src/hdrdump/pe_hdrdump_sec_tbl.c
+++ b/src/hexdump/pe_hexdump_sec_tbl.c
@@ -11,7 +11,7 @@
#include <perk/perk_structs.h>
#include <perk/perk_output.h>
#include "perk_driver_impl.h"
-#include "perk_hdrdump_impl.h"
+#include "perk_hexdump_impl.h"
#include "perk_dprintf_impl.h"
#include "perk_errinfo_impl.h"
@@ -19,7 +19,7 @@
#define PE_RAW_STRUCT sec_hdr
#define PE_OUTPUT(x) PE_OUTPUT_TABLE(x)
-static int pe_hdrdump_sec_hdr_impl(
+static int pe_hexdump_sec_hdr_impl(
const struct pe_driver_ctx * dctx,
const struct pe_image_meta * meta,
uint32_t idx)
@@ -69,14 +69,14 @@ static int pe_hdrdump_sec_hdr_impl(
return 0;
}
-int pe_hdrdump_sec_tbl(
+int pe_hexdump_sec_tbl(
const struct pe_driver_ctx * dctx,
const struct pe_image_meta * meta)
{
uint32_t idx;
for (idx=0; idx<meta->m_coff.cfh_num_of_sections; idx++)
- if (pe_hdrdump_sec_hdr_impl(dctx,meta,idx) < 0)
+ if (pe_hexdump_sec_hdr_impl(dctx,meta,idx) < 0)
return PERK_NESTED_ERROR(dctx);
return 0;
diff --git a/src/info/pe_get_image_abi.c b/src/info/pe_info_get_image_abi.c
index 0bdcbb8..faf141b 100644
--- a/src/info/pe_get_image_abi.c
+++ b/src/info/pe_info_get_image_abi.c
@@ -16,7 +16,7 @@ static const char * const pe_abi_str[PE_ABI_CAP] = {
[PE_ABI_PE64] = "PE64",
};
-int pe_get_image_abi(const struct pe_image_meta * m, struct pe_info_string * infostr)
+int pe_info_get_image_abi(const struct pe_image_meta * m, struct pe_info_string * infostr)
{
int abi;
diff --git a/src/info/pe_get_image_framework.c b/src/info/pe_info_get_image_framework.c
index 31b6760..b56ae38 100644
--- a/src/info/pe_get_image_framework.c
+++ b/src/info/pe_info_get_image_framework.c
@@ -26,7 +26,7 @@ static const char * const pe_framework_str[PE_FRAMEWORK_CAP] = {
[PE_FRAMEWORK_WIN32] = "win32",
};
-int pe_get_image_framework(const struct pe_image_meta * m, struct pe_info_string * infostr)
+int pe_info_get_image_framework(const struct pe_image_meta * m, struct pe_info_string * infostr)
{
int framework;
diff --git a/src/info/pe_get_image_subsystem.c b/src/info/pe_info_get_image_subsystem.c
index ac9655e..dfe1b80 100644
--- a/src/info/pe_get_image_subsystem.c
+++ b/src/info/pe_info_get_image_subsystem.c
@@ -23,7 +23,7 @@ static const char * const pe_subsystem_str[0x10] = {
[PE_IMAGE_SUBSYSTEM_XBOX] = "xbox"
};
-int pe_get_image_subsystem(const struct pe_image_meta * m, struct pe_info_string * infostr)
+int pe_info_get_image_subsystem(const struct pe_image_meta * m, struct pe_info_string * infostr)
{
int subsystem;
diff --git a/src/info/pe_get_image_subtype.c b/src/info/pe_info_get_image_subtype.c
index 4d7ae5d..4a2b1da 100644
--- a/src/info/pe_get_image_subtype.c
+++ b/src/info/pe_info_get_image_subtype.c
@@ -19,7 +19,7 @@ static const char * const pe_subtype_str[PE_SUBTYPE_CAP] = {
[PE_SUBTYPE_OBJ] = "obj",
};
-int pe_get_image_subtype(const struct pe_image_meta * m, struct pe_info_string * infostr)
+int pe_info_get_image_subtype(const struct pe_image_meta * m, struct pe_info_string * infostr)
{
int subtype;
diff --git a/src/internal/perk_ar_impl.h b/src/internal/perk_ar_impl.h
new file mode 100644
index 0000000..0da7559
--- /dev/null
+++ b/src/internal/perk_ar_impl.h
@@ -0,0 +1,116 @@
+/***************************************************************/
+/* perk: PE Resource Kit */
+/* Copyright (C) 2015--2025 SysDeer Technologies, LLC */
+/* Released under GPLv2 and GPLv3; see COPYING.PERK. */
+/***************************************************************/
+
+#ifndef SLIBTOOL_AR_IMPL_H
+#define SLIBTOOL_AR_IMPL_H
+
+#include "argv/argv.h"
+#include <perk/perk.h>
+#include <perk/perk_arbits.h>
+
+/* decimal values in archive header are right padded with ascii spaces */
+#define AR_DEC_PADDING (0x20)
+
+/* archive file members are right padded as needed with ascii newline */
+#define AR_OBJ_PADDING (0x0A)
+
+/* initial number of elements in the transient, on-stack vector */
+# define AR_STACK_VECTOR_ELEMENTS (0x200)
+
+/* bit mask to indicate that the first non-option argument is <posname> */
+#define AR_POSNAME_MASK (PERK_DRIVER_AR_POSITION_AFTER \
+ |PERK_DRIVER_AR_POSITION_BEFORE)
+
+#define AR_UPDATE_MASK (PERK_DRIVER_AR_UPDATE_MEMBERS \
+ |PERK_DRIVER_AR_REPLACE_MEMBERS)
+
+#define AR_ACTION_MASK (PERK_DRIVER_AR_LIST_MEMBERS \
+ |PERK_DRIVER_AR_MOVE_MEMBERS \
+ |PERK_DRIVER_AR_UPDATE_MEMBERS \
+ |PERK_DRIVER_AR_DELETE_MEMBERS \
+ |PERK_DRIVER_AR_APPEND_MEMBERS \
+ |PERK_DRIVER_AR_REPLACE_MEMBERS \
+ |PERK_DRIVER_AR_EXTRACT_MEMBERS \
+ |PERK_DRIVER_AR_PRINT_MEMBERS)
+
+extern const struct argv_option pe_ar_options[];
+
+struct ar_armaps_impl {
+ struct ar_meta_armap_ref_32 * armap_symrefs_32;
+ struct ar_meta_armap_ref_64 * armap_symrefs_64;
+ struct ar_raw_armap_bsd_32 armap_bsd_32;
+ struct ar_raw_armap_bsd_64 armap_bsd_64;
+ struct ar_raw_armap_sysv_32 armap_sysv_32;
+ struct ar_raw_armap_sysv_64 armap_sysv_64;
+ struct ar_meta_armap_common_32 armap_common_32;
+ struct ar_meta_armap_common_64 armap_common_64;
+ uint64_t armap_nsyms;
+};
+
+struct pe_archive_meta_impl {
+ const struct pe_driver_ctx * dctx;
+ struct pe_archive_ctx * actx;
+ size_t ofmtattr;
+ size_t nentries;
+ void * hdrinfov;
+ char * namestrs;
+ const char * symstrs;
+ const char ** symstrv;
+ const char ** mapstrv;
+ off_t * offsetv;
+ struct ar_meta_symbol_info * syminfo;
+ struct ar_meta_symbol_info ** syminfv;
+ struct ar_meta_member_info ** memberv;
+ struct ar_meta_member_info * members;
+ struct ar_armaps_impl armaps;
+ struct pe_txtfile_ctx * nminfo;
+ struct pe_archive_meta armeta;
+};
+
+struct ar_meta_member_info * pe_archive_member_from_offset(
+ struct pe_archive_meta_impl * meta,
+ off_t offset);
+
+int pe_ar_parse_primary_armap_bsd_32(
+ const struct pe_driver_ctx * dctx,
+ struct pe_archive_meta_impl * m);
+
+int pe_ar_parse_primary_armap_bsd_64(
+ const struct pe_driver_ctx * dctx,
+ struct pe_archive_meta_impl * m);
+
+int pe_ar_parse_primary_armap_sysv_32(
+ const struct pe_driver_ctx * dctx,
+ struct pe_archive_meta_impl * m);
+
+int pe_ar_parse_primary_armap_sysv_64(
+ const struct pe_driver_ctx * dctx,
+ struct pe_archive_meta_impl * m);
+
+int pe_update_mapstrv(
+ const struct pe_driver_ctx * dctx,
+ struct pe_archive_meta_impl * m);
+
+int pe_ar_update_syminfo(
+ struct pe_archive_ctx * actx);
+
+int pe_ar_update_syminfo_ex(
+ struct pe_archive_ctx * actx,
+ int fdout);
+
+static inline struct pe_archive_meta_impl * pe_archive_meta_ictx(const struct pe_archive_meta * meta)
+{
+ uintptr_t addr;
+
+ if (meta) {
+ addr = (uintptr_t)meta - offsetof(struct pe_archive_meta_impl,armeta);
+ return (struct pe_archive_meta_impl *)addr;
+ }
+
+ return 0;
+}
+
+#endif
diff --git a/src/internal/perk_dprintf_impl.c b/src/internal/perk_dprintf_impl.c
index 30d3d11..8e834e4 100644
--- a/src/internal/perk_dprintf_impl.c
+++ b/src/internal/perk_dprintf_impl.c
@@ -4,7 +4,9 @@
#include <unistd.h>
#include <errno.h>
-int pe_dprintf(int fd, const char * fmt, ...)
+#include "perk_visibility_impl.h"
+
+perk_hidden int pe_dprintf(int fd, const char * fmt, ...)
{
int ret;
int cnt;
diff --git a/src/internal/perk_driver_impl.h b/src/internal/perk_driver_impl.h
index dafad86..22e7894 100644
--- a/src/internal/perk_driver_impl.h
+++ b/src/internal/perk_driver_impl.h
@@ -13,11 +13,15 @@
#define PERK_OPTV_ELEMENTS 64
extern const struct argv_option pe_default_options[];
+extern const struct argv_option pe_perk_options[];
+extern const struct argv_option pe_ar_options[];
enum app_tags {
TAG_HELP,
TAG_VERSION,
+ TAG_CMD,
TAG_PRETTY,
+ TAG_VERBOSE,
TAG_CATEGORY,
TAG_SECTIONS,
TAG_SYMBOLS,
@@ -28,6 +32,8 @@ enum app_tags {
TAG_DSOLIBS,
TAG_DSOSYMS,
TAG_HDRDUMP,
+ TAG_AR_LIST_MEMBERS,
+ TAG_AR_PRINT_MEMBERS,
};
struct pe_driver_ctx_impl {
@@ -43,10 +49,14 @@ struct pe_driver_ctx_impl {
};
struct pe_unit_ctx_impl {
- const char * path;
- struct pe_raw_image map;
- struct pe_image_meta * meta;
- struct pe_unit_ctx uctx;
+ const char * path;
+ struct pe_raw_image map;
+ struct pe_image_meta * meta;
+ struct pe_raw_archive armap;
+ struct pe_archive_meta * armeta;
+ struct pe_image_meta ** objmeta;
+ const struct pe_image_meta**usrobjmeta;
+ struct pe_unit_ctx uctx;
};
@@ -78,42 +88,42 @@ static inline void pe_driver_set_ectx(
static inline int pe_driver_fdin(const struct pe_driver_ctx * dctx)
{
struct pe_fd_ctx fdctx;
- pe_get_driver_fdctx(dctx,&fdctx);
+ pe_lib_get_driver_fdctx(dctx,&fdctx);
return fdctx.fdin;
}
static inline int pe_driver_fdout(const struct pe_driver_ctx * dctx)
{
struct pe_fd_ctx fdctx;
- pe_get_driver_fdctx(dctx,&fdctx);
+ pe_lib_get_driver_fdctx(dctx,&fdctx);
return fdctx.fdout;
}
static inline int pe_driver_fderr(const struct pe_driver_ctx * dctx)
{
struct pe_fd_ctx fdctx;
- pe_get_driver_fdctx(dctx,&fdctx);
+ pe_lib_get_driver_fdctx(dctx,&fdctx);
return fdctx.fderr;
}
static inline int pe_driver_fdlog(const struct pe_driver_ctx * dctx)
{
struct pe_fd_ctx fdctx;
- pe_get_driver_fdctx(dctx,&fdctx);
+ pe_lib_get_driver_fdctx(dctx,&fdctx);
return fdctx.fdlog;
}
static inline int pe_driver_fdcwd(const struct pe_driver_ctx * dctx)
{
struct pe_fd_ctx fdctx;
- pe_get_driver_fdctx(dctx,&fdctx);
+ pe_lib_get_driver_fdctx(dctx,&fdctx);
return fdctx.fdcwd;
}
static inline int pe_driver_fddst(const struct pe_driver_ctx * dctx)
{
struct pe_fd_ctx fdctx;
- pe_get_driver_fdctx(dctx,&fdctx);
+ pe_lib_get_driver_fdctx(dctx,&fdctx);
return fdctx.fddst;
}
diff --git a/src/internal/perk_errinfo_impl.c b/src/internal/perk_errinfo_impl.c
index 22b084e..d930c1a 100644
--- a/src/internal/perk_errinfo_impl.c
+++ b/src/internal/perk_errinfo_impl.c
@@ -7,8 +7,9 @@
#include <perk/perk.h>
#include "perk_driver_impl.h"
#include "perk_errinfo_impl.h"
+#include "perk_visibility_impl.h"
-int pe_record_error(
+perk_hidden int pe_record_error(
const struct pe_driver_ctx * dctx,
int esyscode,
int elibcode,
diff --git a/src/internal/perk_hdrdump_impl.c b/src/internal/perk_hexdump_impl.c
index 6bf1867..01effe0 100644
--- a/src/internal/perk_hdrdump_impl.c
+++ b/src/internal/perk_hexdump_impl.c
@@ -10,7 +10,8 @@
#include <perk/perk.h>
#include <perk/perk_consts.h>
#include <perk/perk_structs.h>
-#include "perk_hdrdump_impl.h"
+#include "perk_hexdump_impl.h"
+#include "perk_visibility_impl.h"
#define PE_TABWIDTH 8
#define PE_HDRSPACE 40
@@ -24,7 +25,7 @@ static const char pe_hex_header_dot[] =
static const char pe_hex_footer[] =
"|---------------------------------------------------| |-----------------|\n\n";
-size_t pe_output_hex_header(
+perk_hidden size_t pe_output_hex_header(
char * buf,
const char * sname,
uint64_t faddr,
@@ -94,7 +95,7 @@ size_t pe_output_hex_header(
return ch - buf;
}
-size_t pe_output_hex_footer(char * buf)
+perk_hidden size_t pe_output_hex_footer(char * buf)
{
size_t nlen;
@@ -107,7 +108,7 @@ size_t pe_output_hex_footer(char * buf)
return PE_HDRSPACE + nlen;
}
-size_t pe_output_raw_element(
+perk_hidden size_t pe_output_raw_element(
char * ch,
const void * rdata,
const char * mname,
diff --git a/src/internal/perk_hdrdump_impl.h b/src/internal/perk_hexdump_impl.h
index 379d427..379d427 100644
--- a/src/internal/perk_hdrdump_impl.h
+++ b/src/internal/perk_hexdump_impl.h
diff --git a/src/internal/perk_synopsis_impl.h b/src/internal/perk_synopsis_impl.h
new file mode 100644
index 0000000..f3d0a3a
--- /dev/null
+++ b/src/internal/perk_synopsis_impl.h
@@ -0,0 +1,46 @@
+/***************************************************************/
+/* perk: PE Resource Kit */
+/* Copyright (C) 2015--2025 SysDeer Technologies, LLC */
+/* Released under GPLv2 and GPLv3; see COPYING.PERK. */
+/***************************************************************/
+
+#ifndef SLIBTOOL_SYNOPSIS_IMPL_H
+#define SLIBTOOL_SYNOPSIS_IMPL_H
+
+#define PERK_DEFAULT_CMD_SYNOPSIS \
+ "%s — PE/COFF Resource Kit\n\n" \
+ "Synopsis:\n" \
+ " %s [option] ...\n" \
+ " %s --cmd=<command> [option] ...\n" \
+ " %s --cmd=<command> [option] ... <file> ...\n\n" \
+ "Options:\n"
+
+#define PERK_PERK_CMD_SYNOPSIS \
+ "%s — PE/COFF Resource Kit\n\n" \
+ "Synopsis:\n" \
+ " %s [option] ...\n" \
+ " %s [option] ... <file> ...\n\n" \
+ "Options:\n"
+
+#define PERK_AR_CMD_SYNOPSIS \
+ "%s — the PE/COFF Resource Kit Archiver\n\n" \
+ "Synopsis:\n" \
+ " %s -d [-v] <archive> <file> ...\n" \
+ " %s -p [-v] [-s] <archive> <file> ...\n" \
+ " %s -q [-v] [-c] <archive> <file> ...\n" \
+ " %s -r [-v] [-c] [-u] <archive> <file> ...\n" \
+ " %s -t [-v] [-s] <archive> [<file> ...]\n" \
+ " %s -x [-v] [-s] [-C] [-T] <archive> [<file> ...]\n\n" \
+ \
+ " %s -m [-v] <archive> <file> ...\n" \
+ " %s -m -a [-v] <posname> <archive> <file> ...\n" \
+ " %s -m -b [-v] <posname> <archive> <file> ...\n" \
+ " %s -m -i [-v] <posname> <archive> <file> ...\n\n" \
+ \
+ " %s -r [-v] [-c] [-u] <archive> <file> ...\n" \
+ " %s -r -a [-v] [-c] [-u] <posname> <archive> <file> ...\n" \
+ " %s -r -b [-v] [-c] [-u] <posname> <archive> <file> ...\n" \
+ " %s -r -i [-v] [-c] [-u] <posname> <archive> <file> ...\n\n" \
+ "Options:\n"
+
+#endif
diff --git a/src/internal/perk_visibility_impl.h b/src/internal/perk_visibility_impl.h
new file mode 100644
index 0000000..0057b8b
--- /dev/null
+++ b/src/internal/perk_visibility_impl.h
@@ -0,0 +1,26 @@
+#ifndef PERK_VISIBILITY_IMPL_H
+#define PERK_VISIBILITY_IMPL_H
+
+/**********************************************************************/
+/* PE targets: __dllexport suffices for the purpose of exporting only */
+/* the desired subset of global symbols; this makes the visibility */
+/* attribute not only redundant, but also tricky if not properly */
+/* supported by the toolchain. */
+/* */
+/* When targeting Midipix hosts, where elf-like visibility is fully */
+/* supported and may be detected via the __PE_VISIBILITY__ macro, */
+/* we utilize the attribute to render private symbols invisibile */
+/* to dlsym(), as well as reduce the size of the .gotstrs section. */
+/**********************************************************************/
+
+#if defined(__PE_VISIBILITY__)
+#define perk_hidden _ATTR_VISIBILITY_HIDDEN
+#elif defined(__PE__)
+#define perk_hidden
+#elif defined(_ATTR_VISIBILITY_HIDDEN)
+#define perk_hidden _ATTR_VISIBILITY_HIDDEN
+#else
+#define perk_hidden
+#endif
+
+#endif
diff --git a/src/logic/pe_get_image_meta.c b/src/logic/pe_image_meta_data.c
index daf6939..9753487 100644
--- a/src/logic/pe_get_image_meta.c
+++ b/src/logic/pe_image_meta_data.c
@@ -34,12 +34,12 @@ static int pe_free_image_meta_impl(struct pe_image_meta * meta, int ret)
return ret;
}
-void pe_free_image_meta(struct pe_image_meta * meta)
+void pe_meta_free_image_meta(struct pe_image_meta * meta)
{
pe_free_image_meta_impl(meta,0);
}
-int pe_get_named_section_index(const struct pe_image_meta * m, const char * name)
+static int pe_get_named_section_index(const struct pe_image_meta * m, const char * name)
{
int i; for (i=0; i<m->m_coff.cfh_num_of_sections; i++)
if (!(strcmp(name,m->m_sectbl[i].sh_name)))
@@ -48,7 +48,12 @@ int pe_get_named_section_index(const struct pe_image_meta * m, const char * name
return -1;
}
-int pe_get_block_section_index(const struct pe_image_meta * m, const struct pe_block * block)
+int pe_meta_get_named_section_index(const struct pe_image_meta * m, const char * name)
+{
+ return pe_get_named_section_index(m,name);
+}
+
+static int pe_get_block_section_index(const struct pe_image_meta * m, const struct pe_block * block)
{
int i;
uint32_t low,high;
@@ -67,7 +72,12 @@ int pe_get_block_section_index(const struct pe_image_meta * m, const struct pe_b
return -1;
}
-int pe_get_roffset_from_rva(const struct pe_image_meta * m, uint32_t rva, uint32_t * roffset)
+int pe_meta_get_block_section_index(const struct pe_image_meta * m, const struct pe_block * block)
+{
+ return pe_get_block_section_index(m,block);
+}
+
+int pe_meta_get_roffset_from_rva(const struct pe_image_meta * m, uint32_t rva, uint32_t * roffset)
{
int i;
uint32_t low,high;
@@ -85,7 +95,7 @@ int pe_get_roffset_from_rva(const struct pe_image_meta * m, uint32_t rva, uint32
return -1;
}
-int pe_get_rva_from_roffset(const struct pe_image_meta * m, uint32_t roffset, uint32_t * rva)
+int pe_meta_get_rva_from_roffset(const struct pe_image_meta * m, uint32_t roffset, uint32_t * rva)
{
int i;
uint32_t low,high,ref;
@@ -110,7 +120,7 @@ int pe_get_rva_from_roffset(const struct pe_image_meta * m, uint32_t roffset, ui
return -1;
}
-int pe_get_expsym_by_name(
+static int pe_get_expsym_by_name(
const struct pe_image_meta * m,
const char * name,
struct pe_expsym * expsym)
@@ -144,7 +154,15 @@ int pe_get_expsym_by_name(
return -1;
}
-int pe_get_expsym_by_index(
+int pe_meta_get_expsym_by_name(
+ const struct pe_image_meta * m,
+ const char * name,
+ struct pe_expsym * expsym)
+{
+ return pe_get_expsym_by_name(m,name,expsym);
+}
+
+static int pe_get_expsym_by_index(
const struct pe_image_meta * m,
unsigned index,
struct pe_expsym * expsym)
@@ -173,6 +191,15 @@ int pe_get_expsym_by_index(
return 0;
}
+
+int pe_meta_get_expsym_by_index(
+ const struct pe_image_meta * m,
+ unsigned index,
+ struct pe_expsym * expsym)
+{
+ return pe_get_expsym_by_index(m,index,expsym);
+}
+
static void pe_detect_image_abi(struct pe_image_meta * m)
{
int abi;
@@ -302,7 +329,7 @@ static void pe_detect_image_framework(struct pe_image_meta * m)
m->m_framework = framework;
}
-int pe_get_image_meta(
+int pe_meta_get_image_meta(
const struct pe_driver_ctx * dctx,
const struct pe_raw_image * image,
struct pe_image_meta ** meta)
diff --git a/src/logic/pe_map_raw_image.c b/src/logic/pe_image_raw_data.c
index 03c47c7..7ab6da6 100644
--- a/src/logic/pe_map_raw_image.c
+++ b/src/logic/pe_image_raw_data.c
@@ -16,7 +16,7 @@
#include "perk_driver_impl.h"
#include "perk_errinfo_impl.h"
-int pe_map_raw_image(
+int pe_raw_map_raw_image(
const struct pe_driver_ctx * dctx,
int fd,
const char * path,
@@ -60,7 +60,7 @@ int pe_map_raw_image(
: 0;
}
-int pe_unmap_raw_image(struct pe_raw_image * map)
+int pe_raw_unmap_raw_image(struct pe_raw_image * map)
{
return munmap(map->map_addr,map->map_size);
}
diff --git a/src/output/pe_output_error.c b/src/output/pe_output_error.c
index 84a867b..50c7357 100644
--- a/src/output/pe_output_error.c
+++ b/src/output/pe_output_error.c
@@ -27,13 +27,26 @@ static const char * const pe_error_strings[PERK_ERR_CAP] = {
[PERK_ERR_NULL_CONTEXT] = "null driver or unit context",
[PERK_ERR_NULL_IMAGE] = "null image base pointer",
[PERK_ERR_INVALID_CONTEXT] = "invalid driver or unit context",
- [PERK_ERR_INVALID_IMAGE] = "invalid PE image",
+ [PERK_ERR_INVALID_IMAGE] = "invalid PE image, object, or common archive",
[PERK_ERR_IMAGE_SIZE_ZERO] = "PE image size cannot be zero",
[PERK_ERR_IMAGE_MALFORMED] = "malformed PE image detected",
[PERK_ERR_BAD_DOS_HEADER] = "bad DOS header",
[PERK_ERR_BAD_COFF_HEADER] = "bad COFF header",
[PERK_ERR_BAD_IMAGE_TYPE] = "bad PE image type",
[PERK_ERR_UNSUPPORTED_ABI] = "unsupported image abi",
+
+ [PERK_ERR_AR_NON_ARCHIVE_IMAGE]= "the parsed PE/COFF object or image is not an archive",
+ [PERK_ERR_AR_NON_PE_MEMBERS] = "format of current archive member is not PE/COFF",
+ [PERK_ERR_AR_MIXED_PE_MEMBERS] = "archive mixes objects of different architectures",
+ [PERK_ERR_AR_NESTED_ARCHIVE] = "nested archives are currently not supported",
+
+ [PERK_ERR_AR_MISSING_ACTION] = "missing action, which should be exactly one of [dqmrxpt]",
+ [PERK_ERR_AR_MULTIPLE_ACTIONS] = "exactly one action permitted, multiple actions specified",
+ [PERK_ERR_AR_MULTIPLE_ANCHORS] = "multiple anchors: may specify _before_ or _after_, but not both",
+ [PERK_ERR_AR_INVALID_ANCHORS] = "mismatched arguments: anchors are incompatible with the selected action",
+ [PERK_ERR_AR_MISSING_ANCHOR] = "missing anchor: <posname> provided, but no anchor specified",
+ [PERK_ERR_AR_NULL_POSNAME] = "null <posname> argument with [-a], [-b], or [-i]",
+ [PERK_ERR_AR_NULL_ARNAME] = "null <arname> argument",
};
static const char * pe_output_error_header(const struct pe_error_info * erri)
diff --git a/src/output/pe_output_image_category.c b/src/output/pe_output_image_category.c
index 863c84f..b3d72df 100644
--- a/src/output/pe_output_image_category.c
+++ b/src/output/pe_output_image_category.c
@@ -24,10 +24,10 @@ int pe_output_image_category(
fdout = pe_driver_fdout(dctx);
- pe_get_image_abi (meta,&abi);
- pe_get_image_subtype (meta,&subtype);
- pe_get_image_subsystem(meta,&subsystem);
- pe_get_image_framework(meta,&framework);
+ pe_info_get_image_abi (meta,&abi);
+ pe_info_get_image_subtype (meta,&subtype);
+ pe_info_get_image_subsystem(meta,&subsystem);
+ pe_info_get_image_framework(meta,&framework);
if (dctx->cctx->fmtflags & PERK_PRETTY_YAML) {
if (pe_dprintf(
diff --git a/src/output/pe_output_mdso_libraries.c b/src/output/pe_output_mdso_libraries.c
index c5ee1b4..049cd4e 100644
--- a/src/output/pe_output_mdso_libraries.c
+++ b/src/output/pe_output_mdso_libraries.c
@@ -92,7 +92,7 @@ static char * dsolib_name(const struct pe_image_meta * m, int i)
rva = va - m->m_opt.oh_mem.coh_image_base;
}
- if (pe_get_roffset_from_rva(m,(uint32_t)rva,&roffset) < 0)
+ if (pe_meta_get_roffset_from_rva(m,(uint32_t)rva,&roffset) < 0)
return 0;
return (addr = m->r_image.map_addr) + roffset;
@@ -117,14 +117,14 @@ static unsigned char * dsosym_meta(const struct pe_image_meta * m, int j)
rva = va;
}
- if ((idx = pe_get_named_section_index(m,MDSO_META_SECTION)) >= 0)
- if (idx != pe_get_block_section_index(m,&(struct pe_block){rva,0}))
+ if ((idx = pe_meta_get_named_section_index(m,MDSO_META_SECTION)) >= 0)
+ if (idx != pe_meta_get_block_section_index(m,&(struct pe_block){rva,0}))
return (unsigned char *)(-1);
if (va > rva)
return 0;
- if (pe_get_roffset_from_rva(m,rva,&roffset) < 0)
+ if (pe_meta_get_roffset_from_rva(m,rva,&roffset) < 0)
return 0;
return (unsigned char *)m->r_image.map_addr + roffset;
@@ -150,14 +150,14 @@ static char * dsosym_string(const struct pe_image_meta * m, int j)
rva = va;
}
- if ((idx = pe_get_named_section_index(m,MDSO_STRS_SECTION)) >= 0)
- if (idx != pe_get_block_section_index(m,&(struct pe_block){rva,0}))
+ if ((idx = pe_meta_get_named_section_index(m,MDSO_STRS_SECTION)) >= 0)
+ if (idx != pe_meta_get_block_section_index(m,&(struct pe_block){rva,0}))
return (char *)(-2);
if (va > rva)
return 0;
- if (pe_get_roffset_from_rva(m,rva,&roffset) < 0)
+ if (pe_meta_get_roffset_from_rva(m,rva,&roffset) < 0)
return 0;
return (addr = m->r_image.map_addr) + roffset;
@@ -180,7 +180,7 @@ int pe_output_mdso_libraries(
if (!m->m_stats.t_ndsolibs)
return 0;
- if (pe_get_image_abi(m,0) == PE_ABI_UNSUPPORTED)
+ if (pe_info_get_image_abi(m,0) == PE_ABI_UNSUPPORTED)
return PERK_CUSTOM_ERROR(
dctx,PERK_ERR_UNSUPPORTED_ABI);
diff --git a/src/skin/pe_skin_ar.c b/src/skin/pe_skin_ar.c
new file mode 100644
index 0000000..4bdce0e
--- /dev/null
+++ b/src/skin/pe_skin_ar.c
@@ -0,0 +1,35 @@
+#include "perk_driver_impl.h"
+#include "perk_visibility_impl.h"
+#include "argv/argv.h"
+
+const perk_hidden struct argv_option pe_ar_options[] = {
+ {"Wversion", 'V',TAG_VERSION,ARGV_OPTARG_NONE,
+ ARGV_OPTION_HYBRID_ONLY,0,0,
+ "show version information"},
+
+ {"Whelp", 'h',TAG_HELP,ARGV_OPTARG_NONE,
+ ARGV_OPTION_HYBRID_ONLY,0,0,
+ "show usage information"},
+
+ {"Wverbose", 'v',TAG_VERBOSE,ARGV_OPTARG_NONE,
+ ARGV_OPTION_HYBRID_ONLY,0,0,
+ "provide verbose output"},
+
+ {"Wprint", 'p',TAG_AR_PRINT_MEMBERS,ARGV_OPTARG_NONE,
+ ARGV_OPTION_HYBRID_ONLY,0,0,
+ "print archive members"},
+
+ {"Wlist", 't',TAG_AR_LIST_MEMBERS,ARGV_OPTARG_NONE,
+ ARGV_OPTION_HYBRID_ONLY,0,0,
+ "list archive members; names only be default, "
+ "or otherwise a detailed table of contents in "
+ "verbose mode"},
+
+ {"Wpretty", 0,TAG_PRETTY,ARGV_OPTARG_REQUIRED,
+ ARGV_OPTION_HYBRID_ONLY|ARGV_OPTION_HYBRID_EQUAL,
+ "yaml|posix|hexdata",0,
+ "list archive members or print content "
+ "using the %s format specification"},
+
+ {0,0,0,0,0,0,0,0}
+};
diff --git a/src/skin/pe_skin_default.c b/src/skin/pe_skin_default.c
index 963af6e..95024c7 100644
--- a/src/skin/pe_skin_default.c
+++ b/src/skin/pe_skin_default.c
@@ -1,54 +1,17 @@
#include "perk_driver_impl.h"
+#include "perk_visibility_impl.h"
#include "argv/argv.h"
-const struct argv_option pe_default_options[] = {
+const perk_hidden struct argv_option pe_default_options[] = {
{"version", 'v',TAG_VERSION,ARGV_OPTARG_NONE,0,0,0,
"show version information"},
{"help", 'h',TAG_HELP,ARGV_OPTARG_OPTIONAL,0,"short|long",0,
"show usage information [listing %s options only]"},
- {"pretty", 'p',TAG_PRETTY,ARGV_OPTARG_REQUIRED,0,"yaml|dlltool",0,
- "format output for parsing by %s"},
-
- {"category", 'y',TAG_CATEGORY,ARGV_OPTARG_NONE,0,0,0,
- "print image category"},
-
- {"sections", 'c',TAG_SECTIONS,ARGV_OPTARG_NONE,0,0,0,
- "list image sections"},
-
- {"symbols", 'm',TAG_SYMBOLS,ARGV_OPTARG_NONE,0,0,0,
- "list symbols found in the coff symbol table"},
-
- {"strings", 's',TAG_STRINGS,ARGV_OPTARG_NONE,0,0,0,
- "list strings found in the coff string table"},
-
- {"expsyms", 'e',TAG_EXPSYMS,ARGV_OPTARG_NONE,0,0,0,
- "list exported symbols" },
-
- {"implibs", 'i',TAG_IMPLIBS,ARGV_OPTARG_NONE,0,0,0,
- "list .idata dependency libraries"},
-
- {"impsyms", 'I',TAG_IMPSYMS,ARGV_OPTARG_NONE,0,0,0,
- "list .idata dependency libraries "
- "along with imported symbols"},
-
- {"dsolibs", 'd',TAG_DSOLIBS,ARGV_OPTARG_NONE,0,0,0,
- "list .dsometa (mdso) dependency libraries"},
-
- {"dsosyms", 'D',TAG_DSOSYMS,ARGV_OPTARG_NONE,0,0,0,
- "list .dsometa (mdso) dependency libraries "
- "along with referenced symbols"},
-
- {"hdrdump", 'X',TAG_HDRDUMP,ARGV_OPTARG_OPTIONAL,0,
- "dos|image.dos|"
- "coff|coff.image|coff.object|coff.optional|"
- "sectbl|section.table|"
- "exphdr|export.header|"
- "imptbl|import.table",0,
- "output struct-based information for "
- "either all headers (the default) "
- "or a specific header"},
+ {"cmd", 0,TAG_CMD,ARGV_OPTARG_REQUIRED,0,
+ "perk|ar",0,
+ "invoke one of the following perk commands: {%s}"},
{0,0,0,0,0,0,0,0}
};
diff --git a/src/skin/pe_skin_perk.c b/src/skin/pe_skin_perk.c
new file mode 100644
index 0000000..a6ea35f
--- /dev/null
+++ b/src/skin/pe_skin_perk.c
@@ -0,0 +1,55 @@
+#include "perk_driver_impl.h"
+#include "perk_visibility_impl.h"
+#include "argv/argv.h"
+
+const perk_hidden struct argv_option pe_perk_options[] = {
+ {"version", 'v',TAG_VERSION,ARGV_OPTARG_NONE,0,0,0,
+ "show version information"},
+
+ {"help", 'h',TAG_HELP,ARGV_OPTARG_OPTIONAL,0,"short|long",0,
+ "show usage information [listing %s options only]"},
+
+ {"pretty", 'p',TAG_PRETTY,ARGV_OPTARG_REQUIRED,0,"yaml|dlltool",0,
+ "format output for parsing by %s"},
+
+ {"category", 'y',TAG_CATEGORY,ARGV_OPTARG_NONE,0,0,0,
+ "print image category"},
+
+ {"sections", 'c',TAG_SECTIONS,ARGV_OPTARG_NONE,0,0,0,
+ "list image sections"},
+
+ {"symbols", 'm',TAG_SYMBOLS,ARGV_OPTARG_NONE,0,0,0,
+ "list symbols found in the coff symbol table"},
+
+ {"strings", 's',TAG_STRINGS,ARGV_OPTARG_NONE,0,0,0,
+ "list strings found in the coff string table"},
+
+ {"expsyms", 'e',TAG_EXPSYMS,ARGV_OPTARG_NONE,0,0,0,
+ "list exported symbols" },
+
+ {"implibs", 'i',TAG_IMPLIBS,ARGV_OPTARG_NONE,0,0,0,
+ "list .idata dependency libraries"},
+
+ {"impsyms", 'I',TAG_IMPSYMS,ARGV_OPTARG_NONE,0,0,0,
+ "list .idata dependency libraries "
+ "along with imported symbols"},
+
+ {"dsolibs", 'd',TAG_DSOLIBS,ARGV_OPTARG_NONE,0,0,0,
+ "list .dsometa (mdso) dependency libraries"},
+
+ {"dsosyms", 'D',TAG_DSOSYMS,ARGV_OPTARG_NONE,0,0,0,
+ "list .dsometa (mdso) dependency libraries "
+ "along with referenced symbols"},
+
+ {"hdrdump", 'X',TAG_HDRDUMP,ARGV_OPTARG_OPTIONAL,0,
+ "dos|image.dos|"
+ "coff|coff.image|coff.object|coff.optional|"
+ "sectbl|section.table|"
+ "exphdr|export.header|"
+ "imptbl|import.table",0,
+ "output struct-based information for "
+ "either all headers (the default) "
+ "or a specific header"},
+
+ {0,0,0,0,0,0,0,0}
+};
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-05 04:49:33 +0000