embedaddon/mpd/src/util.c - diff

Return to util.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mpd / src

Diff for /embedaddon/mpd/src/util.c between versions 1.1 and 1.1.1.3

version 1.1, 2012/02/21 23:32:47	version 1.1.1.3, 2016/11/01 09:56:12
Line 10	Line 10
#include "ppp.h"	#include "ppp.h"
#include "util.h"	#include "util.h"
#include <termios.h>	#include <termios.h>
	#include <paths.h>

	#include <libutil.h>
#include <netdb.h>	#include <netdb.h>
#include <tcpd.h>	#include <tcpd.h>
#include <sys/wait.h>	#include <sys/wait.h>
#include <sys/sysctl.h>	#include <sys/sysctl.h>
#include <net/route.h>	#include <net/route.h>
#include <netinet/if_ether.h>	#include <netinet/if_ether.h>
	#include <net/ethernet.h>
	#include <osreldate.h>

/*	/*
* DEFINITIONS	* DEFINITIONS
Line 32	Line 36
* INTERNAL VARIABLES	* INTERNAL VARIABLES
*/	*/

	#ifndef USE_NG_PRED1
static const u_int16_t Crc16Table[256] = {	static const u_int16_t Crc16Table[256] = {
/* 00 */ 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,	/* 00 */ 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
/* 08 */ 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,	/* 08 */ 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
Line 66 static const u_int16_t Crc16Table[256] = {	Line 71 static const u_int16_t Crc16Table[256] = {
/* f0 */ 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,	/* f0 */ 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
/* f8 */ 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78	/* f8 */ 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
};	};
	#endif

static FILE *lockFp = NULL;	static FILE *lockFp = NULL;

Line 73 static const u_int16_t Crc16Table[256] = {	Line 79 static const u_int16_t Crc16Table[256] = {
* INTERNAL FUNCTIONS	* INTERNAL FUNCTIONS
*/	*/

static int UuLock(const char *devname);
static int UuUnlock(const char *devname);

static void Escape(char *line);	static void Escape(char *line);
static char ReadLine(FILE fp, int lineNum, char result, int resultsize);	static char ReadLine(FILE fp, int lineNum, char result, int resultsize);

Line 130 ExecCmd(int log, const char label, const char fmt, .	Line 133 ExecCmd(int log, const char label, const char fmt, .

/* Hide any stdout output of command */	/* Hide any stdout output of command */

snprintf(cmdn + strlen(cmdn), sizeof(cmdn) - strlen(cmdn), " >/dev/null 2>&1");	snprintf(cmdn + strlen(cmdn), sizeof(cmdn) - strlen(cmdn), " >%s 2>&1", _PATH_DEVNULL);

/* Do command */	/* Do command */

Line 202 ExecCmdNosh(int log, const char label, const char fm	Line 205 ExecCmdNosh(int log, const char label, const char fm
(void)sigaction(SIGQUIT, &quitact, NULL);	(void)sigaction(SIGQUIT, &quitact, NULL);
(void)sigprocmask(SIG_SETMASK, &oldsigblock, NULL);	(void)sigprocmask(SIG_SETMASK, &oldsigblock, NULL);
close(1);	close(1);
open("/dev/null", O_WRONLY);	open(_PATH_DEVNULL, O_WRONLY);
close(2);	close(2);
open("/dev/null", O_WRONLY);	open(_PATH_DEVNULL, O_WRONLY);
execv(argv[0], argv);	execv(argv[0], argv);
exit(127);	exit(127);
default: /* parent */	default: /* parent */
Line 388 ReadFile(const char filename, const char target,	Line 391 ReadFile(const char filename, const char target,
/* Open file */	/* Open file */

if ((fp = OpenConfFile(filename, &cf)) == NULL)	if ((fp = OpenConfFile(filename, &cf)) == NULL)
return(-1);	return(-2);

/* Find label */	/* Find label */

Line 666 ReadLine(FILE fp, int lineNum, char *result, int res	Line 669 ReadLine(FILE fp, int lineNum, char *result, int res
return(result);	return(result);
}	}

	#ifdef PHYSTYPE_MODEM
/*	/*
* OpenSerialDevice()	* OpenSerialDevice()
*	*
Line 737 ExclusiveOpenDevice(const char label, const char pat	Line 741 ExclusiveOpenDevice(const char label, const char pat

/* Lock device UUCP style, if it resides in /dev */	/* Lock device UUCP style, if it resides in /dev */

if (!strncmp(pathname, "/dev/", 5))	if (!strncmp(pathname, _PATH_DEV, 5))
{	{
	int res;
ttyname = pathname + 5;	ttyname = pathname + 5;
if (UuLock(ttyname) < 0)	if ((res = uu_lock(ttyname)) != UU_LOCK_OK) {
{	Log(LG_ERR, ("[%s] uu_lock(%s): %s", label, ttyname, uu_lockerr(res)));
Log(LG_ERR, ("[%s] can't lock device %s", label, ttyname));
return(-1);	return(-1);
}	}
locked = TRUE;	locked = TRUE;
Line 757 ExclusiveOpenDevice(const char label, const char pat	Line 761 ExclusiveOpenDevice(const char label, const char pat
{	{
Perror("[%s] can't open %s", label, pathname);	Perror("[%s] can't open %s", label, pathname);
if (locked)	if (locked)
UuUnlock(ttyname);	uu_unlock(ttyname);
return(-1);	return(-1);
}	}

Line 768 ExclusiveOpenDevice(const char label, const char pat	Line 772 ExclusiveOpenDevice(const char label, const char pat
Log(LG_ERR, ("[%s] can't open %s after %d secs",	Log(LG_ERR, ("[%s] can't open %s after %d secs",
label, pathname, MAX_OPEN_DELAY));	label, pathname, MAX_OPEN_DELAY));
if (locked)	if (locked)
UuUnlock(ttyname);	uu_unlock(ttyname);
return(-1);	return(-1);
}	}
(void) fcntl(fd, F_SETFD, 1);	(void) fcntl(fd, F_SETFD, 1);
Line 810 ExclusiveCloseDevice(const char *label, int fd, const	Line 814 ExclusiveCloseDevice(const char *label, int fd, const

/* Remove lock */	/* Remove lock */

if (!strncmp(pathname, "/dev/", 5))	if (!strncmp(pathname, _PATH_DEV, 5))
{	{
ttyname = pathname + 5;	ttyname = pathname + 5;
if (UuUnlock(ttyname) < 0)	if (uu_unlock(ttyname) < 0)
Perror("[%s] can't unlock %s", label, ttyname);	Perror("[%s] can't unlock %s", label, ttyname);
}	}
}	}
	#endif /* PHYSTYPE_MODEM */

/*
* UuLock()
*
* Try to atomically create lockfile. Returns negative if failed.
*/

static int
UuLock(const char *ttyname)
{
int fd, pid;
char tbuf[sizeof(PATH_LOCKFILENAME) + MAX_FILENAME];
char pid_buf[64];

snprintf(tbuf, sizeof(tbuf), PATH_LOCKFILENAME, ttyname);
if ((fd = open(tbuf, O_RDWR\|O_CREAT\|O_EXCL, 0664)) < 0)
{

/* File is already locked; Check to see if the process
* holding the lock still exists */

if ((fd = open(tbuf, O_RDWR, 0)) < 0)
{
Perror("%s: open(%s)", __FUNCTION__, tbuf);
return(-1);
}

if (read(fd, pid_buf, sizeof(pid_buf)) <= 0)
{
(void)close(fd);
Perror("%s: read", __FUNCTION__);
return(-1);
}

pid = atoi(pid_buf);

if (kill(pid, 0) == 0 \|\| errno != ESRCH)
{
(void)close(fd); /* process is still running */
return(-1);
}

/* The process that locked the file isn't running, so we'll lock it */

if (lseek(fd, (off_t) 0, L_SET) < 0)
{
(void)close(fd);
Perror("%s: lseek", __FUNCTION__);
return(-1);
}
}

/* Finish the locking process */

sprintf(pid_buf, "%10u\n", (int) gPid);
if (write(fd, pid_buf, strlen(pid_buf)) != strlen(pid_buf))
{
(void)close(fd);
(void)unlink(tbuf);
Perror("%s: write", __FUNCTION__);
return(-1);
}
(void)close(fd);
return(0);
}

/*	/*
* UuUnlock()
*/

static int
UuUnlock(const char *ttyname)
{
char tbuf[sizeof(PATH_LOCKFILENAME) + MAX_FILENAME];

(void) sprintf(tbuf, PATH_LOCKFILENAME, ttyname);
return(unlink(tbuf));
}

/*
* GenerateMagic()	* GenerateMagic()
*	*
* Generate random number which will be used as magic number.	* Generate random number which will be used as magic number.
Line 925 GenerateMagic(void)	Line 853 GenerateMagic(void)
int	int
PIDCheck(const char *filename, int killem)	PIDCheck(const char *filename, int killem)
{	{
int fd = -1, n_tries;	int n_tries;
	struct pidfh *pfh = NULL;

/* Sanity */	/* Sanity */

Line 933 PIDCheck(const char *filename, int killem)	Line 862 PIDCheck(const char *filename, int killem)

/* Atomically open and lock file */	/* Atomically open and lock file */

for (n_tries = 0;	for (n_tries = 0; n_tries < MAX_LOCK_ATTEMPTS; n_tries++)
n_tries < MAX_LOCK_ATTEMPTS
&& (fd = open(filename, O_RDWR\|O_CREAT\|O_EXLOCK\|O_NONBLOCK, 0644)) < 0;
n_tries++)
{	{
int nscan, old_pid;	pid_t old_pid;
FILE *fp;

/* Abort on any unexpected errors */	pfh = pidfile_open(filename, 0644, &old_pid);
	if (pfh == NULL) {
if (errno != EAGAIN)	if (errno == EEXIST) {
{	if (!killem) {
Perror("%s: open(%s)", __FUNCTION__, filename);	Log(LG_ERR, ("already running as process %d", old_pid));
return(-1);	return(-1);
	}
	if (kill(old_pid, SIGTERM) < 0)
	switch (errno) {
	case ESRCH:
	Log(LG_ERR, ("process %d no longer exists", old_pid));
	break;
	default:
	Perror("%s: kill(%d)", __FUNCTION__, old_pid);
	return(-1);
	}
	/* Wait and try again */
	Log(LG_ERR, ("waiting for process %d to die...", old_pid));
	sleep(1);
	} else {
	Perror("cannot open pid file");
	return(-1);
	}
	} else {
	pidfile_write(pfh);
	break;
}	}

/* We're already running ... see who it is */

if ((fp = fopen(filename, "r")) == NULL)
{
Perror("%s: fopen(%s)", __FUNCTION__, filename);
return(-1);
}

/* If there's a PID in there, sniff it out */

nscan = fscanf(fp, "%d", &old_pid);
fclose(fp);
if (nscan != 1)
{
Log(LG_ERR, ("%s: contents mangled", filename));
return(-1);
}

/* Maybe kill the other guy */

if (!killem)
{
Log(LG_ERR, ("already running as process %d", old_pid));
return(-1);
}
if (kill(old_pid, SIGTERM) < 0)
switch (errno)
{
case ESRCH:
Log(LG_ERR, ("process %d no longer exists", old_pid));
break;
default:
Perror("%s: kill(%d)", __FUNCTION__, old_pid);
return(-1);
}

/* Wait and try again */

Log(LG_ERR, ("waiting for process %d to die...", old_pid));
sleep(1);
}	}
if (n_tries == MAX_LOCK_ATTEMPTS)	if (n_tries == MAX_LOCK_ATTEMPTS)
{	{
Log(LG_ERR, ("can't lock %s after %d attempts", filename, n_tries));	Log(LG_ERR, ("can't lock %s after %d attempts", filename, n_tries));
return(-1);	return(-1);
}	}

/* Close on exec */

(void) fcntl(fd, F_SETFD, 1);

/* Create a stream on top of file descriptor */

if ((lockFp = fdopen(fd, "r+")) == NULL)
{
Perror("%s: fdopen", __FUNCTION__);
return(-1);
}
setbuf(lockFp, NULL);

/* Write my PID in there */

rewind(lockFp);
fprintf(lockFp, "%u\n", (u_int) gPid);
fflush(lockFp);
(void) ftruncate(fileno(lockFp), ftell(lockFp));
return(0);	return(0);
}	}

Line 1093 TcpGetListenPort(struct u_addr *addr, in_port_t port,	Line 977 TcpGetListenPort(struct u_addr *addr, in_port_t port,

/* Make socket available for connections */	/* Make socket available for connections */

if (listen(sock, 2) < 0)	if (listen(sock, -1) < 0)
{	{
Perror("%s: listen", __FUNCTION__);	Perror("%s: listen", __FUNCTION__);
(void) close(sock);	(void) close(sock);
Line 1186 Bin2Hex(const unsigned char *bin, size_t len)	Line 1070 Bin2Hex(const unsigned char *bin, size_t len)
size_t i, j;	size_t i, j;
char *buf;	char *buf;

buf = Malloc(MB_UTIL, len * 2 + 1);	if (len > 0) {
for (i = j = 0; i < len; i++) {	buf = Malloc(MB_UTIL, len * 2 + 1);
buf[j++] = hexconvtab[bin[i] >> 4];	for (i = j = 0; i < len; i++) {
buf[j++] = hexconvtab[bin[i] & 15];	buf[j++] = hexconvtab[bin[i] >> 4];
	buf[j++] = hexconvtab[bin[i] & 15];
	}
	buf[j] = 0;
	} else {
	buf = Malloc(MB_UTIL, 3);
	buf[0] = '0';
	buf[1] = '0';
	buf[2] = 0;
}	}
buf[j] = 0;
return buf;	return buf;
}	}

Line 1228 HexVal(char c)	Line 1119 HexVal(char c)
}	}
}	}

	#ifndef USE_NG_PRED1
/*	/*
* Crc16()	* Crc16()
*	*
Line 1242 Crc16(u_short crc, u_char *cp, int len)	Line 1134 Crc16(u_short crc, u_char *cp, int len)
crc = (crc >> 8) ^ Crc16Table[(crc ^ *cp++) & 0xff];	crc = (crc >> 8) ^ Crc16Table[(crc ^ *cp++) & 0xff];
return(crc);	return(crc);
}	}
	#endif

/*	/*
* GetAnyIpAddress()	* GetAnyIpAddress()
Line 1434 GetEther(struct u_addr addr, struct sockaddr_dl hwad	Line 1327 GetEther(struct u_addr addr, struct sockaddr_dl hwad
ifreq.ifr_addr = ifr->ifr_addr;	ifreq.ifr_addr = ifr->ifr_addr;

/* Check that the interface is up, and not point-to-point or loopback */	/* Check that the interface is up, and not point-to-point or loopback */
if (ioctl(s, SIOCGIFFLAGS, &ifreq) < 0)	if (ioctl(s, SIOCGIFFLAGS, &ifreq) < 0) {
	Log(LG_IFACE2, ("ioctl(SIOCGIFFLAGS, %s): %d", ifr->ifr_name, errno));
continue;	continue;
	}
if ((ifreq.ifr_flags &	if ((ifreq.ifr_flags &
(IFF_UP\|IFF_BROADCAST\|IFF_POINTOPOINT\|IFF_LOOPBACK\|IFF_NOARP))	(IFF_UP\|IFF_BROADCAST\|IFF_POINTOPOINT\|IFF_LOOPBACK\|IFF_NOARP))
!= (IFF_UP\|IFF_BROADCAST))	!= (IFF_UP\|IFF_BROADCAST))
Line 1514 GetPeerEther(struct u_addr addr, struct sockaddr_dl	Line 1409 GetPeerEther(struct u_addr addr, struct sockaddr_dl
mib[5] = 0;	mib[5] = 0;
#endif	#endif
if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) {	if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) {
Log(LG_ERR, ("route-sysctl-estimate"));	Perror("route-sysctl-estimate");
return (0);	return (0);
}	}
if (needed == 0) /* empty table */	if (needed == 0) /* empty table */
Line 1594 ppp_util_ascify(char buf, size_t bsiz, const char da	Line 1489 ppp_util_ascify(char buf, size_t bsiz, const char da
*bp = '\0';	*bp = '\0';
}	}

	#ifndef HAVE_NTOA_R
	/*
	* Convert a binary representation of an ethernet address to an ASCII string.
	*/
	char *
	ether_ntoa_r(const struct ether_addr n, char a)
	{
	int i;

	i = sprintf(a, "%02x:%02x:%02x:%02x:%02x:%02x", n->octet[0],
	n->octet[1], n->octet[2], n->octet[3], n->octet[4], n->octet[5]);
	if (i < 17)
	return (NULL);
	return (a);
	}
	#endif

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.1
changed lines
	Added in v.1.1.1.3