struct mbuf *
m_get(size_t m_len, int type)
{
struct mbucket **mb;
struct mbuf *bp;
size_t size;
if (type > MB_MAX) {
log_Printf(LogERROR, "Bad mbuf type %d\n", type);
type = MB_UNKNOWN;
}
if (m_len > M_MAXLEN || m_len == 0) {
log_Printf(LogERROR, "Request for mbuf size %lu (\"%s\") denied !\n",
(u_long)m_len, mbuftype(type));
AbortProgram(EX_OSERR);
}
mb = M_BUCKET(m_len);
size = M_ROUNDUP(m_len);
if (*mb) {
/* We've got some free blocks of the right size */
bp = &(*mb)->u.m;
if (--(*mb)->u.f.count == 0)
*mb = (*mb)->u.f.next;
else {
((struct mbucket *)((char *)*mb + size))->u.f.count = (*mb)->u.f.count;
*mb = (struct mbucket *)((char *)*mb + size);
(*mb)->u.f.next = NULL;
}
} else {
/*
* Allocate another chunk of mbufs, use the first and put the rest on
* the free list
*/
*mb = (struct mbucket *)malloc(BUCKET_CHUNK * size);
if (*mb == NULL) {
log_Printf(LogALERT, "Failed to allocate memory (%lu)\n",
(unsigned long)BUCKET_CHUNK * size);
AbortProgram(EX_OSERR);
}
bp = &(*mb)->u.m;
*mb = (struct mbucket *)((char *)*mb + size);
(*mb)->u.f.count = BUCKET_CHUNK - 1;
(*mb)->u.f.next = NULL;
}
mbuf_Mallocs++;
memset(bp, '\0', sizeof(struct mbuf));
bp->m_size = size - sizeof *bp;
bp->m_len = m_len;
bp->m_type = type;
MemMap[type].fragments++;
MemMap[type].octets += bp->m_size;
return bp;
}
//------------------------------------------------------------------------
// основная программа
//------------------------------------------------------------------------
void main(void)
{
WORD i;
// зачистим экран монитора
system("cls");
printf(" ******************************************\n");
printf(" Module E14-140 \n");
printf(" Console example for DLL dynamic loading \n");
printf(" ******************************************\n");
// динамическая загрузка библиотеки "Lusbapi.dll"
pLoadDll = new TLoadDll("Lusbapi.dll");
if(!pLoadDll) AbortProgram(" Can't alloc 'TLoadDll' object!!!\n");
// проверим смогли ли мы загрузить библиотеку?
if(!pLoadDll->GetDllHinstance()) AbortProgram(" 'Lusbapi.dll' Dynamic Loading --> Bad\n");
else printf(" 'Lusbapi.dll' Dynamic Loading --> OK\n");
// адрес функции получения версии библиотеки
pGetDllVersion GetDllVersion = (pGetDllVersion)pLoadDll->CallGetDllVersion();
if(!GetDllVersion) AbortProgram(" Address of GetDllVersion() --> Bad\n");
else printf(" Address of GetDllVersion() --> OK\n");
// проверим версию используемой библиотеки Lusbapi.dll
if((DllVersion = GetDllVersion()) != CURRENT_VERSION_LUSBAPI)
{
char String[128];
sprintf(String, " Lusbapi.dll Version Error!!!\n Current: %1u.%1u. Required: %1u.%1u",
DllVersion >> 0x10, DllVersion & 0xFFFF,
CURRENT_VERSION_LUSBAPI >> 0x10, CURRENT_VERSION_LUSBAPI & 0xFFFF);
AbortProgram(String);
}
struct device *
udp_iov2device(int type, struct physical *p, struct iovec *iov, int *niov,
int maxiov, int *auxfd, int *nauxfd)
{
if (type == UDP_DEVICE) {
struct udpdevice *dev = (struct udpdevice *)iov[(*niov)++].iov_base;
struct udpdevice *newdev;
newdev = realloc(dev, sizeof *dev); /* Reduce to the correct size */
if (newdev == NULL) {
log_Printf(LogALERT, "Failed to allocate memory: %d\n",
(int)(sizeof *dev));
AbortProgram(EX_OSERR);
}
dev = newdev;
/* Refresh function pointers etc */
memcpy(&dev->dev, &baseudpdevice, sizeof dev->dev);
physical_SetupStack(p, dev->dev.name, PHYSICAL_FORCE_SYNC);
return &dev->dev;
}
return NULL;
}
struct device *
i4b_iov2device(int type, struct physical *p, struct iovec *iov, int *niov,
int maxiov, int *auxfd, int *nauxfd)
{
if (type == I4B_DEVICE) {
struct i4bdevice *dev = (struct i4bdevice *)iov[(*niov)++].iov_base;
dev = realloc(dev, sizeof *dev); /* Reduce to the correct size */
if (dev == NULL) {
log_Printf(LogALERT, "Failed to allocate memory: %d\n",
(int)(sizeof *dev));
AbortProgram(EX_OSERR);
}
/* Refresh function pointers etc */
memcpy(&dev->dev, &basei4bdevice, sizeof dev->dev);
physical_SetupStack(p, dev->dev.name, PHYSICAL_NOFORCE);
if (dev->Timer.state != TIMER_STOPPED) {
dev->Timer.state = TIMER_STOPPED;
p->handler = &dev->dev; /* For the benefit of StartTimer */
i4b_StartTimer(p);
}
return &dev->dev;
}
return NULL;
}
struct device *
ether_iov2device(int type, struct physical *p, struct iovec *iov, int *niov,
int maxiov __unused, int *auxfd, int *nauxfd)
{
if (type == ETHER_DEVICE) {
struct etherdevice *dev = (struct etherdevice *)iov[(*niov)++].iov_base;
dev = realloc(dev, sizeof *dev); /* Reduce to the correct size */
if (dev == NULL) {
log_Printf(LogALERT, "Failed to allocate memory: %d\n",
(int)(sizeof *dev));
AbortProgram(EX_OSERR);
}
if (*nauxfd) {
dev->cs = *auxfd;
(*nauxfd)--;
} else
dev->cs = -1;
/* Refresh function pointers etc */
memcpy(&dev->dev, &baseetherdevice, sizeof dev->dev);
physical_SetupStack(p, dev->dev.name, PHYSICAL_FORCE_SYNCNOACF);
return &dev->dev;
}
return NULL;
}
static void
ID0set0(void)
{
if (seteuid(euid) == -1) {
log_Printf(LogERROR, "ID0set0: Unable to seteuid!\n");
AbortProgram(EX_NOPERM);
}
}
static void
udp_device2iov(struct device *d, struct iovec *iov, int *niov,
int maxiov, int *auxfd, int *nauxfd)
{
int sz = physical_MaxDeviceSize();
iov[*niov].iov_base = realloc(d, sz);
if (iov[*niov].iov_base == NULL) {
log_Printf(LogALERT, "Failed to allocate memory: %d\n", sz);
AbortProgram(EX_OSERR);
}
iov[*niov].iov_len = sz;
(*niov)++;
}
//------------------------------------------------------------------------
// основная программа
//------------------------------------------------------------------------
void main(void)
{
WORD i;
SHORT DacSample;
// сбросим флажок завершения потока ввода данных
IsReadThreadComplete = false;
// пока ничего не выделено под буфер данных
ReadBuffer = NULL;
// пока не создан поток ввода данных
hReadThread = NULL;
// пока откытого файла нет :(
hFile = INVALID_HANDLE_VALUE;
// сбросим флаг ошибок потока ввода данных
ReadThreadErrorNumber = 0x0;
// сбросим флажок завершения потока вывода данных
IsWriteThreadComplete = false;
// пока ничего не выделено под буфер данных
WriteBuffer = NULL;
// пока не создан поток ввода данных
hWriteThread = NULL;
// сбросим флаг ошибок потока ввода данных
WriteThreadErrorNumber = 0x0;
// зачистим экран монитора
system("cls");
printf(" ************************************\n");
printf(" Module E14-440 \n");
printf(" Console example for ADC&DAC Streams \n");
printf(" ************************************\n\n");
// проверим версию используемой библиотеки Lusbapi.dll
if((DllVersion = GetDllVersion()) != CURRENT_VERSION_LUSBAPI)
{
char String[128];
sprintf(String, " Lusbapi.dll Version Error!!!\n Current: %1u.%1u. Required: %1u.%1u",
DllVersion >> 0x10, DllVersion & 0xFFFF,
CURRENT_VERSION_LUSBAPI >> 0x10, CURRENT_VERSION_LUSBAPI & 0xFFFF);
AbortProgram(String);
}
static void
i4b_device2iov(struct device *d, struct iovec *iov, int *niov,
int maxiov, int *auxfd, int *nauxfd)
{
struct i4bdevice *dev = device2i4b(d);
int sz = physical_MaxDeviceSize();
iov[*niov].iov_base = realloc(d, sz);
if (iov[*niov].iov_base == NULL) {
log_Printf(LogALERT, "Failed to allocate memory: %d\n", sz);
AbortProgram(EX_OSERR);
}
iov[*niov].iov_len = sz;
(*niov)++;
if (dev->Timer.state != TIMER_STOPPED) {
timer_Stop(&dev->Timer);
dev->Timer.state = TIMER_RUNNING;
}
}
static void
ether_device2iov(struct device *d, struct iovec *iov, int *niov,
int maxiov __unused, int *auxfd, int *nauxfd)
{
struct etherdevice *dev;
int sz = physical_MaxDeviceSize();
iov[*niov].iov_base = d = realloc(d, sz);
if (d == NULL) {
log_Printf(LogALERT, "Failed to allocate memory: %d\n", sz);
AbortProgram(EX_OSERR);
}
iov[*niov].iov_len = sz;
(*niov)++;
dev = device2ether(d);
if (dev->cs >= 0) {
*auxfd = dev->cs;
(*nauxfd)++;
}
}
//------------------------------------------------------------------------
// основная программа
//------------------------------------------------------------------------
void main(void)
{
WORD i, j;
// проинициализируем указатели и переменные
for(i = 0x0; i < MaxVirtualSoltsQuantity; i++)
{
// обнулим указатель на интерфейс
pModules[i] = NULL;
// сбросим флажок прерывания потока сбора данных
IsReadThreadTerminated[i] = false;
// пока ничего не выделено под буфер данных
Buffer[i] = NULL;
// пока не создан поток ввода данных
ReadThreadHandle[i] = NULL;
// сбросим флаг ошибок потока ввода данных
ReadThreadErrorNumber[i] = 0x0;
}
// зачищаем экран монитора
clrscr();
printf(" ***********************************\n");
printf(" Module E14-440 \n");
printf(" Console example for Multi Modules \n");
printf(" ***********************************\n\n");
// инициализация критической секции
InitializeCriticalSection(&cs);
// проверим версию используемой библиотеки Lusbapi.dll
if((DllVersion = GetDllVersion()) != CURRENT_VERSION_LUSBAPI)
{
char String[128];
sprintf(String, " Lusbapi.dll Version Error!!!\n Current: %1u.%1u. Required: %1u.%1u",
DllVersion >> 0x10, DllVersion & 0xFFFF,
CURRENT_VERSION_LUSBAPI >> 0x10, CURRENT_VERSION_LUSBAPI & 0xFFFF);
AbortProgram(String);
}
//------------------------------------------------------------------------
// основная программа
//------------------------------------------------------------------------
void main(void)
{
WORD i;
// зачистим экран монитора
clrscr();
printf(" *************************************\n");
printf(" Module E14-140 \n");
printf(" Console example for DAC_SAMPLE Stream\n");
printf(" *************************************\n\n");
// проверим версию используемой библиотеки Lusbapi.dll
if((DllVersion = GetDllVersion()) != CURRENT_VERSION_LUSBAPI)
{
char String[128];
sprintf(String, " Lusbapi.dll Version Error!!!\n Current: %1u.%1u. Required: %1u.%1u",
DllVersion >> 0x10, DllVersion & 0xFFFF,
CURRENT_VERSION_LUSBAPI >> 0x10, CURRENT_VERSION_LUSBAPI & 0xFFFF);
AbortProgram(String);
}
//------------------------------------------------------------------------
// основная программа
//------------------------------------------------------------------------
void main(void)
{
WORD i;
// зачистим экран монитора
system("cls");
printf(" ***************************************\n");
printf(" Module E-310 \n");
printf(" Digital IO console example \n");
printf(" ***************************************\n\n");
// проверим версию используемой библиотеки Lusbapi.dll
if((DllVersion = GetDllVersion()) != CURRENT_VERSION_LUSBAPI)
{
char String[128];
sprintf_s(String, " Lusbapi.dll Version Error!!!\n Current: %1u.%1u. Required: %1u.%1u",
DllVersion >> 0x10, DllVersion & 0xFFFF,
CURRENT_VERSION_LUSBAPI >> 0x10, CURRENT_VERSION_LUSBAPI & 0xFFFF);
AbortProgram(String);
}
int
main(int argc, char **argv)
{
char *name;
const char *lastlabel;
int arg, f, holdfd[3], label;
struct bundle *bundle;
struct prompt *prompt;
struct switches sw;
probe_Init();
/*
* We open 3 descriptors to ensure that STDIN_FILENO, STDOUT_FILENO and
* STDERR_FILENO are always open. These are closed before DoLoop(),
* but *after* we've avoided the possibility of erroneously closing
* an important descriptor with close(STD{IN,OUT,ERR}_FILENO).
*/
if ((holdfd[0] = open(_PATH_DEVNULL, O_RDWR)) == -1) {
fprintf(stderr, "Cannot open %s !\n", _PATH_DEVNULL);
return 2;
}
for (f = 1; f < sizeof holdfd / sizeof *holdfd; f++)
holdfd[f] = dup(holdfd[0]);
name = strrchr(argv[0], '/');
log_Open(name ? name + 1 : argv[0]);
#ifndef NONAT
PacketAliasInit();
#endif
label = ProcessArgs(argc, argv, &sw);
/*
* A FreeBSD & OpenBSD hack to dodge a bug in the tty driver that drops
* output occasionally.... I must find the real reason some time. To
* display the dodgy behaviour, comment out this bit, make yourself a large
* routing table and then run ppp in interactive mode. The `show route'
* command will drop chunks of data !!!
*/
if (sw.mode == PHYS_INTERACTIVE) {
close(STDIN_FILENO);
if (open(_PATH_TTY, O_RDONLY) != STDIN_FILENO) {
fprintf(stderr, "Cannot open %s for input !\n", _PATH_TTY);
return 2;
}
}
/* Allow output for the moment (except in direct mode) */
if (sw.mode == PHYS_DIRECT)
prompt = NULL;
else
SignalPrompt = prompt = prompt_Create(NULL, NULL, PROMPT_STD);
ID0init();
if (ID0realuid() != 0) {
char conf[200], *ptr;
snprintf(conf, sizeof conf, "%s/%s", PPP_CONFDIR, CONFFILE);
do {
struct stat sb;
if (stat(conf, &sb) == 0 && sb.st_mode & S_IWOTH) {
log_Printf(LogALERT, "ppp: Access violation: Please protect %s\n",
conf);
return -1;
}
ptr = conf + strlen(conf)-2;
while (ptr > conf && *ptr != '/')
*ptr-- = '\0';
} while (ptr >= conf);
}
if (label < argc)
for (arg = label; arg < argc; arg++)
CheckLabel(argv[arg], prompt, sw.mode);
else
CheckLabel("default", prompt, sw.mode);
if (!sw.quiet)
prompt_Printf(prompt, "Working in %s mode\n", mode2Nam(sw.mode));
if ((bundle = bundle_Create(TUN_PREFIX, sw.mode, sw.unit)) == NULL)
return EX_START;
/* NOTE: We may now have changed argv[1] via a ``set proctitle'' */
if (prompt) {
prompt->bundle = bundle; /* couldn't do it earlier */
if (!sw.quiet)
prompt_Printf(prompt, "Using interface: %s\n", bundle->iface->name);
}
SignalBundle = bundle;
bundle->NatEnabled = sw.nat;
if (sw.nat)
opt_enable(bundle, OPT_IFACEALIAS);
if (system_Select(bundle, "default", CONFFILE, prompt, NULL) < 0)
prompt_Printf(prompt, "Warning: No default entry found in config file.\n");
sig_signal(SIGHUP, CloseSession);
sig_signal(SIGTERM, CloseSession);
sig_signal(SIGINT, CloseConnection);
sig_signal(SIGQUIT, CloseSession);
sig_signal(SIGALRM, SIG_IGN);
signal(SIGPIPE, SIG_IGN);
if (sw.mode == PHYS_INTERACTIVE)
sig_signal(SIGTSTP, TerminalStop);
sig_signal(SIGUSR1, RestartServer);
sig_signal(SIGUSR2, BringDownServer);
lastlabel = argv[argc - 1];
for (arg = label; arg < argc; arg++) {
/* In case we use LABEL or ``set enddisc label'' */
bundle_SetLabel(bundle, lastlabel);
system_Select(bundle, argv[arg], CONFFILE, prompt, NULL);
}
if (label < argc)
/* In case the last label did a ``load'' */
bundle_SetLabel(bundle, lastlabel);
if (sw.mode == PHYS_AUTO &&
ncprange_family(&bundle->ncp.ipcp.cfg.peer_range) == AF_UNSPEC) {
prompt_Printf(prompt, "You must ``set ifaddr'' with a peer address "
"in auto mode.\n");
AbortProgram(EX_START);
}
if (sw.mode != PHYS_INTERACTIVE) {
if (sw.mode != PHYS_DIRECT) {
if (!sw.fg) {
int bgpipe[2];
pid_t bgpid;
if (sw.mode == PHYS_BACKGROUND && pipe(bgpipe)) {
log_Printf(LogERROR, "pipe: %s\n", strerror(errno));
AbortProgram(EX_SOCK);
}
bgpid = fork();
if (bgpid == -1) {
log_Printf(LogERROR, "fork: %s\n", strerror(errno));
AbortProgram(EX_SOCK);
}
if (bgpid) {
char c = EX_NORMAL;
int ret;
if (sw.mode == PHYS_BACKGROUND) {
close(bgpipe[1]);
BGPid = bgpid;
/* If we get a signal, kill the child */
signal(SIGHUP, KillChild);
signal(SIGTERM, KillChild);
signal(SIGINT, KillChild);
signal(SIGQUIT, KillChild);
/* Wait for our child to close its pipe before we exit */
while ((ret = read(bgpipe[0], &c, 1)) == 1) {
switch (c) {
case EX_NORMAL:
if (!sw.quiet) {
prompt_Printf(prompt, "PPP enabled\n");
log_Printf(LogPHASE, "Parent: PPP enabled\n");
}
break;
case EX_REDIAL:
if (!sw.quiet)
prompt_Printf(prompt, "Attempting redial\n");
continue;
case EX_RECONNECT:
if (!sw.quiet)
prompt_Printf(prompt, "Attempting reconnect\n");
continue;
default:
prompt_Printf(prompt, "Child failed (%s)\n",
ex_desc((int)c));
log_Printf(LogPHASE, "Parent: Child failed (%s)\n",
ex_desc((int) c));
}
break;
}
if (ret != 1) {
prompt_Printf(prompt, "Child exit, no status.\n");
log_Printf(LogPHASE, "Parent: Child exit, no status.\n");
}
close(bgpipe[0]);
}
return c;
} else if (sw.mode == PHYS_BACKGROUND) {
close(bgpipe[0]);
bundle->notify.fd = bgpipe[1];
}
bundle_ChangedPID(bundle);
bundle_LockTun(bundle); /* we have a new pid */
}
/* -auto, -dedicated, -ddial, -foreground & -background */
prompt_Destroy(prompt, 0);
close(STDOUT_FILENO);
close(STDERR_FILENO);
close(STDIN_FILENO);
if (!sw.fg)
setsid();
} else {
/* -direct - STDIN_FILENO gets used by physical_Open */
prompt_TtyInit(NULL);
close(STDOUT_FILENO);
close(STDERR_FILENO);
}
} else {
/* -interactive */
close(STDERR_FILENO);
prompt_TtyInit(prompt);
prompt_TtyCommandMode(prompt);
prompt_Required(prompt);
}
/* We can get rid of these now */
for (f = 0; f < sizeof holdfd / sizeof *holdfd; f++)
close(holdfd[f]);
log_Printf(LogPHASE, "PPP Started (%s mode).\n", mode2Nam(sw.mode));
DoLoop(bundle);
AbortProgram(EX_NORMAL);
return EX_NORMAL;
}
int
physical2iov(struct physical *p, struct iovec *iov, int *niov, int maxiov,
int *auxfd, int *nauxfd)
{
struct device *h;
int sz;
h = NULL;
if (p) {
hdlc_StopTimer(&p->hdlc);
lqr_StopTimer(p);
timer_Stop(&p->link.lcp.fsm.FsmTimer);
timer_Stop(&p->link.ccp.fsm.FsmTimer);
timer_Stop(&p->link.lcp.fsm.OpenTimer);
timer_Stop(&p->link.ccp.fsm.OpenTimer);
timer_Stop(&p->link.lcp.fsm.StoppedTimer);
timer_Stop(&p->link.ccp.fsm.StoppedTimer);
if (p->handler) {
h = p->handler;
p->handler = (struct device *)(long)p->handler->type;
}
if (Enabled(p->dl->bundle, OPT_KEEPSESSION) ||
tcgetpgrp(p->fd) == getpgrp())
p->session_owner = getpid(); /* So I'll eventually get HUP'd */
else
p->session_owner = (pid_t)-1;
timer_Stop(&p->link.stats.total.Timer);
}
if (*niov + 2 >= maxiov) {
log_Printf(LogERROR, "physical2iov: No room for physical + throughput"
" + device !\n");
if (p)
free(p);
return -1;
}
iov[*niov].iov_base = (void *)p;
iov[*niov].iov_len = sizeof *p;
(*niov)++;
iov[*niov].iov_base = p ? (void *)p->link.stats.total.in.SampleOctets : NULL;
iov[*niov].iov_len = SAMPLE_PERIOD * sizeof(long long);
(*niov)++;
iov[*niov].iov_base = p ? (void *)p->link.stats.total.out.SampleOctets : NULL;
iov[*niov].iov_len = SAMPLE_PERIOD * sizeof(long long);
(*niov)++;
sz = physical_MaxDeviceSize();
if (p) {
if (h && h->device2iov)
(*h->device2iov)(h, iov, niov, maxiov, auxfd, nauxfd);
else {
if ((iov[*niov].iov_base = malloc(sz)) == NULL) {
log_Printf(LogALERT, "physical2iov: Out of memory (%d bytes)\n", sz);
AbortProgram(EX_OSERR);
}
if (h)
memcpy(iov[*niov].iov_base, h, sizeof *h);
iov[*niov].iov_len = sz;
(*niov)++;
}
} else {
iov[*niov].iov_base = NULL;
iov[*niov].iov_len = sz;
(*niov)++;
}
return p ? p->fd : 0;
}
