../pkg/configure --default-format=txz

# GitHub action to compile pkg on ubuntu-24.04, ubuntu-latest/22.04 (amd64) and macos-latest (arm64)

# We run in a matrix with os/number of workers, to demonstrate the errors on MacOSX when running 

# pkg repo multi-threaded.

# Intended to increase awareness in issues with MacOS builds of pkg.

        name: build ${{ matrix.workers-count }} ${{ matrix.build-os }} ${{ matrix.compiler }}

                workers-count:

                - 0

                - 1

                  - build-os: ubuntu-24.04

                    workers-count: 1

                  - build-os: ubuntu-latest

                    workers-count: 1

            HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=Y brew install ${{ join(matrix.pkgs, ' ') }}

            # this is miracolously not picked up by automake as the default

            echo Building pkg

            ${GITHUB_WORKSPACE}/src.pkg/configure --prefix=${INST_PKG} --with-libarchive.pc --with-libcurl --with-openssl.pc

            make

        - name: test&instal pkg

            echo Checking and  pkg

            if WORKERS_COUNT=${{ matrix.workers-count }} make check; then

            tar cvf pkg-${{ matrix.build-os }}-${{ matrix.compiler }}-report${{ matrix.workers-count }}.tar -C "${BUILD_PKG}/html" .

              name: pkg-test${{ matrix.workers-count }}-${{ matrix.build-os }}-${{ matrix.compiler }}

*.So

/external/libmachista/Makefile

pkg - a binary package manager for FreeBSD

==========================================

* [Local Database](#localdb)

* [Upgrading packages](#pkgupg)

* [Deleting packages](#pkgdel)

* [Installing pkg](#installpkg)

* [pkg in Ports](#pkgports)

* [Building pkg using sources from Git](#pkggit)

* [A quick usage introduction to pkg](#usageintro)

* [Getting help on the commands usage](#pkghelp)

* [Querying the local package database](#pkginfo)

* [Installing packages](#pkginstalling)

* [Working with a remote package repository](#pkgrepos)

* [Working with multiple remote package repositories](#multirepos)

* [Updating remote repositories](#pkgupdate)

* [Searching in remote package repositories](#pkgsearch)

* [Installing from remote repositories](#pkginstall)

* [Creating a package repository](#pkgcreate)

SourceHut CI:

[![builds.sr.ht status](https://builds.sr.ht/~bapt/pkg/commits/master/freebsd.svg)](https://builds.sr.ht/~bapt/pkg/commits/master/freebsd?)

[![builds.sr.ht status](https://builds.sr.ht/~bapt/pkg/commits/master/alpine.svg)](https://builds.sr.ht/~bapt/pkg/commits/master/alpine?)

[![builds.sr.ht status](https://builds.sr.ht/~bapt/pkg/commits/master/debian.svg)](https://builds.sr.ht/~bapt/pkg/commits/master/debian?)

#### The metadata

pkg uses several files for metadata:

* +COMPACT\_MANIFEST

* +MANIFEST

##### COMPACT\_MANIFEST

This is a subset of the information included in the main MANIFEST,

omitting the lists of files, checksums, directories and scripts.

It contains the information used to build the repository catalogue.

##### MANIFEST

The manifest is in [UCL](https://github.com/vstakhov/libucl) format, it contains all the

information about the package:

	name: foo

	version: 1.0

	origin: category/foo

	comment: this is foo package

	arch: i386

	www: http://www.foo.org

	maintainer: foo@bar.org

	prefix: /usr/local

	licenselogic: or

	licenses: [MIT, MPL]

	flatsize: 482120

	users: [USER1, USER2]

	groups: [GROUP1, GROUP2]

	options: { OPT1: off, OPT2: on }

	desc: <<EOD

	  This is the description

	  Of foo

	  A component of bar

	EOD

	categories: [bar, plop]

	deps: {

	  libiconv: {origin: converters/libiconv, version: 1.13.1_2};

	  perl: {origin: lang/perl5.12, version: 5.12.4 };

	}

	files: {

	  /usr/local/bin/foo: 'sha256sum',

	  /usr/local/bin/i_am_a_link: 'sha256sum';

	  /usr/local/share/foo-1.0/foo.txt: 'sha256sum;

	}

	directories: {

	  /usr/local/share/foo-1.0 : 'y';

	}

	scripts: {

	  post-install: <<EOD

	    #!/bin/sh

	    echo post-install

	EOD

	  pre-install: <<EOD

	    #!/bin/sh

	    echo pre-install

	EOD

	}

Valid scripts are:

* pre-install

* post-install

* install

* pre-deinstall

* post-deinstall

* deinstall

Script *MUST* be in sh format.

Nothing else will work.

The shebang is not required.

When the manifest is read by pkg\_create files and dirs can use an

alternate format:

	files: {

	  /usr/local/bin/foo: 'sha256sum',

	  /usr/local/bin/bar: {sum: 'sha256sum', uname: baruser, gname: foogroup, perm: 0644 }

	}

	directories: {

	  /usr/local/share/foo-1.0: 'y',

	  /path/to/directory: {uname: foouser, gname: foogroup, perm: 0755}

	}

This allows overriding the users, groups and mode of files and

directories during package creation.

So, for example, this allows to creation of a package containing

root-owned files without being packaged by the root user.

<a name="localdb"></a>

### Local database

When a package is installed, it is registered in a SQLite database.

The SQLite database allows fast queries and ACID transactions.  It also

allows finding the reverse dependencies reliably without needing the

__+REQUIRED_BY__ hack.

In order to save space the MTREE is only stored once, which saves 18K per

installed package.

pkg supports a `register` command to register packages into the SQLite

database from the ports. The register command can execute the install script,

show pkg-message, ...

`pkg add` can install a package archive from the local disk, or from a

remote FTP/HTTP server.

If only a package name is given, it will search the repository catalogues

and download and install the package if it exists. Any dependencies will be

downloaded and installed first.

This is possible because we have the dependency information in the

catalogue of the remote repository.

`pkg add` will check if the user attempts to install a package built

for another arch or release.

<a name="pkgupg"></a>

### Upgrading packages

pkg also supports upgrades of binary packages.

pkg will compare the versions of installed packages and those available in

the repository. It will compute the proper update order and apply them.

<a name="pkgdel"></a>

### Deleting packages

`pkg delete` will remove a package, and (depending on the command line

arguments) any other packages that depend on what you're trying to

delete.

Directory leftovers are automatically removed if they are empty and

not in the MTREE.

<a name="installpkg"></a>

## Installing pkg

There are three ways to install pkg: two for general day-to-day use,

and the third if you want to help with pkg development.

<a name="pkgports"></a>

### pkg in Ports

pkg-1.0 release was committed to the ports tree on 30th August 2012,

and a series of further releases are planned.  To install the latest

release version:

	$ make -C /usr/ports/ports-mgmt/pkg install clean

	$ echo "WITH_PKG=yes" >> /etc/make.conf

<a name="pkggit"></a>

### Building pkg using sources from Git [FreeBSD]

In order to build pkg from source, you will need to have GNU

autotools and some other tools installed.

	# pkg install autoconf automake libtool pkgconf

The next thing to do is to get the pkg sources installed on your machine.

You can grab a development snapshot of pkg from the [pkg GitHub repository][1]

To get the latest version of pkg from the Git repo, just clone it:

	% git clone https://github.com/freebsd/pkg

or

	% git clone git@github.com:freebsd/pkg.git

Or you can take an already tagged release of pkg from the above web

page as well.

Just open your browser and download the release you want.

Once you have the pkg sources, installing it is fairly easy:

	% cd pkg

	% ./configure

	% make

	# make install

Now you should have the latest pkg installed on your system.  Note

that this build and install procedure does not update the local

package database at all, so you will get some odd effects due to the

packaging system being misled into thinking an older version of pkg is

installed.

Note: if you're running anything other than FreeBSD or DragonFly, you

will need to do some porting work.  The pkg(8) codebase should be

reasonably portable onto anything with a c99 compiler, POSIX compliant

system and capable of running GNU autotools.  However, various places

in the pkg(8) code make assumptions about OS specific behaviour.  If

you do try anything like this, we'd be very interested to hear how you

get on.

<a name="usageintro"></a>

## A quick usage introduction to pkg

In this section of the document we will try to give a quick and dirty

introduction on the practical usage of pkg - installing packages,

searching in remote package repositories, updating remote package

repositories and installing from them, etc.

<a name="pkghelp"></a>

### Getting help on the commands usage

In order to get help on any of the pkg commands you should use the `pkg help <command>`

command, which will take the man page of the specified command.

In order to get the available commands in pkg, just execute `pkg help`

	# pkg help

	# pkg help <command>

<a name="pkginfo"></a>

### Querying the local package database

In order to get information about installed packages use the `pkg

info` command.

`pkg info` will query the local package database and display

information about the package you are interested in.

To list all install/registered packages in the local database, use

this command:

	# pkg info -a

For more information on querying the local package database, please

refer to *pkg-info(1)* man page.

<a name="pkginstalling"></a>

### Installing packages

Packages are installed either from a repository, from the results of a

local compilation of software via the ports or from a pkg tarball

independently obtained from some other source.

A repository is a collection of packages which have been gathered

together, had a catalogue created and then published, typically by

exposing the repository via HTTP or some other networking protocol.

You can also publish a repository from a local or NFS mounted

filesystem (using file:// style URLs) or via SSH (using ssh:// URLs.)

<a name="pkgrepos"></a>

### Working with a remote package repository

While pkg(8) can deal with individual package tarballs, the real power

comes from the use of repositories, which publish a 'catalogue' of

meta-data about the packages they contain.

You can configure pkg(8) to use one or several repositories.

Supported versions of FreeBSD now contain a default configuration out

of the box: `/etc/pkg/FreeBSD.conf` which is setup to install packages

from the official package repositories.

To add additional repositories, create a per-repository configuration

file in `/usr/local/etc/pkg/repos` -- it doesn't matter what the

filename is other than it must match '*.conf' and you should add a

'priority' setting indicating the preference order.  This is just an

integer, where higher values indicate the more preferred repositories.

Priority defaults to 0 unless explicitly stated.  This is the value

for the default `/etc/pkg/FreeBSD.conf`

To disable the default FreeBSD.conf, create a file

`/usr/local/etc/pkg/repos/FreeBSD.conf` with the contents:

```

FreeBSD: { enabled: no }

```

To check quickly what repositories you have configured, run `pkg -vv`.

See *pkg.conf(5)* for details of the format of `pkg.conf` and the

per-repository `repo.conf` files.  See *pkg-repository(5)* for more

details about package repositories and how to work with them.

Note that the old style of setting _PACKAGESITE_ in pkg.conf is

no-longer supported.  Setting _PACKAGESITE_ in the environment has

meaning for the pkg(7) shim, but is ignored by pkg(8).

<a name="pkgupdate"></a>

### Updating from remote repositories

Then fetch the repository catalogues using the command:

	# pkg update

For more information on updating from remote repositories, please

refer to *pkg-update(1)*.

This will fetch the remote package database to your local system. Now

in order to install packages from the remote repository, you can use

the `pkg install` command:

	# pkg install zsh cfengine3

<a name="multirepos"></a>

### Working with multiple repositories

If you have more than one repository defined, then you probably want

to install some packages from a specific repository, but allow others

to be obtained from whatever repository has them available.

You can install a package from a specific repository:

    # pkg install -r myrepo zsh

where `myrepo` is one of the tags shown in the `pkg -vv` output.

pkg(8) will automatically create an annotation showing which

repository a package came from, similarly to the effect of running:

    # pkg annotate -A pkgname repository myrepo

pkg(8) will attempt to use the same repository for any updates to this

package, even if there are more recent versions available from other

repositories.  This is usually the desired behaviour.  Otherwise see

the documentation for `CONSERVATIVE_UPGRADE` in pkg.conf(5).

<a name="pkgsearch"></a>

### Searching in remote package repositories

You can search in the remote package repositories using the `pkg

search` command.

If you have multiple repositories configured, `pkg search` will return

results from searching each of them.  Use the `-r reponame` option to

confine your search to a specific repository.

An example search for a package could be done like this:

	# pkg search -x apache

For more information on the repositories search, please refer to

*pkg-search(1)*

<a name="pkginstall"></a>

### Installing from remote repositories

pkg(8) will install a package from the highest priority repository

that contains the package and that allows the solver to satisfy the

package dependencies.  This may entail reinstalling existing packages

from a different repository.

The process continues until the package is fetched and installed, or

all remote repositories fail to fetch the package.

Remote installations of packages using pkg are done by the `pkg

install` command.

Here's an example installation of few packages:

	# pkg install www/apache22

	# pkg install zsh

	# pkg install perl5-5.18.2_4

Or you could also install the packages using only one command, like this:

	# pkg install www/apache22 zsh perl5-5.18.2_4

For more information on the remote package installs, please refer to

*pkg-install(1)*

<a name="pkgcreate"></a>

### Creating a package repository

You can also use pkg, so that you create a package repository.

In order to create a package repository you need to use the `pkg

create` command.

Here's an example that will create a repository of all your currently

installed packages:

	# cd /path/with/enough/space

	# pkg create -a

	# pkg repo .

The above commands will create a repository of all packages on your system.

Now you can share your repo with other people by letting them know of

your repository :)

* The Git repository of [pkg is hosted on GitHub][1]

* The [pkg Wiki page][2]

[pkg issue tracker][3].

[1]: https://github.com/freebsd/pkg

[2]: http://wiki.freebsd.org/pkg

[3]: https://github.com/freebsd/pkg/issues

	define pkg_freebsd

if {![cc-check-functions __res_query]} {

	cc-with { -libs { -lresolv }} {

		if {[cc-check-functions __res_query]} {

			define-feature LIBRESOLV

		}

	}

}

foreach header [list endian.h sys/endian.h] {

	if {[cc-check-includes $header]} {

		cc-with [list -includes $header] {

			cc-check-decls be16dec be16enc be32dec be32enc be64dec be64enc \

				le16dec le16enc le32dec le32enc le64dec le64enc

	define libmachista

	external/libucl external/libelf external/libmachista tests docs \

@if libmachista

DIRS+=	libmachista

@endif

Copyright (c) 2011 Clemens Lang <cal@macports.org>

Copyright (c) 2011 - 2014 Landon Fuller <landonf@macports.org>

Copyright (c) 2004 - 2014, The MacPorts Project.

Copyright (c) 2002 - 2003, Apple Inc.

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions

are met:

1. Redistributions of source code must retain the above copyright

   notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright

   notice, this list of conditions and the following disclaimer in the

   documentation and/or other materials provided with the distribution.

3. Neither the name of Apple Inc., The MacPorts Project nor the

   names of its contributors may be used to endorse or promote products

   derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE

FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

SUCH DAMAGE.

hashmap.c is subject to the following license:

Copyright (c) 2011 Christoph Erhardt. All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice,

   this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice,

   this list of conditions and the following disclaimer in the documentation

   and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY CHRISTOPH ERHARDT ``AS IS'' AND ANY EXPRESS OR

IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO

EVENT SHALL CHRISTOPH ERHARDT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,

INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

include @builddir@/mk/defs.mk

LIB=	machista

SRCS=	libmachista.c \

	hashmap.c

VPATH=	$(top_srcdir)/external/libmachista

include $(MK)/static-lib.mk

/* vim:expandtab:tw=80:ts=2:sts=2:sw=2

 */

/*-

 * Copyright (c) 2011 Christoph Erhardt. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY CHRISTOPH ERHARDT ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO

 * EVENT SHALL CHRISTOPH ERHARDT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,

 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

/*-

 * Modified by Clemens Lang to accept values of arbitrary type.

 */

#ifndef _BSD_SOURCE

  #define _BSD_SOURCE

#endif

#ifndef _CRT_NONSTDC_NO_DEPRECATE

  #define _CRT_NONSTDC_NO_DEPRECATE

#endif

#include "hashmap.h"

#include <limits.h>

#include <stdint.h>

#include <string.h>

static const size_t INITIAL_CAPACITY = 16; /* Must be a power of 2 */

static const size_t MAXIMUM_CAPACITY = (1U << 31);

static const float  LOAD_FACTOR      = 0.75;

typedef struct HashMapEntry {

  char                *key;

  const void          *value;

  struct HashMapEntry *next;

  uint32_t             hash;

} HashMapEntry;

struct HashMap {

  HashMapEntry **table;

  size_t         capacity;

  size_t         size;

  size_t         threshold;

  void         (*freeFunc)(const void *);

};

static void setTable(HashMap *map, HashMapEntry **table, size_t capacity) {

  map->table     = table;

  map->capacity  = capacity;

  map->threshold = (size_t) (capacity * LOAD_FACTOR);

}

static uint32_t doHash(const char key[]) {

  size_t   length;

  size_t   i;

  uint32_t h = 0;

  if (key == NULL)

    return 0;

  length = strlen(key);

  for (i = 0; i < length; ++i) {

    h = (31 * h) + key[i];

  }

  h ^= (h >> 20) ^ (h >> 12);

  return h ^ (h >> 7) ^ (h >> 4);

}

static size_t indexFor(uint32_t hash, size_t length) {

  return hash & (length - 1);

}

static int isHit(HashMapEntry *e, const char key[], uint32_t hash) {

  return (e->hash == hash

          && (e->key == key || (key != NULL && strcmp(e->key, key) == 0)));

}

static void copyOrFree(void (*freeFunc)(const void *),

                       const void *value, const void **valPtr) {

  if (valPtr != NULL)

    *valPtr = value;

  else

    freeFunc(value);

}

static int updateValue(HashMap *map, HashMapEntry *e, const void *newVal,

                       const void **oldValPtr) {

  copyOrFree(map->freeFunc, e->value, oldValPtr);

  e->value = newVal;

  return 1;

}

/* Creates a hash map. */

HashMap *hashMapCreate(void (*freeFunc)(const void *)) {

  HashMapEntry **table;

  HashMap       *map = malloc(sizeof(*map));

  if (map == NULL)

    return NULL;

  table = calloc(INITIAL_CAPACITY, sizeof(*map->table));

  if (table == NULL) {

    free(map);

    return NULL;

  }

  setTable(map, table, INITIAL_CAPACITY);

  map->size = 0;

  map->freeFunc = freeFunc;

  return map;

}

/* Inserts a key-value pair into a hash map. */

int hashMapPut(HashMap *map, const char key[], const void * const value,

               const void **oldValPtr) {

  HashMapEntry  *e;

  size_t         newCapacity;

  HashMapEntry **newTable;

  size_t         i;

  /* If an entry with the same key exists, update it */

  uint32_t hash  = doHash(key);

  size_t   index = indexFor(hash, map->capacity);

  for (e = map->table[index]; e != NULL; e = e->next) {

    if (isHit(e, key, hash) == 0)

      continue;

    return updateValue(map, e, value, oldValPtr);

  }

  /* Create a new entry */

  e = calloc(1, sizeof(HashMapEntry)); /* Must be zeroed */

  if (e == NULL)

    return 0;

  /* Copy key and value into the entry */

  if (key != NULL) {

    e->key = strdup(key);

    if (e->key == NULL) {

      free(e);

      return 0;

    }

  }

  if (updateValue(map, e, value, oldValPtr) == 0) {

    free(e->key);

    free(e);

    return 0;

  }

  /* Insert entry into the table */

  e->hash = hash;

  e->next = map->table[index];

  map->table[index] = e;

  if (map->size++ < map->threshold)

    return 1;

  /* If the size exceeds the threshold, double the table's capacity */

  newCapacity = 2 * map->capacity;

  if (map->capacity == MAXIMUM_CAPACITY) {

    map->threshold = UINT_MAX;

    return 1;

  }

  newTable = calloc(newCapacity, sizeof(*newTable));

  if (newTable == NULL)

    return 0;

  /* Copy entries from the old table into the new one */

  for (i = 0; i < map->capacity; ++i) {

    HashMapEntry *next;

    for (e = map->table[i]; e != NULL; e = next) {

      index   = indexFor(e->hash, newCapacity);

      next    = e->next;

      e->next = newTable[index];

      newTable[index] = e;

    }

  }

  /* Release the old table and set the new one */

  free(map->table);

  setTable(map, newTable, newCapacity);

  return 1;

}

/* Performs a hash map lookup. */

const void *hashMapGet(HashMap *map, const char key[]) {

  HashMapEntry *e;

  uint32_t      hash  = doHash(key);

  size_t        index = indexFor(hash, map->capacity);

  for (e = map->table[index]; e != NULL; e = e->next) {

    if (isHit(e, key, hash))

      return e->value;

  }

  return NULL;

}

/* Checks whether a hash map contains an entry with a certain key. */

int hashMapContainsKey(HashMap *map, const char key[]) {

  HashMapEntry *e;

  uint32_t      hash  = doHash(key);

  size_t        index = indexFor(hash, map->capacity);

  for (e = map->table[index]; e != NULL; e = e->next) {

    if (isHit(e, key, hash))

      return 1;

  }

  return 0;

}

/* Removes a key-value pair from a hash map. */

void hashMapRemove(HashMap *map, const char key[], const void **valPtr) {

  uint32_t      hash  = doHash(key);

  size_t        index = indexFor(hash, map->capacity);

  HashMapEntry *prev  = map->table[index];

  HashMapEntry *e     = prev;

  while (e != NULL) {

    HashMapEntry *next = e->next;

    if (isHit(e, key, hash)) {

      map->size--;

      if (prev == e)

        map->table[index] = next;

      else

        prev->next = next;

      break;

    }

    prev = e;

    e    = next;

  }

  if (e == NULL) {

    copyOrFree(map->freeFunc, NULL, valPtr);

    return;

  }

  free(e->key);

  copyOrFree(map->freeFunc, e->value, valPtr);

  free(e);

}

/* Returns the number of elements stored in a hash map. */

size_t hashMapSize(const HashMap *map) {

  return map->size;

}

/* Checks whether a hash map is empty. */

int hashMapIsEmpty(const HashMap *map) {

  return (map->size == 0);

}

/* Removes all entries from a hash map. */

void hashMapClear(HashMap *map) {

  size_t i;

  for (i = 0; i < map->capacity; ++i) {

    HashMapEntry *e;

    HashMapEntry *next;

    for (e = map->table[i]; e != NULL; e = next) {

      free(e->key);

      map->freeFunc(e->value);

      next = e->next;

      free(e);

    }

    map->table[i] = NULL;

  }

}

/* Destroys a hash map. */

void hashMapDestroy(HashMap *map) {

  if (map == NULL)

    return;

  hashMapClear(map);

  free(map->table);

  free(map);

}

/* vim:tw=80:expandtab

 */

/**

 * @file  hashmap.h

 * @brief A hash map implementation in C.

 * @author Christoph Erhardt <erhardt@cs.fau.de>

 */

/*-

 * Copyright (c) 2011 Christoph Erhardt. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY CHRISTOPH ERHARDT ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO

 * EVENT SHALL CHRISTOPH ERHARDT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,

 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

/*-

 * Modified by Clemens Lang to accept values of arbitrary type.

 */

#ifndef HASHMAP_H

#define HASHMAP_H

#include <stdlib.h>

/** Hash map type. */

typedef struct HashMap HashMap;

/**

 * @brief Creates a hash map.

 *

 * The keys and values managed in the map can be arbitrary C strings.

 * @param freeFunc Function to call in order to free a stored value

 * @return Pointer to the newly created hash map, or @c NULL on error.

 */

HashMap *hashMapCreate(void (*freeFunc)(const void *));

/**

 * @brief Inserts a key-value pair into a hash map.

 *

 * Both key and value are copied internally, so the caller can reuse the

 * original variables.

 * If oldValPtr is @c NULL, the previously stored value corresponding to the key

 * is freed. Otherwise it is written into @c *valPtr and the caller is

 * responsible for freeing it.

 * @param map       Hash map.

 * @param key       Key.

 * @param value     Value.

 * @param oldValPtr Output parameter receiving the previously stored value

 *                  corresponding to the key (@c NULL if no mapping existed

 *                  before).

 * @return Nonzero on success, 0 on error.

 */

int hashMapPut(HashMap *map, const char key[], const void * const value,

               const void **oldValPtr);

/**

 * @brief Performs a hash map lookup.

 *

 * The returned value must not be freed or otherwise manipulated by the caller.

 * @param map Hash map.

 * @param key Key.

 * @return Value corresponding to the key on success, @c NULL if no matching

 *         entry was found.

 */

const void *hashMapGet(HashMap *map, const char key[]);

/**

 * @brief Checks whether a hash map contains an entry with a certain key.

 * @param map Hash map.

 * @param key Key.

 * @return Nonzero if the map contains an entry with the given key, 0 if it does

 *         not.

 */

int hashMapContainsKey(HashMap *map, const char key[]);

/**

 * @brief Removes a key-value pair from a hash map and frees the stored key.

 *

 * If @c valPtr is @c NULL, the internally stored value corresponding to the key

 * is freed. Otherwise it is written into @c *valPtr and the caller is

 * responsible for freeing it.

 * @param map    Hash map.

 * @param key    Key.

 * @param valPtr Output parameter receiving the internally stored value

 *               corresponding to the key.

 */

void hashMapRemove(HashMap *map, const char key[], const void **valPtr);

/**

 * @brief Returns the number of elements stored in a hash map.

 * @param map Hash map.

 * @return Number of elements stored in the map.

 */

size_t hashMapSize(const HashMap *map);

/**

 * @brief Checks whether a hash map is empty.

 * @param map Hash map.

 * @return Nonzero if the map contains no entries, 0 otherwise.

 */

int hashMapIsEmpty(const HashMap *map);

/**

 * @brief Removes all entries from a hash map.

 * @param map Hash map.

 */

void hashMapClear(HashMap *map);

/**

 * @brief Destroys a hash map.

 * @param map Hash map to be destroyed.

 */

void hashMapDestroy(HashMap *map);

#endif /* HASHMAP_H */

/*

 * -*- coding: utf-8; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- vim:fenc=utf-8:filetype=c:et:sw=4:ts=4:sts=4:tw=100

 * libmachista.c

 * $Id: libmachista.c 120067 2014-05-14 22:18:53Z cal@macports.org $

 *

 * Copyright (c) 2011 The MacPorts Project

 * Copyright (c) 2011 Landon Fuller <landonf@macports.org>

 * Copyright (c) 2011 Clemens Lang <cal@macports.org>

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 */

#ifdef HAVE_CONFIG_H

#include <pkg_config.h>

#endif

/* required for asprintf(3) on OS X */

#define _DARWIN_C_SOURCE

/* required for asprintf(3) on Linux */

#define _GNU_SOURCE

#include <stdbool.h>

#include <stdio.h>

#include <stdlib.h>

#include <fcntl.h>

#include <sys/mman.h>

#include <sys/stat.h>

#include <unistd.h>

#include <err.h>

#include <string.h>

#include <strings.h>

#ifdef __MACH__

#include <mach-o/fat.h>

#include <mach-o/loader.h>

#include <libkern/OSAtomic.h>

#endif

#include "libmachista.h"

#include "hashmap.h"

#ifdef __MACH__

/* Tiger compatibility */

#ifndef LC_RPATH

#define LC_RPATH       (0x1c | LC_REQ_DYLD)    /* runpath additions */

/*

 * The rpath_command contains a path which at runtime should be added to

 * the current run path used to find @rpath prefixed dylibs.

 */

struct rpath_command {

    uint32_t     cmd;       /* LC_RPATH */

    uint32_t     cmdsize;   /* includes string */

    union lc_str path;      /* path to add to run path */

};

#endif

#ifndef LC_REEXPORT_DYLIB

#define LC_REEXPORT_DYLIB (0x1f | LC_REQ_DYLD) /* load and re-export dylib */

#endif

#endif /* __MACH__ */

typedef struct macho_input {

    const void *data;

    size_t length;

} macho_input_t;

/* This is macho_handle_t. The corresponding typedef is in the header */

struct macho_handle {

    HashMap *result_map;

};

#ifdef __MACH__

/* Verify that the given range is within bounds. */

static const void *macho_read (macho_input_t *input, const void *address, size_t length) {

    if ((((uint8_t *) address) - ((uint8_t *) input->data)) + length > input->length) {

       // warnx("Short read parsing Mach-O input");

        return NULL;

    }

    return address;

}

/* Verify that address + offset + length is within bounds. */

static const void *macho_offset (macho_input_t *input, const void *address, size_t offset, size_t length) {

    void *result = ((uint8_t *) address) + offset;

    return macho_read(input, result, length);

}

#endif

/* return a human readable formatted version number. the result must be free()'d. */

char *macho_format_dylib_version (uint32_t version) {

    char *result;

    asprintf(&result, "%"PRIu32".%"PRIu32".%"PRIu32, (version >> 16) & 0xFFFF, (version >> 8) & 0xFF, version & 0xFF);

    return result;

}

#ifdef __MACH__

const char *macho_get_arch_name (cpu_type_t cputype) {

    const NXArchInfo *archInfo = NXGetArchInfoFromCpuType(cputype, CPU_SUBTYPE_MULTIPLE);	

    if (!archInfo) {

        return NULL;

    }

    return archInfo->name;

#else

const char *macho_get_arch_name (cpu_type_t cputype UNUSED) {

    return NULL;

#endif

}

#ifdef __MACH__

/* Some byteswap wrappers */

static uint32_t macho_swap32 (uint32_t input) {

    return OSSwapInt32(input);

}

static uint32_t macho_nswap32(uint32_t input) {

    return input;

}

/* Creates a new macho_t.

 * Returns NULL on failure or a pointer to a 0-initialized macho_t on success */

static macho_t *create_macho_t (void) {

    macho_t *mt = malloc(sizeof(macho_t));

    if (mt == NULL)

        return NULL;

    memset(mt, 0, sizeof(macho_t));

    return mt;

}

/* Creates a new macho_arch_t.

 * Returns NULL on failure or a pointer to a 0-initialized macho_arch_t on success */

static macho_arch_t *create_macho_arch_t (void) {

    macho_arch_t *mat = malloc(sizeof(macho_arch_t));

    if (mat == NULL)

        return NULL;

    memset(mat, 0, sizeof(macho_arch_t));

    return mat;

}

/* Creates a new macho_loadcmd_t.

 * Returns NULL on failure or a pointer to a 0-initialized macho_loadcmd_t on success */

static macho_loadcmd_t *create_macho_loadcmd_t (void) {

    macho_loadcmd_t *mlt = malloc(sizeof(macho_loadcmd_t));

    if (mlt == NULL)

        return NULL;

    memset(mlt, 0, sizeof(macho_loadcmd_t));

    return mlt;

}

#endif

/* Frees a previously allocated macho_loadcmd_t and all it's associated resources */

static void free_macho_loadcmd_t (macho_loadcmd_t *mlt) {

    if (mlt == NULL)

        return;

    free(mlt->mlt_install_name);

    free(mlt);

}

/* Frees a previously allocated macho_arch_t and all it's associated resources */

static void free_macho_arch_t (macho_arch_t *mat) {

    if (mat == NULL)

        return;

    macho_loadcmd_t *current = mat->mat_loadcmds;

    while (current != NULL) {

        macho_loadcmd_t *freeme = current;

        current = current->next;

        free_macho_loadcmd_t(freeme);

    }

    free(mat->mat_install_name);

    free(mat->mat_rpath);

    free(mat);

}

/* Frees a previously allocated macho_t and all it's associated resources */

static void free_macho_t (macho_t *mt) {

    if (mt == NULL)

        return;

    macho_arch_t *current = mt->mt_archs;

    while (current != NULL) {

        macho_arch_t *freeme = current;

        current = current->next;

        free_macho_arch_t(freeme);

    }

    free(mt);

}

#ifdef __MACH__

/* Creates a new element in the architecture list of a macho_t (mt_archs), increases the counter of

 * architectures (mt_arch_count) and returns a pointer to the newly allocated element or NULL on

 * error */

static macho_arch_t *macho_archlist_append (macho_t *mt) {

    macho_arch_t *old_head = mt->mt_archs;

    macho_arch_t *new_head = create_macho_arch_t();

    if (new_head == NULL)

        return NULL;

    new_head->next = old_head;

    mt->mt_archs = new_head;

    return mt->mt_archs;

}

/* Creates a new element in the load command list of a macho_arch_t (mat_loadcmds), increases the

 * counter of load commands (mat_loadcmd_count) and returns a pointer to the newly allocated element

 * or NULL on error */

static macho_loadcmd_t *macho_loadcmdlist_append (macho_arch_t *mat) {

    macho_loadcmd_t *old_head = mat->mat_loadcmds;

    macho_loadcmd_t *new_head = create_macho_loadcmd_t();

    if (new_head == NULL)

        return NULL;

    new_head->next = old_head;

    mat->mat_loadcmds = new_head;

    return mat->mat_loadcmds;

}

#endif

/* Parse a Mach-O header */

#ifdef __MACH__

static int parse_macho (macho_t *mt, macho_input_t *input) {

    /* Read the file type. */

    const uint32_t *magic = macho_read(input, input->data, sizeof(uint32_t));

    if (magic == NULL)

        return MACHO_ERANGE;

    /* Parse the Mach-O header */

    bool universal = false;

    uint32_t (*swap32)(uint32_t) = macho_nswap32;

    const struct mach_header *header;

    const struct mach_header_64 *header64;

    size_t header_size;

    const struct fat_header *fat_header;

    macho_arch_t *mat = NULL;

    switch (*magic) {

        case MH_CIGAM:

            swap32 = macho_swap32;

            // Fall-through

        case MH_MAGIC:

            header_size = sizeof(*header);

            header = macho_read(input, input->data, header_size);

            if (header == NULL)

                return MACHO_ERANGE;

            mat = macho_archlist_append(mt);

            if (mat == NULL)

                return MACHO_EMEM;

            /* 32-bit Mach-O */

            mat->mat_cputype = swap32(header->cputype);

            mat->mat_cpusubtype = swap32(header->cpusubtype);

            break;

        case MH_CIGAM_64:

            swap32 = macho_swap32;

            // Fall-through

        case MH_MAGIC_64:

            header_size = sizeof(*header64);

            header64 = macho_read(input, input->data, sizeof(*header64));

            if (header64 == NULL)

                return MACHO_ERANGE;

            mat = macho_archlist_append(mt);

            if (mat == NULL)

                return MACHO_EMEM;

            /* The 64-bit header is a direct superset of the 32-bit header */

            header = (struct mach_header *) header64;

            /* 64-bit Macho-O */

            mat->mat_cputype = swap32(header->cputype);

            mat->mat_cpusubtype = swap32(header->cpusubtype);

            break;

        case FAT_CIGAM:

        case FAT_MAGIC:

            fat_header = macho_read(input, input->data, sizeof(*fat_header));

            universal = true;

            /* Universal binary */

            break;

        default:

            /* Unknown binary type */

            //warnx("Unknown Mach-O magic: 0x%" PRIx32 "", *magic);

            return MACHO_EMAGIC;

    }

    /* Parse universal file. */

    if (universal) {

        uint32_t nfat = OSSwapBigToHostInt32(fat_header->nfat_arch);

        const struct fat_arch *archs = macho_offset(input, fat_header, sizeof(struct fat_header), sizeof(struct fat_arch));

        if (archs == NULL)

            return MACHO_ERANGE;

        for (uint32_t i = 0; i < nfat; i++) { // foreach architecture

            const struct fat_arch *arch = macho_read(input, archs + i, sizeof(struct fat_arch));

            if (arch == NULL)

                return MACHO_ERANGE;

            /* Fetch a pointer to the architecture's Mach-O header. */

            macho_input_t arch_input;

            arch_input.length = OSSwapBigToHostInt32(arch->size);

            arch_input.data = macho_offset(input, input->data, OSSwapBigToHostInt32(arch->offset), arch_input.length);

            if (arch_input.data == NULL)

                return MACHO_ERANGE;

            /* Parse the architecture's Mach-O header */

            int res = parse_macho(mt, &arch_input);

            if (res != MACHO_SUCCESS)

                return res;

        }

        return MACHO_SUCCESS;

    }

    /* Copy the architecture */

    mat->mat_cputype = swap32(header->cputype);