static char *hdt_device_type_equates(char *typname)
{
DTEQ *device_type;
char *(*nextcall)(char *);
for(device_type = dteq; device_type->name; device_type++)
if(!strcasecmp(device_type->alias, typname))
return device_type->name;
if((nextcall = HDL_FINDNXT(hdt_device_type_equates)))
return nextcall(typname);
return NULL;
}
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include "libfakechroot.h"
#include "readlink.h"
wrapper(__lxstat, int, (int ver, const char * filename, struct stat * buf))
{
char tmp[FAKECHROOT_PATH_MAX];
int retval;
READLINK_TYPE_RETURN linksize;
const char* orig_filename;
debug("__lxstat(%d, \"%s\", &buf)", ver, filename);
orig_filename = filename;
expand_chroot_path(filename);
retval = nextcall(__lxstat)(ver, filename, buf);
/* deal with http://bugs.debian.org/561991 */
if ((retval == 0) && (buf->st_mode & S_IFMT) == S_IFLNK)
if ((linksize = readlink(orig_filename, tmp, sizeof(tmp)-1)) != -1)
buf->st_size = linksize;
return retval;
}
#else
typedef int empty_translation_unit;
#endif
#define _LARGEFILE64_SOURCE
#include <glob.h>
#include "libfakechroot.h"
wrapper(glob64, int, (const char * pattern, int flags, int (* errfunc) (const char *, int), glob64_t * pglob))
{
int rc, i;
char tmp[FAKECHROOT_PATH_MAX], *tmpptr;
char *fakechroot_path, *fakechroot_ptr, fakechroot_buf[FAKECHROOT_PATH_MAX];
debug("glob64(\"%s\", %d, &errfunc, &pglob)", pattern, flags);
expand_chroot_path(pattern, fakechroot_path, fakechroot_buf);
rc = nextcall(glob64)(pattern, flags, errfunc, pglob);
if (rc < 0)
return rc;
for (i = 0; i < pglob->gl_pathc; i++) {
strcpy(tmp,pglob->gl_pathv[i]);
fakechroot_path = getenv("FAKECHROOT_BASE");
if (fakechroot_path != NULL) {
fakechroot_ptr = strstr(tmp, fakechroot_path);
if (fakechroot_ptr != tmp) {
tmpptr = tmp;
} else {
tmpptr = tmp + strlen(fakechroot_path);
}
strcpy(pglob->gl_pathv[i], tmpptr);
}
void
main(void)
{
uint32 nrftx = 0, nrxuf = 0;
int i = 0;
static __xdata Rcall c;
uint8 state = Idle;
uint8 waitflag = 0, clearflag = 0;
uint8 laststate, lastflag, lastMARCSTATE;
laststate = state;
lastflag = flag;
lastMARCSTATE = MARCSTATE;
memset(&curcall, 0, sizeof curcall);
SLEEP &= ~SLEEP_OSC_PD;
await(SLEEP & SLEEP_XOSC_S);
CLKCON = (CLKCON & ~(CLKCON_CLKSPD | CLKCON_OSC)) | CLKSPD_DIV_1;
await(!(CLKCON & CLKCON_OSC));
SLEEP |= SLEEP_OSC_PD;
await(SLEEP & SLEEP_XOSC_S);
P1DIR |= LEDBITS;
printinit();
srvinit();
rfinit();
GREEN = RED = 0;
// Enables interrupts. (Go go go)
EA = 1;
wdinit();
dprint("pingrf started.\n");
srvrx();
for(;;){
wdreset();
if(flag&Fpanic){
GREEN = 0;
RED = 0;
for(;;){
RED ^= 1;
sleep(1000);
/* TODO: reset */
}
}
if((flag&clearflag) != 0)
flag &= ~(flag&clearflag);
switch(state){
case Idle:
if(peekcall()->type == Nop)
break;
nextcall(&c);
waitflag = clearflag = 0;
call(&c, &state, &waitflag, &clearflag);
break;
case Reply:
reply(&c);
state = Replying;
break;
case Replying:
if(flag&Ftxcall){
flag &= ~Ftxcall;
state = Idle;
}
// GREEN=1;
break;
default:
if((flag&waitflag) != 0){
waitflag = flag&waitflag;
flag &= ~waitflag;
call(&c, &state, &waitflag, &clearflag);
}
/*
if((flag&waitflag)==waitflag){
flag &= ~waitflag;
call(&c, &state, &waitflag, &clearflag);
}
*/
break;
}
#ifdef DEBUG
if((i++%100000 == 0) || (flag != lastflag || state != laststate | lastMARCSTATE != MARCSTATE)){
//__critical {
wdreset();
switch(state){
case Idle:
dprint("idle"); break;
case Replying:
case Reply:
dprint("replying %d", c.type);
break;
default:
dprint("handling(%d) %d", state, c.type);;
break;
}
lastflag = flag;
laststate = state;
lastMARCSTATE = MARCSTATE;
dprint(" flag=");
printflag(flag);
dprint(" waitflag=");
printflag(waitflag);
dprint(" radio=%s\n", strmarcstate(lastMARCSTATE));
// dprint(" flag=%F waitflag=%F radio=%S\n", flag, waitflag, lastMARCSTATE);
//
// putchar('.');
// putchar('\n');
//}
}
#endif
}
}
# define SOCKADDR(addr) ((addr).__sockaddr__)
# define SOCKADDR_UN(addr) ((addr).__sockaddr_un__)
#else
# define SOCKADDR(addr) (addr)
# define SOCKADDR_UN(addr) (addr)
#endif
wrapper(getpeername, int, (int s, GETPEERNAME_TYPE_ARG2(addr), socklen_t * addrlen))
{
int status;
socklen_t origlen = *addrlen;
debug("getpeername(%d, &addr, &addrlen)", s);
status = nextcall(getpeername)(s, addr, addrlen);
if (status == 0 && SOCKADDR(addr)->sa_family == AF_UNIX) {
struct sockaddr_un *addr_un = SOCKADDR_UN(addr);
size_t path_max = origlen - offsetof(struct sockaddr_un, sun_path);
if (path_max > origlen) {
/* underflow, addr does not have space for the path */
return status;
} else if (path_max > sizeof(addr_un->sun_path)) {
path_max = sizeof(addr_un->sun_path);
}
if (addr_un->sun_path && *(addr_un->sun_path)) {
char tmp[FAKECHROOT_PATH_MAX];
strlcpy(tmp, addr_un->sun_path, FAKECHROOT_PATH_MAX);
narrow_chroot_path(tmp);
strlcpy(addr_un->sun_path, tmp, path_max);
*addrlen = SUN_LEN(addr_un);
