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"))); }