int main (int argc, char const * argv [])
{
static char const * optv [] =
{
"hqv",
"",
"enumerate available pcap devices on stdout",
"h\tprint host definitions for scripting",
"q\tquiet",
"v\tverbose messages",
(char const *) (0)
};
flag_t flags = PCAP_DEVICES;
signed c;
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch ((char) (c))
{
case 'h':
_clrbits (flags, (PCAP_DEVICES));
_setbits (flags, (PCAP_NICS | PCAP_MACS));
break;
case 'q':
_setbits (flags, PCAP_SILENCE);
break;
case 'v':
_setbits (flags, PCAP_VERBOSE);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (argc)
{
error (1, ECANCELED, ERROR_TOOMANY);
}
pcap_enum (flags);
return (0);
}
signed openchannel (struct channel * channel)
{
#if defined (__linux__)
struct ifreq ifreq;
struct sockaddr_ll sockaddr_ll =
{
PF_PACKET,
0x0000,
0x0000,
ARPHRD_ETHER,
PACKET_HOST,
ETHER_ADDR_LEN,
{
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00
}
};
/*
* raw packets require root privileges on linux; one does not have to be
* root when this program is installed setuid using 'chown root:root' and
* 'chmod 4555';
*/
if (geteuid ())
{
error (1, EPERM, ERROR_NOTROOT);
}
memset (&ifreq, 0, sizeof (ifreq));
sockaddr_ll.sll_protocol = htons (channel->type);
if ((channel->fd = socket (sockaddr_ll.sll_family, SOCK_RAW, sockaddr_ll.sll_protocol)) == -1)
{
error (1, errno, "%s", channel->ifname);
}
memcpy (ifreq.ifr_name, channel->ifname, sizeof (ifreq.ifr_name));
if (ioctl (channel->fd, SIOCGIFINDEX, &ifreq) == -1)
{
error (1, errno, "%s", ifreq.ifr_name);
}
channel->ifindex = sockaddr_ll.sll_ifindex = ifreq.ifr_ifindex;
if (ioctl (channel->fd, SIOCGIFHWADDR, &ifreq) == -1)
{
error (1, errno, "%s", ifreq.ifr_name);
}
memcpy (sockaddr_ll.sll_addr, ifreq.ifr_ifru.ifru_hwaddr.sa_data, sizeof (sockaddr_ll.sll_addr));
if (bind (channel->fd, (struct sockaddr *) (&sockaddr_ll), sizeof (sockaddr_ll)) == -1)
{
error (1, errno, "%s", ifreq.ifr_name);
}
memcpy (channel->host, sockaddr_ll.sll_addr, sizeof (channel->host));
if (ioctl (channel->fd, SIOCGIFFLAGS, &ifreq) == -1)
{
error (1, errno, "%s", ifreq.ifr_name);
}
channel->ifstate = ifreq.ifr_flags;
_setbits (ifreq.ifr_flags, (IFF_UP | IFF_BROADCAST | IFF_MULTICAST));
_clrbits (ifreq.ifr_flags, (IFF_ALLMULTI | IFF_PROMISC));
if (ioctl (channel->fd, SIOCSIFFLAGS, &ifreq) == -1)
{
error (1, errno, "%s", ifreq.ifr_name);
}
#else
struct bpf_program bpf_program;
static struct bpf_insn bpf_insn [] =
{
{
BPF_LD + BPF_H + BPF_ABS,
0,
0,
12
},
{
BPF_JMP + BPF_JEQ + BPF_K,
0,
18,
0
},
{
BPF_LD + BPF_B + BPF_ABS,
0,
0,
0
},
{
BPF_JMP + BPF_JEQ + BPF_K,
0,
10,
0
},
{
BPF_LD + BPF_B + BPF_ABS,
0,
0,
1
},
{
BPF_JMP + BPF_JEQ + BPF_K,
0,
8,
0
},
{
BPF_LD + BPF_B + BPF_ABS,
0,
0,
2
},
{
BPF_JMP + BPF_JEQ + BPF_K,
0,
6,
0
},
{
BPF_LD + BPF_B + BPF_ABS,
0,
0,
3
},
{
BPF_JMP + BPF_JEQ + BPF_K,
0,
4,
0
},
{
BPF_LD + BPF_B + BPF_ABS,
0,
0,
4
},
{
BPF_JMP + BPF_JEQ + BPF_K,
0,
2,
0
},
{
BPF_LD + BPF_B + BPF_ABS,
0,
0,
5
},
{
BPF_JMP + BPF_JEQ + BPF_K,
4,
0,
0
},
{
BPF_LD + BPF_W + BPF_ABS,
0,
0,
0
},
{
BPF_JMP + BPF_JEQ + BPF_K,
0,
4,
0xFFFFFFFF
},
{
BPF_LD + BPF_H + BPF_ABS,
0,
0,
4
},
{
BPF_JMP + BPF_JEQ + BPF_K,
0,
2,
0xFFFF
},
{
BPF_LD + BPF_W + BPF_LEN,
0,
0,
0
},
{
BPF_RET + BPF_A,
0,
0,
0
},
{
BPF_RET + BPF_K,
0,
0,
0
}
};
#if defined (__APPLE__) || defined (__OpenBSD__) || defined (__NetBSD__)
struct ifreq ifreq;
struct timeval timeval;
struct bpf * bpf;
char filename [sizeof (CHANNEL_BPFDEVICE) + 1];
unsigned count;
unsigned state;
int stat_errno = 0;
int open_errno = 0;
for (count = 0; count < 100; count++)
{
struct stat st;
snprintf (filename, sizeof (filename), CHANNEL_BPFDEVICE, count);
if (stat(filename, &st) == -1)
{
stat_errno = errno;
continue;
}
if ((channel->fd = open (filename, O_RDWR)) != -1)
{
break;
}
else
{
open_errno = errno;
}
}
if (channel->fd == -1)
{
if (open_errno)
{
error (1, open_errno, "Could not open bpf device");
}
else
{
error (1, stat_errno, "No bpf device found");
}
}
memcpy (ifreq.ifr_name, channel->ifname, sizeof (ifreq.ifr_name));
if (ioctl (channel->fd, BIOCSETIF, &ifreq) == -1)
{
error (1, errno, "%s", ifreq.ifr_name);
}
channel->bpf = bpf = malloc (sizeof (* bpf));
if (ioctl (channel->fd, BIOCGBLEN, &bpf->bpf_length) == -1)
{
error (1, errno, "Can't determine buffer length: %s", ifreq.ifr_name);
}
bpf->bpf_bp = bpf->bpf_buffer = malloc (bpf->bpf_length);
if (bpf->bpf_buffer == NULL)
{
error (1, errno, "Can't allocate receive buffer");
}
#if defined (__APPLE__) || defined (__NetBSD__)
state = 0;
if (ioctl (channel->fd, BIOCSSEESENT, &state) == -1)
{
error (1, errno, "Can't hide outgoing frames: %s", ifreq.ifr_name);
}
#elif defined (__OpenBSD__)
state = BPF_DIRECTION_OUT;
if (ioctl (channel->fd, BIOCSDIRFILT, &state) == -1)
{
error (0, errno, "Can't hide outgoing frames");
}
#else
#error "Abandon all hope"
#endif
if (channel->capture > 1000)
{
timeval.tv_sec = channel->capture / 1000;
timeval.tv_usec = 0;
}
else
{
#if defined (__MAC_10_6)
/*
* accommodate known bug in BPF on MAC OS X 10.6; shorter times cause socket read
* operations to block indefinitely if no frames are waiting because tv_usec gets
* clobbered;
*/
timeval.tv_sec = 1;
timeval.tv_usec = 0;
#else
timeval.tv_sec = 0;
timeval.tv_usec = channel->capture * 1000;
#endif
}
if (ioctl (channel->fd, BIOCSRTIMEOUT, &timeval) == -1)
{
error (1, errno, "Can't set channel timeout: %s", ifreq.ifr_name);
}
state = 1;
if (ioctl (channel->fd, BIOCIMMEDIATE, &state) == -1)
{
error (1, errno, "Can't set immediate mode: %s", ifreq.ifr_name);
}
#if 1
state = 1;
if (ioctl (channel->fd, BIOCSHDRCMPLT, &state) == -1)
{
error (1, errno, "Can't set header complete mode: %s", ifreq.ifr_name);
}
#endif
#if 1
gethwaddr (channel->host, channel->ifname);
#else
if (ioctl (channel->fd, SIOCGIFADDR, &ifreq) > 0)
{
error (1, errno, "%s", ifreq.ifr_name);
}
memcpy (channel->host, LLADDR (ifreq.ifr_ifru.ifru_addr), sizeof (channel->host));
#endif
bpf_program.bf_len = sizeof (bpf_insn) / sizeof (struct bpf_insn);
bpf_program.bf_insns = bpf_insn;
if (channel->type == ETH_P_802_2)
{
bpf_insn [1].code = BPF_JMP + BPF_JGT + BPF_K;
bpf_insn [1].jt = 18;
bpf_insn [1].jf = 0;
bpf_insn [1].k = ETHERMTU;
}
else
{
bpf_insn [1].code = BPF_JMP + BPF_JEQ + BPF_K;
bpf_insn [1].jt = 0;
bpf_insn [1].jf = 18;
bpf_insn [1].k = channel->type;
}
bpf_insn [3].k = channel->host [0];
bpf_insn [5].k = channel->host [1];
bpf_insn [7].k = channel->host [2];
bpf_insn [9].k = channel->host [3];
bpf_insn [11].k = channel->host [4];
bpf_insn [13].k = channel->host [5];
if (ioctl (channel->fd, BIOCSETF, &bpf_program) == -1)
{
error (1, errno, "Can't store filter: %s", channel->ifname);
}
#elif defined (WINPCAP) || defined (LIBPCAP)
channel->ifname = getifname (channel->ifindex);
gethwaddr (channel->host, channel->ifname);
channel->socket = pcap_open_live (channel->ifname, 65536, 0, channel->capture, channel->errbuf);
snprintf ((char *)(channel->ifname), strlen (channel->ifname), "nic%d", channel->ifindex);
if (!channel->socket)
{
error (1, errno, "Can't open interface: %s", channel->ifname);
}
bpf_program.bf_len = sizeof (bpf_insn)/sizeof (struct bpf_insn);
bpf_program.bf_insns = bpf_insn;
if (channel->type == ETH_P_802_2)
{
bpf_insn [1].code = BPF_JMP + BPF_JGT + BPF_K;
bpf_insn [1].jt = 18;
bpf_insn [1].jf = 0;
bpf_insn [1].k = ETHERMTU;
}
else
{
bpf_insn [1].code = BPF_JMP + BPF_JEQ + BPF_K;
bpf_insn [1].jt = 0;
bpf_insn [1].jf = 18;
bpf_insn [1].k = channel->type;
}
bpf_insn [3].k = channel->host [0];
bpf_insn [5].k = channel->host [1];
bpf_insn [7].k = channel->host [2];
bpf_insn [9].k = channel->host [3];
bpf_insn [11].k = channel->host [4];
bpf_insn [13].k = channel->host [5];
if (pcap_setfilter (channel->socket, &bpf_program) < 0)
{
error (1, errno, "Can't store filter: %s", channel->ifname);
}
if (pcap_setmintocopy (channel->socket, ETHER_MIN_LEN) < 0)
{
error (1, errno, "Can't set pcap mintocopy: %s", channel->ifname);
}
#else
#error "Unknown Environment"
#endif
#endif
return (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
static char const * optv [] =
{
"cd:ei:l:o:nqrRtTuvw:x",
"device [device] [...]",
"Qualcomm Atheros INT6x00 PHY Rate Monitor",
"c\tdisplay coded PHY rates",
"d n\ttraffic duration is (n) seconds per leg [" LITERAL (PLC_ECHOTIME) "]",
"e\tredirect stderr to stdout",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"l n\tloop (n) times [" LITERAL (INT6KRATE_LOOP) "]",
"n\tnetwork TX/RX information",
"o n\tread timeout is (n) milliseconds [" LITERAL (CHANNEL_TIMEOUT) "]",
"q\tquiet mode",
"r\trequest device information",
"R\treset device with VS_RS_DEV",
"t\tgenerate network traffic (one-to-many)",
"T\tgenerate network traffic (many-to-many)",
"u\tdisplay uncoded PHY rates",
"v\tverbose mode",
"w n\twait (n) seconds [" LITERAL (INT6KRATE_WAIT) "]",
"x\texit on error",
(char const *) (0)
};
#include "../plc/plc.c"
signed loop = INT6KRATE_LOOP;
signed wait = INT6KRATE_WAIT;
signed c;
optind = 1;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
plc.timer = PLC_ECHOTIME;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'c':
_clrbits (plc.flags, PLC_UNCODED_RATES);
break;
case 'd':
plc.timer = (unsigned)(uintspec (optarg, 1, 60));
case 'e':
dup2 (STDOUT_FILENO, STDERR_FILENO);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'l':
loop = (unsigned)(uintspec (optarg, 0, UINT_MAX));
break;
case 'n':
_setbits (plc.flags, PLC_NETWORK);
break;
case 'o':
channel.timeout = (signed)(uintspec (optarg, 0, UINT_MAX));
break;
case 'q':
_setbits (plc.flags, PLC_SILENCE);
break;
case 'r':
_setbits (plc.flags, PLC_VERSION);
break;
case 'R':
_setbits (plc.flags, PLC_RESET_DEVICE);
break;
case 't':
_setbits (plc.flags, PLC_LOCAL_TRAFFIC);
break;
case 'T':
_setbits (plc.flags, PLC_NETWORK_TRAFFIC);
break;
case 'u':
_setbits (plc.flags, PLC_UNCODED_RATES);
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
_setbits (plc.flags, PLC_VERBOSE);
break;
case 'w':
wait = (unsigned)(uintspec (optarg, 0, 3600));
break;
case 'x':
_setbits (plc.flags, PLC_BAILOUT);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
openchannel (&channel);
desuid ();
if (_allclr (plc.flags, (PLC_VERSION | PLC_LOCAL_TRAFFIC | PLC_NETWORK_TRAFFIC | PLC_RESET_DEVICE)))
{
_setbits (plc.flags, PLC_NETWORK);
}
if (!(plc.message = malloc (sizeof (* plc.message))))
{
error (1, errno, PLC_NOMEMORY);
}
if (!argc)
{
manager (&plc, loop, wait);
}
while ((argc) && (* argv))
{
if (!hexencode (channel.peer, sizeof (channel.peer), synonym (* argv, devices, SIZEOF (devices))))
{
error (1, errno, PLC_BAD_MAC, * argv);
}
manager (&plc, loop, wait);
argv++;
argc--;
}
free (plc.message);
closechannel (&channel);
exit (0);
}
int main (int argc, char const * argv [])
{
static char const * optv [] =
{
"list folders or links or standard files",
"path [path] [...] [> stdout]",
"c:dflnw:",
"c n\tcolumn count is (n) [" LITERAL (COUNT) "]",
"d\tlist directory files",
"f\tlist standard files",
"l\tlist symbolic links",
"w n\tscreen width is (n) [" LITERAL (WIDTH) "]",
"n\tnumber items",
(char const *) (0)
};
char filename [FILENAME_MAX];
bool index = false;
flag_t flags = (flag_t) (0);
size_t width = WIDTH;
size_t count = COUNT;
signed c;
while (~ (c = getoptv (argc, argv, optv)))
{
switch (c)
{
case 'd':
_clrbits (flags, FIND_B_REG);
_clrbits (flags, FIND_B_LNK);
_setbits (flags, FIND_B_DIR);
break;
case 'l':
_clrbits (flags, FIND_B_REG);
_setbits (flags, FIND_B_LNK);
_clrbits (flags, FIND_B_DIR);
break;
case 'f':
_setbits (flags, FIND_B_REG);
_clrbits (flags, FIND_B_LNK);
_clrbits (flags, FIND_B_DIR);
break;
case 'n':
index = true;
break;
case 'w':
width = uintspec (optarg, 1, 132);
break;
case 'c':
count = uintspec (optarg, 1, 16);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (_allclr (flags, (FIND_B_ALL)))
{
_setbits (flags, FIND_B_DIR);
}
if (! argc)
{
strcpy (filename, getenv ("PWD"));
function (filename, filename, width, count, index, flags);
}
while ((argc) && (* argv))
{
strcpy (filename, * argv);
function (filename, filename, width, count, index, flags);
argc--;
argv++;
}
exit (0);
}
int ihpapi_InitializeDevice (uint8_t sa [], uint8_t da [], size_t FW_len, uint8_t FW_pbuffer [], size_t PIB_len, uint8_t PIB_pbuffer [], unsigned options)
{
extern struct SeqCB scb;
NVMBlockHeader *hdr;
TxInfo *tcb = &scb.tcb;
tcb->txok = false;
#if INTELLON_SAFEMODE
if (PIB_pbuffer == (uint8_t *)(0))
{
errno = EFAULT;
return (-1);
}
#endif
if (_anyset (scb.flags, scbFlag_bsy))
{
errno = EBUSY;
return (-1);
}
memset (&scb, 0, sizeof (scb));
scb.flags = options;
_clrbits (scb.flags, ~scbFlag_options);
scb.opcode = IHPAPI_OPCODE_INITIALIZE_DEVICE;
tcb->txok = true;
memcpy (tcb->ODA, da, IHPAPI_ETHER_ADDR_LEN);
memcpy (tcb->OSA, sa, IHPAPI_ETHER_ADDR_LEN);
_setbits (scb.flags, scbFlag_PB);
scb.bcb [1] = bopen (PIB_pbuffer, PIB_len, MAX_MODULE_TX_LENGTH);
if (scb.bcb [1] == (buffer_t *)(0))
{
return (-1);
}
scb.modid = PIB_MODID;
if (_anybits (scb.flags, scbFlag_is6k) || _allbits (scb.flags, scbFlag_noINT6Kfwflash))
{
/*! At this point:
* Could be a Host Action Required)
* Firmware and PIB only -> VS_WR_MOD
* No trailer in the tcb required.
*/
if (FW_pbuffer)
{
scb.bcb [0] = bopen (FW_pbuffer, FW_len, MAX_MODULE_TX_LENGTH);
if (scb.bcb [0] == (buffer_t *)(0))
{
bclose (scb.bcb [1]);
return (-1);
}
_setbits (scb.flags, scbFlag_FW);
scb.txbcb = scb.bcb [0];
scb.modid |= MACSW_MODID;
tcb->WRMDBLKR.MODULEID = MACSW_MODID;
tcb->datalen = bgets (&tcb->data, 0, scb.bcb [0]);
}
else
{
scb.txbcb = scb.bcb [1];
tcb->WRMDBLKR.MODULEID = PIB_MODID;
tcb->datalen = bgets (&tcb->data, 0, scb.bcb [1]);
}
tcb->MMTYPE = VS_WR_MOD | MMTYPE_REQ;
tcb->hdrlen = sizeof (tcb->WRMDBLKR);
tcb->WRMDBLKR.LENGTH = ihtons(tcb->datalen);
tcb->WRMDBLKR.OFFSET = 0;
tcb->WRMDBLKR.CHKSUM = ihtonl(checksum32 ((const uint32_t *)tcb->data, (tcb->datalen >> 2), 0));
}
else
{
/*! At this point:
* Host Action Required
* Device Type -> Not a INT6000
* Blank Flash or No Flash
* The Firmware and the PIB -> VS_WR_MEM
* No trailer in the tcb required
*/
/*! Initialize the bcb for the firmware:
* need to search to find the firmware header from the nvm file. The firmware
* is the last entry on the nvm file, i.e. NEXTHEADER is equal to 0.;
*/
if (FW_pbuffer == (uint8_t *)(0))
int main (int argc, char const * argv [])
{
struct sigaction sa;
struct ifreq ifreq;
struct sockaddr_ll sockaddr =
{
PF_PACKET,
htons (ETH_P_HPAV),
0x0000,
ARPHRD_ETHER,
PACKET_OTHERHOST,
ETHER_ADDR_LEN,
{
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00
}
};
static char const * optv [] =
{
"di:qv",
PUTOPTV_S_DIVINE,
"Qualcomm Atheros HomePlug AV Packet Daemon",
"d\trun in background as daemon",
"i s\thost interface is (s) [" ETHDEVICE "]",
"q\tsuppress normal output",
"v\tverbose messages on stdout",
(char const *) (0)
};
uint8_t packet [ETHER_MAX_LEN];
flag_t state = (flag_t)(0);
flag_t flags = (flag_t)(0);
sock_t fd = -1;
signed c;
memset (&ifreq, 0, sizeof (ifreq));
memcpy (ifreq.ifr_name, ETHDEVICE, sizeof (ETHDEVICE));
if (getenv (PLCDEVICE))
{
memcpy (ifreq.ifr_name, getenv (PLCDEVICE), sizeof (ifreq.ifr_name));
}
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch ((char) (c))
{
case 'd':
_setbits (flags, HPAVD_DAEMON);
break;
case 'i':
memcpy (ifreq.ifr_name, optarg, sizeof (ifreq.ifr_name));
break;
case 'q':
_setbits (flags, HPAVD_SILENCE);
break;
case 'v':
_setbits (flags, HPAVD_VERBOSE);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (geteuid ())
{
error (1, EPERM, ERROR_NOTROOT);
}
if (_anyset (flags, HPAVD_DAEMON))
{
pid_t pid = fork ();
if (pid < 0)
{
error (1, errno, "razzlefrats!");
}
if (pid > 0)
{
exit (0);
}
}
memset (&sa, 0, sizeof (struct sigaction));
sa.sa_handler = terminate;
sigaction (SIGTERM, &sa, (struct sigaction *)(0));
sigaction (SIGQUIT, &sa, (struct sigaction *)(0));
sigaction (SIGTSTP, &sa, (struct sigaction *)(0));
sigaction (SIGINT, &sa, (struct sigaction *)(0));
sigaction (SIGHUP, &sa, (struct sigaction *)(0));
if ((fd = socket (sockaddr.sll_family, SOCK_RAW, sockaddr.sll_protocol)) == -1)
{
error (1, errno, "Can't create socket for %s", ifreq.ifr_name);
}
if (ioctl (fd, SIOCGIFFLAGS, &ifreq) < 0)
{
error (1, errno, "Can't read %s device state", ifreq.ifr_name);
}
state = ifreq.ifr_flags;
_setbits (ifreq.ifr_flags, (IFF_UP | IFF_BROADCAST));
_clrbits (ifreq.ifr_flags, (IFF_MULTICAST | IFF_ALLMULTI | IFF_PROMISC));
if (ioctl (fd, SIOCSIFFLAGS, &ifreq) < 0)
{
error (1, errno, "Can't change %s device state", ifreq.ifr_name);
}
if (ioctl (fd, SIOCGIFINDEX, &ifreq) == -1)
{
error (1, errno, "Can't get %s interface index", ifreq.ifr_name);
}
sockaddr.sll_ifindex = ifreq.ifr_ifindex;
if (ioctl (fd, SIOCGIFHWADDR, &ifreq) == -1)
{
error (1, errno, "Can't get %s hardware address", ifreq.ifr_name);
}
memcpy (sockaddr.sll_addr, ifreq.ifr_ifru.ifru_hwaddr.sa_data, sizeof (sockaddr.sll_addr));
if (bind (fd, (struct sockaddr *) (&sockaddr), sizeof (struct sockaddr_ll)) == -1)
{
error (1, errno, "Can't bind socket to %s", ifreq.ifr_name);
}
while (!done)
{
signed length = recvfrom (fd, packet, sizeof (packet), 0, (struct sockaddr *) (0), (socklen_t *)(0));
if (length > 0)
{
if (_allclr (flags, HPAVD_SILENCE))
{
MMEPeek (&packet, length, stdout);
}
if (_anyset (flags, HPAVD_VERBOSE))
{
hexdump (&packet, 0, length, stdout);
}
}
}
ifreq.ifr_flags = state;
if (ioctl (fd, SIOCSIFFLAGS, &ifreq) < 0)
{
error (1, errno, "Can't restore %s device state", ifreq.ifr_name);
}
close (fd);
return (0);
}
int main (int argc, char const *argv [])
{
extern char const *host_name;
extern char const *domain_name;
static char const *optv [] =
{
"a:df:"
#ifdef SYSLOGD_INETAF
"hi:l:"
#endif
"m:no:p:"
#ifdef SYSLOGD_INETAF
"rs:"
#endif
"xvw:",
"System Logging Daemon",
"a s\tadd unix socket path s",
"d\trun as daemon (background)",
"f s\tuse configuration file s [" _PATH_SYSLOG_CONF "]",
#ifdef SYSLOGD_INETAF
"h\tforward messages to other hosts",
"i n\tadd inet socket on port n",
"l s\tlist of hostnames separated by ':'",
#endif
"m nn\tmark internal is nn[s|S|m|M|h|H]",
"n\trun as normal program (foreground)",
"o s\toutput file is s",
"p s\tlocal log device path is s [" _PATH_SYSLOG "]",
#ifdef SYSLOGD_UNIXAF
"r\treceive messages from other hosts",
"s s\tdomain list is s",
#endif
"v\tdisplay version and exit",
"w n\twait n seconds for klogd to start",
"x\tnot implemented",
(char const *) (0)
};
#ifdef SYSLOGD_INETAF
struct servent *servent;
struct sockaddr_in *sockaddr_inet;
#endif
#ifdef SYSLOGD_UNIXAF
struct socket * socket;
struct sockaddr_un *sockaddr_unix;
#endif
struct hostent *hostent;
char fqdn [HOSTNAME_MAX];
time_t delay = SYSLOGD_DELAY_TIME;
file_t fd;
int c;
chdir ("/");
/*--------------------------------------------------------------------*
* point host_name and domain_name to constant strings; technically,
* the fqdn is the name returned by gethostbyname when given the name
* returned by gethostname; store the fqdn then break it at the first
* '.', if present;
*--------------------------------------------------------------------*/
gethostname (fqdn, sizeof (fqdn));
if ((hostent = gethostbyname (fqdn)) != (struct hostent *) (0))
{
strncpy (fqdn, hostent->h_name, sizeof (fqdn));
}
strlwr (fqdn);
for (host_name = domain_name = fqdn; *domain_name != (char) (0); domain_name++)
{
if (*domain_name == '.')
{
fqdn [domain_name++ - host_name] = (char) (0);
break;
}
}
#ifdef SYSLOGD_INETAF
/*--------------------------------------------------------------------*
* confirm that the service is registered; the name is "syslog", the
* type is "udp" and it should appear in "/etc/services"; record the
* port number in struct sockaddr_in for global reference;
*--------------------------------------------------------------------*/
servent = getservbyname (SYSLOGD_SERVICE_NAME, SYSLOGD_SERVICE_TYPE);
if (servent == (struct servent *) (0))
{
error (1, ENOTSUP, "The %s %s service is not registered on %s", SYSLOGD_SERVICE_NAME, SYSLOGD_SERVICE_TYPE, host_name);
}
if (servent != (struct servent *) (0))
{
inetsock_addr.sin_port = servent->s_port;
}
#endif
optind = 1;
opterr = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch ((char) (c))
{
#ifdef SYSLOGD_UNIXAF
/*--------------------------------------------------------------------*
* create additional unix socket with specified pathname and append
* it to the sockets list;
*--------------------------------------------------------------------*/
case 'a':
sockaddr_unix = NEW (struct sockaddr_un);
if (sockaddr_unix == (struct sockaddr_un *)(0))
{
break;
}
memset (sockaddr_unix, 0, sizeof (struct sockaddr_un));
sockaddr_unix->sun_family = AF_UNIX;
memcpy (&sockaddr_unix->sun_path, optarg, sizeof (sockaddr_unix->sun_path));
socket = NEW (struct socket);
if (socket == (struct socket *)(0))
{
error (0, errno, "Can't add socket %s", optarg);
free (sockaddr_unix);
break;
}
memset (socket, 0, sizeof (struct socket));
socket->desc = -1;
socket->socksize = sizeof (struct sockaddr_un);
socket->sockaddr = (struct sockaddr *)(sockaddr_unix);
socket->next = &unixsock;
socket->prev = unixsock.prev;
unixsock.prev->next = socket;
unixsock.prev = socket;
break;
#endif
#ifdef SYSLOGD_INETAF
case 'i':
sockaddr_inet = NEW (struct sockaddr_in);
if (sockaddr_inet == (struct sockaddr_in *)(0))
{
break;
}
sockaddr_inet->sin_family = AF_INET;
sockaddr_inet->sin_port = (unsigned short)(uintspec (optarg, IPPORT_RESERVED, IPPORT_USERRESERVED));
socket = NEW (struct socket);
if (socket == (struct socket *)(0))
{
error (0, errno, "Can't add socket %s", optarg);
free (sockaddr_inet);
break;
}
memset (socket, 0, sizeof (struct socket));
socket->desc = -1;
socket->socksize = sizeof (struct sockaddr_in);
socket->sockaddr = (struct sockaddr *)(sockaddr_inet);
socket->next = &inetsock;
socket->prev = inetsock.prev;
inetsock.prev->next = socket;
inetsock.prev = socket;
break;
#endif
case 'd':
_setbits (state, SYSLOGD_STATE_DAEMON);
break;
case 'f':
cfgfile = optarg;
break;
#ifdef SYSLOGD_INETAF
case 'h':
_setbits (state, SYSLOGD_STATE_FORWARD);
break;
#endif
#ifdef SYSLOGD_INETAF
case 'l':
if (ourhosts != (char const **) (0))
{
error (0, EINVAL, "discarding '%s': only one host list allowed", optarg);
break;
}
ourhosts = stov (optarg, ':');
break;
#endif
case 'm':
timer = waitspec (optarg);
break;
case 'n':
_clrbits (state, SYSLOGD_STATE_DAEMON);
break;
case 'o':
mapfile = optarg;
break;
#ifdef SYSLOGD_UNIXAF
case 'p':
strncpy (unixsock_addr.sun_path, optarg, sizeof (unixsock_addr.sun_path));
break;
#endif
#ifdef SYSLOGD_INETAF
case 'r':
_setbits (state, SYSLOGD_STATE_RECEIVE);
break;
#endif
#ifdef SYSLOGD_INETAF
case 's':
if (ourdomains != (char const **) (0))
{
error (0, 0, "ignoring '%s': only one -s argument allowed", optarg);
break;
}
ourdomains = stov (optarg, ':');
break;
#endif
case 't':
delay = uintspec (optarg, 0, 3600);
break;
case 'v':
version ();
exit (0);
case 'w':
delay = waitspec (optarg);
break;
case 'x':
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (getuid ())
{
error (1, EACCES, NOTROOT);
}
if (checkpf (pidfile))
{
error (1, 0, "service is already running");
}
#ifdef SYSLOGD_INETAF
if (_allset (state, (SYSLOGD_STATE_RECEIVE|SYSLOGD_STATE_FORWARD)))
{
error (1, EPERM, "Can't receive and forward messages in same session");
}
#endif
memset (&sigquit, 0, sizeof (struct sigaction));
sigquit.sa_handler = syslogd_sigquit;
sigquit.sa_flags = SA_ONESHOT;
sigemptyset (&sigquit.sa_mask);
memset (&sigterm, 0, sizeof (struct sigaction));
sigterm.sa_handler = syslogd_sigterm;
sigterm.sa_flags = SA_ONESHOT;
sigemptyset (&sigterm.sa_mask);
memset (&sigchld, 0, sizeof (struct sigaction));
sigchld.sa_handler = syslogd_sigchld;
sigchld.sa_flags = 0;
sigemptyset (&sigchld.sa_mask);
memset (&sigalrm, 0, sizeof (struct sigaction));
sigalrm.sa_handler = syslogd_sigalrm;
sigalrm.sa_flags = 0;
sigemptyset (&sigalrm.sa_mask);
memset (&sigusr1, 0, sizeof (struct sigaction));
sigusr1.sa_handler = syslogd_sigusr1;
sigusr1.sa_flags = 0;
sigemptyset (&sigusr1.sa_mask);
memset (&sighup, 0, sizeof (struct sigaction));
sighup.sa_handler = syslogd_sighup;
sighup.sa_flags = 0;
sigemptyset (&sighup.sa_mask);
sigaction (SIGINT, &sigquit, (struct sigaction *) (0));
sigaction (SIGTERM, &sigquit, (struct sigaction *) (0));
sigaction (SIGQUIT, &sigquit, (struct sigaction *) (0));
if (_allset (state, SYSLOGD_STATE_DAEMON))
{
if (fork ())
{
sleep (delay);
error (1, 0, "daemon did not start");
}
setsid ();
for (fd = getdtablesize (); fd-- > 0; close (fd));
kill (getppid (), SIGTERM);
sigquit.sa_handler = SIG_IGN;
}
sigaction (SIGTERM, &sigterm, (struct sigaction *) (0));
sigaction (SIGCHLD, &sigchld, (struct sigaction *) (0));
sigaction (SIGALRM, &sigalrm, (struct sigaction *) (0));
sigaction (SIGHUP, &sighup, (struct sigaction *) (0));
setlinebuf (stdout);
if (!writepf (pidfile))
{
error (1, errno, "can't create pidfile %s", pidfile);
}
#ifdef SYSLOGD_INETAF
/*--------------------------------------------------------------------*
* the next two checks require some double-think; the forward and
* receive flags cannot occur together because that is eliminated
* above; thus only one or the other or neither flag is set here;
*
* we disable receiving and forwarding at the same time to avoid
* accidental message loops; this means that each syslog host is
* either a divinity (source) or a black hole (sink);
*
* when forwardng messages we do not add inet sockets to the socket
* list but we use the first inet socket (inetsock) as the template
* for host-type syslogs; consequently, we allocate the descriptor
* calling syslogd_parse() where it is used in * that way;
*
* when receiving messages then we add inet sockets to the socket
* list and let syslogd_open_sockets() allocate their descriptors
* since syslog_parse() does not use inetsock in receive mode;
*--------------------------------------------------------------------*/
if (_anyset (state, SYSLOGD_STATE_RECEIVE))
{
socket = unixsock.next;
unixsock.next = inetsock.next;
inetsock.next = socket;
socket = unixsock.prev;
unixsock.prev = inetsock.prev;
inetsock.prev = socket;
}
if (_anyset (state, SYSLOGD_STATE_FORWARD))
{
inetsock.desc = syslogd_inet_socket ((struct sockaddr_in *)(inetsock.sockaddr));
if (inetsock.desc == -1)
{
error (1, errno, "Can't start %s %s service", SYSLOGD_SERVICE_NAME, SYSLOGD_SERVICE_TYPE);
}
}
#endif
/*--------------------------------------------------------------------*
* start mark message timer so that it activates on even multiples of
* clock time relative to minute 0; timer must be an integral divisor
* of 3600 and greater than 60 for this to work as intended; function
* waitspec() filters input to ensure this;
*--------------------------------------------------------------------*/
if (timer)
{
time_t clock = time (&clock);
alarm (timer - clock%timer);
}
/*--------------------------------------------------------------------*
* read configuration, create syslogs and open them; write the syslog
* map file, if enabled and requested; open sockets; read messages and
* dispatch them until terminated; close sockets then close syslogs;
*--------------------------------------------------------------------*/
syslogd_start (&syslogs, state, cfgfile);
#ifdef SYSLOGD_REPORT
syslogd_admin (&syslogs, state, mapfile);
#endif
syslogd_open_sockets (&unixsock);
while (loop)
{
syslogd_read_sockets (&unixsock);
}
syslogd_close_sockets (&unixsock);
syslogd_stop (&syslogs, state);
removepf (pidfile);
exit (0);
}
int main (int argc, char const * argv [])
{
extern FIND find;
static char const * optv [] =
{
"copy remote files to local folder",
"folder findspec [findspec] [...]",
"o:qrv",
"q\tquiet (don't report failures)",
"r\trecursive search",
"v\tverbose (report successes)",
(char const *) (0)
};
FIND home;
flag_t flags = (flag_t) (0);
signed c;
while (~ (c = getoptv (argc, argv, optv)))
{
switch (c)
{
case 'r':
_setbits (find.flagword, FIND_B_RECURSE);
break;
case 'q':
_clrbits (flags, IMPORT_SILENCE);
break;
case 'v':
_setbits (flags, IMPORT_VERBOSE);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (_allclr (find.flagword, (FIND_B_LNK | FIND_B_REG)))
{
_setbits (find.flagword, (FIND_B_LNK | FIND_B_REG));
}
if (argc)
{
strcpy (home.pathname, * argv);
if (lstat (home.pathname, & home.statinfo))
{
error (1, errno, FILE_CANTSTAT, * argv);
}
if (! S_ISDIR (home.statinfo.st_mode))
{
error (1, EINVAL, "%s is not a folder", * argv);
}
argc--;
argv++;
}
while ((argc) && (* argv))
{
makefind (& find, * argv);
findfile (& find, & home, flags);
argc--;
argv++;
}
exit (0);
}
