#define  _ISOC99_SOURCE
#define  _BSD_SOURCE
#define  _POSIX_C_SOURCE 200809L

#include <unistd.h>
#include <stdlib.h>
#include <stddef.h>
#include <sys/types.h>
#include <dirent.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>

#include <stdio.h>

/* This function finds and returns a list of process IDs currently
 * running a command matching the specified parameter.
 * The parameter should be the name or base name of the command.
 * (The parameter should not specify a path.)
 *
 * If successful, the function returns a pointer to a zero-terminated list.
 * If an error occurs, the function will return NULL with errno set.
 * If no processes are found, the function will return NULL with errno == 0.
 *
 * If the kernel provides /proc/<pid>/comm files, they are used;
 * otherwise the function falls back to /proc/<pid>/cmdline files.
 * When matching, the specified parameter is compared as-is,
 * but the contents of the above files are trimmed:
 * leading path (up to and including the final /), and any trailing
 * ASCII control characters (including newlines and tabs), are ignored.
 * The result must match the parameter exactly.
 *
 * This function is thread-safe.
 * (You should disable thread cancellation while this function runs,
 *  so that if the thread is cancelled, it does not leak memory.)
*/
pid_t *pidof(const char *const command)
{
	const size_t	 command_length = (command) ? strlen(command) : 0;

	/* PID list */
	pid_t		*pid = NULL;
	size_t		 pids = 0;
	size_t		 pids_max = 0;

	/* Buffer for "/proc/<pid>/cmdline" */
	char		 path[16 + 3 * sizeof(pid_t)] = "/proc/";
	char		*name;

	/* Buffer for command data */
	char		 data[128];
	unsigned char	*contents;
	int		 descriptor;

	/* /proc handle and a directory entry */
	DIR		*dir = NULL;
	struct dirent	*dir_entry = NULL;

	/* General and temporary variables */
	struct dirent	*entry;
	int		 result;
	pid_t		 curr;
	ssize_t		 bytes;
	size_t		 length;

	/* An empty or NULL comm is invalid. */
	if (command_length < (size_t)1) {
		errno = EINVAL;
		return NULL;
	}

	dir = opendir("/proc/");
	if (!dir)
		return NULL;

	/* From this point on, some cleanup is necessary before failing.
	 * This expands to a full block { ... }. When using the macro
	 * in an if..then..else expression, you must not use a semicolon
	 * at end, or you will end the statement! */
#define RETURN_FAILURE(with_errno) 			\
	{	const int __e = (with_errno);		\
		int       __r;				\
		if (pid)       free(pid);		\
		if (dir_entry) free(dir_entry);		\
		do {					\
			__r = closedir(dir);		\
		} while (__r == -1 && errno == EINTR);	\
		errno = __e;				\
		return NULL;				\
	}

	/* Allocate a directory entry sufficiently large for /proc/ entries. */
	dir_entry = malloc( offsetof(struct dirent, d_name)
	                  + fpathconf(dirfd(dir), _PC_NAME_MAX)
	                  + (size_t)1 );
	if (!dir_entry)
		RETURN_FAILURE(ENOMEM);

	while (1) {

		/* Get the next directory entry. */
		do {
			entry = NULL;
			result = readdir_r(dir, dir_entry, &entry);
		} while (result == -1 && errno == EINTR);
		if (result == -1)
			RETURN_FAILURE(errno);

		/* All done? */
		if (!entry)
			break;

#ifdef _DIRENT_HAVE_D_TYPE
		/* Skip entries that are not directories. */
		if (entry->d_type != DT_UNKNOWN && entry->d_type != DT_DIR)
			continue;
#endif

		/* Ignore entries not starting with a digit. */
		if (!(entry->d_name[0] >= '0' && entry->d_name[0] <= '9'))
			continue;

		/* Parse the PID, and construct the path at the same time. */
		{	const char	*src = (const char *)&(entry->d_name[0]);

			/* Skip "/proc/" in path. */
			name = path + 6;

			curr = (pid_t)0;

			while (*src >= '0' && *src <= '9') {
				const pid_t	prev = curr;

				curr = (pid_t)10 * curr + (pid_t)(*src - '0');
				if (curr < prev)
					break; /* Overflow! */

				*(name++) = *(src++);
			}

			/* Overflow? Not a PID directory? */
			if (*src)
				continue;
		}

		/* Append slash to the path. */
		*(name++) = '/';

		/* Open /proc/<pid>/comm file. */
		name[0] = 'c';
		name[1] = 'o';
		name[2] = 'm';
		name[3] = 'm';
		name[4] = 0;
		do {
			descriptor = open(path, O_RDONLY | O_NOCTTY);
		} while (descriptor == -1 && errno == EINTR);
		if (descriptor != -1)
			goto opened;

		/* Open /proc/<pid>/cmdline file. */
		name[0] = 'c';
		name[1] = 'm';
		name[2] = 'd';
		name[3] = 'l';
		name[4] = 'i';
		name[5] = 'n';
		name[6] = 'e';
		name[7] = 0;
		do {
			descriptor = open(path, O_RDONLY | O_NOCTTY);
		} while (descriptor == -1 && errno == EINTR);
		if (descriptor != -1)
			goto opened;

		/* The process no longer exists, or we don't have sufficient
		 * access rights to know what it is. So ignore it. */
		continue;

	opened:
		/* Read the initial part of the file. Note that it is a procfs file,
		 * so a loop (for less than a page of data) is not necessary.
		 * All read errors are treated as if the file was never there. */
		do {
			bytes = read(descriptor, data, sizeof(data) - (size_t)1);
		} while (bytes == (ssize_t)-1 && errno == EINTR);

		/* Close the file. */
		do {
			result = close(descriptor);
		} while (result == -1 && errno == EINTR);

		/* Did we get anything out of the file? */
		if (bytes < (ssize_t)1)
			continue;

		/* Yes, bytes bytes. */
		data[bytes] = 0;

		/* Skip leading dash, or directory part if a path. */
		if (data[0] == '-')
			contents = (unsigned char *)data + 1;
		else
		if (data[0] == '/')
			contents = (unsigned char *)strrchr(data, '/') + 1;
		else
			contents = (unsigned char *)data;

		/* Trim out trailing control characters. */
		length = strlen((char *)contents);
		while (length > (size_t)0 && (contents[length - 1] < 32 || contents[length - 1] == 127))
			length--;
		contents[length] = 0;

		/* The result must match the given command exactly. */
		if (length != command_length || strcmp(command, (char *)contents))
			continue;

		/* Grow pid list if necessary. */
		if (pids >= pids_max) {
			const size_t	 new_max = pids + 128;
			pid_t		*new_pid;

			new_pid = realloc(pid, sizeof(pid_t) * (new_max + (size_t)1));
			if (!new_pid)
				RETURN_FAILURE(ENOMEM);

			pid      = new_pid;
			pids_max = new_max;
		}

		/* Append this pid to the list. */
		pid[pids++] = curr;
	}

	/* Close the directory handle. */
	do {
		result = closedir(dir);
	} while (result == -1 && errno == EINTR);
	if (result) 
		RETURN_FAILURE(errno);

	/* The RETURN_FAILURE macro is not valid after this point. */
#undef  RETURN_FAILURE

	/* If there are no pids, discard the list. */
	if (!pids && pid) {
		free(pid);
		pid = NULL;
	}

	/* If there are pids, terminate the list. */
	if (pids)
		pid[pids] = (pid_t)0;

	/* Done. */
	errno = 0;
	return pid;

}


int main(int argc, char *argv[])
{
	int	 arg, i, n;
	pid_t	*list;

	for (arg = 1; arg < argc; arg++) {

		list = pidof(argv[arg]);
		if (!list) {
			if (errno) {
				fprintf(stderr, "%s: %s.\n", argv[arg], strerror(errno));
				fflush(stderr);
			} else {
				fprintf(stdout, "%s: No processes.\n", argv[arg]);
				fflush(stdout);
			}
			continue;
		}

		n = 0; while (list[n]) n++;
		fprintf(stdout, "%s: Found %d processes:\n", argv[arg], n);
		for (i = 0; i < n; i++)
			fprintf(stdout, "\t%d\n", (int)list[i]);
		fflush(stdout);

		free(list);
	}

	return 0;
}

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <dirent.h>
#include <stdlib.h>
#include <errno.h>

/* Limit the number of binaries specified on the command line,
 * so we won't consume too many file descriptors et cetera.
*/
#define   MAX_BINARIES          512

#define   EXITSTATUS_OK		0	/* Success */
#define   EXITSTATUS_OUTPUT	1	/* Error writing to standard output */
#define   EXITSTATUS_NONE       0	/* No files found */
#define   EXITSTATUS_TOOMANY    2       /* Too many binaries specified */
#define   EXITSTATUS_MEMORY	2	/* Out of memory */
#define   EXITSTATUS_OPENDIR	3	/* Cannot open /proc */
#define   EXITSTATUS_READDIR	3	/* Error reading /proc */
#define   EXITSTATUS_CLOSEDIR	3	/* Error closing /proc */

/* Output buffer. */
static unsigned char		 out_data[65536];
static unsigned char *const	 out_ends = out_data + sizeof(out_data);
static unsigned char *const	 out_mark = out_data + 2 + 3 * sizeof(unsigned long);
static unsigned char		*out_next = out_data + sizeof(out_data);
static int			 out_errno = 0;

/* Flush output. */
static inline int out_flush(void)
{
	const int		 f = STDOUT_FILENO;
	unsigned char		*p = out_next;
	unsigned char *const	 q = out_ends;
	ssize_t			 n;

	/* Mark buffer clear */
	out_next = out_ends;

	/* Previous error? */
	if (out_errno)
		return out_errno;

	while (p < q) {

		/* Read some new data. */
		n = write(f, p, (size_t)(q - p));

		if (n > (ssize_t)0)
			p += n;

		else
		if (n != (ssize_t)-1)
			return out_errno = EIO;

		else
		if (errno != EINTR)
			return out_errno = errno;

	}

	return 0;
}

/* Write a PID and a newline to standard output. */
static inline void out_pid(const pid_t pid)
{
	/* Note: PIDs are always positive. */
	unsigned long	u = (unsigned long)pid;

	/* If the buffer is full, flush it. */
	if (out_next < out_mark)
		out_flush();

	/* Prepend the PID to the buffer. */
	*(--out_next) = '\n';
	do {
		*(--out_next) = '0' + (u % 10UL);
		u /= 10UL;
	} while (u);

	/* Done. */
	return;
}

int main(int argc, char *argv[])
{
	size_t		 count = 0;
	dev_t		 device[MAX_BINARIES];
	ino_t		 inode[MAX_BINARIES];
	int		 descriptor[MAX_BINARIES];

	DIR		*dir = NULL;
	struct dirent	*entry;
	char		 exe[128] = "/proc/"; /* "/proc/<pid>/exe" */

	struct stat	 info;
	size_t		 i;
	pid_t		 pid;
	const char	*src;
	char		*dst;
	int		 arg, result, desc;

	/* Scan the named files on the command line. */
	for (arg = 1; arg < argc; arg++) {

		/* Open file read-only. */
		do {
			desc = open(argv[arg], O_RDONLY | O_NOCTTY);
		} while (desc == -1 && errno == EINTR);
		if (desc == -1)
			continue;

		/* Get statistics on it. */
		do {
			result = fstat(desc, (struct stat *)&info);
		} while (result == -1 && errno == EINTR);
		if (result == -1) {
			do {
				result = close(desc);
			} while (result == -1 && errno == EINTR);
			continue;
		}

		/* Check if already listed. */
		for (i = 0; i < count; i++)
			if (device[i] == info.st_dev && inode[i] == info.st_ino)
				break;
		if (i < count) {
			do {
				result = close(desc);
			} while (result == -1 && errno == EINTR);
			continue;
		}

		/* Too many? */
		if (count >= (size_t)MAX_BINARIES) {
			for (i = 0; i < count; i++)
				do {
					result = close(descriptor[i]);
				} while (result == -1 && errno == EINTR);
			return EXITSTATUS_TOOMANY;
		}

		/* Append device and inode to the list. */
		device[count]     = info.st_dev;
		inode[count]      = info.st_ino;
		descriptor[count] = desc;
		count++;
	}

	/* Any files found? */
	if (count < (size_t)1)
		return EXITSTATUS_NONE;

	/* Open /proc for scanning. */
	do {
		dir = opendir("/proc/");
	} while (!dir && errno == EINTR);
	if (!dir) {
		for (i = 0; i < count; i++)
			do {
				result = close(descriptor[i]);
			} while (result == -1 && errno == EINTR);
		return EXITSTATUS_OPENDIR;
	}

	/* Scan loop. */
	while (1) {

		do {
			errno = 0;
			entry = readdir(dir);
		} while (!entry && errno == EINTR);
		if (!entry)
			break;

#if defined(_DIRENT_HAVE_D_TYPE) && defined(DT_DIR) && defined(DT_UNKNOWN)
		/* Skip entries that are not directories. */
		if (entry->d_type != DT_DIR && entry->d_type != DT_UNKNOWN)
			continue;
#endif

		/* Skip entries that do not begin with a digit. */
		if (!(entry->d_name[0] >= '0' && entry->d_name[0] <= '9'))
			continue;

		/* Parse the entry as a PID, but construct /proc/PID simultaneously. */
		src = (const char *)&(entry->d_name[0]);
		dst = (char *)&(exe[6]); /* Skip "/proc/", which is already there. */

		pid = (pid_t)0;
		while (*src >= '0' && *src <= '9') {
			const pid_t	old = pid;

			pid = (pid_t)10 * pid + (pid_t)(*src - '0');

			/* Check for overflow */
			if (pid < old)
				break;

			*(dst++) = *(src++);
		}

		/* Not a valid PID? */
		if (!pid || *src)
			continue;

		/* Complete the exe name. */
		dst[0] = '/';
		dst[1] = 'e';
		dst[2] = 'x';
		dst[3] = 'e';
		dst[4] = 0;

		/* Get the statistics on the symlink target.
		 * Note that this operation may fail, if the process has
		 * already exited. */
		do {
			result = stat(exe, (struct stat *)&info);
		} while (result == -1 && errno == EINTR);
		if (result == -1)
			continue;

		/* Check if we have a match. */
		for (i = 0; i < count; i++)
			if (device[i] == info.st_dev && inode[i] == info.st_ino)
				break;
		/* No match? */
		if (i >= count)
			continue;

		/* Output this pid. */
		out_pid(pid);
	}

	/* Read error? */
	if (errno) {
		do {
			result = closedir(dir);
		} while (result == -1 && errno == EINTR);
		for (i = 0; i < count; i++)
			do {
				result = close(descriptor[i]);
			} while (result == -1 && errno == EINTR);
		out_flush();
		return EXITSTATUS_READDIR;
	}

	/* Close the directory. */
	do {
		result = closedir(dir);
	} while (result == -1 && errno == EINTR);
	if (result == -1) {
		for (i = 0; i < count; i++)
			do {
				result = close(descriptor[i]);
			} while (result == -1 && errno == EINTR);
		out_flush();
		return EXITSTATUS_CLOSEDIR;
	}

	/* Close all descriptors. We no longer need them,
	 * to keep the device and inode numbers stable. */
	for (i = 0; i < count; i++)
		do {
			result = close(descriptor[i]);
		} while (result == -1 && errno == EINTR);

	/* Flush output. */
	if (out_flush())
		return EXITSTATUS_OUTPUT;

	/* All done successfully. */
	return EXITSTATUS_OK;	
}

gcc -Wall -pedantic -std=c99 -o pidof-executable pidof-executable.c
sudo install -m 04755 pidof-executable /usr/local/bin/pidof-executable