From 8d25596b5b112f7bfb1cc844f31caaf32bfd53a8 Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Mon, 20 Feb 2006 18:24:30 +0000 Subject: r13573: removing wrepld from SAMBA_3_0. The Samba 4 work is more current and any integration into Samba 3 would most likely be from scratch (This used to be commit 028b1f26aeebc46d6ae433fc3d2eae69e493c312) --- source3/Makefile.in | 22 +- source3/wrepld/parser.c | 759 ---------------------------------- source3/wrepld/partners.c | 200 --------- source3/wrepld/process.c | 983 --------------------------------------------- source3/wrepld/server.c | 670 ------------------------------ source3/wrepld/socket.c | 69 ---- source3/wrepld/wins_repl.h | 161 -------- 7 files changed, 2 insertions(+), 2862 deletions(-) delete mode 100644 source3/wrepld/parser.c delete mode 100644 source3/wrepld/partners.c delete mode 100644 source3/wrepld/process.c delete mode 100644 source3/wrepld/server.c delete mode 100644 source3/wrepld/socket.c delete mode 100644 source3/wrepld/wins_repl.h (limited to 'source3') diff --git a/source3/Makefile.in b/source3/Makefile.in index 5d3a6e7109..2eae4e3e03 100644 --- a/source3/Makefile.in +++ b/source3/Makefile.in @@ -439,13 +439,6 @@ NMBD_OBJ1 = nmbd/asyncdns.o nmbd/nmbd.o nmbd/nmbd_become_dmb.o \ NMBD_OBJ = $(NMBD_OBJ1) $(PARAM_OBJ) $(LIBSMB_OBJ) $(KRBCLIENT_OBJ) \ $(PROFILE_OBJ) $(LIB_NONSMBD_OBJ) $(SECRETS_OBJ) $(POPT_LIB_OBJ) -WREPL_OBJ1 = wrepld/server.o wrepld/process.o wrepld/parser.o wrepld/socket.o \ - wrepld/partners.o - -WREPL_OBJ = $(WREPL_OBJ1) $(PARAM_OBJ) \ - $(PROFILE_OBJ) $(LIB_NONSMBD_OBJ) $(POPT_LIB_OBJ) $(SECRETS_OBJ) \ - $(LIBSAMBA_OBJ) - SWAT_OBJ1 = web/cgi.o web/diagnose.o web/startstop.o web/statuspage.o \ web/swat.o web/neg_lang.o @@ -892,10 +885,6 @@ bin/nmbd@EXEEXT@: $(NMBD_OBJ) @BUILD_POPT@ bin/.dummy @echo Linking $@ @$(CC) $(FLAGS) @PIE_LDFLAGS@ -o $@ $(NMBD_OBJ) $(LDFLAGS) $(DYNEXP) $(LIBS) @POPTLIBS@ $(KRB5LIBS) $(LDAP_LIBS) -bin/wrepld@EXEEXT@: $(WREPL_OBJ) @BUILD_POPT@ bin/.dummy - @echo Linking $@ - @$(CC) $(FLAGS) @PIE_LDFLAGS@ -o $@ $(WREPL_OBJ) $(LDFLAGS) $(DYNEXP) $(LIBS) @POPTLIBS@ - bin/swat@EXEEXT@: $(SWAT_OBJ) @BUILD_POPT@ bin/.dummy @echo Linking $@ @$(CC) $(FLAGS) @PIE_LDFLAGS@ -o $@ $(SWAT_OBJ) $(LDFLAGS) $(DYNEXP) $(PRINT_LIBS) \ @@ -1533,13 +1522,13 @@ clean: delheaders python_clean # exist, not necessarily that they are up to date. Since they're # removed by "make clean" this will always be run when you do anything # afterwards. -proto_exists: include/proto.h include/wrepld_proto.h include/build_env.h \ +proto_exists: include/proto.h include/build_env.h \ nsswitch/winbindd_proto.h web/swat_proto.h \ client/client_proto.h utils/net_proto.h utils/ntlm_auth_proto.h smbd/build_options.c delheaders: @echo Removing prototype headers - @rm -f include/proto.h include/build_env.h include/wrepld_proto.h \ + @rm -f include/proto.h include/build_env.h \ nsswitch/winbindd_proto.h web/swat_proto.h \ client/client_proto.h utils/net_proto.h \ smbd/build_options.c @@ -1557,12 +1546,6 @@ include/build_env.h: script/build_env.sh @$(SHELL) $(srcdir)/script/build_env.sh $(srcdir) $(builddir) $(CC) \ > $(builddir)/include/build_env.h -include/wrepld_proto.h: - @echo Building include/wrepld_proto.h - @cd $(srcdir) && $(SHELL) $(MKPROTO_SH) $(AWK) \ - -h _WREPLD_PROTO_H_ $(builddir)/include/wrepld_proto.h \ - $(WREPL_OBJ1) - nsswitch/winbindd_proto.h: @cd $(srcdir) && $(SHELL) $(MKPROTO_SH) $(AWK) \ -h _WINBINDD_PROTO_H_ $(builddir)/nsswitch/winbindd_proto.h \ @@ -1601,7 +1584,6 @@ headers: $(MAKE) smbd/build_options.c; \ $(MAKE) include/proto.h; \ $(MAKE) include/build_env.h; \ - $(MAKE) include/wrepld_proto.h; \ $(MAKE) nsswitch/winbindd_proto.h; \ $(MAKE) web/swat_proto.h; \ $(MAKE) client/client_proto.h; \ diff --git a/source3/wrepld/parser.c b/source3/wrepld/parser.c deleted file mode 100644 index 915895507c..0000000000 --- a/source3/wrepld/parser.c +++ /dev/null @@ -1,759 +0,0 @@ -/* - * Unix SMB/CIFS implementation. - * RPC Pipe client / server routines - * Copyright (C) Jean François Micouleau 1998-2002. - * - * 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 "includes.h" -#include "wins_repl.h" - -extern TALLOC_CTX *mem_ctx; - -/**************************************************************************** -grow the send buffer if necessary -****************************************************************************/ -BOOL grow_buffer(struct BUFFER *buffer, int more) -{ - char *temp; - - DEBUG(10,("grow_buffer: size is: %d offet is:%d growing by %d\n", buffer->length, buffer->offset, more)); - - /* grow by at least 256 bytes */ - if (more<256) - more=256; - - if (buffer->offset+more >= buffer->length) { - temp=talloc_realloc(mem_ctx, buffer->buffer, char, buffer->length + more); - if (temp==NULL) { - DEBUG(0,("grow_buffer: can't grow buffer\n")); - return False; - } - buffer->length+=more; - buffer->buffer=temp; - } - - return True; -} - -/**************************************************************************** -check if the buffer has that much data -****************************************************************************/ -static BOOL check_buffer(struct BUFFER *buffer, int more) -{ - DEBUG(10,("check_buffer: size is: %d offet is:%d growing by %d\n", buffer->length, buffer->offset, more)); - - if (buffer->offset+more > buffer->length) { - DEBUG(10,("check_buffer: buffer smaller than requested, size is: %d needed: %d\n", buffer->length, buffer->offset+more)); - return False; - } - - return True; -} - -/**************************************************************************** -decode a WINS_OWNER struct -****************************************************************************/ -static void decode_wins_owner(struct BUFFER *inbuf, WINS_OWNER *wins_owner) -{ - if(!check_buffer(inbuf, 24)) - return; - - wins_owner->address.s_addr=IVAL(inbuf->buffer, inbuf->offset); - wins_owner->max_version=((SMB_BIG_UINT)RIVAL(inbuf->buffer, inbuf->offset+4))<<32; - wins_owner->max_version|=RIVAL(inbuf->buffer, inbuf->offset+8); - wins_owner->min_version=((SMB_BIG_UINT)RIVAL(inbuf->buffer, inbuf->offset+12))<<32; - wins_owner->min_version|=RIVAL(inbuf->buffer, inbuf->offset+16); - wins_owner->type=RIVAL(inbuf->buffer, inbuf->offset+20); - inbuf->offset+=24; - -} - -/**************************************************************************** -decode a WINS_NAME struct -****************************************************************************/ -static void decode_wins_name(struct BUFFER *outbuf, WINS_NAME *wins_name) -{ - char *p; - int i; - - if(!check_buffer(outbuf, 40)) - return; - - wins_name->name_len=RIVAL(outbuf->buffer, outbuf->offset); - outbuf->offset+=4; - memcpy(wins_name->name,outbuf->buffer+outbuf->offset, 15); - wins_name->name[15]='\0'; - if((p = strchr(wins_name->name,' ')) != NULL) - *p = 0; - - outbuf->offset+=15; - - wins_name->type=(int)outbuf->buffer[outbuf->offset++]; - - /* - * fix to bug in WINS replication, - * present in all versions including W2K SP2 ! - */ - if (wins_name->name[0]==0x1B) { - wins_name->name[0]=(char)wins_name->type; - wins_name->type=0x1B; - } - - wins_name->empty=RIVAL(outbuf->buffer, outbuf->offset); - outbuf->offset+=4; - - wins_name->name_flag=RIVAL(outbuf->buffer, outbuf->offset); - outbuf->offset+=4; - wins_name->group_flag=RIVAL(outbuf->buffer, outbuf->offset); - outbuf->offset+=4; - wins_name->id=((SMB_BIG_UINT)RIVAL(outbuf->buffer, outbuf->offset))<<32; - outbuf->offset+=4; - wins_name->id|=RIVAL(outbuf->buffer, outbuf->offset); - outbuf->offset+=4; - - /* special groups have multiple address */ - if (wins_name->name_flag & 2) { - if(!check_buffer(outbuf, 4)) - return; - wins_name->num_ip=IVAL(outbuf->buffer, outbuf->offset); - outbuf->offset+=4; - } - else - wins_name->num_ip=1; - - if(!check_buffer(outbuf, 4)) - return; - wins_name->owner.s_addr=IVAL(outbuf->buffer, outbuf->offset); - outbuf->offset+=4; - - if (wins_name->name_flag & 2) { - wins_name->others=talloc_array(mem_ctx, struct in_addr, wins_name->num_ip); - if (wins_name->others==NULL) - return; - - if(!check_buffer(outbuf, 4*wins_name->num_ip)) - return; - for (i=0; inum_ip; i++) { - wins_name->others[i].s_addr=IVAL(outbuf->buffer, outbuf->offset); - outbuf->offset+=4; - } - } - - if(!check_buffer(outbuf, 4)) - return; - wins_name->foo=RIVAL(outbuf->buffer, outbuf->offset); - outbuf->offset+=4; - -} - -/**************************************************************************** -decode a update notification request -****************************************************************************/ -static void decode_update_notify_request(struct BUFFER *inbuf, UPDATE_NOTIFY_REQUEST *un_rq) -{ - int i; - - if(!check_buffer(inbuf, 4)) - return; - un_rq->partner_count=RIVAL(inbuf->buffer, inbuf->offset); - inbuf->offset+=4; - - un_rq->wins_owner=talloc_array(mem_ctx, WINS_OWNER, un_rq->partner_count); - if (un_rq->wins_owner==NULL) - return; - - for (i=0; ipartner_count; i++) - decode_wins_owner(inbuf, &un_rq->wins_owner[i]); - - if(!check_buffer(inbuf, 4)) - return; - un_rq->initiating_wins_server.s_addr=IVAL(inbuf->buffer, inbuf->offset); - inbuf->offset+=4; -} - -/**************************************************************************** -decode a send entries request -****************************************************************************/ -static void decode_send_entries_request(struct BUFFER *inbuf, SEND_ENTRIES_REQUEST *se_rq) -{ - decode_wins_owner(inbuf, &se_rq->wins_owner); -} - -/**************************************************************************** -decode a send entries reply -****************************************************************************/ -static void decode_send_entries_reply(struct BUFFER *inbuf, SEND_ENTRIES_REPLY *se_rp) -{ - int i; - - if(!check_buffer(inbuf, 4)) - return; - se_rp->max_names = RIVAL(inbuf->buffer, inbuf->offset); - inbuf->offset+=4; - - se_rp->wins_name=talloc_array(mem_ctx, WINS_NAME, se_rp->max_names); - if (se_rp->wins_name==NULL) - return; - - for (i=0; imax_names; i++) - decode_wins_name(inbuf, &se_rp->wins_name[i]); -} - -/**************************************************************************** -decode a add version number map table reply -****************************************************************************/ -static void decode_add_version_number_map_table_reply(struct BUFFER *inbuf, AVMT_REP *avmt_rep) -{ - int i; - - if(!check_buffer(inbuf, 4)) - return; - - avmt_rep->partner_count=RIVAL(inbuf->buffer, inbuf->offset); - inbuf->offset+=4; - - avmt_rep->wins_owner=talloc_array(mem_ctx, WINS_OWNER, avmt_rep->partner_count); - if (avmt_rep->wins_owner==NULL) - return; - - for (i=0; ipartner_count; i++) - decode_wins_owner(inbuf, &avmt_rep->wins_owner[i]); - - if(!check_buffer(inbuf, 4)) - return; - avmt_rep->initiating_wins_server.s_addr=IVAL(inbuf->buffer, inbuf->offset); - inbuf->offset+=4; -} - -/**************************************************************************** -decode a replicate packet and fill a structure -****************************************************************************/ -static void decode_replicate(struct BUFFER *inbuf, REPLICATE *rep) -{ - if(!check_buffer(inbuf, 4)) - return; - - rep->msg_type = RIVAL(inbuf->buffer, inbuf->offset); - - inbuf->offset+=4; - - switch (rep->msg_type) { - case 0: - break; - case 1: - /* add version number map table reply */ - decode_add_version_number_map_table_reply(inbuf, &rep->avmt_rep); - break; - case 2: - /* send entry request */ - decode_send_entries_request(inbuf, &rep->se_rq); - break; - case 3: - /* send entry request */ - decode_send_entries_reply(inbuf, &rep->se_rp); - break; - case 4: - /* update notification request */ - decode_update_notify_request(inbuf, &rep->un_rq); - break; - default: - DEBUG(0,("decode_replicate: unknown message type:%d\n", rep->msg_type)); - break; - } -} - -/**************************************************************************** -read the generic header and fill the struct. -****************************************************************************/ -static void read_generic_header(struct BUFFER *inbuf, generic_header *q) -{ - if(!check_buffer(inbuf, 16)) - return; - - q->data_size = RIVAL(inbuf->buffer, inbuf->offset+0); - q->opcode = RIVAL(inbuf->buffer, inbuf->offset+4); - q->assoc_ctx = RIVAL(inbuf->buffer, inbuf->offset+8); - q->mess_type = RIVAL(inbuf->buffer, inbuf->offset+12); -} - -/******************************************************************* -decode a start association request -********************************************************************/ -static void decode_start_assoc_request(struct BUFFER *inbuf, START_ASSOC_REQUEST *q) -{ - if(!check_buffer(inbuf, 8)) - return; - - q->assoc_ctx = RIVAL(inbuf->buffer, inbuf->offset+0); - q->min_ver = RSVAL(inbuf->buffer, inbuf->offset+4); - q->maj_ver = RSVAL(inbuf->buffer, inbuf->offset+6); -} - -/******************************************************************* -decode a start association reply -********************************************************************/ -static void decode_start_assoc_reply(struct BUFFER *inbuf, START_ASSOC_REPLY *r) -{ - if(!check_buffer(inbuf, 8)) - return; - - r->assoc_ctx=RIVAL(inbuf->buffer, inbuf->offset+0); - r->min_ver = RSVAL(inbuf->buffer, inbuf->offset+4); - r->maj_ver = RSVAL(inbuf->buffer, inbuf->offset+6); -} - -/******************************************************************* -decode a start association reply -********************************************************************/ -static void decode_stop_assoc(struct BUFFER *inbuf, STOP_ASSOC *r) -{ - if(!check_buffer(inbuf, 4)) - return; - - r->reason=RIVAL(inbuf->buffer, inbuf->offset); -} - -/**************************************************************************** -decode a packet and fill a generic structure -****************************************************************************/ -void decode_generic_packet(struct BUFFER *inbuf, GENERIC_PACKET *q) -{ - read_generic_header(inbuf, &q->header); - - inbuf->offset+=16; - - switch (q->header.mess_type) { - case 0: - decode_start_assoc_request(inbuf, &q->sa_rq); - break; - case 1: - decode_start_assoc_reply(inbuf, &q->sa_rp); - break; - case 2: - decode_stop_assoc(inbuf, &q->so); - break; - case 3: - decode_replicate(inbuf, &q->rep); - break; - default: - DEBUG(0,("decode_generic_packet: unknown message type:%d\n", q->header.mess_type)); - break; - } -} - -/**************************************************************************** -encode a WINS_OWNER struct -****************************************************************************/ -static void encode_wins_owner(struct BUFFER *outbuf, WINS_OWNER *wins_owner) -{ - if (!grow_buffer(outbuf, 24)) - return; - - SIVAL(outbuf->buffer, outbuf->offset, wins_owner->address.s_addr); - outbuf->offset+=4; - RSIVAL(outbuf->buffer, outbuf->offset, (int)(wins_owner->max_version>>32)); - outbuf->offset+=4; - RSIVAL(outbuf->buffer, outbuf->offset, (int)(wins_owner->max_version&0xffffffff)); - outbuf->offset+=4; - RSIVAL(outbuf->buffer, outbuf->offset, wins_owner->min_version>>32); - outbuf->offset+=4; - RSIVAL(outbuf->buffer, outbuf->offset, wins_owner->min_version&0xffffffff); - outbuf->offset+=4; - RSIVAL(outbuf->buffer, outbuf->offset, wins_owner->type); - outbuf->offset+=4; - -} - -/**************************************************************************** -encode a WINS_NAME struct -****************************************************************************/ -static void encode_wins_name(struct BUFFER *outbuf, WINS_NAME *wins_name) -{ - int i; - - if (!grow_buffer(outbuf, 48+(4*wins_name->num_ip))) - return; - - RSIVAL(outbuf->buffer, outbuf->offset, wins_name->name_len); - outbuf->offset+=4; - - memset(outbuf->buffer+outbuf->offset, ' ', 15); - - /* to prevent copying the leading \0 */ - memcpy(outbuf->buffer+outbuf->offset, wins_name->name, strlen(wins_name->name)); - outbuf->offset+=15; - - outbuf->buffer[outbuf->offset++]=(char)wins_name->type; - - RSIVAL(outbuf->buffer, outbuf->offset, wins_name->empty); - outbuf->offset+=4; - - RSIVAL(outbuf->buffer, outbuf->offset, wins_name->name_flag); - outbuf->offset+=4; - RSIVAL(outbuf->buffer, outbuf->offset, wins_name->group_flag); - outbuf->offset+=4; - RSIVAL(outbuf->buffer, outbuf->offset, wins_name->id>>32); - outbuf->offset+=4; - RSIVAL(outbuf->buffer, outbuf->offset, wins_name->id); - outbuf->offset+=4; - - if (wins_name->name_flag & 2) { - SIVAL(outbuf->buffer, outbuf->offset, wins_name->num_ip); - outbuf->offset+=4; - } - - SIVAL(outbuf->buffer, outbuf->offset, wins_name->owner.s_addr); - outbuf->offset+=4; - - if (wins_name->name_flag & 2) { - for (i=0;inum_ip;i++) { - SIVAL(outbuf->buffer, outbuf->offset, wins_name->others[i].s_addr); - outbuf->offset+=4; - } - } - - RSIVAL(outbuf->buffer, outbuf->offset, wins_name->foo); - outbuf->offset+=4; -} - -/**************************************************************************** -encode a update notification request -****************************************************************************/ -static void encode_update_notify_request(struct BUFFER *outbuf, UPDATE_NOTIFY_REQUEST *un_rq) -{ - int i; - - if (!grow_buffer(outbuf, 8)) - return; - - RSIVAL(outbuf->buffer, outbuf->offset, un_rq->partner_count); - outbuf->offset+=4; - - for (i=0; ipartner_count; i++) - encode_wins_owner(outbuf, &un_rq->wins_owner[i]); - - SIVAL(outbuf->buffer, outbuf->offset, un_rq->initiating_wins_server.s_addr); - outbuf->offset+=4; - -} - -/**************************************************************************** -decode a send entries request -****************************************************************************/ -static void encode_send_entries_request(struct BUFFER *outbuf, SEND_ENTRIES_REQUEST *se_rq) -{ - encode_wins_owner(outbuf, &se_rq->wins_owner); -} - -/**************************************************************************** -decode a send entries reply -****************************************************************************/ -static void encode_send_entries_reply(struct BUFFER *outbuf, SEND_ENTRIES_REPLY *se_rp) -{ - int i; - - if (!grow_buffer(outbuf, 4)) - return; - - RSIVAL(outbuf->buffer, outbuf->offset, se_rp->max_names); - outbuf->offset+=4; - - for (i=0; imax_names; i++) - encode_wins_name(outbuf, &se_rp->wins_name[i]); - -} - -/**************************************************************************** -encode a add version number map table reply -****************************************************************************/ -static void encode_add_version_number_map_table_reply(struct BUFFER *outbuf, AVMT_REP *avmt_rep) -{ - int i; - - if (!grow_buffer(outbuf, 8)) - return; - - RSIVAL(outbuf->buffer, outbuf->offset, avmt_rep->partner_count); - outbuf->offset+=4; - - for (i=0; ipartner_count; i++) - encode_wins_owner(outbuf, &avmt_rep->wins_owner[i]); - - SIVAL(outbuf->buffer, outbuf->offset, avmt_rep->initiating_wins_server.s_addr); - outbuf->offset+=4; - -} - -/**************************************************************************** -decode a replicate packet and fill a structure -****************************************************************************/ -static void encode_replicate(struct BUFFER *outbuf, REPLICATE *rep) -{ - if (!grow_buffer(outbuf, 4)) - return; - - RSIVAL(outbuf->buffer, outbuf->offset, rep->msg_type); - outbuf->offset+=4; - - switch (rep->msg_type) { - case 0: - break; - case 1: - /* add version number map table reply */ - encode_add_version_number_map_table_reply(outbuf, &rep->avmt_rep); - break; - case 2: - /* send entry request */ - encode_send_entries_request(outbuf, &rep->se_rq); - break; - case 3: - /* send entry request */ - encode_send_entries_reply(outbuf, &rep->se_rp); - break; - case 4: - /* update notification request */ - encode_update_notify_request(outbuf, &rep->un_rq); - break; - default: - DEBUG(0,("encode_replicate: unknown message type:%d\n", rep->msg_type)); - break; - } -} - -/**************************************************************************** -write the generic header. -****************************************************************************/ -static void write_generic_header(struct BUFFER *outbuf, generic_header *r) -{ - RSIVAL(outbuf->buffer, 0, r->data_size); - RSIVAL(outbuf->buffer, 4, r->opcode); - RSIVAL(outbuf->buffer, 8, r->assoc_ctx); - RSIVAL(outbuf->buffer,12, r->mess_type); -} - -/******************************************************************* -decode a start association request -********************************************************************/ -static void encode_start_assoc_request(struct BUFFER *outbuf, START_ASSOC_REQUEST *q) -{ - if (!grow_buffer(outbuf, 45)) - return; - - RSIVAL(outbuf->buffer, outbuf->offset, q->assoc_ctx); - RSSVAL(outbuf->buffer, outbuf->offset+4, q->min_ver); - RSSVAL(outbuf->buffer, outbuf->offset+6, q->maj_ver); - - outbuf->offset=45; -} - -/******************************************************************* -decode a start association reply -********************************************************************/ -static void encode_start_assoc_reply(struct BUFFER *outbuf, START_ASSOC_REPLY *r) -{ - if (!grow_buffer(outbuf, 45)) - return; - - RSIVAL(outbuf->buffer, outbuf->offset, r->assoc_ctx); - RSSVAL(outbuf->buffer, outbuf->offset+4, r->min_ver); - RSSVAL(outbuf->buffer, outbuf->offset+6, r->maj_ver); - - outbuf->offset=45; -} - -/******************************************************************* -decode a start association reply -********************************************************************/ -static void encode_stop_assoc(struct BUFFER *outbuf, STOP_ASSOC *r) -{ - if (!grow_buffer(outbuf, 44)) - return; - - RSIVAL(outbuf->buffer, outbuf->offset, r->reason); - - outbuf->offset=44; -} - -/**************************************************************************** -write the generic header size. -****************************************************************************/ -static void write_generic_header_size(generic_header *r, int size) -{ - /* the buffer size is the total size minus the size field */ - r->data_size=size-4; -} - -/**************************************************************************** -encode a packet and read a generic structure -****************************************************************************/ -void encode_generic_packet(struct BUFFER *outbuf, GENERIC_PACKET *q) -{ - if (!grow_buffer(outbuf, 16)) - return; - - outbuf->offset=16; - - switch (q->header.mess_type) { - case 0: - encode_start_assoc_request(outbuf, &q->sa_rq); - break; - case 1: - encode_start_assoc_reply(outbuf, &q->sa_rp); - break; - case 2: - encode_stop_assoc(outbuf, &q->so); - break; - case 3: - encode_replicate(outbuf, &q->rep); - break; - default: - DEBUG(0,("encode_generic_packet: unknown message type:%d\n", q->header.mess_type)); - break; - } - - write_generic_header_size(&q->header, outbuf->offset); - write_generic_header(outbuf, &q->header); -} - - -/**************************************************************************** -dump a WINS_OWNER structure -****************************************************************************/ -static void dump_wins_owner(WINS_OWNER *wins_owner) -{ - DEBUGADD(10,("\t\t\t\taddress : %s\n", inet_ntoa(wins_owner->address))); - DEBUGADD(10,("\t\t\t\tmax version: %d\n", (int)wins_owner->max_version)); - DEBUGADD(10,("\t\t\t\tmin version: %d\n", (int)wins_owner->min_version)); - DEBUGADD(10,("\t\t\t\ttype : %d\n", wins_owner->type)); -} - -/**************************************************************************** -dump a WINS_NAME structure -****************************************************************************/ -static void dump_wins_name(WINS_NAME *wins_name) -{ - fstring name; - int i; - - strncpy(name, wins_name->name, 15); - - DEBUGADD(10,("name: %d, %s<%02x> %x,%x, %d %s %d ", wins_name->name_len, name, wins_name->type, - wins_name->name_flag, wins_name->group_flag, (int)wins_name->id, - inet_ntoa(wins_name->owner), wins_name->num_ip)); - - if (wins_name->num_ip!=1) - for (i=0; inum_ip; i++) - DEBUGADD(10,("%s ", inet_ntoa(wins_name->others[i]))); - - DEBUGADD(10,("\n")); -} - -/**************************************************************************** -dump a replicate structure -****************************************************************************/ -static void dump_replicate(REPLICATE *rep) -{ - int i; - - DEBUGADD(5,("\t\tmsg_type: %d ", rep->msg_type)); - - switch (rep->msg_type) { - case 0: - DEBUGADD(5,("(Add Version Map Table Request)\n")); - break; - case 1: - DEBUGADD(5,("(Add Version Map Table Reply)\n")); - DEBUGADD(5,("\t\t\tpartner_count : %d\n", rep->avmt_rep.partner_count)); - for (i=0; iavmt_rep.partner_count; i++) - dump_wins_owner(&rep->avmt_rep.wins_owner[i]); - DEBUGADD(5,("\t\t\tinitiating_wins_server: %s\n", inet_ntoa(rep->avmt_rep.initiating_wins_server))); - break; - case 2: - DEBUGADD(5,("(Send Entries Request)\n")); - dump_wins_owner(&rep->se_rq.wins_owner); - break; - case 3: - DEBUGADD(5,("(Send Entries Reply)\n")); - DEBUGADD(5,("\t\t\tmax_names : %d\n", rep->se_rp.max_names)); - for (i=0; ise_rp.max_names; i++) - dump_wins_name(&rep->se_rp.wins_name[i]); - break; - case 4: - DEBUGADD(5,("(Update Notify Request)\n")); - DEBUGADD(5,("\t\t\tpartner_count : %d\n", rep->un_rq.partner_count)); - for (i=0; iun_rq.partner_count; i++) - dump_wins_owner(&rep->un_rq.wins_owner[i]); - DEBUGADD(5,("\t\t\tinitiating_wins_server: %s\n", inet_ntoa(rep->un_rq.initiating_wins_server))); - break; - default: - DEBUG(5,("\n")); - break; - } -} - -/**************************************************************************** -dump a generic structure -****************************************************************************/ -void dump_generic_packet(GENERIC_PACKET *q) -{ - DEBUG(5,("dump_generic_packet:\n")); - DEBUGADD(5,("\tdata_size: %08x\n", q->header.data_size)); - DEBUGADD(5,("\topcode : %08x\n", q->header.opcode)); - DEBUGADD(5,("\tassoc_ctx: %08x\n", q->header.assoc_ctx)); - DEBUGADD(5,("\tmess_type: %08x ", q->header.mess_type)); - - switch (q->header.mess_type) { - case 0: - DEBUGADD(5,("(Start Association Request)\n")); - DEBUGADD(5,("\t\tassoc_ctx: %08x\n", q->sa_rq.assoc_ctx)); - DEBUGADD(5,("\t\tmin_ver : %04x\n", q->sa_rq.min_ver)); - DEBUGADD(5,("\t\tmaj_ver : %04x\n", q->sa_rq.maj_ver)); - break; - case 1: - DEBUGADD(5,("(Start Association Reply)\n")); - DEBUGADD(5,("\t\tassoc_ctx: %08x\n", q->sa_rp.assoc_ctx)); - DEBUGADD(5,("\t\tmin_ver : %04x\n", q->sa_rp.min_ver)); - DEBUGADD(5,("\t\tmaj_ver : %04x\n", q->sa_rp.maj_ver)); - break; - case 2: - DEBUGADD(5,("(Stop Association)\n")); - DEBUGADD(5,("\t\treason: %08x\n", q->so.reason)); - break; - case 3: - DEBUGADD(5,("(Replication Message)\n")); - dump_replicate(&q->rep); - break; - default: - DEBUG(5,("\n")); - break; - } - -} - -/**************************************************************************** -generate a stop packet -****************************************************************************/ -void stop_packet(GENERIC_PACKET *q, GENERIC_PACKET *r, int reason) -{ - r->header.opcode=OPCODE_NON_NBT; - r->header.assoc_ctx=get_server_assoc(q->header.assoc_ctx); - r->header.mess_type=MESSAGE_TYPE_STOP_ASSOC; - r->so.reason=reason; - -} - - diff --git a/source3/wrepld/partners.c b/source3/wrepld/partners.c deleted file mode 100644 index 2387f5b45f..0000000000 --- a/source3/wrepld/partners.c +++ /dev/null @@ -1,200 +0,0 @@ -/* - Unix SMB/CIFS implementation. - process incoming packets - main loop - Copyright (C) Jean François Micouleau 1998-2002. - - 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 "includes.h" -#include "wins_repl.h" - -/* we can exchange info with 64 partners at any given time */ -WINS_PARTNER current_partners[64]; -int total_current_partners; - -/******************************************************************* -verify if we know this partner -********************************************************************/ -BOOL check_partner(int assoc) -{ - int i; - - DEBUG(5,("check_partner: total_current_partners: %d\n", total_current_partners)); - - for (i=0; is_addr=current_partners[i].partner_server.s_addr; - server->s_addr=current_partners[i].other_server.s_addr; - return True; - } - - return False; -} - - diff --git a/source3/wrepld/process.c b/source3/wrepld/process.c deleted file mode 100644 index 7a94cdcafb..0000000000 --- a/source3/wrepld/process.c +++ /dev/null @@ -1,983 +0,0 @@ -/* - Unix SMB/CIFS implementation. - process incoming packets - main loop - Copyright (C) Jean François Micouleau 1998-2002. - - 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 "includes.h" -#include "wins_repl.h" - -extern fd_set *listen_set; -extern int listen_number; -extern int *sock_array; - -WINS_OWNER global_wins_table[64][64]; -int partner_count; - -TALLOC_CTX *mem_ctx; - -#define WINS_LIST "wins.tdb" -#define INFO_VERSION "INFO/version" -#define INFO_COUNT "INFO/num_entries" -#define INFO_ID_HIGH "INFO/id_high" -#define INFO_ID_LOW "INFO/id_low" -#define ENTRY_PREFIX "ENTRY/" - - -/******************************************************************* -fill the header of a reply. -********************************************************************/ -static void fill_header(GENERIC_PACKET *g, int opcode, int ctx, int mess) -{ - if (g==NULL) - return; - - g->header.opcode=opcode; - g->header.assoc_ctx=ctx; - g->header.mess_type=mess; -} - -/******************************************************************* -dump the global table, that's a debug code. -********************************************************************/ -static void dump_global_table(void) -{ - int i,j; - - for (i=0;isa_rp.assoc_ctx=time(NULL); - fill_header(r, OPCODE_NON_NBT, q->sa_rq.assoc_ctx, MESSAGE_TYPE_START_ASSOC_REPLY); - - /* reply we are a NT4 server */ - - /* w2K is min=2, maj=5 */ - - r->sa_rp.min_ver=1; - r->sa_rp.maj_ver=1; - - add_partner(r->sa_rp.assoc_ctx, q->sa_rq.assoc_ctx, False, False); -} - -/******************************************************************* -start association reply -********************************************************************/ -static void start_assoc_reply(GENERIC_PACKET *q, GENERIC_PACKET *r) -{ - int i; - - /* check if we have already registered this client */ - if (!check_partner(q->header.assoc_ctx)) { - DEBUG(0,("start_assoc_reply: unknown client\n")); - stop_packet(q, r, STOP_REASON_USER_REASON); - return; - } - - if (!update_server_partner(q->header.assoc_ctx, q->sa_rp.assoc_ctx)) { - DEBUG(0,("start_assoc_reply: can't update server ctx\n")); - stop_packet(q, r, STOP_REASON_USER_REASON); - return; - } - - /* if pull, request map table */ - if (check_pull_partner(q->header.assoc_ctx)) { - fill_header(r, OPCODE_NON_NBT, get_server_assoc(q->header.assoc_ctx), MESSAGE_TYPE_REPLICATE); - - r->rep.msg_type=MESSAGE_REP_ADD_VERSION_REQUEST; - DEBUG(5,("start_assoc_reply: requesting map table\n")); - - return; - } - - /* if push, send our table */ - if (check_push_partner(q->header.assoc_ctx)) { - fill_header(r, OPCODE_NON_NBT, get_server_assoc(q->header.assoc_ctx), MESSAGE_TYPE_REPLICATE); - r->rep.msg_type=MESSAGE_REP_UPDATE_NOTIFY_REQUEST; - r->rep.un_rq.partner_count=partner_count; - - r->rep.un_rq.wins_owner=talloc_array(mem_ctx, WINS_OWNER, partner_count); - if (r->rep.un_rq.wins_owner==NULL) { - DEBUG(0,("start_assoc_reply: can't alloc memory\n")); - stop_packet(q, r, STOP_REASON_USER_REASON); - return; - } - - for (i=0; irep.un_rq.wins_owner[i]=global_wins_table[0][i]; - - DEBUG(5,("start_assoc_reply: sending update table\n")); - return; - } - - /* neither push/pull, stop */ - /* we should not come here */ - DEBUG(0,("we have a partner which is neither push nor pull !\n")); - stop_packet(q, r, STOP_REASON_USER_REASON); -} - -/**************************************************************************** -initialise and fill the in-memory partner table. -****************************************************************************/ -int init_wins_partner_table(void) -{ - int i=1,j=0,k; - char **partner = str_list_make(lp_wins_partners(), NULL); - - if (partner==NULL) { - DEBUG(0,("wrepld: no partner list in smb.conf, exiting\n")); - exit_server("normal exit"); - return(0); - } - - DEBUG(4, ("init_wins_partner_table: partners: %s\n", lp_wins_partners())); - - global_wins_table[0][0].address=*iface_n_ip(0); - global_wins_table[0][0].max_version=0; - global_wins_table[0][0].min_version=0; - global_wins_table[0][0].type=0; - - while (partner[j]!=NULL) { - DEBUG(3,("init_wins_partner_table, adding partner: %s\n", partner[j])); - - global_wins_table[0][i].address=*interpret_addr2(partner[j]); - global_wins_table[0][i].max_version=0; - global_wins_table[0][i].min_version=0; - global_wins_table[0][i].type=0; - global_wins_table[0][i].last_pull=0; - global_wins_table[0][i].last_push=0; - - i++; - j++; - } - - for (k=1; kmax_version=((SMB_BIG_UINT)tdb_fetch_int32(tdb, INFO_ID_HIGH))<<32 | - (SMB_BIG_UINT)tdb_fetch_int32(tdb, INFO_ID_LOW); - - tdb_close(tdb); -} - -/**************************************************************************** -send the list of wins server we know. -****************************************************************************/ -static void send_version_number_map_table(GENERIC_PACKET *q, GENERIC_PACKET *r) -{ - int i; - int s_ctx=get_server_assoc(q->header.assoc_ctx); - - if (s_ctx==0) { - DEBUG(5, ("send_version_number_map_table: request for a partner not in our table\n")); - stop_packet(q, r, STOP_REASON_USER_REASON); - return; - } - - /* - * return an array of wins servers, we are partner with. - * each entry contains the IP address and the version info - * version: ID of the last entry we've got - */ - - /* the first wins server must be self */ - - /* - * get our last ID from the wins database - * it can have been updated since last read - * as nmbd got registration/release. - */ - get_our_last_id(&global_wins_table[0][0]); - - r->rep.avmt_rep.wins_owner=talloc_array(mem_ctx, WINS_OWNER, partner_count); - if (r->rep.avmt_rep.wins_owner==NULL) { - stop_packet(q, r, STOP_REASON_USER_REASON); - return; - } - - DEBUG(5,("send_version_number_map_table: partner_count: %d\n", partner_count)); - - for (i=0; i %s, \n", i, inet_ntoa(global_wins_table[0][i].address))); - r->rep.avmt_rep.wins_owner[i]=global_wins_table[0][i]; - } - - r->rep.msg_type=1; - r->rep.avmt_rep.partner_count=partner_count; - r->rep.avmt_rep.initiating_wins_server.s_addr=0; /* blatant lie, NT4/w2K do the same ! */ - fill_header(r, OPCODE_NON_NBT, s_ctx, MESSAGE_TYPE_REPLICATE); -} - -/**************************************************************************** -for a given partner, ask it to send entries we don't have. -****************************************************************************/ -static BOOL check_partners_and_send_entries(GENERIC_PACKET *q, GENERIC_PACKET *r, int partner) -{ - int server; - int other; - SMB_BIG_UINT temp; - SMB_BIG_UINT current; - - - /* - * we check if our partner has more records than us. - * we need to check more than our direct partners as - * we can have this case: - * us: A, partners: B,C, indirect partner: D - * A<->B, A<->C, B<->D, C<->D - * - * So if we're talking to B, we need to check if between - * B and C, which one have more records about D. - * and also check if we don't already have the records. - */ - - - /* check all servers even indirect */ - for (server=1; global_wins_table[0][server].address.s_addr!=0; server++) { - current = global_wins_table[partner][server].max_version; - - temp=0; - - for (other=1; other temp) - temp=global_wins_table[other][server].max_version; - } - - if (current >= temp && current > global_wins_table[0][server].max_version) { - /* - * it has more records than every body else and more than us, - * ask it the difference between what we have and what it has - */ - fill_header(r, OPCODE_NON_NBT, get_server_assoc(q->header.assoc_ctx), MESSAGE_TYPE_REPLICATE); - - r->rep.msg_type=MESSAGE_REP_SEND_ENTRIES_REQUEST; - r->rep.se_rq.wins_owner.address=global_wins_table[partner][server].address; - - r->rep.se_rq.wins_owner.max_version=global_wins_table[partner][server].max_version; - r->rep.se_rq.wins_owner.min_version=global_wins_table[0][server].max_version; - r->rep.se_rq.wins_owner.type=0; - - write_server_assoc_table(q->header.assoc_ctx, global_wins_table[0][partner].address, global_wins_table[partner][server].address); - - /* - * and we update our version for this server - * as we can't use the IDs returned in the send_entries function - * the max ID can be larger than the largest ID returned - */ - - global_wins_table[0][server].max_version=global_wins_table[partner][server].max_version; - - return True; - } - } - return False; -} - -/**************************************************************************** -receive the list of wins server we know. -****************************************************************************/ -static void receive_version_number_map_table(GENERIC_PACKET *q, GENERIC_PACKET *r) -{ - fstring peer; - struct in_addr addr; - int i,j,k,l; - int s_ctx=get_server_assoc(q->header.assoc_ctx); - - if (s_ctx==0) { - DEBUG(5, ("receive_version_number_map_table: request for a partner not in our table\n")); - stop_packet(q, r, STOP_REASON_USER_REASON); - return; - } - - fstrcpy(peer,get_peer_addr(q->fd)); - addr=*interpret_addr2(peer); - - get_our_last_id(&global_wins_table[0][0]); - - DEBUG(5,("receive_version_number_map_table: received a map of %d server from: %s\n", - q->rep.avmt_rep.partner_count ,inet_ntoa(q->rep.avmt_rep.initiating_wins_server))); - DEBUG(5,("real peer is: %s\n", peer)); - - for (i=0; global_wins_table[0][i].address.s_addr!=addr.s_addr && irep.avmt_rep.partner_count;j++) { - /* - * search if we already have this entry or if it's a new one - * it can be a new one in case of propagation - */ - for (k=0; global_wins_table[0][k].address.s_addr!=0 && - global_wins_table[0][k].address.s_addr!=q->rep.avmt_rep.wins_owner[j].address.s_addr; k++); - - global_wins_table[i][k].address.s_addr=q->rep.avmt_rep.wins_owner[j].address.s_addr; - global_wins_table[i][k].max_version=q->rep.avmt_rep.wins_owner[j].max_version; - global_wins_table[i][k].min_version=q->rep.avmt_rep.wins_owner[j].min_version; - global_wins_table[i][k].type=q->rep.avmt_rep.wins_owner[j].type; - - /* - * in case it's a new one, rewrite the address for all the partner - * to reserve the slot. - */ - - for(l=0; lrep.avmt_rep.wins_owner[j].address.s_addr; - } - - dump_global_table(); - - /* - * if this server have newer records than what we have - * for several wins servers, we need to ask it. - * Alas a send entry request is only on one server. - * So in the send entry reply, we'll ask for the next server if required. - */ - - if (check_partners_and_send_entries(q, r, i)) - return; - - /* it doesn't have more entries than us */ - stop_packet(q, r, STOP_REASON_USER_REASON); -} - -/**************************************************************************** -add an entry to the wins list we'll send. -****************************************************************************/ -static BOOL add_record_to_winsname(WINS_NAME **wins_name, int *max_names, char *name, int type, int wins_flags, int id, struct in_addr *ip_list, int num_ips) -{ - WINS_NAME *temp_list; - int i; - int current=*max_names; - - temp_list=talloc_realloc(mem_ctx, *wins_name, WINS_NAME, current + 1); - if (temp_list==NULL) - return False; - - temp_list[current].name_len=0x11; - - safe_strcpy(temp_list[current].name, name, 15); - - temp_list[current].type=type; - temp_list[current].empty=0; - - temp_list[current].name_flag=wins_flags; - - if ( (wins_flags&0x03) == 1 || (wins_flags&0x03)==2) - temp_list[current].group_flag=0x01000000; - else - temp_list[current].group_flag=0x00000000; - - temp_list[current].id=id; - - temp_list[current].owner.s_addr=ip_list[0].s_addr; - - if (temp_list[current].name_flag & 2) { - temp_list[current].num_ip=num_ips; - temp_list[current].others=talloc_array(mem_ctx, struct in_addr, num_ips); - if (temp_list[current].others==NULL) - return False; - - for (i=0; iheader.assoc_ctx); - int num_interfaces = iface_count(); - - if (s_ctx==0) { - DEBUG(1, ("send_entry_request: request for a partner not in our table\n")); - stop_packet(q, r, STOP_REASON_USER_REASON); - return; - } - - - wins_owner=&q->rep.se_rq.wins_owner; - r->rep.se_rp.wins_name=NULL; - - DEBUG(3,("send_entry_request: we have been asked to send the list of wins records\n")); - DEBUGADD(3,("owned by: %s and between min: %d and max: %d\n", inet_ntoa(wins_owner->address), - (int)wins_owner->min_version, (int)wins_owner->max_version)); - - /* - * if we are asked to send records owned by us - * we overwrite the wins ip with 0.0.0.0 - * to make it easy in case of multihomed - */ - - for (i=0; iaddress, *iface_n_ip(i))) { - wins_owner->address=*interpret_addr2("0.0.0.0"); - break; - } - - - tdb = tdb_open_log(lock_path(WINS_LIST), 0, TDB_DEFAULT, O_RDONLY, 0600); - if (!tdb) { - DEBUG(2,("send_entry_request: Can't open wins database file %s. Error was %s\n", WINS_LIST, strerror(errno) )); - return; - } - - for (kbuf = tdb_firstkey(tdb); - kbuf.dptr; - newkey = tdb_nextkey(tdb, kbuf), safe_free(kbuf.dptr), kbuf=newkey) { - fstring name_type; - pstring name, ip_str; - char *p; - int type = 0; - int nb_flags; - int ttl; - unsigned int num_ips; - int low, high; - SMB_BIG_UINT version; - struct in_addr wins_ip; - struct in_addr *ip_list; - int wins_flags; - int len; - - if (strncmp(kbuf.dptr, ENTRY_PREFIX, strlen(ENTRY_PREFIX)) != 0) - continue; - - - dbuf = tdb_fetch(tdb, kbuf); - if (!dbuf.dptr) - continue; - - fstrcpy(name_type, kbuf.dptr+strlen(ENTRY_PREFIX)); - pstrcpy(name, name_type); - - if((p = strchr(name,'#')) != NULL) { - *p = 0; - sscanf(p+1,"%x",&type); - } - - len = tdb_unpack(dbuf.dptr, dbuf.dsize, "dddfddd", - &nb_flags, - &high, - &low, - ip_str, - &ttl, - &num_ips, - &wins_flags); - - wins_ip=*interpret_addr2(ip_str); - - /* Allocate the space for the ip_list. */ - if((ip_list = talloc_array(mem_ctx, struct in_addr, num_ips)) == NULL) { - SAFE_FREE(dbuf.dptr); - DEBUG(0,("initialise_wins: talloc fail !\n")); - return; - } - - for (i = 0; i < num_ips; i++) { - len += tdb_unpack(dbuf.dptr+len, dbuf.dsize-len, "f", ip_str); - ip_list[i] = *interpret_addr2(ip_str); - } - - SAFE_FREE(dbuf.dptr); - - /* add all entries that have 60 seconds or more to live */ - if ((ttl - 60) > time_now || ttl == PERMANENT_TTL) { - if(ttl != PERMANENT_TTL) - ttl -= time_now; - - DEBUG( 4, ("send_entry_request: add name: %s#%02x ttl = %d first IP %s flags = %2x\n", - name, type, ttl, inet_ntoa(ip_list[0]), nb_flags)); - - /* add the record to the list to send */ - version=((SMB_BIG_UINT)high)<<32 | low; - - if (wins_owner->min_version<=version && wins_owner->max_version>=version && - wins_owner->address.s_addr==wins_ip.s_addr) { - if(!add_record_to_winsname(&r->rep.se_rp.wins_name, &max_names, name, type, wins_flags, version, ip_list, num_ips)) - return; - max_names++; - } - - } else { - DEBUG(4, ("send_entry_request: not adding name (ttl problem) %s#%02x ttl = %d first IP %s flags = %2x\n", - name, type, ttl, inet_ntoa(ip_list[0]), nb_flags)); - } - } - - tdb_close(tdb); - - DEBUG(4,("send_entry_request, sending %d records\n", max_names)); - fill_header(r, OPCODE_NON_NBT, s_ctx, MESSAGE_TYPE_REPLICATE); - r->rep.msg_type=MESSAGE_REP_SEND_ENTRIES_REPLY; /* reply */ - r->rep.se_rp.max_names=max_names; -} - - -/**************************************************************************** -. -****************************************************************************/ -static void update_notify_request(GENERIC_PACKET *q, GENERIC_PACKET *r) -{ - int i,j,k,l; - UPDATE_NOTIFY_REQUEST *u; - int s_ctx=get_server_assoc(q->header.assoc_ctx); - - if (s_ctx==0) { - DEBUG(4, ("update_notify_request: request for a partner not in our table\n")); - stop_packet(q, r, STOP_REASON_USER_REASON); - return; - } - - u=&q->rep.un_rq; - - /* check if we already have the range of records */ - - DEBUG(5,("update_notify_request: wins server: %s offered this list of %d records:\n", - inet_ntoa(u->initiating_wins_server), u->partner_count)); - - get_our_last_id(&global_wins_table[0][0]); - - for (i=0; iinitiating_wins_server.s_addr) { - DEBUG(5,("update_notify_request: found initiator at index %d\n", i)); - break; - } - } - - /* - * some explanation is required, before someone say it's crap. - * - * let's take an example, we have 2 wins partners, we already now - * that our max id is 10, partner 1 ID is 20 and partner 2 ID is 30 - * the array looks like: - * - * 0 1 2 - * 0 10 20 30 - * 1 - * 2 - * - * we receive an update from partner 2 saying he has: 1:15, 2:40, 3:50 - * we must enlarge the array to add partner 3, it will look like: - * - * 0 1 2 3 - * 0 10 20 30 - * 1 - * 2 15 40 50 - * - * now we know, we should pull from partner 2, the records 30->40 of 2 and 0->50 of 3. - * once the pull will be over, our table will look like: - * - * 0 1 2 3 - * 0 10 20 40 50 - * 1 - * 2 15 40 50 - * - * - */ - - for (j=0; jpartner_count;j++) { - /* - * search if we already have this entry or if it's a new one - * it can be a new one in case of propagation - */ - - for (k=0; global_wins_table[0][k].address.s_addr!=0 && - global_wins_table[0][k].address.s_addr!=u->wins_owner[j].address.s_addr; k++); - - global_wins_table[i][k].address.s_addr=u->wins_owner[j].address.s_addr; - global_wins_table[i][k].max_version=u->wins_owner[j].max_version; - global_wins_table[i][k].min_version=u->wins_owner[j].min_version; - global_wins_table[i][k].type=u->wins_owner[j].type; - - /* - * in case it's a new one, rewrite the address for all the partner - * to reserve the slot. - */ - - for(l=0; lwins_owner[j].address.s_addr; - } - - dump_global_table(); - - stop_packet(q, r, STOP_REASON_USER_REASON); -} - -/**************************************************************************** -. -****************************************************************************/ -static void send_entry_reply(GENERIC_PACKET *q, GENERIC_PACKET *r) -{ - int i,j,k; - struct in_addr partner, server; - pid_t pid; - int s_ctx=get_server_assoc(q->header.assoc_ctx); - WINS_RECORD record; - - if (s_ctx==0) { - DEBUG(1, ("send_entry_reply: request for a partner not in our table\n")); - stop_packet(q, r, STOP_REASON_USER_REASON); - return; - } - - DEBUG(5,("send_entry_reply:got %d new records\n", q->rep.se_rp.max_names)); - - /* we got records from a wins partner but that can be from another wins server */ - /* hopefully we track that */ - - /* and the only doc available from MS is wrong ! */ - - get_server_assoc_table(q->header.assoc_ctx, &partner, &server); - - for (j=0; global_wins_table[0][j].address.s_addr!=0; j++) { - if (global_wins_table[0][j].address.s_addr==server.s_addr) { - DEBUG(5,("send_entry_reply: found server at index %d\n", j)); - break; - } - } - - pid = pidfile_pid("nmbd"); - if (pid == 0) { - DEBUG(0,("send_entry_reply: Can't find pid for nmbd\n")); - return; - } - - for (k=0; krep.se_rp.max_names; k++) { - DEBUG(5,("send_entry_reply: %s<%02x> %d\n", q->rep.se_rp.wins_name[k].name, q->rep.se_rp.wins_name[k].type, - (int)q->rep.se_rp.wins_name[k].id)); - - safe_strcpy(record.name, q->rep.se_rp.wins_name[k].name, 16); - record.type=q->rep.se_rp.wins_name[k].type; - record.id=q->rep.se_rp.wins_name[k].id; - record.wins_flags=q->rep.se_rp.wins_name[k].name_flag&0x00ff; - record.num_ips=q->rep.se_rp.wins_name[k].num_ip; - - record.wins_ip.s_addr=server.s_addr; - - if (record.num_ips==1) - record.ip[0]=q->rep.se_rp.wins_name[k].owner; - else - for (i=0; irep.se_rp.wins_name[k].others[i]; - - record.nb_flags=0; - - if (record.wins_flags&WINS_NGROUP || record.wins_flags&WINS_SGROUP) - record.nb_flags|=NB_GROUP; - - if (record.wins_flags&WINS_ACTIVE) - record.nb_flags|=NB_ACTIVE; - - record.nb_flags|=record.wins_flags&WINS_HNODE; - - message_send_pid(pid, MSG_WINS_NEW_ENTRY, &record, sizeof(record), False); - - } - - dump_global_table(); - - /* - * we got some entries, - * ask the partner to send us the map table again - * to get the other servers entries. - * - * we're getting the map table 1 time more than really - * required. We could remove that call, but that - * would complexify the code. I prefer this trade-of. - */ - fill_header(r, OPCODE_NON_NBT, s_ctx, MESSAGE_TYPE_REPLICATE); - - r->rep.msg_type=MESSAGE_REP_ADD_VERSION_REQUEST; -} - -/**************************************************************************** -decode the replication message and reply. -****************************************************************************/ -static void replicate(GENERIC_PACKET *q, GENERIC_PACKET *r) -{ - switch (q->rep.msg_type) { - case 0: - /* add version number map table request */ - send_version_number_map_table(q, r); - break; - case 1: - receive_version_number_map_table(q, r); - break; - case 2: - /* send entry request */ - send_entry_request(q, r); - break; - case 3: - /* send entry reply */ - send_entry_reply(q, r); - break; - case 4: - /* update notification request */ - update_notify_request(q, r); - break; - } -} - -/**************************************************************************** -do a switch on the message type, and return the response size -****************************************************************************/ -static BOOL switch_message(GENERIC_PACKET *q, GENERIC_PACKET *r) -{ - switch (q->header.mess_type) { - case 0: - /* Start association type */ - start_assoc_process(q, r); - return True; - break; - case 1: - /* start association reply */ - start_assoc_reply(q, r); - return True; - break; - case 2: - /* stop association message */ - return False; - break; - case 3: - /* replication message */ - replicate(q, r); - return True; - break; - } - - return False; -} - - -/**************************************************************************** - construct a reply to the incoming packet -****************************************************************************/ -void construct_reply(struct wins_packet_struct *p) -{ - GENERIC_PACKET r; - struct BUFFER buffer; - - buffer.buffer=NULL; - buffer.offset=0; - buffer.length=0; - - DEBUG(5,("dump: received packet\n")); - dump_generic_packet(p->packet); - - /* Verify if the request we got is from a listed partner */ - if (!check_partner(p->packet->header.assoc_ctx)) { - fstring peer; - struct in_addr addr; - int i; - fstrcpy(peer,get_peer_addr(p->fd)); - addr=*interpret_addr2(peer); - - for (i=1; ipacket, &r, STOP_REASON_AUTH_FAILED); - p->stop_packet=True; - encode_generic_packet(&buffer, &r); - if (!send_smb(p->fd, buffer.buffer)) - exit_server("process_smb: send_smb failed."); - return; - } - } - - if (switch_message(p->packet, &r)) { - encode_generic_packet(&buffer, &r); - DEBUG(5,("dump: sending packet\n")); - dump_generic_packet(&r); - - if(buffer.offset > 0) { - if (!send_smb(p->fd, buffer.buffer)) - exit_server("process_smb: send_smb failed."); - } - } - - /* if we got a stop assoc or if we send a stop assoc, close the fd after */ - if (p->packet->header.mess_type==MESSAGE_TYPE_STOP_ASSOC || - r.header.mess_type==MESSAGE_TYPE_STOP_ASSOC) { - remove_partner(p->packet->header.assoc_ctx); - p->stop_packet=True; - } -} - -/**************************************************************************** - contact periodically our wins partner to do a pull replication -****************************************************************************/ -void run_pull_replication(time_t t) -{ - /* we pull every 30 minutes to query about new records*/ - int i, s; - struct BUFFER buffer; - GENERIC_PACKET p; - - buffer.buffer=NULL; - buffer.offset=0; - buffer.length=0; - - for (i=1; i 0) { - if (!send_smb(s, buffer.buffer)) - exit_server("run_pull_replication: send_smb failed."); - } - - add_fd_to_sock_array(s); - FD_SET(s, listen_set); - - /* add ourself as a client */ - add_partner((int)t, 0, True, False); - } - } -} - -/**************************************************************************** - contact periodically our wins partner to do a push replication -****************************************************************************/ -void run_push_replication(time_t t) -{ - /* we push every 30 minutes or 25 new entries */ - int i, s; - struct BUFFER buffer; - GENERIC_PACKET p; - - buffer.buffer=NULL; - buffer.offset=0; - buffer.length=0; - - for (i=1; i 0) { - if (!send_smb(s, buffer.buffer)) - exit_server("run_push_replication: send_smb failed."); - } - - add_fd_to_sock_array(s); - FD_SET(s, listen_set); - - /* add ourself as a client */ - add_partner((int)t, 0, False, True); - } - } -} - diff --git a/source3/wrepld/server.c b/source3/wrepld/server.c deleted file mode 100644 index 754bad01b0..0000000000 --- a/source3/wrepld/server.c +++ /dev/null @@ -1,670 +0,0 @@ -/* - Unix SMB/CIFS implementation. - Main SMB server routines - Copyright (C) Jean François Micouleau 1998-2002. - - 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 "includes.h" -#include "wins_repl.h" - -extern pstring user_socket_options; - -extern WINS_OWNER *global_wins_table; -extern int partner_count; - -extern fd_set *listen_set; -extern int listen_number; -extern int *sock_array; - -extern TALLOC_CTX *mem_ctx; - -int wins_port = 42; - -/**************************************************************************** - when exiting, take the whole family -****************************************************************************/ -static void *dflt_sig(void) -{ - exit_server("caught signal"); - return NULL; -} - -/**************************************************************************** - reload the services file - **************************************************************************/ -BOOL reload_services(BOOL test) -{ - BOOL ret; - - if (lp_loaded()) { - pstring fname; - pstrcpy(fname,lp_configfile()); - if (file_exist(fname,NULL) && !strcsequal(fname,dyn_CONFIGFILE)) { - pstrcpy(dyn_CONFIGFILE,fname); - test = False; - } - } - - reopen_logs(); - - if (test && !lp_file_list_changed()) - return(True); - - ret = lp_load(dyn_CONFIGFILE,False,False,True,True); - - - /* perhaps the config filename is now set */ - if (!test) - reload_services(True); - - reopen_logs(); - - load_interfaces(); - - return(ret); -} - -/**************************************************************************** - Catch a sighup. -****************************************************************************/ - -VOLATILE sig_atomic_t reload_after_sighup = False; - -static void sig_hup(int sig) -{ - BlockSignals(True,SIGHUP); - DEBUG(0,("Got SIGHUP\n")); - - sys_select_signal(SIGHUP); - reload_after_sighup = True; - BlockSignals(False,SIGHUP); -} - -#if DUMP_CORE -/******************************************************************* -prepare to dump a core file - carefully! -********************************************************************/ -static BOOL dump_core(void) -{ - char *p; - pstring dname; - pstrcpy(dname,lp_logfile()); - if ((p=strrchr_m(dname,'/'))) *p=0; - pstrcat(dname,"/corefiles"); - mkdir(dname,0700); - sys_chown(dname,getuid(),getgid()); - chmod(dname,0700); - if (chdir(dname)) return(False); - umask(~(0700)); - -#ifdef HAVE_GETRLIMIT -#ifdef RLIMIT_CORE - { - struct rlimit rlp; - getrlimit(RLIMIT_CORE, &rlp); - rlp.rlim_cur = MAX(4*1024*1024,rlp.rlim_cur); - setrlimit(RLIMIT_CORE, &rlp); - getrlimit(RLIMIT_CORE, &rlp); - DEBUG(3,("Core limits now %d %d\n", - (int)rlp.rlim_cur,(int)rlp.rlim_max)); - } -#endif -#endif - - - DEBUG(0,("Dumping core in %s\n",dname)); - abort(); - return(True); -} -#endif - -/**************************************************************************** -exit the server -****************************************************************************/ -void exit_server(const char *reason) -{ - static int firsttime=1; - - if (!firsttime) - exit(0); - firsttime = 0; - - DEBUG(2,("Closing connections\n")); - - if (!reason) { - int oldlevel = DEBUGLEVEL; - DEBUGLEVEL = 10; - DEBUGLEVEL = oldlevel; - DEBUG(0,("===============================================================\n")); -#if DUMP_CORE - if (dump_core()) return; -#endif - } - - DEBUG(3,("Server exit (%s)\n", (reason ? reason : ""))); - exit(0); -} - -/**************************************************************************** - Create an fd_set containing all the sockets in the subnet structures, - plus the broadcast sockets. -***************************************************************************/ - -static BOOL create_listen_fdset( int *maxfd) -{ - int i; - int num_interfaces = iface_count(); - int s; - - listen_set = (fd_set *)malloc(sizeof(fd_set)); - if(listen_set == NULL) { - DEBUG(0,("create_listen_fdset: malloc fail !\n")); - return True; - } - -#ifdef HAVE_ATEXIT - { - static int atexit_set; - if(atexit_set == 0) { - atexit_set=1; - } - } -#endif - - FD_ZERO(listen_set); - - if(lp_interfaces() && lp_bind_interfaces_only()) { - /* We have been given an interfaces line, and been - told to only bind to those interfaces. Create a - socket per interface and bind to only these. - */ - - if(num_interfaces > FD_SETSIZE) { - DEBUG(0,("create_listen_fdset: Too many interfaces specified to bind to. Number was %d max can be %d\n", num_interfaces, FD_SETSIZE)); - return False; - } - - /* Now open a listen socket for each of the interfaces. */ - for(i = 0; i < num_interfaces; i++) { - struct in_addr *ifip = iface_n_ip(i); - - if(ifip == NULL) { - DEBUG(0,("create_listen_fdset: interface %d has NULL IP address !\n", i)); - continue; - } - s = open_socket_in(SOCK_STREAM, wins_port, 0, ifip->s_addr, True); - if(s == -1) - return False; - - /* ready to listen */ - set_socket_options(s,"SO_KEEPALIVE"); - set_socket_options(s,user_socket_options); - - if (listen(s, 5) == -1) { - DEBUG(5,("listen: %s\n",strerror(errno))); - close(s); - return False; - } - add_fd_to_sock_array(s); - FD_SET(s, listen_set); - *maxfd = MAX( *maxfd, s); - } - } else { - /* Just bind to 0.0.0.0 - accept connections from anywhere. */ - num_interfaces = 1; - - /* open an incoming socket */ - s = open_socket_in(SOCK_STREAM, wins_port, 0, interpret_addr(lp_socket_address()),True); - if (s == -1) - return(False); - - /* ready to listen */ - set_socket_options(s,"SO_KEEPALIVE"); - set_socket_options(s,user_socket_options); - - if (listen(s, 5) == -1) { - DEBUG(0,("create_listen_fdset: listen: %s\n", strerror(errno))); - close(s); - return False; - } - - add_fd_to_sock_array(s); - FD_SET(s, listen_set); - *maxfd = MAX( *maxfd, s); - } - - return True; -} - -/******************************************************************* - read a packet from a socket and parse it, returning a packet ready - to be used or put on the queue. This assumes a UDP socket - ******************************************************************/ -static struct wins_packet_struct *read_wins_packet(int fd, int timeout) -{ - struct wins_packet_struct *p; - GENERIC_PACKET *q; - struct BUFFER inbuf; - ssize_t len=0; - size_t total=0; - ssize_t ret; - BOOL ok = False; - - inbuf.buffer=NULL; - inbuf.length=0; - inbuf.offset=0; - - if(!grow_buffer(&inbuf, 4)) - return NULL; - - ok = (read(fd, inbuf.buffer,4) == 4); - if (!ok) - return NULL; - len = smb_len(inbuf.buffer); - - if (len<=0) - return NULL; - - if(!grow_buffer(&inbuf, len)) - return NULL; - - while (total < len) { - ret = read(fd, inbuf.buffer + total + 4, len - total); - if (ret == 0) { - DEBUG(10,("read_socket_data: recv of %d returned 0. Error = %s\n", (int)(len - total), strerror(errno) )); - return NULL; - } - if (ret == -1) { - DEBUG(0,("read_socket_data: recv failure for %d. Error = %s\n", (int)(len - total), strerror(errno) )); - return NULL; - } - total += ret; - } - - q = talloc(mem_ctx, GENERIC_PACKET); - p = talloc(mem_ctx, struct wins_packet_struct); - if (q==NULL || p==NULL) - return NULL; - - decode_generic_packet(&inbuf, q); - - q->fd=fd; - - p->next = NULL; - p->prev = NULL; - p->stop_packet = False; - p->timestamp = time(NULL); - p->fd = fd; - p->packet=q; - - return p; -} - -static struct wins_packet_struct *packet_queue = NULL; - -/******************************************************************* - Queue a packet into a packet queue -******************************************************************/ -static void queue_packet(struct wins_packet_struct *packet) -{ - struct wins_packet_struct *p; - - if (!packet_queue) { - packet->prev = NULL; - packet->next = NULL; - packet_queue = packet; - return; - } - - /* find the bottom */ - for (p=packet_queue;p->next;p=p->next) - ; - - p->next = packet; - packet->next = NULL; - packet->prev = p; -} - -/**************************************************************************** - Listens for NMB or DGRAM packets, and queues them. - return True if the socket is dead -***************************************************************************/ -static BOOL listen_for_wins_packets(void) -{ - int num_interfaces = iface_count(); - fd_set fds; - int i, num, s, new_s; - static int maxfd = 0; - struct timeval timeout; - - if(listen_set == NULL) { - if(!create_listen_fdset( &maxfd)) { - DEBUG(0,("listen_for_packets: Fatal error. unable to create listen set. Exiting.\n")); - return True; - } - } - - memcpy((char *)&fds, (char *)listen_set, sizeof(fd_set)); - - timeout.tv_sec = NMBD_SELECT_LOOP; - timeout.tv_usec = 0; - - /* Prepare for the select - allow certain signals. */ - - BlockSignals(False, SIGTERM); - - num = sys_select(maxfd+1, &fds, NULL, NULL, &timeout); - - /* We can only take signals when we are in the select - block them again here. */ - - BlockSignals(True, SIGTERM); - - if(num == -1) - return False; - - for (; num > 0; num--) { - s = -1; - /* check the sockets we are only listening on, waiting to accept */ - for (i=0; ifd = sock_array[i]; - queue_packet(packet); - } - DEBUG(2,("listen_for_wins_packets: some data on fd %d\n", sock_array[i])); - FD_CLR(sock_array[i], &fds); - break; - } - - } - - } - - return False; -} - - -/******************************************************************* - Run elements off the packet queue till its empty -******************************************************************/ - -static void run_wins_packet_queue(void) -{ - struct wins_packet_struct *p; - - while ((p = packet_queue)) { - packet_queue = p->next; - if (packet_queue) - packet_queue->prev = NULL; - p->next = p->prev = NULL; - - construct_reply(p); - - /* if it was a stop assoc, close the connection */ - if (p->stop_packet) { - FD_CLR(p->fd, listen_set); - remove_fd_from_sock_array(p->fd); - close(p->fd); - } - } -} - -/**************************************************************************** ** - The main select loop. - **************************************************************************** */ -static void process(void) -{ - - while( True ) { - time_t t = time(NULL); - - /* check for internal messages */ - message_dispatch(); - - if(listen_for_wins_packets()) - return; - - run_wins_packet_queue(); - - run_pull_replication(t); - - run_push_replication(t); - - /* - * Reload the services file if we got a sighup. - */ - - if(reload_after_sighup) { - reload_services( True ); - reopen_logs(); - reload_after_sighup = False; - } - - /* free temp memory */ - talloc_free_children(mem_ctx); - - /* free up temp memory */ - lp_talloc_free(); - } -} /* process */ - -/**************************************************************************** - main program -****************************************************************************/ - int main(int argc,char *argv[]) -{ - /* shall I run as a daemon */ - static BOOL is_daemon = False; - static BOOL interactive = False; - static BOOL Fork = True; - static BOOL log_stdout = False; - struct poptOption long_options[] = { - POPT_AUTOHELP - { "daemon", 'D', POPT_ARG_VAL, &is_daemon, True, "Become a daemon (default)" }, - { "foreground", 'F', POPT_ARG_VAL, &Fork, False, "Run daemon in foreground (for daemontools, etc)" }, - { "stdout", 'S', POPT_ARG_VAL, &log_stdout, True, "Log to stdout" }, - { "interactive", 'i', POPT_ARG_NONE, NULL, 'i', "Run interactive (not a daemon)" }, - { "port", 'p', POPT_ARG_INT, &wins_port, 'p', "Listen on the specified port" }, - POPT_COMMON_SAMBA - POPT_TABLEEND - }; - int opt; - poptContext pc; - -#ifdef HAVE_SET_AUTH_PARAMETERS - set_auth_parameters(argc,argv); -#endif - - pc = poptGetContext("wrepld", argc, (const char **)argv, long_options, - POPT_CONTEXT_KEEP_FIRST); - - while ((opt = poptGetNextOpt(pc)) != -1) { - switch (opt) { - case 'i': - interactive = True; - Fork = False; - log_stdout = True; - break; - } - } - - - if (log_stdout && Fork) { - d_printf("Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"); - poptPrintUsage(pc, stderr, 0); - exit(1); - } - -#ifdef HAVE_SETLUID - /* needed for SecureWare on SCO */ - setluid(0); -#endif - - sec_init(); - - load_case_tables(); - - set_remote_machine_name("wrepld", False); - - setup_logging(argv[0],log_stdout); - - /* we want to re-seed early to prevent time delays causing - client problems at a later date. (tridge) */ - generate_random_buffer(NULL, 0); - - /* make absolutely sure we run as root - to handle cases where people - are crazy enough to have it setuid */ - - gain_root_privilege(); - gain_root_group_privilege(); - - fault_setup((void (*)(void *))exit_server); - CatchSignal(SIGTERM , SIGNAL_CAST dflt_sig); - - /* we are never interested in SIGPIPE */ - BlockSignals(True,SIGPIPE); - -#if defined(SIGFPE) - /* we are never interested in SIGFPE */ - BlockSignals(True,SIGFPE); -#endif - -#if defined(SIGUSR2) - /* We are no longer interested in USR2 */ - BlockSignals(True,SIGUSR2); -#endif - - /* POSIX demands that signals are inherited. If the invoking process has - * these signals masked, we will have problems, as we won't recieve them. */ - BlockSignals(False, SIGHUP); - BlockSignals(False, SIGUSR1); - - /* we want total control over the permissions on created files, - so set our umask to 0 */ - umask(0); - - reopen_logs(); - - DEBUG(0,( "wrepld version %s started.\n", SAMBA_VERSION_STRING)); - DEBUGADD( 0, ( "%s\n", COPYRIGHT_STARTUP_MESSAGE ) ); - - DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n", - (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid())); - - if (sizeof(uint16) < 2 || sizeof(uint32) < 4) { - DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n")); - exit(1); - } - - /* - * Do this before reload_services. - */ - - if (!reload_services(False)) - return(-1); - - if (!init_names()) - return -1; - -#ifdef WITH_PROFILE - if (!profile_setup(False)) { - DEBUG(0,("ERROR: failed to setup profiling\n")); - return -1; - } -#endif - - CatchSignal(SIGHUP,SIGNAL_CAST sig_hup); - - DEBUG(3,( "loaded services\n")); - - if (!is_daemon && !is_a_socket(0)) { - DEBUG(0,("standard input is not a socket, assuming -D option\n")); - is_daemon = True; - } - - if (is_daemon && !interactive) { - DEBUG( 3, ( "Becoming a daemon.\n" ) ); - become_daemon(Fork); - } - -#if HAVE_SETPGID - /* - * If we're interactive we want to set our own process group for - * signal management. - */ - if (interactive) - setpgid( (pid_t)0, (pid_t)0); -#endif - - if (!directory_exist(lp_lockdir(), NULL)) { - mkdir(lp_lockdir(), 0755); - } - - if (is_daemon) { - pidfile_create("wrepld"); - } - - if (!message_init()) { - exit(1); - } - - /* Initialise the memory context */ - mem_ctx=talloc_init("wins repl talloc ctx"); - - /* initialise the global partners table */ - partner_count=init_wins_partner_table(); - - /* We can only take signals in the select. */ - BlockSignals( True, SIGTERM ); - - process(); - - poptFreeContext(pc); - exit_server("normal exit"); - return(0); -} diff --git a/source3/wrepld/socket.c b/source3/wrepld/socket.c deleted file mode 100644 index 3d759f0ab8..0000000000 --- a/source3/wrepld/socket.c +++ /dev/null @@ -1,69 +0,0 @@ -/* - Unix SMB/CIFS implementation. - process incoming packets - main loop - Copyright (C) Jean François Micouleau 1998-2002. - - 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 "includes.h" -#include "wins_repl.h" - -fd_set *listen_set = NULL; -int listen_number = 0; -int *sock_array = NULL; - -/******************************************************************* - Add an fd from the sock_array -******************************************************************/ -void add_fd_to_sock_array(int fd) -{ - int *temp_sock=NULL; - - temp_sock=(int *)Realloc(sock_array, (listen_number+1)*sizeof(int)); - if (temp_sock==NULL) - return; - - sock_array=temp_sock; - sock_array[listen_number]=fd; - listen_number++; -} - - -/******************************************************************* - Remove an fd from the sock_array -******************************************************************/ -void remove_fd_from_sock_array(int fd) -{ - int i,j; - - for (i=0; sock_array[i]!=fd && i