void testEndpoint ()
{
testcase ("Endpoint");
{
std::pair <Endpoint, bool> result (
Endpoint::from_string_checked ("1.2.3.4"));
expect (result.second);
if (expect (result.first.address().is_v4 ()))
{
expect (result.first.address().to_v4() ==
AddressV4 (1, 2, 3, 4));
expect (result.first.port() == 0);
expect (to_string (result.first) == "1.2.3.4");
}
}
{
std::pair <Endpoint, bool> result (
Endpoint::from_string_checked ("1.2.3.4:5"));
expect (result.second);
if (expect (result.first.address().is_v4 ()))
{
expect (result.first.address().to_v4() ==
AddressV4 (1, 2, 3, 4));
expect (result.first.port() == 5);
expect (to_string (result.first) == "1.2.3.4:5");
}
}
Endpoint ep;
ep = Endpoint (AddressV4 (127,0,0,1), 80);
expect (! is_unspecified (ep));
expect (! is_public (ep));
expect ( is_private (ep));
expect (! is_multicast (ep));
expect ( is_loopback (ep));
expect (to_string (ep) == "127.0.0.1:80");
ep = Endpoint (AddressV4 (10,0,0,1));
expect (AddressV4::get_class (ep.to_v4()) == 'A');
expect (! is_unspecified (ep));
expect (! is_public (ep));
expect ( is_private (ep));
expect (! is_multicast (ep));
expect (! is_loopback (ep));
expect (to_string (ep) == "10.0.0.1");
ep = Endpoint (AddressV4 (166,78,151,147));
expect (! is_unspecified (ep));
expect ( is_public (ep));
expect (! is_private (ep));
expect (! is_multicast (ep));
expect (! is_loopback (ep));
expect (to_string (ep) == "166.78.151.147");
}
void Field::check_access_by(InstanceClass* sender_class,
InstanceClass* static_receiver_class,
FailureMode fail_mode JVM_TRAPS) {
InstanceClass* field_class = ic();
if (is_public()) {
return;
}
if (field_class->equals(sender_class)) {
return;
}
if (!is_private()) {
if (field_class->is_same_class_package(sender_class)) {
return;
}
if (is_protected()) {
if (sender_class->is_subclass_of(field_class)) {
if (static_receiver_class->equals(sender_class) ||
static_receiver_class->is_subclass_of(sender_class) ||
sender_class->is_subclass_of(static_receiver_class)) {
return;
}
}
}
}
Throw::illegal_access(fail_mode JVM_NO_CHECK_AT_BOTTOM);
}
/** \brief return true is the ip_addr is public (aka not local and not private not linklocal)
*/
bool ip_addr_t::is_public() const throw()
{
if( is_null() ) return false;
if( !is_fully_qualified() ) return false;
if( is_private() ) return false;
if( is_localhost() ) return false;
if( is_linklocal() ) return false;
return true;
}
// constants symbols in theorem types that should be ignored
bool ignore_F(name const & F) const {
if (is_private(m_env, F))
return true; // we ignore private decls
if (is_class_instance_somewhere(m_env, F))
return true; // ignore if F is a class or class-instance in some namespace
if (is_connective(F))
return true;
return false;
}
// Theorems/Axioms that should be ignored
bool ignore_T(name const & T) const {
if (is_private(m_env, T))
return true;
if (inductive::is_elim_rule(m_env, T))
return true;
if (inductive::is_intro_rule(m_env, T))
return true;
return false;
}
static HashNode
getprivatenode(HashTable ht, const char *nam)
{
HashNode hn = getparamnode(ht, nam);
Param pm = (Param) hn;
while (!fakelevel && pm && locallevel > pm->level && is_private(pm))
pm = pm->old;
return (HashNode)pm;
}
static HashNode
getprivatenode2(HashTable ht, const char *nam)
{
/* getparamnode() would follow autoloads, we must not do that here */
HashNode hn = gethashnode2(ht, nam);
Param pm = (Param) hn;
while (!fakelevel && pm && locallevel > pm->level && is_private(pm))
pm = pm->old;
return (HashNode)pm;
}
static void
makeprivate(HashNode hn, UNUSED(int flags))
{
Param pm = (Param)hn;
if (pm->level == locallevel) {
if (pm->ename || (pm->node.flags & PM_NORESTORE) ||
(pm->old &&
(pm->old->level == locallevel - 1 ||
((pm->node.flags & (PM_SPECIAL|PM_REMOVABLE)) == PM_SPECIAL &&
/* typeset_single() line 2300 discards PM_REMOVABLE -- why? */
!is_private(pm->old))))) {
zwarnnam("private", "can't change scope of existing param: %s",
pm->node.nam);
makeprivate_error = 1;
return;
}
struct gsu_closure *gsu = zhalloc(sizeof(struct gsu_closure));
switch (PM_TYPE(pm->node.flags)) {
case PM_SCALAR:
gsu->g = (void *)(pm->gsu.s);
gsu->u.s = scalar_private_gsu;
pm->gsu.s = (GsuScalar)gsu;
break;
case PM_INTEGER:
gsu->g = (void *)(pm->gsu.i);
gsu->u.i = integer_private_gsu;
pm->gsu.i = (GsuInteger)gsu;
break;
case PM_EFLOAT:
case PM_FFLOAT:
gsu->g = (void *)(pm->gsu.f);
gsu->u.f = float_private_gsu;
pm->gsu.f = (GsuFloat)gsu;
break;
case PM_ARRAY:
gsu->g = (void *)(pm->gsu.a);
gsu->u.a = array_private_gsu;
pm->gsu.a = (GsuArray)gsu;
break;
case PM_HASHED:
gsu->g = (void *)(pm->gsu.h);
gsu->u.h = hash_private_gsu;
pm->gsu.h = (GsuHash)gsu;
break;
default:
makeprivate_error = 1;
break;
}
/* PM_HIDE so new parameters in deeper scopes do not shadow */
pm->node.flags |= (PM_HIDE|PM_SPECIAL|PM_REMOVABLE);
pm->level -= 1;
}
}
static void
printprivatenode(HashNode hn, int printflags)
{
Param pm = (Param) hn;
while (pm && (!fakelevel ||
(fakelevel > pm->level && (pm->node.flags & PM_UNSET))) &&
locallevel > pm->level && is_private(pm))
pm = pm->old;
/* Ideally, we'd print the word "private" here instead of "typeset"
* when the parameter is in fact a private, but that would require
* re-implementing the entirety of printparamnode(). */
if (pm)
printparamnode((HashNode)pm, printflags);
}
// @Override
virtual void debug_print(int indent) override {
print_space(indent);
if (is_public())
printf("public ");
else if (is_protected())
printf("protected ");
else if (is_private())
printf("private ");
if (is_static())
printf("static ");
if (is_final())
printf("final ");
}
static void
scopeprivate(HashNode hn, int onoff)
{
Param pm = (Param)hn;
if (pm->level == locallevel) {
if (!is_private(pm))
return;
if (onoff == PM_UNSET)
if (pm->node.flags & PM_UNSET)
pm->node.flags |= PM_NORESTORE;
else
pm->node.flags |= PM_UNSET;
else if (!(pm->node.flags & PM_NORESTORE))
pm->node.flags &= ~PM_UNSET;
pm->node.flags &= ~PM_NORESTORE;
}
}
void AccessFlags::print_on(outputStream* st) const {
if (is_public ()) st->print("public " );
if (is_private ()) st->print("private " );
if (is_protected ()) st->print("protected " );
if (is_static ()) st->print("static " );
if (is_final ()) st->print("final " );
if (is_synchronized()) st->print("synchronized ");
if (is_volatile ()) st->print("volatile " );
if (is_transient ()) st->print("transient " );
if (is_native ()) st->print("native " );
if (is_interface ()) st->print("interface " );
if (is_abstract ()) st->print("abstract " );
if (is_strict ()) st->print("strict " );
if (is_synthetic ()) st->print("synthetic " );
if (is_old ()) st->print("{old} " );
if (is_obsolete ()) st->print("{obsolete} " );
}
void
M2c::process_sym_table(SymTable *st)
{
bool st_is_private = is_private(st);
Iter<SymbolTableObject*> iter = st->get_symbol_table_object_iterator();
for (/* iter */; iter.is_valid(); iter.next()) {
SymbolTableObject *the_sto = iter.current();
if (is_kind_of<VariableSymbol>(the_sto)) {
if (is_kind_of<ParameterSymbol>(the_sto))
continue; // don't shadow an arg!
VarSym *v = to<VariableSymbol>(the_sto);
if (!is_global(st)) {
printer->print_var_def(v, false);
}
else if (v->get_definition() != NULL) {
postponed_vars.push_back(v);
printer->print_var_def(v, true);
}
else {
claim(is_external(v));
fprintf(out, "extern ");
printer->print_sym_decl(v);
fprintf(out, ";\n");
}
} else if (is_kind_of<ProcedureSymbol>(the_sto)) {
if (st_is_private) fputs("static ", out);
printer->print_proc_decl(to<ProcedureSymbol>(the_sto));
} else if (is_kind_of<Type>(the_sto)) {
if (is_kind_of<EnumeratedType>(the_sto) ||
(is_kind_of<GroupType>(the_sto) &&
to<GroupType>(the_sto)->get_is_complete())) {
printer->print_type(to<Type>(the_sto));
fprintf(out, ";\n");
}
}
}
}
static LUA_FUNCTION(openssl_rsa_decrypt)
{
RSA* rsa = CHECK_OBJECT(1, RSA, "openssl.rsa");
size_t l;
const unsigned char* from = (const unsigned char *) luaL_checklstring(L, 2, &l);
int padding = openssl_get_padding(L, 3, "pkcs1");
int ispriv = lua_isnone(L, 4) ? is_private(rsa) : lua_toboolean(L, 4);
unsigned char* to = OPENSSL_malloc(RSA_size(rsa));
int flen = l;
flen = ispriv
? RSA_private_decrypt(flen, from, to, rsa, padding)
: RSA_public_decrypt(flen, from, to, rsa, padding);
if (flen > 0)
{
lua_pushlstring(L, (const char*)to, flen);
OPENSSL_free(to);
return 1;
}
OPENSSL_free(to);
return openssl_pushresult(L, flen);
};
// ------------------------------------------------------------------
// ciFlags::print_member_flags
void ciFlags::print_member_flags(outputStream* st) {
if (is_public()) {
st->print("public");
} else if (is_private()) {
st->print("private");
} else if (is_protected()) {
st->print("protected");
} else {
st->print("DEFAULT_ACCESS");
}
if (is_static()) {
st->print(",static");
}
if (is_final()) {
st->print(",final");
}
if (is_synchronized()) {
st->print(",synchronized");
}
if (is_volatile()) {
st->print(",volatile");
}
if (is_transient()) {
st->print(",transient");
}
if (is_native()) {
st->print(",native");
}
if (is_abstract()) {
st->print(",abstract");
}
if (is_strict()) {
st->print(",strict");
}
}
static int ftp_init_transfer(void)
{
struct sockaddr_storage sa;
unsigned char *a, *p;
if(!ftp_connected())
return -1;
if (!(ftp->data = sock_create())) {
return -1;
}
sock_copy(ftp->data, ftp->ctrl);
if (ftp_is_passive())
{
memcpy(&sa, sock_remote_addr(ftp->ctrl), sizeof(struct sockaddr_storage));
unsigned char pac[6];
unsigned short ipv6_port;
if (!ftp_pasv(sa.ss_family != AF_INET, pac, &ipv6_port))
goto err1;
socklen_t len = sizeof(struct sockaddr_in);
if (sa.ss_family == AF_INET)
{
memcpy(&((struct sockaddr_in*)&sa)->sin_addr, pac, (size_t)4);
memcpy(&((struct sockaddr_in*)&sa)->sin_port, pac+4, (size_t)2);
}
#ifdef HAVE_IPV6
else if (sa.ss_family == AF_INET6)
{
((struct sockaddr_in6*)&sa)->sin6_port = htons(ipv6_port);
len = sizeof(struct sockaddr_in6);
}
#endif
else
return -1;
struct sockaddr_storage tmp;
memcpy(&tmp, sock_remote_addr(ftp->ctrl), sizeof(struct sockaddr_storage));
if (is_reserved((struct sockaddr*) &sa) ||
is_multicast((struct sockaddr*) &sa) ||
(is_private((struct sockaddr*) &sa) != is_private((struct sockaddr*) &tmp)) ||
(is_loopback((struct sockaddr*) &sa) != is_loopback((struct sockaddr*) &tmp)))
{
// Invalid address returned by PASV. Replace with address from control
// socket.
ftp_err(_("Address returned by PASV seems to be incorrect.\n"));
((struct sockaddr_in*)&sa)->sin_addr = ((struct sockaddr_in*)&tmp)->sin_addr;
}
if (!sock_connect_addr(ftp->data, (struct sockaddr*) &sa, len))
{
perror("connect()");
goto err1;
}
} else {
const struct sockaddr* local = sock_local_addr(ftp->data);
sock_listen(ftp->data, local->sa_family);
if (local->sa_family == AF_INET)
{
struct sockaddr_in* tmp = (struct sockaddr_in*)local;
a = (unsigned char *)&tmp->sin_addr;
p = (unsigned char *)&tmp->sin_port;
ftp_set_tmp_verbosity(vbError);
ftp_cmd("PORT %d,%d,%d,%d,%d,%d",
a[0], a[1], a[2], a[3], p[0], p[1]);
}
#ifdef HAVE_IPV6
else if (local->sa_family == AF_INET6)
{
char* addr = printable_address(local);
ftp_set_tmp_verbosity(vbError);
ftp_cmd("EPRT |2|%s|%u", addr, ntohs(((struct sockaddr_in6*)local)->sin6_port));
free(addr);
}
#endif
else
goto err1;
if(ftp->code != ctComplete)
goto err1;
}
sock_throughput(ftp->data);
return 0;
err1:
sock_destroy(ftp->data);
ftp->data = 0;
return -1;
}
static LUA_FUNCTION(openssl_rsa_isprivate)
{
RSA* rsa = CHECK_OBJECT(1, RSA, "openssl.rsa");
lua_pushboolean(L, is_private(rsa));
return 1;
};
static int ftp_init_transfer(void)
{
if (!ftp_connected())
return -1;
if (!sock_dup(ftp->ctrl, &ftp->data))
return -1;
if (ftp_is_passive())
{
ftp_trace("Initializing passive connection.\n");
struct sockaddr_storage sa;
memcpy(&sa, sock_remote_addr(ftp->ctrl), sizeof(struct sockaddr_storage));
unsigned char pac[6] = { 0 };
unsigned short ipv6_port = { 0 };
if (!ftp_pasv(sa.ss_family != AF_INET, pac, &ipv6_port))
{
ftp_trace("PASV/EPSV failed.\n");
sock_destroy(ftp->data);
ftp->data = NULL;
return -1;
}
socklen_t len = sizeof(struct sockaddr_in);
if (sa.ss_family == AF_INET)
{
memcpy(&((struct sockaddr_in*)&sa)->sin_addr, pac, (size_t)4);
memcpy(&((struct sockaddr_in*)&sa)->sin_port, pac+4, (size_t)2);
}
#ifdef HAVE_IPV6
else if (sa.ss_family == AF_INET6)
{
((struct sockaddr_in6*)&sa)->sin6_port = htons(ipv6_port);
len = sizeof(struct sockaddr_in6);
}
#endif
else
{
ftp_trace("Do not know how to handle family %d.\n", sa.ss_family);
sock_destroy(ftp->data);
ftp->data = NULL;
return -1;
}
struct sockaddr_storage tmp;
memcpy(&tmp, sock_remote_addr(ftp->ctrl), sizeof(struct sockaddr_storage));
if (is_reserved((struct sockaddr*) &sa) ||
is_multicast((struct sockaddr*) &sa) ||
(is_private((struct sockaddr*) &sa) != is_private((struct sockaddr*) &tmp)) ||
(is_loopback((struct sockaddr*) &sa) != is_loopback((struct sockaddr*) &tmp)))
{
// Invalid address returned by PASV. Replace with address from control
// socket.
ftp_err(_("Address returned by PASV seems to be incorrect.\n"));
((struct sockaddr_in*)&sa)->sin_addr = ((struct sockaddr_in*)&tmp)->sin_addr;
}
if (!sock_connect_addr(ftp->data, (struct sockaddr*) &sa, len))
{
ftp_trace("Could not connect to address from PASV/EPSV.\n");
perror("connect()");
sock_destroy(ftp->data);
ftp->data = NULL;
return -1;
}
} else {
ftp_trace("Initializing active connection.\n");
const struct sockaddr* local = sock_local_addr(ftp->data);
sock_listen(ftp->data, local->sa_family);
if (local->sa_family == AF_INET)
{
struct sockaddr_in* tmp = (struct sockaddr_in*)local;
unsigned char* a = (unsigned char *)&tmp->sin_addr;
unsigned char* p = (unsigned char *)&tmp->sin_port;
ftp_set_tmp_verbosity(vbError);
ftp_cmd("PORT %d,%d,%d,%d,%d,%d",
a[0], a[1], a[2], a[3], p[0], p[1]);
}
#ifdef HAVE_IPV6
else if (local->sa_family == AF_INET6)
{
char* addr = printable_address(local);
ftp_set_tmp_verbosity(vbError);
ftp_cmd("EPRT |2|%s|%u|", addr, ntohs(((struct sockaddr_in6*)local)->sin6_port));
free(addr);
}
#endif
else
{
ftp_trace("Do not know how to handle family %d.\n", local->sa_family);
sock_destroy(ftp->data);
ftp->data = NULL;
return -1;
}
if(ftp->code != ctComplete)
{
ftp_trace("PORT/EPRT not successful\n");
sock_destroy(ftp->data);
ftp->data = NULL;
return -1;
}
}
sock_throughput(ftp->data);
return 0;
}
void testEndpoint ()
{
testcase ("Endpoint");
{
std::pair <Endpoint, bool> result (
Endpoint::from_string_checked ("1.2.3.4"));
expect (result.second);
if (expect (result.first.address().is_v4 ()))
{
expect (result.first.address().to_v4() ==
AddressV4 (1, 2, 3, 4));
expect (result.first.port() == 0);
expect (to_string (result.first) == "1.2.3.4");
}
}
{
std::pair <Endpoint, bool> result (
Endpoint::from_string_checked ("1.2.3.4:5"));
expect (result.second);
if (expect (result.first.address().is_v4 ()))
{
expect (result.first.address().to_v4() ==
AddressV4 (1, 2, 3, 4));
expect (result.first.port() == 5);
expect (to_string (result.first) == "1.2.3.4:5");
}
}
Endpoint ep;
ep = Endpoint (AddressV4 (127,0,0,1), 80);
expect (! is_unspecified (ep));
expect (! is_public (ep));
expect ( is_private (ep));
expect (! is_multicast (ep));
expect ( is_loopback (ep));
expect (to_string (ep) == "127.0.0.1:80");
ep = Endpoint (AddressV4 (10,0,0,1));
expect (AddressV4::get_class (ep.to_v4()) == 'A');
expect (! is_unspecified (ep));
expect (! is_public (ep));
expect ( is_private (ep));
expect (! is_multicast (ep));
expect (! is_loopback (ep));
expect (to_string (ep) == "10.0.0.1");
ep = Endpoint (AddressV4 (166,78,151,147));
expect (! is_unspecified (ep));
expect ( is_public (ep));
expect (! is_private (ep));
expect (! is_multicast (ep));
expect (! is_loopback (ep));
expect (to_string (ep) == "166.78.151.147");
{
ep = Endpoint::from_string ("192.0.2.112");
expect (! is_unspecified (ep));
expect (ep == Endpoint::from_string_altform ("192.0.2.112"));
auto const ep1 = Endpoint::from_string ("192.0.2.112:2016");
expect (! is_unspecified (ep1));
expect (ep.address() == ep1.address());
expect (ep1.port() == 2016);
auto const ep2 =
Endpoint::from_string_altform ("192.0.2.112:2016");
expect (! is_unspecified (ep2));
expect (ep.address() == ep2.address());
expect (ep2.port() == 2016);
expect (ep1 == ep2);
auto const ep3 =
Endpoint::from_string_altform ("192.0.2.112 2016");
expect (! is_unspecified (ep3));
expect (ep.address() == ep3.address());
expect (ep3.port() == 2016);
expect (ep2 == ep3);
auto const ep4 =
Endpoint::from_string_altform ("192.0.2.112 2016");
expect (! is_unspecified (ep4));
expect (ep.address() == ep4.address());
expect (ep4.port() == 2016);
expect (ep3 == ep4);
expect (to_string(ep1) == to_string(ep2));
expect (to_string(ep1) == to_string(ep3));
expect (to_string(ep1) == to_string(ep4));
}
// Failures:
expect (is_unspecified (
Endpoint::from_string ("192.0.2.112:port")));
expect (is_unspecified (
Endpoint::from_string_altform ("192.0.2.112:port")));
expect (is_unspecified (
Endpoint::from_string_altform ("192.0.2.112 port")));
expect (is_unspecified (
Endpoint::from_string ("ip:port")));
expect (is_unspecified (
Endpoint::from_string_altform ("ip:port")));
expect (is_unspecified (
Endpoint::from_string_altform ("ip port")));
expect (is_unspecified (
Endpoint::from_string("")));
expect (is_unspecified (
Endpoint::from_string_altform("")));
expect (is_unspecified (
Endpoint::from_string("255")));
expect (is_unspecified (
Endpoint::from_string_altform("255")));
expect (is_unspecified (
Endpoint::from_string("512")));
expect (is_unspecified (
Endpoint::from_string_altform("512")));
expect (is_unspecified (
Endpoint::from_string("1.2.3.256")));
expect (is_unspecified (
Endpoint::from_string_altform("1.2.3.256")));
expect (is_unspecified (
Endpoint::from_string("1.2.3:80")));
expect (is_unspecified (
Endpoint::from_string_altform("1.2.3:80")));
expect (is_unspecified (
Endpoint::from_string_altform("1.2.3 80")));
expect (is_unspecified (
Endpoint::from_string("1.2.3.4:65536")));
expect (is_unspecified (
Endpoint::from_string_altform("1.2.3:65536")));
expect (is_unspecified (
Endpoint::from_string_altform("1.2.3 65536")));
expect (is_unspecified (
Endpoint::from_string("1.2.3.4:89119")));
expect (is_unspecified (
Endpoint::from_string_altform("1.2.3:89119")));
expect (is_unspecified (
Endpoint::from_string_altform("1.2.3 89119")));
}
