the 'ADS server' smb.conf parameter, which is what we really want anyway
*/
static NTSTATUS ads_resolve_dc(fstring remote_machine,
- struct in_addr *dest_ip)
+ struct ipv4_addr *dest_ip)
{
ADS_STRUCT *ads;
ads = ads_init_simple();
*/
static NTSTATUS rpc_resolve_dc(const char *server,
fstring remote_machine,
- struct in_addr *dest_ip)
+ struct ipv4_addr *dest_ip)
{
if (is_ipaddress(server)) {
- struct in_addr to_ip = interpret_addr2(server);
+ struct ipv4_addr to_ip = interpret_addr2(server);
/* we need to know the machines netbios name - this is a lousy
way to find it, but until we have a RPC call that does this
const uint8_t *trust_passwd,
BOOL *retry)
{
- struct in_addr dest_ip;
+ struct ipv4_addr dest_ip;
fstring remote_machine;
NTSTATUS result;
uint32_t neg_flags = 0x000001ff;
static NTSTATUS attempt_connect_to_dc(struct smbcli_state **cli,
const char *domain,
- struct in_addr *ip,
+ struct ipv4_addr *ip,
const char *setup_creds_as,
uint16_t sec_chan,
const uint8_t *trust_passwd)
uint8_t *trust_passwd,
time_t last_change_time)
{
- struct in_addr dc_ip;
+ struct ipv4_addr dc_ip;
fstring srv_name;
if ( !rpc_find_dc(lp_workgroup(), srv_name, &dc_ip) ) {
{
struct smbcli_state *cli = NULL;
fstring desthost;
- struct in_addr dest_ip;
+ struct ipv4_addr dest_ip;
const char *p;
char *pserver;
BOOL connected_ok = False;
#define HAVE_IFACE_AIX 1
#define AUTOCONF_TEST 1
#include "confdefs.h"
-#include "${srcdir-.}/lib/interfaces.c"],
+#include "${srcdir-.}/lib/netif/netif.h"
+#include "${srcdir-.}/lib/netif/netif.c"],
samba_cv_HAVE_IFACE_AIX=yes,samba_cv_HAVE_IFACE_AIX=no,samba_cv_HAVE_IFACE_AIX=cross)])
if test x"$samba_cv_HAVE_IFACE_AIX" = x"yes"; then
iface=yes;AC_DEFINE(HAVE_IFACE_AIX,1,[Whether iface AIX is available])
#define HAVE_IFACE_IFCONF 1
#define AUTOCONF_TEST 1
#include "confdefs.h"
-#include "${srcdir-.}/lib/interfaces.c"],
+#include "${srcdir-.}/lib/netif/netif.h"
+#include "${srcdir-.}/lib/netif/netif.c"],
samba_cv_HAVE_IFACE_IFCONF=yes,samba_cv_HAVE_IFACE_IFCONF=no,samba_cv_HAVE_IFACE_IFCONF=cross)])
if test x"$samba_cv_HAVE_IFACE_IFCONF" = x"yes"; then
iface=yes;AC_DEFINE(HAVE_IFACE_IFCONF,1,[Whether iface ifconf is available])
#define HAVE_IFACE_IFREQ 1
#define AUTOCONF_TEST 1
#include "confdefs.h"
-#include "${srcdir-.}/lib/interfaces.c"],
+#include "${srcdir-.}/lib/netif/netif.h"
+#include "${srcdir-.}/lib/netif/netif.c"],
samba_cv_HAVE_IFACE_IFREQ=yes,samba_cv_HAVE_IFACE_IFREQ=no,samba_cv_HAVE_IFACE_IFREQ=cross)])
if test x"$samba_cv_HAVE_IFACE_IFREQ" = x"yes"; then
iface=yes;AC_DEFINE(HAVE_IFACE_IFREQ,1,[Whether iface ifreq is available])
char * share;
char * ipaddress_string = NULL;
struct hostent * host_entry;
- struct in_addr server_ipaddr;
+ struct ipv4_addr server_ipaddr;
int rc,j;
char temp[64];
static pstring service;
static pstring options;
-static struct in_addr dest_ip;
+static struct ipv4_addr dest_ip;
static BOOL have_ip;
static int smb_port = 0;
static BOOL got_user;
struct smbcli_state *c;
struct nmb_name called, calling;
char *server_n;
- struct in_addr ip;
+ struct ipv4_addr ip;
pstring server;
char *share;
typedef struct {
void *ld; /* the active ldap structure */
- struct in_addr ldap_ip; /* the ip of the active connection, if any */
+ struct ipv4_addr ldap_ip; /* the ip of the active connection, if any */
time_t last_attempt; /* last attempt to reconnect */
int ldap_port;
#endif /* RELIANTUNIX */
#include <sys/types.h>
+#include <stdint.h>
#ifdef TIME_WITH_SYS_TIME
#include <sys/time.h>
#include <stdlib.h>
#endif
-#ifdef HAVE_SYS_SOCKET_H
-#include <sys/socket.h>
-#endif
-
-#ifdef HAVE_UNIXSOCKET
-#include <sys/un.h>
-#endif
-
#ifdef HAVE_SYS_SYSCALL_H
#include <sys/syscall.h>
#elif HAVE_SYSCALL_H
#include <varargs.h>
#endif
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-
#ifdef HAVE_SYSLOG_H
#include <syslog.h>
#else
#include <sys/file.h>
-#ifdef HAVE_NETINET_TCP_H
-#include <netinet/tcp.h>
-#endif
-
-/*
- * The next three defines are needed to access the IPTOS_* options
- * on some systems.
- */
-
-#ifdef HAVE_NETINET_IN_SYSTM_H
-#include <netinet/in_systm.h>
-#endif
-
-#ifdef HAVE_NETINET_IN_IP_H
-#include <netinet/in_ip.h>
-#endif
-
-#ifdef HAVE_NETINET_IP_H
-#include <netinet/ip.h>
-#endif
-
#if defined(HAVE_TERMIOS_H)
/* POSIX terminal handling. */
#include <termios.h>
#include <sys/mman.h>
#endif
-#ifdef HAVE_NET_IF_H
-#include <net/if.h>
-#endif
-
-
#ifdef HAVE_SYS_MOUNT_H
#include <sys/mount.h>
#endif
#endif
#endif
-#ifdef HAVE_KRB5_H
-#include <krb5.h>
-#else
-#undef HAVE_KRB5
-#endif
-
-#ifdef HAVE_GSSAPI_H
-#include <gssapi.h>
-#endif
-
-#ifdef HAVE_GSSAPI_GSSAPI_H
-#include <gssapi/gssapi.h>
-#endif
-
-#ifdef HAVE_GSSAPI_GSSAPI_GENERIC_H
-#include <gssapi/gssapi_generic.h>
-#endif
-
-#ifdef HAVE_COM_ERR_H
-#include <com_err.h>
-#endif
-
/* we support ADS if we want it and have krb5 and ldap libs */
#if defined(WITH_ADS) && defined(HAVE_KRB5) && defined(HAVE_LDAP)
#define HAVE_ADS
#define uint64 uint64_t
#endif
+/*
+ we use struct ipv4_addr to avoid having to include all the
+ system networking headers everywhere
+*/
+struct ipv4_addr {
+ uint32_t s_addr;
+};
+
#ifndef UINT8_MAX
#define UINT8_MAX 255
#endif
#include "talloc.h"
#include "db_wrap.h"
#include "nt_status.h"
-#include "interfaces.h"
#include "trans2.h"
#include "ioctl.h"
#include "nterr.h"
#include "libcli/auth/ntlmssp.h"
#include "libcli/auth/credentials.h"
-#include "libcli/auth/kerberos.h"
#include "libcli/auth/gensec.h"
#include "libcli/auth/spnego.h"
#include "auth/auth.h"
int setenv(const char *name, const char *value, int overwrite);
#endif
-#if (defined(USE_SETRESUID) && !defined(HAVE_SETRESUID_DECL))
-/* stupid glibc */
-int setresuid(uid_t ruid, uid_t euid, uid_t suid);
-#endif
-#if (defined(USE_SETRESUID) && !defined(HAVE_SETRESGID_DECL))
-int setresgid(gid_t rgid, gid_t egid, gid_t sgid);
-#endif
#ifndef HAVE_VASPRINTF_DECL
int vasprintf(char **ptr, const char *format, va_list ap);
#endif
-/*
- This structure is used by lib/interfaces.c to return the list of network
- interfaces on the machine
-*/
-
-#define MAX_INTERFACES 128
-
-struct iface_struct {
- char name[16];
- struct in_addr ip;
- struct in_addr netmask;
-};
{
uint16_t nb_flags; /* Netbios flags. */
int num_ips; /* Number of ip entries. */
- struct in_addr *ip; /* The ip list for this name. */
+ struct ipv4_addr *ip; /* The ip list for this name. */
enum name_source source; /* Where the name came from. */
time_t refresh_time; /* The time the record should be refreshed. */
uint64_t id; /* unique id */
- struct in_addr wins_ip; /* the adress of the wins server this record comes from */
+ struct ipv4_addr wins_ip; /* the adress of the wins server this record comes from */
int wins_flags; /* similar to the netbios flags but different ! */
};
#endif
pstring lmb_name;
pstring work_group;
- struct in_addr ip;
+ struct ipv4_addr ip;
time_t sync_time;
time_t death_time; /* The time the record must be removed. */
};
/* Domain master browser info. Used for efficient syncs. */
struct nmb_name dmb_name;
- struct in_addr dmb_addr;
+ struct ipv4_addr dmb_addr;
};
/* typedefs needed to define copy & free functions for userdata. */
struct nmb_name *,
uint16_t,
int,
- struct in_addr);
+ struct ipv4_addr);
typedef void (*register_name_fail_function)( struct subnet_record *,
struct response_record *,
struct nmb_name *);
typedef void (*release_name_success_function)( struct subnet_record *,
struct userdata_struct *,
struct nmb_name *,
- struct in_addr);
+ struct ipv4_addr);
typedef void (*release_name_fail_function)( struct subnet_record *,
struct response_record *,
struct nmb_name *);
struct nmb_name *,
uint16_t,
int,
- struct in_addr);
+ struct ipv4_addr);
typedef void (*refresh_name_fail_function)( struct subnet_record *,
struct response_record *,
struct nmb_name *);
typedef void (*query_name_success_function)( struct subnet_record *,
struct userdata_struct *,
struct nmb_name *,
- struct in_addr,
+ struct ipv4_addr,
struct res_rec *answers);
typedef void (*query_name_fail_function)( struct subnet_record *,
typedef void (*node_status_success_function)( struct subnet_record *,
struct userdata_struct *,
struct res_rec *,
- struct in_addr);
+ struct ipv4_addr);
typedef void (*node_status_fail_function)( struct subnet_record *,
struct response_record *);
BOOL namelist_changed;
BOOL work_changed;
- struct in_addr bcast_ip;
- struct in_addr mask_ip;
- struct in_addr myip;
+ struct ipv4_addr bcast_ip;
+ struct ipv4_addr mask_ip;
+ struct ipv4_addr myip;
int nmb_sock; /* socket to listen for unicast 137. */
int dgram_sock; /* socket to listen for unicast 138. */
};
BOOL more;
} flags;
int dgm_id;
- struct in_addr source_ip;
+ struct ipv4_addr source_ip;
int source_port;
int dgm_length;
int packet_offset;
struct packet_struct *next;
struct packet_struct *prev;
BOOL locked;
- struct in_addr ip;
+ struct ipv4_addr ip;
int port;
int fd;
time_t timestamp;
int wins_flags;
uint64_t id;
int num_ips;
- struct in_addr ip[25];
- struct in_addr wins_ip;
+ struct ipv4_addr ip[25];
+ struct ipv4_addr wins_ip;
} WINS_RECORD;
/* To be removed. */
struct netr_SamInfo3;
struct netr_Authenticator;
+struct iface_struct;
--- /dev/null
+This directory contains wrappers around logical groups of system
+include files. The idea is to avoid #ifdef blocks in the main code,
+and instead put all the necessary conditional includes in subsystem
+specific header files in this directory.
--- /dev/null
+/*
+ Unix SMB/CIFS implementation.
+
+ kerberos system include wrappers
+
+ Copyright (C) Andrew Tridgell 2004
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+
+#ifdef HAVE_KRB5_H
+#include <krb5.h>
+#else
+#undef HAVE_KRB5
+#endif
+
+#ifdef HAVE_GSSAPI_H
+#include <gssapi.h>
+#endif
+
+#ifdef HAVE_GSSAPI_GSSAPI_H
+#include <gssapi/gssapi.h>
+#endif
+
+#ifdef HAVE_GSSAPI_GSSAPI_GENERIC_H
+#include <gssapi/gssapi_generic.h>
+#endif
+
+#ifdef HAVE_COM_ERR_H
+#include <com_err.h>
+#endif
--- /dev/null
+/*
+ Unix SMB/CIFS implementation.
+
+ networking system include wrappers
+
+ Copyright (C) Andrew Tridgell 2004
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+
+#ifdef HAVE_UNIXSOCKET
+#include <sys/un.h>
+#endif
+
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#ifdef HAVE_NETINET_TCP_H
+#include <netinet/tcp.h>
+#endif
+
+/*
+ * The next three defines are needed to access the IPTOS_* options
+ * on some systems.
+ */
+
+#ifdef HAVE_NETINET_IN_SYSTM_H
+#include <netinet/in_systm.h>
+#endif
+
+#ifdef HAVE_NETINET_IN_IP_H
+#include <netinet/in_ip.h>
+#endif
+
+#ifdef HAVE_NETINET_IP_H
+#include <netinet/ip.h>
+#endif
+
+#ifdef HAVE_NET_IF_H
+#include <net/if.h>
+#endif
+
+
*/
static void add_socket(struct server_service *service,
const struct model_ops *model_ops,
- struct in_addr *ifip)
+ struct ipv4_addr *ifip)
{
struct server_socket *srv_sock;
uint16_t port = 389;
- char *ip_str = talloc_strdup(service, inet_ntoa(*ifip));
+ char *ip_str = talloc_strdup(service, sys_inet_ntoa(*ifip));
srv_sock = service_setup_socket(service, model_ops, "ipv4", ip_str, &port);
socket per interface and bind to only these.
*/
for(i = 0; i < num_interfaces; i++) {
- struct in_addr *ifip = iface_n_ip(i);
+ struct ipv4_addr *ifip = iface_n_ip(i);
if (ifip == NULL) {
DEBUG(0,("ldapsrv_init: interface %d has NULL "
add_socket(service, model_ops, ifip);
}
} else {
- struct in_addr ifip;
+ struct ipv4_addr ifip;
/* Just bind to lp_socket_address() (usually 0.0.0.0) */
ifip = interpret_addr2(lp_socket_address());
dnl # LIB BASIC subsystem
SMB_SUBSYSTEM_MK(LIBREPLACE,lib/basic.mk)
+SMB_SUBSYSTEM_MK(LIBNETIF,lib/basic.mk)
SMB_SUBSYSTEM_MK(LIBBASIC,lib/basic.mk)
# End SUBSYSTEM LIBREPLACE
##############################
+##############################
+# Start SUBSYSTEM LIBNETIF
+[SUBSYSTEM::LIBNETIF]
+INIT_OBJ_FILES = \
+ lib/netif/interface.o
+ADD_OBJ_FILES = \
+ lib/netif/netif.o
+# End SUBSYSTEM LIBNETIF
+##############################
+
##############################
# Start SUBSYSTEM LIBBASIC
[SUBSYSTEM::LIBBASIC]
lib/debug.o \
lib/fault.o \
lib/getsmbpass.o \
- lib/interface.o \
- lib/interfaces.o \
lib/pidfile.o \
lib/signal.o \
lib/system.o \
lib/server_mutex.o \
lib/idtree.o
REQUIRED_SUBSYSTEMS = \
- LIBTDB CHARSET LIBREPLACE
+ LIBTDB CHARSET LIBREPLACE LIBNETIF
# End SUBSYSTEM LIBBASIC
##############################
*/
#include "includes.h"
+#include "system/network.h"
+#include "lib/netif/netif.h"
static struct iface_struct *probed_ifaces;
static int total_probed;
-static struct in_addr allones_ip;
-struct in_addr loopback_ip;
+static struct ipv4_addr allones_ip;
+struct ipv4_addr loopback_ip;
/* used for network interfaces */
struct interface {
struct interface *next, *prev;
- struct in_addr ip;
- struct in_addr bcast;
- struct in_addr nmask;
+ struct ipv4_addr ip;
+ struct ipv4_addr bcast;
+ struct ipv4_addr nmask;
};
static struct interface *local_interfaces;
#define MKBCADDR(_IP, _NM) ((_IP & _NM) | (_NM ^ ALLONES))
#define MKNETADDR(_IP, _NM) (_IP & _NM)
+static struct ipv4_addr tov4(struct in_addr in)
+{
+ struct ipv4_addr in2;
+ in2.s_addr = in.s_addr;
+ return in2;
+}
+
/****************************************************************************
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)
{
struct interface *i;
- if (is_zero_ip(ip)) return local_interfaces;
+ if (is_zero_ip(tov4(ip))) return local_interfaces;
for (i=local_interfaces;i;i=i->next)
if (CheckMask) {
- if (same_net(i->ip,ip,i->nmask)) return i;
+ if (same_net(i->ip,tov4(ip),i->nmask)) return i;
} else if ((i->ip).s_addr == ip.s_addr) return i;
return NULL;
ZERO_STRUCTPN(iface);
- iface->ip = ip;
- iface->nmask = nmask;
+ iface->ip = tov4(ip);
+ iface->nmask = tov4(nmask);
iface->bcast.s_addr = MKBCADDR(iface->ip.s_addr, iface->nmask.s_addr);
DLIST_ADD(local_interfaces, iface);
- DEBUG(2,("added interface ip=%s ",inet_ntoa(iface->ip)));
- DEBUG(2,("bcast=%s ",inet_ntoa(iface->bcast)));
- DEBUG(2,("nmask=%s\n",inet_ntoa(iface->nmask)));
+ DEBUG(2,("added interface ip=%s ",sys_inet_ntoa(iface->ip)));
+ DEBUG(2,("bcast=%s ",sys_inet_ntoa(iface->bcast)));
+ DEBUG(2,("nmask=%s\n",sys_inet_ntoa(iface->nmask)));
}
char *p;
int i, added=0;
- zero_ip(&ip);
- zero_ip(&nmask);
+ ip.s_addr = 0;
+ nmask.s_addr = 0;
/* first check if it is an interface name */
for (i=0;i<total_probed;i++) {
/* maybe it is a DNS name */
p = strchr_m(token,'/');
if (!p) {
- ip = interpret_addr2(token);
+ ip.s_addr = interpret_addr2(token).s_addr;
for (i=0;i<total_probed;i++) {
if (ip.s_addr == probed_ifaces[i].ip.s_addr &&
!ip_equal(allones_ip, probed_ifaces[i].netmask)) {
/* parse it into an IP address/netmasklength pair */
*p++ = 0;
- ip = interpret_addr2(token);
+ ip.s_addr = interpret_addr2(token).s_addr;
if (strlen(p) > 2) {
- nmask = interpret_addr2(p);
+ nmask.s_addr = interpret_addr2(p).s_addr;
} else {
nmask.s_addr = htonl(((ALLONES >> atoi(p)) ^ ALLONES));
}
if (ip.s_addr == MKBCADDR(ip.s_addr, nmask.s_addr) ||
ip.s_addr == MKNETADDR(ip.s_addr, nmask.s_addr)) {
for (i=0;i<total_probed;i++) {
- if (same_net(ip, probed_ifaces[i].ip, nmask)) {
+ if (same_net(tov4(ip), tov4(probed_ifaces[i].ip), tov4(nmask))) {
add_interface(probed_ifaces[i].ip, nmask);
return;
}
/****************************************************************************
check if an IP is one of mine
**************************************************************************/
-BOOL ismyip(struct in_addr ip)
+BOOL ismyip(struct ipv4_addr ip)
{
struct interface *i;
for (i=local_interfaces;i;i=i->next)
/****************************************************************************
check if a packet is from a local (known) net
**************************************************************************/
-BOOL is_local_net(struct in_addr from)
+BOOL is_local_net(struct ipv4_addr from)
{
struct interface *i;
for (i=local_interfaces;i;i=i->next) {
/****************************************************************************
return IP of the Nth interface
**************************************************************************/
-struct in_addr *iface_n_ip(int n)
+struct ipv4_addr *iface_n_ip(int n)
{
struct interface *i;
/****************************************************************************
return bcast of the Nth interface
**************************************************************************/
-struct in_addr *iface_n_bcast(int n)
+struct ipv4_addr *iface_n_bcast(int n)
{
struct interface *i;
an appropriate interface they return the requested field of the
first known interface. */
-struct in_addr *iface_ip(struct in_addr ip)
+struct ipv4_addr *iface_ip(struct ipv4_addr ip)
{
- struct interface *i = iface_find(ip, True);
+ struct in_addr in;
+ struct interface *i;
+ in.s_addr = ip.s_addr;
+ i = iface_find(in, True);
return(i ? &i->ip : &local_interfaces->ip);
}
/*
return True if a IP is directly reachable on one of our interfaces
*/
-BOOL iface_local(struct in_addr ip)
+BOOL iface_local(struct ipv4_addr ip)
{
- return iface_find(ip, True) ? True : False;
+ struct in_addr in;
+ in.s_addr = ip.s_addr;
+ return iface_find(in, True) ? True : False;
}
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
+#include <netdb.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <net/if.h>
#include <netdb.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <net/if.h>
-#ifdef AUTOCONF_TEST
-struct iface_struct {
- char name[16];
- struct in_addr ip;
- struct in_addr netmask;
-};
-#else
+#ifndef AUTOCONF_TEST
+#include "lib/netif/netif.h"
#include "config.h"
-#include "interfaces.h"
#endif
#ifdef HAVE_SYS_TIME_H
#ifdef AUTOCONF_TEST
/* this is the autoconf driver to test get_interfaces() */
-#define MAX_INTERFACES 128
-
int main()
{
struct iface_struct ifaces[MAX_INTERFACES];
--- /dev/null
+/*
+ Unix SMB/CIFS implementation.
+
+ structures for lib/netif/
+
+ Copyright (C) Andrew Tridgell 2004
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+struct iface_struct {
+ char name[16];
+ struct in_addr ip;
+ struct in_addr netmask;
+};
+
+#define MAX_INTERFACES 128
+
#ifndef WITH_PTHREADS
/* REWRITE: not thread safe */
#ifdef REPLACE_INET_NTOA
-char *rep_inet_ntoa(struct in_addr ip)
+char *rep_inet_ntoa(struct ipv4_addr ip)
{
uint8_t *p = (uint8_t *)&ip.s_addr;
static char buf[18];
*/
#include "includes.h"
+#include "system/network.h"
#define FAIL (-1)
#define ALLONES ((uint32_t)0xFFFFFFFF)
*/
#include "includes.h"
+#include "system/network.h"
static NTSTATUS ipv4_tcp_init(struct socket_context *sock)
{
uint32_t flags)
{
struct sockaddr_in srv_addr;
- struct in_addr my_ip;
- struct in_addr srv_ip;
+ struct ipv4_addr my_ip;
+ struct ipv4_addr srv_ip;
int ret;
my_ip = interpret_addr2(my_address);
#ifdef HAVE_SOCK_SIN_LEN
my_addr.sin_len = sizeof(my_addr);
#endif
- my_addr.sin_addr = my_ip;
+ my_addr.sin_addr.s_addr = my_ip.s_addr;
my_addr.sin_port = htons(my_port);
my_addr.sin_family = PF_INET;
#ifdef HAVE_SOCK_SIN_LEN
srv_addr.sin_len = sizeof(srv_addr);
#endif
- srv_addr.sin_addr = srv_ip;
+ srv_addr.sin_addr.s_addr= srv_ip.s_addr;
srv_addr.sin_port = htons(srv_port);
srv_addr.sin_family = PF_INET;
int queue_size, uint32_t flags)
{
struct sockaddr_in my_addr;
- struct in_addr ip_addr;
+ struct ipv4_addr ip_addr;
int ret;
ip_addr = interpret_addr2(my_address);
#ifdef HAVE_SOCK_SIN_LEN
my_addr.sin_len = sizeof(my_addr);
#endif
- my_addr.sin_addr = ip_addr;
+ my_addr.sin_addr.s_addr = ip_addr.s_addr;
my_addr.sin_port = htons(port);
my_addr.sin_family = PF_INET;
*/
#include "includes.h"
+#include "system/network.h"
static struct in6_addr interpret_addr6(const char *name)
{
*/
#include "includes.h"
+#include "system/network.h"
/*
The idea is that this file will eventually have wrappers around all
#endif
}
+
+const char *sys_inet_ntoa(struct ipv4_addr in)
+{
+ struct in_addr in2;
+ in2.s_addr = in.s_addr;
+ return inet_ntoa(in2);
+}
+
+uint32_t sys_inet_addr(const char *s)
+{
+ return inet_addr(s);
+}
+
+struct ipv4_addr sys_inet_makeaddr(int net, int host)
+{
+ struct in_addr in;
+ struct ipv4_addr in2;
+ in = inet_makeaddr(net, host);
+ in2.s_addr = in.s_addr;
+ return in2;
+}
*/
#include "includes.h"
+#include "system/network.h"
/**************************************************************************n
Find a suitable temporary directory. The result should be copied immediately
/* if it's in the form of an IP address then get the lib to interpret it */
if (is_ipaddress(str)) {
- res = inet_addr(str);
+ res = sys_inet_addr(str);
} else {
/* otherwise assume it's a network name of some sort and use
sys_gethostbyname */
/*******************************************************************
A convenient addition to interpret_addr().
******************************************************************/
-struct in_addr interpret_addr2(const char *str)
+struct ipv4_addr interpret_addr2(const char *str)
{
- struct in_addr ret;
+ struct ipv4_addr ret;
uint32_t a = interpret_addr(str);
ret.s_addr = a;
return ret;
Check if an IP is the 0.0.0.0.
******************************************************************/
-BOOL is_zero_ip(struct in_addr ip)
+BOOL is_zero_ip(struct ipv4_addr ip)
{
uint32_t a;
putip((char *)&a,(char *)&ip);
Set an IP to 0.0.0.0.
******************************************************************/
-void zero_ip(struct in_addr *ip)
+void zero_ip(struct ipv4_addr *ip)
{
- *ip = inet_makeaddr(0,0);
+ *ip = sys_inet_makeaddr(0,0);
return;
}
Are two IPs on the same subnet?
********************************************************************/
-BOOL same_net(struct in_addr ip1,struct in_addr ip2,struct in_addr mask)
+BOOL same_net(struct ipv4_addr ip1,struct ipv4_addr ip2,struct ipv4_addr mask)
{
uint32_t net1,net2,nmask;
*/
#include "includes.h"
+#include "system/network.h"
/****************************************************************************
****************************************************************************/
ssize_t read_udp_socket(int fd, char *buf, size_t len,
- struct in_addr *from_addr, int *from_port)
+ struct ipv4_addr *from_addr, int *from_port)
{
ssize_t ret;
struct sockaddr_in sock;
}
if (from_addr) {
- *from_addr = sock.sin_addr;
+ from_addr->s_addr = sock.sin_addr.s_addr;
}
if (from_port) {
*from_port = ntohs(sock.sin_port);
/****************************************************************************
create an outgoing socket. timeout is in milliseconds.
**************************************************************************/
-int open_socket_out(int type, struct in_addr *addr, int port, int timeout)
+int open_socket_out(int type, struct ipv4_addr *addr, int port, int timeout)
{
struct sockaddr_in sock_out;
int res,ret;
/* set it non-blocking */
set_blocking(res,False);
- DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port));
+ DEBUG(3,("Connecting to %s at port %d\n", sys_inet_ntoa(*addr),port));
/* and connect it to the destination */
connect_again:
if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
errno == EAGAIN)) {
- DEBUG(1,("timeout connecting to %s:%d\n",inet_ntoa(*addr),port));
+ DEBUG(1,("timeout connecting to %s:%d\n", sys_inet_ntoa(*addr),port));
close(res);
return -1;
}
if (ret < 0) {
DEBUG(2,("error connecting to %s:%d (%s)\n",
- inet_ntoa(*addr),port,strerror(errno)));
+ sys_inet_ntoa(*addr),port,strerror(errno)));
close(res);
return -1;
}
int type = SOCK_DGRAM;
struct sockaddr_in sock_out;
int res;
- struct in_addr addr;
+ struct ipv4_addr addr;
TALLOC_CTX *mem_ctx;
mem_ctx = talloc_init("open_udp_socket");
matchname - determine if host name matches IP address. Used to
confirm a hostname lookup to prevent spoof attacks
******************************************************************/
-static BOOL matchname(char *remotehost, struct in_addr addr)
+static BOOL matchname(char *remotehost, struct ipv4_addr addr)
{
struct hostent *hp;
int i;
*/
DEBUG(0,("host name/address mismatch: %s != %s\n",
- inet_ntoa(addr), hp->h_name));
+ sys_inet_ntoa(addr), hp->h_name));
return False;
}
{
char *name_buf;
struct hostent *hp;
- struct in_addr addr;
+ struct ipv4_addr addr;
char *p;
/* reverse lookups can be *very* expensive, and in many
* reallocated to new length
**/
-char* ipstr_list_add(char** ipstr_list, const struct in_addr *ip)
+char* ipstr_list_add(char** ipstr_list, const struct ipv4_addr *ip)
{
char* new_ipstr = NULL;
/* attempt to convert ip to a string and append colon separator to it */
if (*ipstr_list) {
- asprintf(&new_ipstr, "%s%s%s", *ipstr_list, IPSTR_LIST_SEP,inet_ntoa(*ip));
+ asprintf(&new_ipstr, "%s%s%s", *ipstr_list, IPSTR_LIST_SEP,sys_inet_ntoa(*ip));
SAFE_FREE(*ipstr_list);
} else {
- asprintf(&new_ipstr, "%s", inet_ntoa(*ip));
+ asprintf(&new_ipstr, "%s", sys_inet_ntoa(*ip));
}
*ipstr_list = new_ipstr;
return *ipstr_list;
* @return pointer to allocated ip string
**/
-char* ipstr_list_make(char** ipstr_list, const struct in_addr* ip_list, int ip_count)
+char* ipstr_list_make(char** ipstr_list, const struct ipv4_addr* ip_list, int ip_count)
{
int i;
* @return number of succesfully parsed addresses
**/
-int ipstr_list_parse(const char* ipstr_list, struct in_addr** ip_list)
+int ipstr_list_parse(const char* ipstr_list, struct ipv4_addr** ip_list)
{
fstring token_str;
int count;
next_token(&ipstr_list, token_str, IPSTR_LIST_SEP, FSTRING_LEN);
count++) {
- struct in_addr addr;
+ struct ipv4_addr addr;
/* convert single token to ip address */
- if ( (addr.s_addr = inet_addr(token_str)) == INADDR_NONE )
+ if ( (addr.s_addr = sys_inet_addr(token_str)) == INADDR_NONE )
break;
/* prepare place for another in_addr structure */
- *ip_list = Realloc(*ip_list, (count + 1) * sizeof(struct in_addr));
+ *ip_list = Realloc(*ip_list, (count + 1) * sizeof(struct ipv4_addr));
if (!*ip_list) return -1;
(*ip_list)[count] = addr;
#define WINS_SRV_FMT "WINS_SRV_DEAD/%s,%s" /* wins_ip,src_ip */
-static char *wins_srv_keystr(struct in_addr wins_ip, struct in_addr src_ip)
+static char *wins_srv_keystr(struct ipv4_addr wins_ip, struct ipv4_addr src_ip)
{
char *keystr;
- if (asprintf(&keystr, WINS_SRV_FMT, inet_ntoa(wins_ip),
- inet_ntoa(src_ip)) == -1) {
+ if (asprintf(&keystr, WINS_SRV_FMT, sys_inet_ntoa(wins_ip),
+ sys_inet_ntoa(src_ip)) == -1) {
DEBUG(0, ("wins_srv_is_dead: malloc error\n"));
return NULL;
}
see if an ip is on the dead list
*/
-BOOL wins_srv_is_dead(struct in_addr wins_ip, struct in_addr src_ip)
+BOOL wins_srv_is_dead(struct ipv4_addr wins_ip, struct ipv4_addr src_ip)
{
char *keystr = wins_srv_keystr(wins_ip, src_ip);
BOOL result;
result = gencache_get(keystr, NULL, NULL);
SAFE_FREE(keystr);
- DEBUG(4, ("wins_srv_is_dead: %s is %s\n", inet_ntoa(wins_ip),
+ DEBUG(4, ("wins_srv_is_dead: %s is %s\n", sys_inet_ntoa(wins_ip),
result ? "dead" : "alive"));
return result;
/*
mark a wins server as being alive (for the moment)
*/
-void wins_srv_alive(struct in_addr wins_ip, struct in_addr src_ip)
+void wins_srv_alive(struct ipv4_addr wins_ip, struct ipv4_addr src_ip)
{
char *keystr = wins_srv_keystr(wins_ip, src_ip);
SAFE_FREE(keystr);
DEBUG(4, ("wins_srv_alive: marking wins server %s alive\n",
- inet_ntoa(wins_ip)));
+ sys_inet_ntoa(wins_ip)));
}
/*
mark a wins server as temporarily dead
*/
-void wins_srv_died(struct in_addr wins_ip, struct in_addr src_ip)
+void wins_srv_died(struct ipv4_addr wins_ip, struct ipv4_addr src_ip)
{
char *keystr;
SAFE_FREE(keystr);
DEBUG(4,("Marking wins server %s dead for %u seconds from source %s\n",
- inet_ntoa(wins_ip), DEATH_TIME, inet_ntoa(src_ip)));
+ sys_inet_ntoa(wins_ip), DEATH_TIME, sys_inet_ntoa(src_ip)));
}
/*
attached */
struct tagged_ip {
fstring tag;
- struct in_addr ip;
+ struct ipv4_addr ip;
};
/*
return the IP of the currently active wins server for the given tag,
or the zero IP otherwise
*/
-struct in_addr wins_srv_ip_tag(const char *tag, struct in_addr src_ip)
+struct ipv4_addr wins_srv_ip_tag(const char *tag, struct ipv4_addr src_ip)
{
const char **list;
int i;
/* if we are a wins server then we always just talk to ourselves */
if (lp_wins_support()) {
- extern struct in_addr loopback_ip;
+ extern struct ipv4_addr loopback_ip;
return loopback_ip;
}
list = lp_wins_server_list();
if (!list || !list[0]) {
- struct in_addr ip;
+ struct ipv4_addr ip;
zero_ip(&ip);
return ip;
}
}
if (!wins_srv_is_dead(t_ip.ip, src_ip)) {
char *src_name;
- src_name = talloc_strdup(mem_ctx, inet_ntoa(src_ip));
+ src_name = talloc_strdup(mem_ctx, sys_inet_ntoa(src_ip));
DEBUG(6,("Current wins server for tag '%s' with source %s is %s\n",
tag,
src_name,
- inet_ntoa(t_ip.ip)));
+ sys_inet_ntoa(t_ip.ip)));
goto exit;
}
}
*/
#include "includes.h"
+#include "system/network.h"
+#include "system/kerberos.h"
#ifdef HAVE_KRB5
*/
#include "includes.h"
+#include "system/kerberos.h"
+#include "libcli/auth/kerberos.h"
#include "librpc/gen_ndr/ndr_krb5pac.h"
#undef DBGC_CLASS
*/
#include "includes.h"
+#include "system/kerberos.h"
#ifdef HAVE_KRB5
*/
#include "includes.h"
+#include "system/kerberos.h"
+#include "libcli/auth/kerberos.h"
#ifdef HAVE_KRB5
struct smbcli_state **ret_cli,
const char *myname,
const char *host,
- struct in_addr *ip,
+ struct ipv4_addr *ip,
const char *sharename,
const char *devtype,
const char *username,
*/
#include "includes.h"
+#include "system/network.h"
/****************************************************************************
*
BOOL ldap_connect(struct ldap_connection *conn, const char *url)
{
struct hostent *hp;
- struct in_addr ip;
+ struct ipv4_addr ip;
if (!ldap_parse_basic_url(conn->mem_ctx, url, &conn->host,
&conn->port, &conn->ldaps))
**/
BOOL namecache_store(TALLOC_CTX *mem_ctx, const char *name, int name_type,
- int num_names, struct in_addr *ip_list)
+ int num_names, struct ipv4_addr *ip_list)
{
time_t expiry;
char *key, *value_string;
num_names, num_names == 1 ? "": "es", name, name_type));
for (i = 0; i < num_names; i++)
- DEBUGADD(5, ("%s%s", inet_ntoa(ip_list[i]),
+ DEBUGADD(5, ("%s%s", sys_inet_ntoa(ip_list[i]),
i == (num_names - 1) ? "" : ", "));
DEBUGADD(5, ("\n"));
* false if name isn't found in the cache or has expired
**/
-BOOL namecache_fetch(TALLOC_CTX *mem_ctx, const char *name, int name_type, struct in_addr **ip_list,
+BOOL namecache_fetch(TALLOC_CTX *mem_ctx, const char *name, int name_type, struct ipv4_addr **ip_list,
int *num_names)
{
char *key, *value;
*/
#include "includes.h"
+#include "system/network.h"
/* A netbios node status array element. */
struct node_status {
structures holding the returned names or NULL if the query failed
**************************************************************************/
struct node_status *node_status_query(int fd,struct nmb_name *name,
- struct in_addr to_ip, int *num_names)
+ struct ipv4_addr to_ip, int *num_names)
{
BOOL found=False;
int retries = 2;
return the matched name in *name
**************************************************************************/
-BOOL name_status_find(const char *q_name, int q_type, int type, struct in_addr to_ip, char *name)
+BOOL name_status_find(const char *q_name, int q_type, int type, struct ipv4_addr to_ip, char *name)
{
struct node_status *status = NULL;
struct nmb_name nname;
}
DEBUG(10, ("name_status_find: looking up %s#%02x at %s\n", q_name,
- q_type, inet_ntoa(to_ip)));
+ q_type, sys_inet_ntoa(to_ip)));
sock = open_socket_in(SOCK_DGRAM, 0, 3, interpret_addr(lp_socket_address()), True);
if (sock == -1)
DEBUG(10, ("name_status_find: name %sfound", result ? "" : "not "));
if (result)
- DEBUGADD(10, (", ip address is %s", inet_ntoa(to_ip)));
+ DEBUGADD(10, (", ip address is %s", sys_inet_ntoa(to_ip)));
DEBUG(10, ("\n"));
/*
comparison function used by sort_ip_list
*/
-int ip_compare(struct in_addr *ip1, struct in_addr *ip2)
+int ip_compare(struct ipv4_addr *ip1, struct ipv4_addr *ip2)
{
int max_bits1=0, max_bits2=0;
int num_interfaces = iface_count();
int i;
for (i=0;i<num_interfaces;i++) {
- struct in_addr ip;
+ struct ipv4_addr ip;
int bits1, bits2;
ip = *iface_n_bcast(i);
bits1 = matching_quad_bits((uint8_t *)&ip1->s_addr, (uint8_t *)&ip.s_addr);
are at the top. This prevents the problem where a WINS server returns an IP that
is not reachable from our subnet as the first match
*/
-static void sort_ip_list(struct in_addr *iplist, int count)
+static void sort_ip_list(struct ipv4_addr *iplist, int count)
{
if (count <= 1) {
return;
}
- qsort(iplist, count, sizeof(struct in_addr), QSORT_CAST ip_compare);
+ qsort(iplist, count, sizeof(struct ipv4_addr), QSORT_CAST ip_compare);
}
*count will be set to the number of addresses returned.
*timed_out is set if we failed by timing out
****************************************************************************/
-struct in_addr *name_query(int fd,const char *name,int name_type,
+struct ipv4_addr *name_query(int fd,const char *name,int name_type,
BOOL bcast,BOOL recurse,
- struct in_addr to_ip, int *count, int *flags,
+ struct ipv4_addr to_ip, int *count, int *flags,
BOOL *timed_out)
{
BOOL found=False;
struct packet_struct p;
struct packet_struct *p2;
struct nmb_packet *nmb = &p.packet.nmb;
- struct in_addr *ip_list = NULL;
+ struct ipv4_addr *ip_list = NULL;
if (lp_disable_netbios()) {
DEBUG(5,("name_query(%s#%02x): netbios is disabled\n", name, name_type));
while (1) {
struct timeval tval2;
- struct in_addr *tmp_ip_list;
+ struct ipv4_addr *tmp_ip_list;
GetTimeOfDay(&tval2);
if (TvalDiff(&tval,&tval2) > retry_time) {
continue;
}
- tmp_ip_list = (struct in_addr *)Realloc( ip_list, sizeof( ip_list[0] )
+ tmp_ip_list = (struct ipv4_addr *)Realloc( ip_list, sizeof( ip_list[0] )
* ( (*count) + nmb2->answers->rdlength/6 ) );
if (!tmp_ip_list) {
ip_list = tmp_ip_list;
if (ip_list) {
- DEBUG(2,("Got a positive name query response from %s ( ", inet_ntoa(p2->ip)));
+ DEBUG(2,("Got a positive name query response from %s ( ", sys_inet_ntoa(p2->ip)));
for (i=0;i<nmb2->answers->rdlength/6;i++) {
putip((char *)&ip_list[(*count)],&nmb2->answers->rdata[2+i*6]);
- DEBUGADD(2,("%s ",inet_ntoa(ip_list[(*count)])));
+ DEBUGADD(2,("%s ",sys_inet_ntoa(ip_list[(*count)])));
(*count)++;
}
DEBUGADD(2,(")\n"));
*********************************************************/
BOOL getlmhostsent( TALLOC_CTX *mem_ctx,
- XFILE *fp, pstring name, int *name_type, struct in_addr *ipaddr)
+ XFILE *fp, pstring name, int *name_type, struct ipv4_addr *ipaddr)
{
pstring line;
*********************************************************/
BOOL name_resolve_bcast(const char *name, int name_type,
- struct in_addr **return_ip_list, int *return_count)
+ struct ipv4_addr **return_ip_list, int *return_count)
{
int sock, i;
int num_interfaces = iface_count();
* the first successful match.
*/
for( i = num_interfaces-1; i >= 0; i--) {
- struct in_addr sendto_ip;
+ struct ipv4_addr sendto_ip;
int flags;
/* Done this way to fix compiler error on IRIX 5.x */
sendto_ip = *iface_n_bcast(i);
Resolve via "wins" method.
*********************************************************/
BOOL resolve_wins(TALLOC_CTX *mem_ctx, const char *name, int name_type,
- struct in_addr **return_iplist, int *return_count)
+ struct ipv4_addr **return_iplist, int *return_count)
{
int sock, t, i;
char **wins_tags;
- struct in_addr src_ip;
+ struct ipv4_addr src_ip;
if (lp_disable_netbios()) {
DEBUG(5,("resolve_wins(%s#%02x): netbios is disabled\n", name, name_type));
for (t=0; wins_tags && wins_tags[t]; t++) {
int srv_count = wins_srv_count_tag(wins_tags[t]);
for (i=0; i<srv_count; i++) {
- struct in_addr wins_ip;
+ struct ipv4_addr wins_ip;
int flags;
BOOL timed_out;
continue;
}
- DEBUG(3,("resolve_wins: using WINS server %s and tag '%s'\n", inet_ntoa(wins_ip), wins_tags[t]));
+ DEBUG(3,("resolve_wins: using WINS server %s and tag '%s'\n", sys_inet_ntoa(wins_ip), wins_tags[t]));
sock = open_socket_in(SOCK_DGRAM, 0, 3, src_ip.s_addr, True);
if (sock == -1) {
*********************************************************/
static BOOL resolve_hosts(const char *name,
- struct in_addr **return_iplist, int *return_count)
+ struct ipv4_addr **return_iplist, int *return_count)
{
/*
* "host" means do a localhost, or dns lookup.
DEBUG(3,("resolve_hosts: Attempting host lookup for name %s<0x20>\n", name));
if (((hp = sys_gethostbyname(name)) != NULL) && (hp->h_addr != NULL)) {
- struct in_addr return_ip;
+ struct ipv4_addr return_ip;
putip((char *)&return_ip,(char *)hp->h_addr);
- *return_iplist = (struct in_addr *)malloc(sizeof(struct in_addr));
+ *return_iplist = (struct ipv4_addr *)malloc(sizeof(struct ipv4_addr));
if(*return_iplist == NULL) {
DEBUG(3,("resolve_hosts: malloc fail !\n"));
return False;
*********************************************************/
static BOOL internal_resolve_name(TALLOC_CTX *mem_ctx, const char *name, int name_type,
- struct in_addr **return_iplist, int *return_count)
+ struct ipv4_addr **return_iplist, int *return_count)
{
char *name_resolve_list;
fstring tok;
BOOL allzeros = (strcmp(name,"0.0.0.0") == 0);
BOOL is_address = is_ipaddress(name);
BOOL result = False;
- struct in_addr *nodupes_iplist;
+ struct ipv4_addr *nodupes_iplist;
int i;
*return_iplist = NULL;
DEBUG(10, ("internal_resolve_name: looking up %s#%x\n", name, name_type));
if (allzeros || allones || is_address) {
- *return_iplist = (struct in_addr *)malloc(sizeof(struct in_addr));
+ *return_iplist = (struct ipv4_addr *)malloc(sizeof(struct ipv4_addr));
if(*return_iplist == NULL) {
DEBUG(3,("internal_resolve_name: malloc fail !\n"));
return False;
controllers including the PDC in iplist[1..n]. Iterating over
the iplist when the PDC is down will cause two sets of timeouts. */
- if (*return_count && (nodupes_iplist = (struct in_addr *)
- malloc(sizeof(struct in_addr) * (*return_count)))) {
+ if (*return_count && (nodupes_iplist = (struct ipv4_addr *)
+ malloc(sizeof(struct ipv4_addr) * (*return_count)))) {
int nodupes_count = 0;
/* Iterate over return_iplist looking for duplicates */
/* Save in name cache */
for (i = 0; i < *return_count && DEBUGLEVEL == 100; i++)
DEBUG(100, ("Storing name %s of type %d (ip: %s)\n", name,
- name_type, inet_ntoa((*return_iplist)[i])));
+ name_type, sys_inet_ntoa((*return_iplist)[i])));
namecache_store(mem_ctx, name, name_type, *return_count, *return_iplist);
*return_count));
for (i = 0; i < *return_count; i++)
- DEBUGADD(10, ("%s ", inet_ntoa((*return_iplist)[i])));
+ DEBUGADD(10, ("%s ", sys_inet_ntoa((*return_iplist)[i])));
DEBUG(10, ("\n"));
or host name or NetBIOS name. This uses the name switch in the
smb.conf to determine the order of name resolution.
*********************************************************/
-BOOL resolve_name(TALLOC_CTX *mem_ctx, const char *name, struct in_addr *return_ip, int name_type)
+BOOL resolve_name(TALLOC_CTX *mem_ctx, const char *name, struct ipv4_addr *return_ip, int name_type)
{
- struct in_addr *ip_list = NULL;
+ struct ipv4_addr *ip_list = NULL;
int count = 0;
if (is_ipaddress(name)) {
int i;
/* only return valid addresses for TCP connections */
for (i=0; i<count; i++) {
- char *ip_str = inet_ntoa(ip_list[i]);
+ const char *ip_str = sys_inet_ntoa(ip_list[i]);
if (ip_str &&
strcmp(ip_str, "255.255.255.255") != 0 &&
strcmp(ip_str, "0.0.0.0") != 0) {
Find the IP address of the master browser or DMB for a workgroup.
*********************************************************/
-BOOL find_master_ip(TALLOC_CTX *mem_ctx, const char *group, struct in_addr *master_ip)
+BOOL find_master_ip(TALLOC_CTX *mem_ctx, const char *group, struct ipv4_addr *master_ip)
{
- struct in_addr *ip_list = NULL;
+ struct ipv4_addr *ip_list = NULL;
int count = 0;
if (lp_disable_netbios()) {
*********************************************************/
BOOL lookup_dc_name(const char *srcname, const char *domain,
- struct in_addr *dc_ip, char *ret_name)
+ struct ipv4_addr *dc_ip, char *ret_name)
{
#if !defined(I_HATE_WINDOWS_REPLY_CODE)
fstring dc_name;
DEBUG(4,("lookup_pdc_name: datagram reply from %s to %s IP %s for %s of type %d len=%d\n",
nmb_namestr(&dgram2->source_name),nmb_namestr(&dgram2->dest_name),
- inet_ntoa(p_ret->ip), smb_buf(buf),SVAL(buf2,0),len));
+ sys_inet_ntoa(p_ret->ip), smb_buf(buf),SVAL(buf2,0),len));
if(SVAL(buf2,0) != QUERYFORPDC_R) {
DEBUG(0,("lookup_pdc_name: datagram type (%u) != QUERYFORPDC_R(%u)\n",
for a domain.
*********************************************************/
-BOOL get_pdc_ip(TALLOC_CTX *mem_ctx, const char *domain, struct in_addr *ip)
+BOOL get_pdc_ip(TALLOC_CTX *mem_ctx, const char *domain, struct ipv4_addr *ip)
{
- struct in_addr *ip_list;
+ struct ipv4_addr *ip_list;
int count;
int i = 0;
a domain.
*********************************************************/
-BOOL get_dc_list(TALLOC_CTX *mem_ctx, const char *domain, struct in_addr **ip_list, int *count, int *ordered)
+BOOL get_dc_list(TALLOC_CTX *mem_ctx, const char *domain, struct ipv4_addr **ip_list, int *count, int *ordered)
{
*ordered = False;
fstring name;
int num_addresses = 0;
int local_count, i, j;
- struct in_addr *return_iplist = NULL;
- struct in_addr *auto_ip_list = NULL;
+ struct ipv4_addr *return_iplist = NULL;
+ struct ipv4_addr *auto_ip_list = NULL;
BOOL done_auto_lookup = False;
int auto_count = 0;
if ( (num_addresses == 0) && !done_auto_lookup )
return internal_resolve_name(mem_ctx, domain, 0x1C, ip_list, count);
- return_iplist = (struct in_addr *)malloc(num_addresses * sizeof(struct in_addr));
+ return_iplist = (struct ipv4_addr *)malloc(num_addresses * sizeof(struct ipv4_addr));
if (return_iplist == NULL) {
DEBUG(3,("get_dc_list: malloc fail !\n"));
/* fill in the return list now with real IP's */
while ( (local_count<num_addresses) && next_token(&p,name,LIST_SEP,sizeof(name)) ) {
- struct in_addr name_ip;
+ struct ipv4_addr name_ip;
/* copy any addersses from the auto lookup */
/*
find the DC for a domain using methods appropriate for a RPC domain
*/
-BOOL rpc_find_dc(const char *domain, fstring srv_name, struct in_addr *ip_out)
+BOOL rpc_find_dc(const char *domain, fstring srv_name, struct ipv4_addr *ip_out)
{
- struct in_addr *ip_list = NULL, dc_ip, exclude_ip;
+ struct ipv4_addr *ip_list = NULL, dc_ip, exclude_ip;
int count, i;
BOOL list_ordered;
BOOL use_pdc_only;
/* Pick a nice close server, but only if the list was not ordered */
if (!list_ordered && (count > 1) ) {
- qsort(ip_list, count, sizeof(struct in_addr), QSORT_CAST ip_compare);
+ qsort(ip_list, count, sizeof(struct ipv4_addr), QSORT_CAST ip_compare);
}
for (i = 0; i < count; i++) {
*/
#include "includes.h"
+#include "system/network.h"
static const struct opcode_names {
const char *nmb_opcode_name;
if (DEBUGLVL(4)) {
DEBUG(4, ("nmb packet from %s(%d) header: id=%d opcode=%s(%d) response=%s\n",
- inet_ntoa(p->ip), p->port,
+ sys_inet_ntoa(p->ip), p->port,
nmb->header.name_trn_id,
lookup_opcode_name(nmb->header.opcode),
nmb->header.opcode,
struct packet_struct *packet;
char buf[MAX_DGRAM_SIZE];
int length;
- struct in_addr addr;
+ struct ipv4_addr addr;
int port;
length = read_udp_socket(fd, buf, sizeof(buf), &addr, &port);
packet->port = port;
DEBUG(5,("Received a packet of len %d from (%s) port %d\n",
- length, inet_ntoa(packet->ip), packet->port));
+ length, sys_inet_ntoa(packet->ip), packet->port));
return packet;
}
/*******************************************************************
send a udp packet on a already open socket
******************************************************************/
-static BOOL send_udp(int fd,char *buf,int len,struct in_addr ip,int port)
+static BOOL send_udp(int fd,char *buf,int len,struct ipv4_addr ip,int port)
{
BOOL ret = False;
int i;
sock_out.sin_family = AF_INET;
DEBUG( 5, ( "Sending a packet of len %d to (%s) on port %d\n",
- len, inet_ntoa(ip), port ) );
+ len, sys_inet_ntoa(ip), port ) );
/*
* Patch to fix asynch error notifications from Linux kernel.
if (!ret)
DEBUG(0,("Packet send failed to %s(%d) ERRNO=%s\n",
- inet_ntoa(ip),port,strerror(errno)));
+ sys_inet_ntoa(ip),port,strerror(errno)));
return(ret);
}
sort a set of 6 byte name query response records so that the IPs that
have the most leading bits in common with the specified address come first
***************************************************************************/
-void sort_query_replies(char *data, int n, struct in_addr ip)
+void sort_query_replies(char *data, int n, struct ipv4_addr ip)
{
if (n <= 1) return;
connect a smbcli_socket context to an IP/port pair
if port is 0 then choose 445 then 139
*/
-BOOL smbcli_sock_connect(struct smbcli_socket *sock, struct in_addr *ip, int port)
+BOOL smbcli_sock_connect(struct smbcli_socket *sock, struct ipv4_addr *ip, int port)
{
NTSTATUS status;
}
talloc_steal(sock, sock->sock);
- status = socket_connect(sock->sock, NULL, 0, inet_ntoa(*ip), port, 0);
+ status = socket_connect(sock->sock, NULL, 0, sys_inet_ntoa(*ip), port, 0);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(sock->sock);
sock->sock = NULL;
BOOL smbcli_sock_connect_byname(struct smbcli_socket *sock, const char *host, int port)
{
int name_type = 0x20;
- struct in_addr ip;
+ struct ipv4_addr ip;
char *name, *p;
BOOL ret;
/* this is the context for a SMB socket associated with the socket itself */
struct smbcli_socket {
- struct in_addr dest_ip;
+ struct ipv4_addr dest_ip;
/* dest hostname (which may or may not be a DNS name) */
char *hostname;
static NTSTATUS libnet_find_pdc_generic(struct libnet_context *ctx, TALLOC_CTX *mem_ctx, union libnet_find_pdc *r)
{
BOOL ret;
- struct in_addr ip;
+ struct ipv4_addr ip;
if (is_ipaddress(r->generic.in.domain_name)) {
r->generic.out.pdc_name = r->generic.in.domain_name;
}
}
- r->generic.out.pdc_name = talloc_strdup(mem_ctx, inet_ntoa(ip));
+ r->generic.out.pdc_name = talloc_strdup(mem_ctx, sys_inet_ntoa(ip));
return NT_STATUS_OK;
}
*/
#include "includes.h"
+#include "system/network.h"
#include "librpc/gen_ndr/ndr_epmapper.h"
/*
}
{
- struct in_addr in;
+ struct ipv4_addr in;
in.s_addr = htonl(floor->rhs.ip.address);
- return talloc_strdup(mem_ctx, inet_ntoa(in));
+ return talloc_strdup(mem_ctx, sys_inet_ntoa(in));
}
case EPM_PROTOCOL_NCACN:
add a socket address to the list of events, one event per dcerpc endpoint
*/
static void add_socket_rpc_tcp_iface(struct server_service *service,
- const struct model_ops *model_ops,
- struct dcesrv_context *dce_ctx,
- struct dcesrv_endpoint *e,
- struct in_addr *ifip)
+ const struct model_ops *model_ops,
+ struct dcesrv_context *dce_ctx,
+ struct dcesrv_endpoint *e,
+ struct ipv4_addr *ifip)
{
struct server_socket *sock;
struct dcesrv_socket_context *dcesrv_sock;
uint16_t port = 0;
- char *ip_str = talloc_strdup(service, inet_ntoa(*ifip));
+ char *ip_str = talloc_strdup(service, sys_inet_ntoa(*ifip));
if (e->ep_description.endpoint)
port = atoi(e->ep_description.endpoint);
int num_interfaces = iface_count();
int i;
for(i = 0; i < num_interfaces; i++) {
- struct in_addr *ifip = iface_n_ip(i);
+ struct ipv4_addr *ifip = iface_n_ip(i);
if (ifip == NULL) {
continue;
}
add_socket_rpc_tcp_iface(service, model_ops, dce_ctx, e, ifip);
}
} else {
- struct in_addr ifip;
+ struct ipv4_addr ifip;
ifip = interpret_addr2(lp_socket_address());
add_socket_rpc_tcp_iface(service, model_ops, dce_ctx, e, &ifip);
}
static void add_socket(struct server_service *service,
const struct model_ops *model_ops,
struct socket_context *socket_ctx,
- struct in_addr *ifip)
+ struct ipv4_addr *ifip)
{
const char **ports = lp_smb_ports();
int i;
- char *ip_str = talloc_strdup(service, inet_ntoa(*ifip));
+ char *ip_str = talloc_strdup(service, sys_inet_ntoa(*ifip));
for (i=0;ports[i];i++) {
uint16_t port = atoi(ports[i]);
socket per interface and bind to only these.
*/
for(i = 0; i < num_interfaces; i++) {
- struct in_addr *ifip = iface_n_ip(i);
+ struct ipv4_addr *ifip = iface_n_ip(i);
if (ifip == NULL) {
DEBUG(0,("open_sockets_smbd: interface %d has NULL IP address !\n", i));
add_socket(service, model_ops, NULL, ifip);
}
} else {
- struct in_addr ifip;
+ struct ipv4_addr ifip;
/* Just bind to lp_socket_address() (usually 0.0.0.0) */
ifip = interpret_addr2(lp_socket_address());
add_socket(service, model_ops, NULL, &ifip);
*/
#include "includes.h"
+#include "system/network.h"
#include "librpc/gen_ndr/ndr_epmapper.h"
case EPM_PROTOCOL_IP:
printf(" IP:");
{
- struct in_addr in;
+ struct ipv4_addr in;
in.s_addr = htonl(rhs->ip.address);
- printf("%s", inet_ntoa(in));
+ printf("%s", sys_inet_ntoa(in));
}
break;
static BOOL give_flags = False;
static BOOL use_bcast = True;
static BOOL got_bcast = False;
-static struct in_addr bcast_addr;
+static struct ipv4_addr bcast_addr;
static BOOL recursion_desired = False;
static BOOL translate_addresses = False;
static int ServerFD= -1;
/****************************************************************************
do a node status query
****************************************************************************/
-static void do_node_status(int fd, const char *name, int type, struct in_addr ip)
+static void do_node_status(int fd, const char *name, int type, struct ipv4_addr ip)
{
struct nmb_name nname;
int count, i, j;
static BOOL query_one(const char *lookup, uint_t lookup_type)
{
int j, count, flags = 0;
- struct in_addr *ip_list=NULL;
+ struct ipv4_addr *ip_list=NULL;
if (got_bcast) {
d_printf("querying %s on %s\n", lookup, inet_ntoa(bcast_addr));
use_bcast?True:recursion_desired,
bcast_addr,&count, &flags, NULL);
} else {
- struct in_addr *bcast;
+ struct ipv4_addr *bcast;
for (j=iface_count() - 1;
!ip_list && j >= 0;
j--) {
for (i=optind;i<argc;i++)
{
char *p;
- struct in_addr ip;
+ struct ipv4_addr ip;
fstrcpy(lookup,argv[i]);
git.samba.org / abartlet / samba.git / .git / commitdiff