snprintf(name_type_hex, sizeof(name_type_hex), "#%X", name_type);
fstrcat(server_name, name_type_hex);
- zero_addr(&ss);
+ zero_sockaddr(&ss);
if (have_ip)
ss = dest_ss;
{
struct interface *i;
for (i=local_interfaces;i;i=i->next) {
- if (addr_equal(&i->ip,ip)) {
+ if (sockaddr_equal(&i->ip,ip)) {
return true;
}
}
if (same_net(ip, &i->ip, &i->netmask)) {
return i;
}
- } else if (addr_equal(&i->ip, ip)) {
+ } else if (sockaddr_equal(&i->ip, ip)) {
return i;
}
}
{
struct interface *i;
for (i=local_interfaces;i;i=i->next) {
- if (addr_equal(&i->ip,pss)) {
+ if (sockaddr_equal(&i->ip,pss)) {
struct sockaddr_in6 *psa6 =
(struct sockaddr_in6 *)pss;
psa6->sin6_scope_id = if_nametoindex(i->name);
}
for (i=0;i<total_probed;i++) {
- if (addr_equal(&ss, &probed_ifaces[i].ip)) {
+ if (sockaddr_equal(&ss, &probed_ifaces[i].ip)) {
add_interface(&probed_ifaces[i]);
return;
}
make_net(&ss_net, &ss, &ss_mask);
/* Maybe the first component was a broadcast address. */
- if (addr_equal(&ss_bcast, &ss) || addr_equal(&ss_net, &ss)) {
+ if (sockaddr_equal(&ss_bcast, &ss) || sockaddr_equal(&ss_net, &ss)) {
for (i=0;i<total_probed;i++) {
if (same_net(&ss, &probed_ifaces[i].ip, &ss_mask)) {
/* Temporarily replace netmask on
}
#endif
- zero_addr(pss);
+ zero_sockaddr(pss);
if (!interpret_string_addr_internal(&res, str, flags|AI_ADDRCONFIG)) {
return false;
Set an address to INADDR_ANY.
******************************************************************/
-void zero_addr(struct sockaddr_storage *pss)
+void zero_sockaddr(struct sockaddr_storage *pss)
{
memset(pss, '\0', sizeof(*pss));
/* Ensure we're at least a valid sockaddr-storage. */
Are two sockaddr_storage's the same family and address ? Ignore port etc.
********************************************************************/
-bool addr_equal(const struct sockaddr_storage *ip1,
- const struct sockaddr_storage *ip2)
+bool sockaddr_equal(const struct sockaddr_storage *ip1,
+ const struct sockaddr_storage *ip2)
{
if (ip1->ss_family != ip2->ss_family) {
/* Never the same. */
if (!res->ai_addr) {
continue;
}
- if (addr_equal((const struct sockaddr_storage *)res->ai_addr,
+ if (sockaddr_equal((const struct sockaddr_storage *)res->ai_addr,
pss)) {
freeaddrinfo(ailist);
return true;
p = get_peer_addr_internal(fd, addr_buf, sizeof(addr_buf), &ss, &length);
/* it might be the same as the last one - save some DNS work */
- if (addr_equal(&ss, &nc.ss)) {
+ if (sockaddr_equal(&ss, &nc.ss)) {
return nc.name ? nc.name : "UNKNOWN";
}
}
n = get_interfaces(nics, MAX_INTERFACES);
for (i=0; i<n; i++) {
- if (addr_equal(&nics[i].ip, &ss)) {
+ if (sockaddr_equal(&nics[i].ip, &ss)) {
TALLOC_FREE(nics);
return true;
}
get_kdc_list(realm, sitename, &ip_srv_site, &count_site);
for (i = 0; i < count_site; i++) {
- if (addr_equal(&ip_srv_site[i].ss, pss)) {
+ if (sockaddr_equal(&ip_srv_site[i].ss, pss)) {
continue;
}
/* Append to the string - inefficient
for (i = 0; i < count_nonsite; i++) {
int j;
- if (addr_equal(&ip_srv_nonsite[i].ss, pss)) {
+ if (sockaddr_equal(&ip_srv_nonsite[i].ss, pss)) {
continue;
}
/* Ensure this isn't an IP already seen (YUK! this is n*n....) */
for (j = 0; j < count_site; j++) {
- if (addr_equal(&ip_srv_nonsite[i].ss,
+ if (sockaddr_equal(&ip_srv_nonsite[i].ss,
&ip_srv_site[j].ss)) {
break;
}
if (dest_ss) {
ss = *dest_ss;
} else {
- zero_addr(&ss);
+ zero_sockaddr(&ss);
}
again:
server_n = server;
- zero_addr(&ss);
+ zero_sockaddr(&ss);
make_nmb_name(&calling, global_myname(), 0x0);
make_nmb_name(&called , server, name_type);
again:
- zero_addr(&ss);
+ zero_sockaddr(&ss);
if (have_ip)
ss = dest_ss;
const char *username_used;
NTSTATUS status;
- zero_addr(&ss);
+ zero_sockaddr(&ss);
ZERO_STRUCT(c);
if (server[0] == 0) {
again:
- zero_addr(&ss);
+ zero_sockaddr(&ss);
/* have to open a new connection */
if ((c = cli_initialise()) == NULL) {
flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
}
- zero_addr(&ss);
+ zero_sockaddr(&ss);
nt_status = cli_full_connection(&ipc_cli,
global_myname(), server,
&ss, 0, "IPC$", "?????",
if (!interpret_string_addr(&ss, lp_socket_address(),
AI_NUMERICHOST|AI_PASSIVE)) {
- zero_addr(&ss);
+ zero_sockaddr(&ss);
}
sock = open_socket_in(SOCK_DGRAM, 0, 3, &ss, True);
}
for ( j=i+1; j<count; j++ ) {
- if (addr_equal(&iplist[i].ss, &iplist[j].ss) &&
+ if (sockaddr_equal(&iplist[i].ss, &iplist[j].ss) &&
iplist[i].port == iplist[j].port) {
- zero_addr(&iplist[j].ss);
+ zero_sockaddr(&iplist[j].ss);
}
}
}
if (!interpret_string_addr(&ss, lp_socket_address(),
AI_NUMERICHOST|AI_PASSIVE)) {
- zero_addr(&ss);
+ zero_sockaddr(&ss);
}
sock = open_socket_in( SOCK_DGRAM, 0, 3, &ss, true );
/* the address we will be sending from */
if (!interpret_string_addr(&src_ss, lp_socket_address(),
AI_NUMERICHOST|AI_PASSIVE)) {
- zero_addr(&src_ss);
+ zero_sockaddr(&src_ss);
}
if (src_ss.ss_family != AF_INET) {
#ifdef HAVE_ADS
*dc_ss = ads->ldap.ss;
#else
- zero_addr(dc_ss);
+ zero_sockaddr(dc_ss);
#endif
ads_destroy(&ads);
bool ret;
bool our_domain = False;
- zero_addr(&dc_ss);
+ zero_sockaddr(&dc_ss);
ret = False;
load_case_tables();
- zero_addr(&server_ss);
+ zero_sockaddr(&server_ss);
setlinebuf(stdout);
server_n = server;
- zero_addr(&ss);
+ zero_sockaddr(&ss);
slprintf(myname,sizeof(myname), "lock-%lu-%u", (unsigned long)getpid(), count++);
make_nmb_name(&called , server, 0x20);
again:
- zero_addr(&ss);
+ zero_sockaddr(&ss);
/* have to open a new connection */
if (!(c=cli_initialise())) {
server_n = server;
- zero_addr(&ss);
+ zero_sockaddr(&ss);
make_nmb_name(&calling, "masktest", 0x0);
make_nmb_name(&called , server, 0x20);
again:
- zero_addr(&ss);
+ zero_sockaddr(&ss);
/* have to open a new connection */
if (!(c=cli_initialise())) {
make_nmb_name(&calling, myname, 0x0);
make_nmb_name(&called , host, 0x20);
- zero_addr(&ss);
+ zero_sockaddr(&ss);
if (!(c = cli_initialise())) {
printf("Failed initialize cli_struct to connect with %s\n", host);
TALLOC_CTX *frame = talloc_stackframe();
- zero_addr(&opt_dest_ip);
+ zero_sockaddr(&opt_dest_ip);
load_case_tables();
NTSTATUS nt_status;
uint32_t flags = 0;
- zero_addr(&ss);
+ zero_sockaddr(&ss);
if (get_cmdline_auth_info_use_kerberos()) {
flags |= CLI_FULL_CONNECTION_USE_KERBEROS |
NTSTATUS nt_status;
uint32_t flags = 0;
- zero_addr(&ss);
+ zero_sockaddr(&ss);
if (get_cmdline_auth_info_use_machine_account() &&
!set_cmdline_auth_info_machine_account_creds()) {
/* start listening on port 445 locally */
- zero_addr(&my_ss);
+ zero_sockaddr(&my_ss);
s = open_socket_in(SOCK_STREAM, 445, 0, &my_ss, True);
if (s == -1) {
/* Make sure there's no duplicates in the list */
for (i=0; i<*num; i++)
- if (addr_equal(&(*dcs)[i].ss, pss))
+ if (sockaddr_equal(&(*dcs)[i].ss, pss))
return False;
*dcs = TALLOC_REALLOC_ARRAY(mem_ctx, *dcs, struct dc_name_ip, (*num)+1);