char *
socktoa(
const sockaddr_u *sock
)
{
register char *buffer;
LIB_GETBUF(buffer);
if (NULL == sock)
strncpy(buffer, "(null)", LIB_BUFLENGTH);
else {
switch(AF(sock)) {
case AF_INET:
case AF_UNSPEC:
inet_ntop(AF_INET, PSOCK_ADDR4(sock), buffer,
LIB_BUFLENGTH);
break;
case AF_INET6:
inet_ntop(AF_INET6, PSOCK_ADDR6(sock), buffer,
LIB_BUFLENGTH);
break;
default:
snprintf(buffer, LIB_BUFLENGTH,
"(socktoa unknown family %d)",
AF(sock));
}
}
return buffer;
}
int HVS_B0307::Init(__u16 v)
{
int rc=Base::Init();
if( rc ) return rc;
rc = AF(afClearLAM)
| AF(afWrite,&v)|AF(afOn);
return rc;
}
/*
* restrict_source - maintains dynamic "restrict source ..." entries as
* peers come and go.
*/
void
restrict_source(
sockaddr_u * addr,
int farewell, /* 0 to add, 1 to remove */
u_long expire /* 0 is infinite, valid until */
)
{
sockaddr_u onesmask;
restrict_u * res;
int found_specific;
if (!restrict_source_enabled || SOCK_UNSPEC(addr) ||
IS_MCAST(addr) || ISREFCLOCKADR(addr))
return;
REQUIRE(AF_INET == AF(addr) || AF_INET6 == AF(addr));
SET_HOSTMASK(&onesmask, AF(addr));
if (farewell) {
hack_restrict(RESTRICT_REMOVE, addr, &onesmask,
0, 0, 0);
DPRINTF(1, ("restrict_source: %s removed", stoa(addr)));
return;
}
/*
* If there is a specific entry for this address, hands
* off, as it is condidered more specific than "restrict
* server ...".
* However, if the specific entry found is a fleeting one
* added by pool_xmit() before soliciting, replace it
* immediately regardless of the expire value to make way
* for the more persistent entry.
*/
if (IS_IPV4(addr)) {
res = match_restrict4_addr(SRCADR(addr), SRCPORT(addr));
INSIST(res != NULL);
found_specific = (SRCADR(&onesmask) == res->u.v4.mask);
} else {
res = match_restrict6_addr(&SOCK_ADDR6(addr),
SRCPORT(addr));
INSIST(res != NULL);
found_specific = ADDR6_EQ(&res->u.v6.mask,
&SOCK_ADDR6(&onesmask));
}
if (!expire && found_specific && res->expire) {
found_specific = 0;
free_res(res, IS_IPV6(addr));
}
if (found_specific)
return;
hack_restrict(RESTRICT_FLAGS, addr, &onesmask,
restrict_source_mflags, restrict_source_flags,
expire);
DPRINTF(1, ("restrict_source: %s host restriction added\n",
stoa(addr)));
}
int HVS_B0307::Init(void)
{
int rc=Base::Init();
if( rc ) return rc;
__u16 code;
rc = AF(afClearLAM)
| AF(afRead, &code);
return rc;
}
/* Creates a socket and returns. */
void
create_socket (
SOCKET *rsock,
sockaddr_u *dest
)
{
*rsock = socket(AF(dest), SOCK_DGRAM, 0);
if (-1 == *rsock && ENABLED_OPT(NORMALVERBOSE))
printf("Failed to create UDP socket with family %d\n", AF(dest));
}
int HVS_B0307::Turn(const bool on)
{
int rc;
if ( on==ON )
rc = AF(afOn);
else
rc = AF(afOff);
if ( !rc )
{
Code &= ~OnMask;
Code |= on2mask(on);
}
return rc;
}
int HVS_B0307::SetVoltage(const __u16 v)
{
u16_t data = v;
int rc = AF(afWrite, &data);
if( !rc ) Code &= ~VoltageMask|v;
return rc;
}
void
test_IPv6AddressWithPort(void) {
#ifdef ISC_PLATFORM_WANTIPV6
const struct in6_addr address = {
0x20, 0x01, 0x0d, 0xb8,
0x85, 0xa3, 0x08, 0xd3,
0x13, 0x19, 0x8a, 0x2e,
0x03, 0x70, 0x73, 0x34
};
const char* expected =
"2001:db8:85a3:8d3:1319:8a2e:370:7334";
const char* expected_port =
"[2001:db8:85a3:8d3:1319:8a2e:370:7334]:123";
sockaddr_u input;
memset(&input, 0, sizeof(input));
AF(&input) = AF_INET6;
SET_ADDR6N(&input, address);
SET_PORT(&input, 123);
TEST_ASSERT_EQUAL_STRING(expected, socktoa(&input));
TEST_ASSERT_EQUAL_STRING(expected_port, sockporttoa(&input));
#else
TEST_IGNORE_MESSAGE("IPV6 disabled in build, skipping.");
#endif /* ISC_PLATFORM_HAVEIPV6 */
}
void test_AddrMatch_anull(void)
{
/* Check the not-an-address logic with a prefix/check length of
* zero bits. Any compare with a NULL or AF_UNSPEC address
* returns inequality (aka FALSE).
*/
sockaddr_u ip4, ip6, ipn;
memset(&ipn, 0, sizeof(ipn));
AF(&ipn) = AF_UNSPEC;
TEST_ASSERT_TRUE(getaddr(AF_INET , "192.128.1.1", &ip4));
TEST_ASSERT_TRUE(getaddr(AF_INET6, "::1" , &ip6));
TEST_ASSERT_FALSE(keyacc_amatch(NULL, NULL, 0));
TEST_ASSERT_FALSE(keyacc_amatch(NULL, &ipn, 0));
TEST_ASSERT_FALSE(keyacc_amatch(NULL, &ip4, 0));
TEST_ASSERT_FALSE(keyacc_amatch(NULL, &ip6, 0));
TEST_ASSERT_FALSE(keyacc_amatch(&ipn, NULL, 0));
TEST_ASSERT_FALSE(keyacc_amatch(&ipn, &ipn, 0));
TEST_ASSERT_FALSE(keyacc_amatch(&ipn, &ip4, 0));
TEST_ASSERT_FALSE(keyacc_amatch(&ipn, &ip6, 0));
TEST_ASSERT_FALSE(keyacc_amatch(&ip4, NULL, 0));
TEST_ASSERT_FALSE(keyacc_amatch(&ip4, &ipn, 0));
TEST_ASSERT_FALSE(keyacc_amatch(&ip6, NULL, 0));
TEST_ASSERT_FALSE(keyacc_amatch(&ip6, &ipn, 0));
}
string CAddress::ToString() const
{
char Dest[65] = {'\0'};
if(m_eAF != None)
_inet_ntop(AF(), m_IP, Dest, 65);
return Dest;
}
void
test_ScopedIPv6AddressWithPort(void) {
#ifdef ISC_PLATFORM_HAVESCOPEID
const struct in6_addr address = { { {
0xfe, 0x80, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x02, 0x12, 0x3f, 0xff,
0xfe, 0x29, 0xff, 0xfa
} } };
const char* expected =
"fe80::212:3fff:fe29:fffa%5";
const char* expected_port =
"[fe80::212:3fff:fe29:fffa%5]:123";
sockaddr_u input;
memset(&input, 0, sizeof(input));
AF(&input) = AF_INET6;
SET_ADDR6N(&input, address);
SET_PORT(&input, 123);
SCOPE_VAR(&input) = 5;
TEST_ASSERT_EQUAL_STRING(expected, socktoa(&input));
TEST_ASSERT_EQUAL_STRING(expected_port, sockporttoa(&input));
#else
TEST_IGNORE_MESSAGE("Skipping because ISC_PLATFORM does not have Scope ID");
#endif
}
int Coincide_C0308::GetMaskAND(u8_t* mask, COI_ch_t ch)
{
u16_t tmp;
int rc = AF(afGetAND[ch], &tmp);
*mask = tmp & maxAndMask;
return rc;
}
static char
decodeaddrtype(
sockaddr_u *sock
)
{
char ch = '-';
u_int32 dummy;
switch(AF(sock)) {
case AF_INET:
dummy = SRCADR(sock);
ch = (char)(((dummy&0xf0000000)==0xe0000000) ? 'm' :
((dummy&0x000000ff)==0x000000ff) ? 'b' :
((dummy&0xffffffff)==0x7f000001) ? 'l' :
((dummy&0xffffffe0)==0x00000000) ? '-' :
'u');
break;
case AF_INET6:
if (IN6_IS_ADDR_MULTICAST(PSOCK_ADDR6(sock)))
ch = 'm';
else
ch = 'u';
break;
default:
ch = '-';
break;
}
return ch;
}
/*
* socktoa - return a numeric host name from a sockaddr_storage structure
*/
const char *
socktoa(
const sockaddr_u *sock
)
{
int saved_errno;
char * res;
char * addr;
u_long scope;
saved_errno = errno;
LIB_GETBUF(res);
if (NULL == sock) {
strlcpy(res, "(null)", LIB_BUFLENGTH);
} else {
switch(AF(sock)) {
case AF_INET:
case AF_UNSPEC:
inet_ntop(AF_INET, PSOCK_ADDR4(sock), res,
LIB_BUFLENGTH);
break;
case AF_INET6:
inet_ntop(AF_INET6, PSOCK_ADDR6(sock), res,
LIB_BUFLENGTH);
scope = SCOPE_VAR(sock);
if (0 != scope && !strchr(res, '%')) {
addr = res;
LIB_GETBUF(res);
snprintf(res, LIB_BUFLENGTH, "%s%%%lu",
addr, scope);
res[LIB_BUFLENGTH - 1] = '\0';
}
break;
default:
snprintf(res, LIB_BUFLENGTH,
"(socktoa unknown family %d)",
AF(sock));
}
}
errno = saved_errno;
return res;
}
int Coincide_C0308::SetMaskOR( u16_t mask)
{
if (mask & badOrMask) return CAMAC_CC_INVALID_ARG;
int rc = AF(afSetOR, &mask);
if ( !rc )
SettingOrMask = mask;
return rc;
}
int HVS_B0307::ReadCode(__u16* pcode)
{
u16_t data;
int rc=AF(afRead, &data);
if ( rc&CAMAC_CC_ERRORS ) return rc;
*pcode = data;
return rc;
}
int HVS_B0307::Update(void)
{
u16_t data;
int rc = AF(afRead, &data);
if ( rc&CAMAC_CC_ERRORS ) return rc;
Code = data;
return rc;
}
QString CAddress::ToQString(bool bForUrl) const
{
char Dest[65] = {'\0'};
if(m_eAF != None)
_inet_ntop(AF(), m_IP, Dest, 65);
if(bForUrl && m_eAF == IPv6)
return QString("[%1]").arg(Dest);
return Dest;
}
int main()
{
FILE *input, *output;
input=fopen("input.dat","r");
output=fopen("output.dat","w");
int x;
char c[1024];
lista = (SENTINEL*) malloc(sizeof(SENTINEL));
lista->head=0;
lista->tail=0;
while(fscanf(input,"%s",c)!=EOF)
{
if(strcmp(c,"PRINT_ALL")==0)
PRINT_ALL(output);
else
if(strcmp(c,"AF")==0)
{
fscanf(input,"%d",&x);
AF(x);
}
else
if(strcmp(c,"AL")==0)
{
fscanf(input,"%d",&x);
AL(x);
}
else
if(strcmp(c,"DF")==0)
DF();
else
if(strcmp(c,"DL")==0)
DL();
else
if(strcmp(c,"DOOM_THE_LIST")==0)
DOOM_THE_LIST();
else
if(strcmp(c,"DE")==0)
{
fscanf(input,"%d",&x);
DE(x);
}
else
if(strcmp(c,"PRINT_F")==0)
{
fscanf(input,"%d",&x);
PRINT_F(x,output);
}
else
if(strcmp(c,"PRINT_L")==0)
{
fscanf(input,"%d",&x);
PRINT_L(x,output);
}
}
return 0;
}
bool CAddress::FromString(const std::string& Str)
{
if(Str.find(".") != string::npos)
m_eAF = IPv4;
else if(Str.find(":") != string::npos)
m_eAF = IPv6;
else
return false;
return _inet_pton(AF(), Str.c_str(), m_IP) == 1;
}
int64_t getMinARead() const
{
libmaus2::aio::InputStreamInstance AISI(lasfn);
libmaus2::dazzler::align::AlignmentFile AF(AISI);
libmaus2::dazzler::align::Overlap OVL;
if ( AF.getNextOverlap(AISI,OVL) )
return OVL.aread;
else
return -1;
}
int main()
{
FILE *g;
l=0;
head=NULL;
tail=NULL;
g=fopen("input.txt", "r");
char cuvant[15];
int n;
if (g==NULL)
{
printf("Error in opening the file.");
exit(1);
}
while(fscanf(g,"%s",cuvant)>0)
{
if (strcmp(cuvant,"AF")==0)
{
fscanf(g,"%d",&n);
AF(n);
}
else if (strcmp(cuvant,"AL")==0)
{
fscanf(g,"%d",&n);
AL(n);
}
else if (strcmp(cuvant,"DF")==0)
DF();
else if(strcmp(cuvant,"DL")==0)
DL();
else if(strcmp(cuvant,"DE")==0)
{
fscanf(g,"%d",&n);
DE(n);
}
else if(strcmp(cuvant,"PRINT_ALL")==0)
PRINT_ALL();
else if(strcmp(cuvant,"PRINT_F")==0)
{
fscanf(g,"%d",&n);
PRINT_F(n);
}
else if(strcmp(cuvant,"PRINT_L")==0)
{
fscanf(g,"%d",&n);
PRINT_L(n);
}
else if(strcmp(cuvant,"DOOM_THE_LIST")==0)
DOOM_THE_LIST();
}
fclose(g);
printf("%d",l);
return 0;
}
/*
* sock_hash - hash a sockaddr_u structure
*/
u_short
sock_hash(
sockaddr_u *addr
)
{
u_int hashVal;
u_int j;
size_t len;
u_char *pch;
hashVal = 0;
len = 0;
/*
* We can't just hash the whole thing because there are hidden
* fields in sockaddr_in6 that might be filled in by recvfrom(),
* so just use the family, port and address.
*/
pch = (u_char *)&AF(addr);
hashVal = 37 * hashVal + *pch;
if (sizeof(AF(addr)) > 1) {
pch++;
hashVal = 37 * hashVal + *pch;
}
switch(AF(addr)) {
case AF_INET:
pch = (u_char *)&SOCK_ADDR4(addr);
len = sizeof(SOCK_ADDR4(addr));
break;
case AF_INET6:
pch = (u_char *)&SOCK_ADDR6(addr);
len = sizeof(SOCK_ADDR6(addr));
break;
}
for (j = 0; j < len ; j++)
hashVal = 37 * hashVal + pch[j];
hashVal = hashVal & NTP_HASH_MASK;
return (u_short)hashVal;
}
int Coincide_C0308::GetMaskOR(u8_t* mask)
{
u16_t tmp;
int rc = AF(afGetOR, &tmp);
if( tmp & badOrMask )
*mask = bad( tmp );
else
*mask = tmp;
return rc;
}
int HVS_B0307::Verify(void)
{
int rc=Base::Verify();
if( rc ) return rc;
__u16 code;
rc = AF(afRead,&code);
if( rc&CAMAC_CC_ERRORS ) return rc;
if( code != Code ) return CAMAC_CC_VERIFICATION_ERROR;
return 0;
}
int Coincide_C0308::SetMaskAND( u16_t mask, COI_ch_t ch)
{
if ( mask & badAndMask || ch & badChannel )
return CAMAC_CC_INVALID_ARG;
u16_t dummy = mask;
// u8_t tmp = SettingAndMask[ch];
// SettingAndMask[ch] = mask;
int rc = AF(afSetAND[ch], &dummy);
if ( rc )
SettingAndMask[ch] = dummy;
return rc;
}
int main()
{
FILE* g=fopen("input.dat", "r");
char t[20];
int value;
sent=(sentinel*)malloc(sizeof(sentinel));
sent->head=NULL;
sent->tail=NULL;
while(fscanf(g, "%s", &t)==1)
{
if(strcmp(t, "AF")==0)
{
fscanf(g, "%d", &value);
AF(value);
}
else if(strcmp(t, "AL")==0)
{
fscanf(g, "%d", &value);
AL(value);
}
else if(strcmp(t, "DF")==0)
DF();
else if(strcmp(t, "DL")==0)
DL();
else if(strcmp(t, "DOOM_THE_LIST")==0)
DOOM();
else if(strcmp(t, "DE")==0)
{
fscanf(g, "%d", &value);
DELX(value);
}
else if(strcmp(t, "PRINT_ALL")==0)
PrALL();
else if(strcmp(t, "PRINT_F")==0)
{
fscanf(g, "%d", &value);
PrFx(value);
}
else if(strcmp(t, "PRINT_L")==0)
{
fscanf(g, "%d", &value);
PrLx(value);
}
}
fclose(g);
return 0;
}
static struct peer *
findexistingpeer_name(
const char * hostname,
u_short hname_fam,
struct peer * start_peer,
int mode
)
{
struct peer *p;
if (NULL == start_peer)
p = peer_list;
else
p = start_peer->p_link;
for (; p != NULL; p = p->p_link)
if (p->hostname != NULL
&& (-1 == mode || p->hmode == mode)
&& (AF_UNSPEC == hname_fam
|| AF_UNSPEC == AF(&p->srcadr)
|| hname_fam == AF(&p->srcadr))
&& !strcasecmp(p->hostname, hostname))
break;
return p;
}
static void pins_init(void)
{
/* Pin usage:
* PA0 (OUT - OD GPIO) : Wakeup on Vnc / Threshold
* PA1 (ANALOG - ADC_IN1) : CC sense
* PA2 (ANALOG - ADC_IN2) : Current sense
* PA3 (ANALOG - ADC_IN3) : Voltage sense
* PA4 (OUT - OD GPIO) : PD TX enable
* PA5 (AF0 - SPI1_SCK) : TX clock in
* PA6 (AF0 - SPI1_MISO) : PD TX
* PA7 (AF5 - TIM3_CH2) : PD RX
* PA9 (AF1 - UART1_TX) : [DEBUG] UART TX
* PA10 (AF1 - UART1_RX) : [DEBUG] UART RX
* PA13 (OUT - GPIO) : voltage select[0]
* PA14 (OUT - GPIO) : voltage select[1]
* PB1 (AF0 - TIM14_CH1) : TX clock out
* PF0 (OUT - GPIO) : LM5050 FET driver off
* PF1 (OUT - GPIO) : discharge FET
*/
STM32_GPIO_ODR(GPIO_A) = /* HIGH(0) | */ HIGH(4);
STM32_GPIO_AFRL(GPIO_A) = AFx(7, 1);
STM32_GPIO_AFRH(GPIO_A) = AFx(9, 1) | AFx(10, 1);
STM32_GPIO_OTYPER(GPIO_A) = ODR(0) | ODR(4);
STM32_GPIO_OSPEEDR(GPIO_A) = HISPEED(5) | HISPEED(6) | HISPEED(7);
STM32_GPIO_MODER(GPIO_A) = OUT(0) | ANALOG(1) | ANALOG(2) | ANALOG(3)
| OUT(4) | AF(5) /*| AF(6)*/ | AF(7) | AF(9)
| AF(10) | OUT(13) | OUT(14);
/* set PF0 / PF1 as output */
STM32_GPIO_ODR(GPIO_F) = 0;
STM32_GPIO_MODER(GPIO_F) = OUT(0) | OUT(1);
STM32_GPIO_OTYPER(GPIO_F) = 0;
/* Set PB1 as AF0 (TIM14_CH1) */
STM32_GPIO_OSPEEDR(GPIO_B) = HISPEED(1);
STM32_GPIO_MODER(GPIO_B) = AF(1);
}
/*
* findexistingpeer - search by address and return a pointer to a peer.
*/
struct peer *
findexistingpeer(
sockaddr_u * addr,
const char * hostname,
struct peer * start_peer,
int mode,
u_char cast_flags
)
{
if (hostname != NULL)
return findexistingpeer_name(hostname, AF(addr),
start_peer, mode);
else
return findexistingpeer_addr(addr, start_peer, mode,
cast_flags);
}
