sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-08-03 04:22:09 +03:00
Code Activity

r25624: Remove ipv4_addr hack. Only causes 4 extra includes of system/network.h because we stripped down includes.

Browse Source 
(This used to be commit 262c1c23a6)
This commit is contained in:
Jelmer Vernooij
2007-10-13 20:24:37 +02:00
committed by Stefan Metzmacher
parent 8517878144
commit b09047b78e
21 changed files with 88 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
source4/auth/auth_server.c
View File

@ -28,7 +28,7 @@ static struct smbcli_state *server_cryptkey(TALLOC_CTX *mem_ctx)
{ {
struct smbcli_state *cli = NULL; struct smbcli_state *cli = NULL;
fstring desthost; fstring desthost;
struct ipv4_addr dest_ip; struct in_addr dest_ip;
const char *p; const char *p;
char *pserver; char *pserver;
bool connected_ok = false; bool connected_ok = false;

2
source4/client/mount.cifs.c
View File

@ -197,7 +197,7 @@ char * parse_server(char * unc_name)
char * share; char * share;
char * ipaddress_string = NULL; char * ipaddress_string = NULL;
struct hostent * host_entry; struct hostent * host_entry;
struct ipv4_addr server_ipaddr; struct in_addr server_ipaddr;
int rc,j; int rc,j;
char temp[64]; char temp[64];

4
source4/client/smbmount.c
View File

@ -33,7 +33,7 @@ static pstring mpoint;
static pstring service; static pstring service;
static pstring options; static pstring options;
static struct ipv4_addr dest_ip; static struct in_addr dest_ip;
static bool have_ip; static bool have_ip;
static int smb_port = 0; static int smb_port = 0;
static bool got_user; static bool got_user;
@ -116,7 +116,7 @@ static struct smbcli_state *do_connection(char *the_service)
struct smbcli_state *c; struct smbcli_state *c;
struct nmb_name called, calling; struct nmb_name called, calling;
char *server_n; char *server_n;
struct ipv4_addr ip; struct in_addr ip;
pstring server; pstring server;
char *share; char *share;

12
source4/lib/ldb/include/ldb.h
View File

@ -735,12 +735,14 @@ struct ldb_register_partition {
struct ldb_dn *dn; struct ldb_dn *dn;
}; };
enum ldb_sequence_type {
LDB_SEQ_HIGHEST_SEQ,
LDB_SEQ_HIGHEST_TIMESTAMP,
LDB_SEQ_NEXT
};
struct ldb_sequence_number { struct ldb_sequence_number {
enum ldb_sequence_type { enum ldb_sequence_type type;
LDB_SEQ_HIGHEST_SEQ,
LDB_SEQ_HIGHEST_TIMESTAMP,
LDB_SEQ_NEXT
} type;
uint64_t seq_num; uint64_t seq_num;
uint32_t flags; uint32_t flags;
}; };

2
source4/lib/samba3/samba3.h
View File

@ -98,7 +98,7 @@ struct samba3_winsdb_entry
int type; int type;
time_t ttl; time_t ttl;
uint32_t ip_count; uint32_t ip_count;
struct ipv4_addr *ips; struct in_addr *ips;
}; };
struct samba3_policy struct samba3_policy

3
source4/lib/samba3/winsdb.c
View File

@ -23,6 +23,7 @@
#include "includes.h" #include "includes.h"
#include "system/filesys.h" #include "system/filesys.h"
#include "lib/samba3/samba3.h" #include "lib/samba3/samba3.h"
#include "system/network.h"
#define WINS_VERSION 1 #define WINS_VERSION 1
@ -110,7 +111,7 @@ NTSTATUS samba3_read_winsdb( const char *fn, TALLOC_CTX *ctx, struct samba3_wins
} }
/* Allocate the space for the ip_list. */ /* Allocate the space for the ip_list. */
if((entry.ips = talloc_array ( ctx, struct ipv4_addr, entry.ip_count)) == NULL) { if((entry.ips = talloc_array ( ctx, struct in_addr, entry.ip_count)) == NULL) {
DEBUG(0,("initialise_wins: Malloc fail !\n")); DEBUG(0,("initialise_wins: Malloc fail !\n"));
SAFE_FREE(line); SAFE_FREE(line);
return NT_STATUS_NO_MEMORY; return NT_STATUS_NO_MEMORY;

45
source4/lib/socket/interface.c
View File

@ -28,8 +28,8 @@
/** used for network interfaces */ /** used for network interfaces */
struct interface { struct interface {
struct interface *next, *prev; struct interface *next, *prev;
struct ipv4_addr ip; struct in_addr ip;
struct ipv4_addr nmask; struct in_addr nmask;
const char *ip_s; const char *ip_s;
const char *bcast_s; const char *bcast_s;
const char *nmask_s; const char *nmask_s;
@ -44,25 +44,18 @@ static struct interface *local_interfaces;
#define MKBCADDR(_IP, _NM) ((_IP & _NM) | (_NM ^ ALLONES)) #define MKBCADDR(_IP, _NM) ((_IP & _NM) | (_NM ^ ALLONES))
#define MKNETADDR(_IP, _NM) (_IP & _NM) #define MKNETADDR(_IP, _NM) (_IP & _NM)
static struct ipv4_addr tov4(struct in_addr in)
{
struct ipv4_addr in2;
in2.addr = in.s_addr;
return in2;
}
/**************************************************************************** /****************************************************************************
Try and find an interface that matches an ip. If we cannot, return NULL Try and find an interface that matches an ip. If we cannot, return NULL
**************************************************************************/ **************************************************************************/
static struct interface *iface_find(struct in_addr ip, bool CheckMask) static struct interface *iface_find(struct in_addr ip, bool CheckMask)
{ {
struct interface *i; struct interface *i;
if (is_zero_ip(tov4(ip))) return local_interfaces; if (is_zero_ip(ip)) return local_interfaces;
for (i=local_interfaces;i;i=i->next) for (i=local_interfaces;i;i=i->next)
if (CheckMask) { if (CheckMask) {
if (same_net(i->ip,tov4(ip),i->nmask)) return i; if (same_net(i->ip,ip,i->nmask)) return i;
} else if (i->ip.addr == ip.s_addr) return i; } else if (i->ip.s_addr == ip.s_addr) return i;
return NULL; return NULL;
} }
@ -74,7 +67,7 @@ add an interface to the linked list of interfaces
static void add_interface(struct in_addr ip, struct in_addr nmask) static void add_interface(struct in_addr ip, struct in_addr nmask)
{ {
struct interface *iface; struct interface *iface;
struct ipv4_addr bcast; struct in_addr bcast;
if (iface_find(ip, false)) { if (iface_find(ip, false)) {
DEBUG(3,("not adding duplicate interface %s\n",inet_ntoa(ip))); DEBUG(3,("not adding duplicate interface %s\n",inet_ntoa(ip)));
@ -86,17 +79,17 @@ static void add_interface(struct in_addr ip, struct in_addr nmask)
ZERO_STRUCTPN(iface); ZERO_STRUCTPN(iface);
iface->ip = tov4(ip); iface->ip = ip;
iface->nmask = tov4(nmask); iface->nmask = nmask;
bcast.addr = MKBCADDR(iface->ip.addr, iface->nmask.addr); bcast.s_addr = MKBCADDR(iface->ip.s_addr, iface->nmask.s_addr);
/* keep string versions too, to avoid people tripping over the implied /* keep string versions too, to avoid people tripping over the implied
static in sys_inet_ntoa() */ static in inet_ntoa() */
iface->ip_s = talloc_strdup(iface, sys_inet_ntoa(iface->ip)); iface->ip_s = talloc_strdup(iface, inet_ntoa(iface->ip));
iface->nmask_s = talloc_strdup(iface, sys_inet_ntoa(iface->nmask)); iface->nmask_s = talloc_strdup(iface, inet_ntoa(iface->nmask));
if (nmask.s_addr != ~0) { if (nmask.s_addr != ~0) {
iface->bcast_s = talloc_strdup(iface, sys_inet_ntoa(bcast)); iface->bcast_s = talloc_strdup(iface, inet_ntoa(bcast));
} }
DLIST_ADD_END(local_interfaces, iface, struct interface *); DLIST_ADD_END(local_interfaces, iface, struct interface *);
@ -145,7 +138,7 @@ static void interpret_interface(const char *token,
if (strpbrk(token, "*?") != NULL) { if (strpbrk(token, "*?") != NULL) {
return; return;
} }
ip.s_addr = interpret_addr2(token).addr; ip.s_addr = interpret_addr2(token).s_addr;
for (i=0;i<total_probed;i++) { for (i=0;i<total_probed;i++) {
if (ip.s_addr == probed_ifaces[i].ip.s_addr) { if (ip.s_addr == probed_ifaces[i].ip.s_addr) {
add_interface(probed_ifaces[i].ip, add_interface(probed_ifaces[i].ip,
@ -160,10 +153,10 @@ static void interpret_interface(const char *token,
/* parse it into an IP address/netmasklength pair */ /* parse it into an IP address/netmasklength pair */
*p++ = 0; *p++ = 0;
ip.s_addr = interpret_addr2(token).addr; ip.s_addr = interpret_addr2(token).s_addr;
if (strlen(p) > 2) { if (strlen(p) > 2) {
nmask.s_addr = interpret_addr2(p).addr; nmask.s_addr = interpret_addr2(p).s_addr;
} else { } else {
nmask.s_addr = htonl(((ALLONES >> atoi(p)) ^ ALLONES)); nmask.s_addr = htonl(((ALLONES >> atoi(p)) ^ ALLONES));
} }
@ -172,7 +165,7 @@ static void interpret_interface(const char *token,
if (ip.s_addr == MKBCADDR(ip.s_addr, nmask.s_addr) || if (ip.s_addr == MKBCADDR(ip.s_addr, nmask.s_addr) ||
ip.s_addr == MKNETADDR(ip.s_addr, nmask.s_addr)) { ip.s_addr == MKNETADDR(ip.s_addr, nmask.s_addr)) {
for (i=0;i<total_probed;i++) { for (i=0;i<total_probed;i++) {
if (same_net(tov4(ip), tov4(probed_ifaces[i].ip), tov4(nmask))) { if (same_net(ip, probed_ifaces[i].ip, nmask)) {
add_interface(probed_ifaces[i].ip, nmask); add_interface(probed_ifaces[i].ip, nmask);
return; return;
} }
@ -193,7 +186,7 @@ static void load_interfaces(void)
const char **ptr; const char **ptr;
int i; int i;
struct iface_struct ifaces[MAX_INTERFACES]; struct iface_struct ifaces[MAX_INTERFACES];
struct ipv4_addr loopback_ip; struct in_addr loopback_ip;
int total_probed; int total_probed;
if (local_interfaces != NULL) { if (local_interfaces != NULL) {
@ -213,7 +206,7 @@ static void load_interfaces(void)
DEBUG(0,("ERROR: Could not determine network interfaces, you must use a interfaces config line\n")); DEBUG(0,("ERROR: Could not determine network interfaces, you must use a interfaces config line\n"));
} }
for (i=0;i<total_probed;i++) { for (i=0;i<total_probed;i++) {
if (ifaces[i].ip.s_addr != loopback_ip.addr) { if (ifaces[i].ip.s_addr != loopback_ip.s_addr) {
add_interface(ifaces[i].ip, add_interface(ifaces[i].ip,
ifaces[i].netmask); ifaces[i].netmask);
} }

22
source4/lib/socket/socket_ip.c
View File

@ -91,8 +91,8 @@ static NTSTATUS ipv4_connect(struct socket_context *sock,
uint32_t flags) uint32_t flags)
{ {
struct sockaddr_in srv_addr; struct sockaddr_in srv_addr;
struct ipv4_addr my_ip; struct in_addr my_ip;
struct ipv4_addr srv_ip; struct in_addr srv_ip;
int ret; int ret;
if (my_address && my_address->sockaddr) { if (my_address && my_address->sockaddr) {
@ -103,13 +103,13 @@ static NTSTATUS ipv4_connect(struct socket_context *sock,
} else if (my_address) { } else if (my_address) {
my_ip = interpret_addr2(my_address->addr); my_ip = interpret_addr2(my_address->addr);
if (my_ip.addr != 0 || my_address->port != 0) { if (my_ip.s_addr != 0 || my_address->port != 0) {
struct sockaddr_in my_addr; struct sockaddr_in my_addr;
ZERO_STRUCT(my_addr); ZERO_STRUCT(my_addr);
#ifdef HAVE_SOCK_SIN_LEN #ifdef HAVE_SOCK_SIN_LEN
my_addr.sin_len = sizeof(my_addr); my_addr.sin_len = sizeof(my_addr);
#endif #endif
my_addr.sin_addr.s_addr = my_ip.addr; my_addr.sin_addr.s_addr = my_ip.s_addr;
my_addr.sin_port = htons(my_address->port); my_addr.sin_port = htons(my_address->port);
my_addr.sin_family = PF_INET; my_addr.sin_family = PF_INET;
@ -127,7 +127,7 @@ static NTSTATUS ipv4_connect(struct socket_context *sock,
} }
} else { } else {
srv_ip = interpret_addr2(srv_address->addr); srv_ip = interpret_addr2(srv_address->addr);
if (!srv_ip.addr) { if (!srv_ip.s_addr) {
return NT_STATUS_BAD_NETWORK_NAME; return NT_STATUS_BAD_NETWORK_NAME;
} }
@ -135,7 +135,7 @@ static NTSTATUS ipv4_connect(struct socket_context *sock,
#ifdef HAVE_SOCK_SIN_LEN #ifdef HAVE_SOCK_SIN_LEN
srv_addr.sin_len = sizeof(srv_addr); srv_addr.sin_len = sizeof(srv_addr);
#endif #endif
srv_addr.sin_addr.s_addr= srv_ip.addr; srv_addr.sin_addr.s_addr= srv_ip.s_addr;
srv_addr.sin_port = htons(srv_address->port); srv_addr.sin_port = htons(srv_address->port);
srv_addr.sin_family = PF_INET; srv_addr.sin_family = PF_INET;
@ -158,7 +158,7 @@ static NTSTATUS ipv4_listen(struct socket_context *sock,
int queue_size, uint32_t flags) int queue_size, uint32_t flags)
{ {
struct sockaddr_in my_addr; struct sockaddr_in my_addr;
struct ipv4_addr ip_addr; struct in_addr ip_addr;
int ret; int ret;
socket_set_option(sock, "SO_REUSEADDR=1", NULL); socket_set_option(sock, "SO_REUSEADDR=1", NULL);
@ -172,7 +172,7 @@ static NTSTATUS ipv4_listen(struct socket_context *sock,
#ifdef HAVE_SOCK_SIN_LEN #ifdef HAVE_SOCK_SIN_LEN
my_addr.sin_len = sizeof(my_addr); my_addr.sin_len = sizeof(my_addr);
#endif #endif
my_addr.sin_addr.s_addr = ip_addr.addr; my_addr.sin_addr.s_addr = ip_addr.s_addr;
my_addr.sin_port = htons(my_address->port); my_addr.sin_port = htons(my_address->port);
my_addr.sin_family = PF_INET; my_addr.sin_family = PF_INET;
@ -355,17 +355,17 @@ static NTSTATUS ipv4_sendto(struct socket_context *sock,
dest_addr->sockaddr, dest_addr->sockaddrlen); dest_addr->sockaddr, dest_addr->sockaddrlen);
} else { } else {
struct sockaddr_in srv_addr; struct sockaddr_in srv_addr;
struct ipv4_addr addr; struct in_addr addr;
ZERO_STRUCT(srv_addr); ZERO_STRUCT(srv_addr);
#ifdef HAVE_SOCK_SIN_LEN #ifdef HAVE_SOCK_SIN_LEN
srv_addr.sin_len = sizeof(srv_addr); srv_addr.sin_len = sizeof(srv_addr);
#endif #endif
addr = interpret_addr2(dest_addr->addr); addr = interpret_addr2(dest_addr->addr);
if (addr.addr == 0) { if (addr.s_addr == 0) {
return NT_STATUS_HOST_UNREACHABLE; return NT_STATUS_HOST_UNREACHABLE;
} }
srv_addr.sin_addr.s_addr = addr.addr; srv_addr.sin_addr.s_addr = addr.s_addr;
srv_addr.sin_port = htons(dest_addr->port); srv_addr.sin_port = htons(dest_addr->port);
srv_addr.sin_family = PF_INET; srv_addr.sin_family = PF_INET;

8
source4/lib/tdr/tdr.c
View File

@ -203,10 +203,10 @@ NTSTATUS tdr_print_charset(struct tdr_print *tdr, const char *name, const char *
NTSTATUS tdr_pull_ipv4address(struct tdr_pull *tdr, TALLOC_CTX *ctx, NTSTATUS tdr_pull_ipv4address(struct tdr_pull *tdr, TALLOC_CTX *ctx,
const char **address) const char **address)
{ {
struct ipv4_addr in; struct in_addr in;
TDR_CHECK(tdr_pull_uint32(tdr, ctx, &in.addr)); TDR_CHECK(tdr_pull_uint32(tdr, ctx, &in.s_addr));
in.addr = htonl(in.addr); in.s_addr = htonl(in.s_addr);
*address = talloc_strdup(tdr, sys_inet_ntoa(in)); *address = talloc_strdup(tdr, inet_ntoa(in));
NT_STATUS_HAVE_NO_MEMORY(*address); NT_STATUS_HAVE_NO_MEMORY(*address);
return NT_STATUS_OK; return NT_STATUS_OK;
} }

13
source4/lib/util/system.c
View File

@ -79,19 +79,12 @@ _PUBLIC_ struct hostent *sys_gethostbyname(const char *name)
#endif /* REDUCE_ROOT_DNS_LOOKUPS */ #endif /* REDUCE_ROOT_DNS_LOOKUPS */
} }
_PUBLIC_ const char *sys_inet_ntoa(struct ipv4_addr in) _PUBLIC_ struct in_addr sys_inet_makeaddr(int net, int host)
{
struct in_addr in2;
in2.s_addr = in.addr;
return inet_ntoa(in2);
}
_PUBLIC_ struct ipv4_addr sys_inet_makeaddr(int net, int host)
{ {
struct in_addr in; struct in_addr in;
struct ipv4_addr in2; struct in_addr in2;
in = inet_makeaddr(net, host); in = inet_makeaddr(net, host);
in2.addr = in.s_addr; in2.s_addr = in.s_addr;
return in2; return in2;
} }

18
source4/lib/util/util.c
View File

@ -285,11 +285,11 @@ _PUBLIC_ uint32_t interpret_addr(const char *str)
/** /**
A convenient addition to interpret_addr(). A convenient addition to interpret_addr().
**/ **/
_PUBLIC_ struct ipv4_addr interpret_addr2(const char *str) _PUBLIC_ struct in_addr interpret_addr2(const char *str)
{ {
struct ipv4_addr ret; struct in_addr ret;
uint32_t a = interpret_addr(str); uint32_t a = interpret_addr(str);
ret.addr = a; ret.s_addr = a;
return ret; return ret;
} }
@ -297,22 +297,22 @@ _PUBLIC_ struct ipv4_addr interpret_addr2(const char *str)
Check if an IP is the 0.0.0.0. Check if an IP is the 0.0.0.0.
**/ **/
_PUBLIC_ bool is_zero_ip(struct ipv4_addr ip) _PUBLIC_ bool is_zero_ip(struct in_addr ip)
{ {
return ip.addr == 0; return ip.s_addr == 0;
} }
/** /**
Are two IPs on the same subnet? Are two IPs on the same subnet?
**/ **/
_PUBLIC_ bool same_net(struct ipv4_addr ip1,struct ipv4_addr ip2,struct ipv4_addr mask) _PUBLIC_ bool same_net(struct in_addr ip1, struct in_addr ip2, struct in_addr mask)
{ {
uint32_t net1,net2,nmask; uint32_t net1,net2,nmask;
nmask = ntohl(mask.addr); nmask = ntohl(mask.s_addr);
net1 = ntohl(ip1.addr); net1 = ntohl(ip1.s_addr);
net2 = ntohl(ip2.addr); net2 = ntohl(ip2.s_addr);
return((net1 & nmask) == (net2 & nmask)); return((net1 & nmask) == (net2 & nmask));
} }

18
source4/lib/util/util.h
View File

@ -254,13 +254,7 @@ void CatchChildLeaveStatus(void);
/* The following definitions come from lib/util/system.c */ /* The following definitions come from lib/util/system.c */
/* struct in_addr;
we use struct ipv4_addr to avoid having to include all the
system networking headers everywhere
*/
struct ipv4_addr {
uint32_t addr;
};
/************************************************************************** /**************************************************************************
A wrapper for gethostbyname() that tries avoids looking up hostnames A wrapper for gethostbyname() that tries avoids looking up hostnames
@ -268,8 +262,8 @@ in the root domain, which can cause dial-on-demand links to come up for no
apparent reason. apparent reason.
****************************************************************************/ ****************************************************************************/
_PUBLIC_ struct hostent *sys_gethostbyname(const char *name); _PUBLIC_ struct hostent *sys_gethostbyname(const char *name);
_PUBLIC_ const char *sys_inet_ntoa(struct ipv4_addr in); _PUBLIC_ const char *sys_inet_ntoa(struct in_addr in);
_PUBLIC_ struct ipv4_addr sys_inet_makeaddr(int net, int host); _PUBLIC_ struct in_addr sys_inet_makeaddr(int net, int host);
/* The following definitions come from lib/util/genrand.c */ /* The following definitions come from lib/util/genrand.c */
@ -676,17 +670,17 @@ _PUBLIC_ uint32_t interpret_addr(const char *str);
/** /**
A convenient addition to interpret_addr(). A convenient addition to interpret_addr().
**/ **/
_PUBLIC_ struct ipv4_addr interpret_addr2(const char *str); _PUBLIC_ struct in_addr interpret_addr2(const char *str);
/** /**
Check if an IP is the 0.0.0.0. Check if an IP is the 0.0.0.0.
**/ **/
_PUBLIC_ bool is_zero_ip(struct ipv4_addr ip); _PUBLIC_ bool is_zero_ip(struct in_addr ip);
/** /**
Are two IPs on the same subnet? Are two IPs on the same subnet?
**/ **/
_PUBLIC_ bool same_net(struct ipv4_addr ip1,struct ipv4_addr ip2,struct ipv4_addr mask); _PUBLIC_ bool same_net(struct in_addr ip1,struct in_addr ip2,struct in_addr mask);
/** /**
Check if a process exists. Does this work on all unixes? Check if a process exists. Does this work on all unixes?

4
source4/libcli/resolve/host.c
View File

@ -65,14 +65,14 @@ static int host_destructor(struct host_state *state)
static void run_child(struct composite_context *c, int fd) static void run_child(struct composite_context *c, int fd)
{ {
struct host_state *state = talloc_get_type(c->private_data, struct host_state); struct host_state *state = talloc_get_type(c->private_data, struct host_state);
struct ipv4_addr ip; struct in_addr ip;
const char *address; const char *address;
/* this is the blocking call we are going to lots of trouble /* this is the blocking call we are going to lots of trouble
to avoid in the parent */ to avoid in the parent */
ip = interpret_addr2(state->name.name); ip = interpret_addr2(state->name.name);
address = sys_inet_ntoa(ip); address = inet_ntoa(ip);
if (address != NULL) { if (address != NULL) {
write(fd, address, strlen(address)+1); write(fd, address, strlen(address)+1);
} }

5
source4/libcli/resolve/resolve.c
View File

@ -25,6 +25,7 @@
#include "libcli/resolve/resolve.h" #include "libcli/resolve/resolve.h"
#include "librpc/gen_ndr/ndr_nbt.h" #include "librpc/gen_ndr/ndr_nbt.h"
#include "param/param.h" #include "param/param.h"
#include "system/network.h"
struct resolve_state { struct resolve_state {
struct nbt_name name; struct nbt_name name;
@ -151,8 +152,8 @@ struct composite_context *resolve_name_send(struct nbt_name *name, struct event_
if (is_ipaddress(state->name.name) || if (is_ipaddress(state->name.name) ||
strcasecmp(state->name.name, "localhost") == 0) { strcasecmp(state->name.name, "localhost") == 0) {
struct ipv4_addr ip = interpret_addr2(state->name.name); struct in_addr ip = interpret_addr2(state->name.name);
state->reply_addr = talloc_strdup(state, sys_inet_ntoa(ip)); state->reply_addr = talloc_strdup(state, inet_ntoa(ip));
if (composite_nomem(state->reply_addr, c)) return c; if (composite_nomem(state->reply_addr, c)) return c;
composite_done(c); composite_done(c);
return c; return c;

2
source4/librpc/ndr/libndr.h
View File

@ -329,7 +329,7 @@ NTSTATUS ndr_push_dom_sid28(struct ndr_push *ndr, int ndr_flags, const struct do
NTSTATUS ndr_pull_dom_sid28(struct ndr_pull *ndr, int ndr_flags, struct dom_sid *sid); NTSTATUS ndr_pull_dom_sid28(struct ndr_pull *ndr, int ndr_flags, struct dom_sid *sid);
void ndr_print_dom_sid28(struct ndr_print *ndr, const char *name, const struct dom_sid *sid); void ndr_print_dom_sid28(struct ndr_print *ndr, const char *name, const struct dom_sid *sid);
size_t ndr_size_dom_sid28(const struct dom_sid *sid, int flags); size_t ndr_size_dom_sid28(const struct dom_sid *sid, int flags);
void ndr_print_ipv4_addr(struct ndr_print *ndr, const char *name, const struct ipv4_addr *_ip); void ndr_print_ipv4_addr(struct ndr_print *ndr, const char *name, const struct in_addr *_ip);
void ndr_print_GUID(struct ndr_print *ndr, const char *name, const struct GUID *guid); void ndr_print_GUID(struct ndr_print *ndr, const char *name, const struct GUID *guid);
#endif /* __LIBNDR_H__ */ #endif /* __LIBNDR_H__ */

8
source4/librpc/ndr/ndr_basic.c
View File

@ -585,10 +585,10 @@ _PUBLIC_ NTSTATUS ndr_pull_time_t(struct ndr_pull *ndr, int ndr_flags, time_t *t
*/ */
_PUBLIC_ NTSTATUS ndr_pull_ipv4address(struct ndr_pull *ndr, int ndr_flags, const char **address) _PUBLIC_ NTSTATUS ndr_pull_ipv4address(struct ndr_pull *ndr, int ndr_flags, const char **address)
{ {
struct ipv4_addr in; struct in_addr in;
NDR_CHECK(ndr_pull_uint32(ndr, ndr_flags, &in.addr)); NDR_CHECK(ndr_pull_uint32(ndr, ndr_flags, &in.s_addr));
in.addr = htonl(in.addr); in.s_addr = htonl(in.s_addr);
*address = talloc_strdup(ndr->current_mem_ctx, sys_inet_ntoa(in)); *address = talloc_strdup(ndr->current_mem_ctx, inet_ntoa(in));
NT_STATUS_HAVE_NO_MEMORY(*address); NT_STATUS_HAVE_NO_MEMORY(*address);
return NT_STATUS_OK; return NT_STATUS_OK;
} }

8
source4/librpc/ndr/ndr_misc.c
View File

@ -24,13 +24,13 @@
#include "system/network.h" #include "system/network.h"
#include "librpc/ndr/libndr.h" #include "librpc/ndr/libndr.h"
_PUBLIC_ void ndr_print_ipv4_addr(struct ndr_print *ndr, const char *name, const struct ipv4_addr *_ip) _PUBLIC_ void ndr_print_in_addr(struct ndr_print *ndr, const char *name, const struct in_addr *_ip)
{ {
struct ipv4_addr ip; struct in_addr ip;
ip.addr = htonl(_ip->addr); ip.s_addr = htonl(_ip->s_addr);
ndr->print(ndr, "%-25s: %s", name, sys_inet_ntoa(ip)); ndr->print(ndr, "%-25s: %s", name, inet_ntoa(ip));
} }
_PUBLIC_ void ndr_print_GUID(struct ndr_print *ndr, const char *name, const struct GUID *guid) _PUBLIC_ void ndr_print_GUID(struct ndr_print *ndr, const char *name, const struct GUID *guid)

2
source4/nbt_server/interfaces.c
View File

@ -233,7 +233,7 @@ NTSTATUS nbtd_startup_interfaces(struct nbtd_server *nbtsrv)
if (num_interfaces > 0) { if (num_interfaces > 0) {
primary_address = iface_n_ip(0); primary_address = iface_n_ip(0);
} else { } else {
primary_address = sys_inet_ntoa(interpret_addr2( primary_address = inet_ntoa(interpret_addr2(
lp_netbios_name(global_loadparm))); lp_netbios_name(global_loadparm)));
} }
primary_address = talloc_strdup(tmp_ctx, primary_address); primary_address = talloc_strdup(tmp_ctx, primary_address);

6
source4/nbt_server/wins/winsserver.c
View File

@ -560,13 +560,13 @@ done:
nbtd_name_registration_reply(nbtsock, packet, src, rcode); nbtd_name_registration_reply(nbtsock, packet, src, rcode);
} }
static uint32_t ipv4_match_bits(struct ipv4_addr ip1,struct ipv4_addr ip2) static uint32_t ipv4_match_bits(struct in_addr ip1, struct in_addr ip2)
{ {
uint32_t i, j, match=0; uint32_t i, j, match=0;
uint8_t *p1, *p2; uint8_t *p1, *p2;
p1 = (uint8_t *)&ip1.addr; p1 = (uint8_t *)&ip1.s_addr;
p2 = (uint8_t *)&ip2.addr; p2 = (uint8_t *)&ip2.s_addr;
for (i=0; i<4; i++) { for (i=0; i<4; i++) {
if (p1[i] != p2[i]) break; if (p1[i] != p2[i]) break;

3
source4/scripting/ejs/smbcalls_samba3.c
View File

@ -25,6 +25,7 @@
#include "lib/samba3/samba3.h" #include "lib/samba3/samba3.h"
#include "libcli/security/security.h" #include "libcli/security/security.h"
#include "librpc/gen_ndr/ndr_misc.h" #include "librpc/gen_ndr/ndr_misc.h"
#include "system/network.h"
static struct MprVar mprRegistry(struct samba3_regdb *reg) static struct MprVar mprRegistry(struct samba3_regdb *reg)
@ -407,7 +408,7 @@ static struct MprVar mprWinsEntries(struct samba3 *samba3)
for (j = 0; j < samba3->winsdb_entries[i].ip_count; j++) { for (j = 0; j < samba3->winsdb_entries[i].ip_count; j++) {
const char *addr; const char *addr;
addr = sys_inet_ntoa(samba3->winsdb_entries[i].ips[j]); addr = inet_ntoa(samba3->winsdb_entries[i].ips[j]);
mprAddArray(&ips, j, mprString(addr)); mprAddArray(&ips, j, mprString(addr));
} }

3
source4/torture/local/resolve.c
View File

@ -23,6 +23,7 @@
#include "lib/events/events.h" #include "lib/events/events.h"
#include "libcli/resolve/resolve.h" #include "libcli/resolve/resolve.h"
#include "torture/torture.h" #include "torture/torture.h"
#include "system/network.h"
static bool test_async_resolve(struct torture_context *tctx) static bool test_async_resolve(struct torture_context *tctx)
{ {
@ -68,7 +69,7 @@ static bool test_sync_resolve(struct torture_context *tctx)
torture_comment(tctx, "Testing sync resolve of '%s' for %d seconds\n", torture_comment(tctx, "Testing sync resolve of '%s' for %d seconds\n",
host, timelimit); host, timelimit);
while (timeval_elapsed(&tv) < timelimit) { while (timeval_elapsed(&tv) < timelimit) {
sys_inet_ntoa(interpret_addr2(host)); inet_ntoa(interpret_addr2(host));
count++; count++;
} }