with gcc. (Not a big change although it looks like it :-).
Jeremy.
extern int max_xmit;
static int interpret_long_filename(int level,char *p,file_info *finfo);
-static void dir_action(char *inbuf,char *outbuf,int attribute,file_info *finfo,BOOL recurse_dir,void (*fn)(),BOOL longdir, BOOL dirstoo);
+static void dir_action(char *inbuf,char *outbuf,int attribute,file_info *finfo,BOOL recurse_dir,void (*fn)(file_info *),BOOL longdir, BOOL dirstoo);
static int interpret_short_filename(char *p,file_info *finfo);
static BOOL do_this_one(file_info *finfo);
/****************************************************************************
show cd/pwd
****************************************************************************/
-static void cmd_pwd(void)
+static void cmd_pwd(char *dum_in, char *dum_out)
{
DEBUG(0,("Current directory is %s",CNV_LANG(service)));
DEBUG(0,("%s\n",CNV_LANG(cur_dir)));
do a directory listing, calling fn on each file found. Use the TRANSACT2
call for long filenames
****************************************************************************/
-static int do_long_dir(char *inbuf,char *outbuf,char *Mask,int attribute,void (*fn)(),BOOL recurse_dir, BOOL dirstoo)
+static int do_long_dir(char *inbuf,char *outbuf,char *Mask,int attribute,void (*fn)(file_info *),BOOL recurse_dir, BOOL dirstoo)
{
int max_matches = 512;
int info_level = Protocol<PROTOCOL_NT1?1:260; /* NT uses 260, OS/2 uses 2. Both accept 1. */
/****************************************************************************
do a directory listing, calling fn on each file found
****************************************************************************/
-static int do_short_dir(char *inbuf,char *outbuf,char *Mask,int attribute,void (*fn)(),BOOL recurse_dir, BOOL dirstoo)
+static int do_short_dir(char *inbuf,char *outbuf,char *Mask,int attribute,void (*fn)(file_info *),BOOL recurse_dir, BOOL dirstoo)
{
char *p;
int received = 0;
/****************************************************************************
do a directory listing, calling fn on each file found
****************************************************************************/
-void do_dir(char *inbuf,char *outbuf,char *Mask,int attribute,void (*fn)(),BOOL recurse_dir, BOOL dirstoo)
+void do_dir(char *inbuf,char *outbuf,char *Mask,int attribute,void (*fn)(file_info *),BOOL recurse_dir, BOOL dirstoo)
{
DEBUG(5,("do_dir(%s,%x,%s)\n",Mask,attribute,BOOLSTR(recurse_dir)));
if (Protocol >= PROTOCOL_LANMAN2)
RJS, 4-Apr-1998, dirstoo added to allow caller to indicate that directories
should be processed as well.
****************************************************************************/
-static void dir_action(char *inbuf,char *outbuf,int attribute,file_info *finfo,BOOL recurse_dir,void (*fn)(),BOOL longdir, BOOL dirstoo)
+static void dir_action(char *inbuf,char *outbuf,int attribute,file_info *finfo,BOOL recurse_dir,void (*fn)(file_info *),BOOL longdir, BOOL dirstoo)
{
if (!((finfo->mode & aDIR) == 0 && *fileselection &&
/****************************************************************************
get a file
****************************************************************************/
-static void cmd_get(void)
+static void cmd_get(char *dum_in, char *dum_out)
{
pstring lname;
pstring rname;
/****************************************************************************
view the file using the pager
****************************************************************************/
-static void cmd_more(void)
+static void cmd_more(char *dum_in, char *dum_out)
{
fstring rname,lname,tmpname,pager_cmd;
char *pager;
/****************************************************************************
put a file
****************************************************************************/
-static void cmd_put(void)
+static void cmd_put(char *dum_in, char *dum_out)
{
pstring lname;
pstring rname;
/****************************************************************************
set the file selection mask
****************************************************************************/
-static void cmd_select(void)
+static void cmd_select(char *dum_in, char *dum_out)
{
strcpy(fileselection,"");
next_token(NULL,fileselection,NULL);
/****************************************************************************
mput some files
****************************************************************************/
-static void cmd_mput(void)
+static void cmd_mput(char *dum_in, char *dum_out)
{
pstring lname;
pstring rname;
/****************************************************************************
toggle the prompt flag
****************************************************************************/
-static void cmd_prompt(void)
+static void cmd_prompt(char *dum_in, char *dum_out)
{
prompt = !prompt;
DEBUG(2,("prompting is now %s\n",prompt?"on":"off"));
/****************************************************************************
set the newer than time
****************************************************************************/
-static void cmd_newer(void)
+static void cmd_newer(char *dum_in, char *dum_out)
{
fstring buf;
BOOL ok;
/****************************************************************************
set the archive level
****************************************************************************/
-static void cmd_archive(void)
+static void cmd_archive(char *dum_in, char *dum_out)
{
fstring buf;
/****************************************************************************
toggle the lowercaseflag
****************************************************************************/
-static void cmd_lowercase(void)
+static void cmd_lowercase(char *dum_in, char *dum_out)
{
lowercase = !lowercase;
DEBUG(2,("filename lowercasing is now %s\n",lowercase?"on":"off"));
/****************************************************************************
toggle the recurse flag
****************************************************************************/
-static void cmd_recurse(void)
+static void cmd_recurse(char *dum_in, char *dum_out)
{
recurse = !recurse;
DEBUG(2,("directory recursion is now %s\n",recurse?"on":"off"));
/****************************************************************************
toggle the translate flag
****************************************************************************/
-static void cmd_translate(void)
+static void cmd_translate(char *dum_in, char *dum_out)
{
translation = !translation;
DEBUG(2,("CR/LF<->LF and print text translation now %s\n",
/****************************************************************************
do a printmode command
****************************************************************************/
-static void cmd_printmode(void)
+static void cmd_printmode(char *dum_in, char *dum_out)
{
fstring buf;
fstring mode;
/****************************************************************************
do the lcd command
****************************************************************************/
-static void cmd_lcd(void)
+static void cmd_lcd(char *dum_in, char *dum_out)
{
fstring buf;
pstring d;
#define strcasecmp StrCaseCmp
#endif /* NOSTRCASECMP */
- extern int strcasecmp();
-
char *rparam = NULL;
char *rdata = NULL;
char *p;
/****************************************************************************
get some server info
****************************************************************************/
-static void server_info()
+static void server_info(void)
{
char *rparam = NULL;
char *rdata = NULL;
struct
{
char *name;
- void (*fn)();
+ void (*fn)(char *, char *);
char *description;
} commands[] =
{
/****************************************************************************
help
****************************************************************************/
-void cmd_help(void)
+void cmd_help(char *dum_in, char *dum_out)
{
int i=0,j;
fstring buf;
DEBUG(0,("%s: command not found\n",CNV_LANG(tok)));
}
- cli_send_logout();
+ cli_send_logout(InBuffer,OutBuffer);
return(True);
}
ret=process_tar(InBuffer, OutBuffer);
- cli_send_logout();
+ cli_send_logout(InBuffer, OutBuffer);
close_sockets();
return(ret);
} else
list_servers(workgroup);
}
- cli_send_logout();
+ cli_send_logout(NULL,NULL);
close_sockets();
}
/****************************************************************************
send a logout command
****************************************************************************/
-void cli_send_logout(void )
+void cli_send_logout(char *dum_in, char *dum_out)
{
pstring inbuf,outbuf;
static void writetarheader(int f, char *aname, int size, time_t mtime,
char *amode, unsigned char ftype);
-static void do_atar();
-static void do_tar();
-static void oct_it();
-static void fixtarname();
-static int dotarbuf();
-static void dozerobuf();
-static void dotareof();
-static void initarbuf();
-static int do_setrattr();
-
-/* restore functions */
-static long readtarheader();
-static long unoct();
-static void do_tarput();
-static void unfixtarname();
+
+/* Forward references. */
+static void fixtarname(char *tptr, char *fp, int l);
+static int dotarbuf(int f, char *b, int n);
+static void oct_it (long value, int ndgs, char *p);
+static long unoct(char *p, int ndgs);
+static void unfixtarname(char *tptr, char *fp, int l);
/*
* tar specific utitlities
/****************************************************************************
Malloc tape buffer
****************************************************************************/
-static void initarbuf()
+static void initarbuf(void)
{
/* initialize tar buffer */
tbufsiz=blocksize*TBLOCK;
/****************************************************************************
Convert from decimal to octal string
****************************************************************************/
-static void oct_it (register long value, register int ndgs, register char *p)
+static void oct_it (long value, int ndgs, char *p)
{
/* Converts long to octal string, pads with leading zeros */
}
}
-/****************************************************************************
-Move to the next block in the buffer, which may mean read in another set of
-blocks.
-****************************************************************************/
-int next_block(char *tarbuf, char *bufferp, int bufsiz)
-{
- int bufread, total = 0;
-
- for (bufread = read(tarhandle, tarbuf, bufsiz); total += bufread; total < bufsiz) {
-
- }
-
-}
-
-static void do_tarput()
+static void do_tarput(void)
{
file_info finfo;
int nread=0, bufread;
/****************************************************************************
Blocksize command
***************************************************************************/
-void cmd_block(void)
+void cmd_block(char *dum_in, char *dum_out)
{
fstring buf;
int block;
/****************************************************************************
command to set incremental / reset mode
***************************************************************************/
-void cmd_tarmode(void)
+void cmd_tarmode(char *dum_in, char *dum_out)
{
fstring buf;
/****************************************************************************
Feeble attrib command
***************************************************************************/
-void cmd_setmode(void)
+void cmd_setmode(char *dum_in, char *dum_out)
{
char *q;
fstring buf;
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <termios.h>
+#include <fcntl.h>
#if __FreeBSD__ >= 3
#include <dirent.h>
#else
#define USE_DIRECT
#endif
-#define SIGNAL_CAST (void (*)())
+#define SIGNAL_CAST (void (*)(int))
#define USE_SETVBUF
#define USE_SETSID
#define USE_GETCWD
#define HAVE_GETTIMEOFDAY
#define HAVE_PATHCONF
#define HAVE_GETGRNAM 1
-#endif
+#define QSORT_CAST (int (*)(const void *, const void *))
+#if !defined(O_SYNC)
+#if defined(O_FSYNC)
+#define O_SYNC O_FSYNC
+#else /* defined(O_FSYNC) */
+#define O_SYNC 0
+#endif /* defined(O_FSYNC) */
+#endif /* !defined(O_SYNC) */
+#endif /* FreeBSD */
#ifdef __OpenBSD__
#include <strings.h>
/*The following definitions come from asyncdns.c */
int asyncdns_fd(void);
-void kill_async_dns_child();
+void kill_async_dns_child(void);
void start_async_dns(void);
void run_dns_queue(void);
BOOL queue_dns_query(struct packet_struct *p,struct nmb_name *question,
struct name_record **n);
BOOL queue_dns_query(struct packet_struct *p,struct nmb_name *question,
struct name_record **n);
-void kill_async_dns_child();
+void kill_async_dns_child(void);
/*The following definitions come from charcnv.c */
/*The following definitions come from client.c */
void cli_smb_close(char *inbuf, char *outbuf, int clnt_fd, int c_num, int f_num);
-void do_dir(char *inbuf,char *outbuf,char *Mask,int attribute,void (*fn)(),BOOL recurse_dir,BOOL dirstoo);
-void cmd_help(void);
+void do_dir(char *inbuf,char *outbuf,char *Mask,int attribute,void (*fn)(file_info *),BOOL recurse_dir, BOOL dirstoo);
+void cmd_help(char *dum_in, char *dum_out);
/*The following definitions come from clientgen.c */
int mdata,int mparam,int msetup);
BOOL cli_send_session_request(char *inbuf,char *outbuf);
BOOL cli_send_login(char *inbuf,char *outbuf,BOOL start_session,BOOL use_setup, struct connection_options *options);
-void cli_send_logout(void );
+void cli_send_logout(char *dum_in, char *dum_out);
BOOL cli_open_sockets(int port );
BOOL cli_reopen_connection(char *inbuf,char *outbuf);
/*The following definitions come from clitar.c */
int padit(char *buf, int bufsize, int padsize);
-void cmd_block(void);
-void cmd_tarmode(void);
-void cmd_setmode(void);
+void cmd_block(char *dum_in, char *dum_out);
+void cmd_tarmode(char *dum_in, char *dum_out);
+void cmd_setmode(char *dum_in, char *dum_out);
void cmd_tar(char *inbuf, char *outbuf);
int process_tar(char *inbuf, char *outbuf);
int clipfind(char **aret, int ret, char *tok);
/*The following definitions come from fault.c */
-void fault_setup(void (*fn)());
+void fault_setup(void (*fn)(void *));
/*The following definitions come from getsmbpass.c */
BOOL ismybcast(struct in_addr bcast);
BOOL is_local_net(struct in_addr from);
int iface_count(void);
-BOOL we_are_multihomed();
+BOOL we_are_multihomed(void);
struct interface *get_interface(int n);
struct in_addr *iface_n_ip(int n);
struct in_addr *iface_bcast(struct in_addr ip);
/*The following definitions come from message.c */
-int reply_sends(char *inbuf,char *outbuf);
-int reply_sendstrt(char *inbuf,char *outbuf);
-int reply_sendtxt(char *inbuf,char *outbuf);
-int reply_sendend(char *inbuf,char *outbuf);
+int reply_sends(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_sendstrt(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_sendtxt(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_sendend(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
/*The following definitions come from namequery.c */
BOOL name_status(int fd,char *name,int name_type,BOOL recurse,
struct in_addr to_ip,char *master,char *rname,
- void (*fn)());
-struct in_addr *name_query(int fd,char *name,int name_type,
- BOOL bcast,BOOL recurse,
- struct in_addr to_ip, int *count, void (*fn)());
+ void (*fn)(struct packet_struct *));
+struct in_addr *name_query(int fd,char *name,int name_type, BOOL bcast,BOOL recurse,
+ struct in_addr to_ip, int *count, void (*fn)(struct packet_struct *));
FILE *startlmhosts(char *fname);
BOOL getlmhostsent( FILE *fp, char *name, int *name_type, struct in_addr *ipaddr);
void endlmhosts(FILE *fp);
/*The following definitions come from nmbd_mynames.c */
-BOOL register_my_workgroup_and_names();
-void release_my_names();
+BOOL register_my_workgroup_and_names(void);
+void release_my_names(void);
void refresh_my_names(time_t t);
/*The following definitions come from nmbd_namelistdb.c */
void expire_names_on_subnet(struct subnet_record *subrec, time_t t);
void expire_names(time_t t);
void add_samba_names_to_subnet(struct subnet_record *subrec);
-void dump_all_namelists();
+void dump_all_namelists(void);
/*The following definitions come from nmbd_namequery.c */
void process_lanman_packet(struct packet_struct *p, char *buf,int len);
BOOL validate_nmb_response_packet( struct nmb_packet *nmb );
BOOL validate_nmb_packet( struct nmb_packet *nmb );
-void run_packet_queue();
+void run_packet_queue(void);
void retransmit_or_expire_response_records(time_t t);
BOOL listen_for_packets(BOOL run_election);
BOOL send_mailslot(BOOL unique, char *mailslot,char *buf,int len,
void broadcast_announce_request(struct subnet_record *subrec, struct work_record *work);
void announce_my_server_names(time_t t);
void announce_my_lm_server_names(time_t t);
-void reset_announce_timer();
+void reset_announce_timer(void);
void announce_myself_to_domain_master_browser(time_t t);
void announce_my_servers_removed(void);
void announce_remote(time_t t);
/*The following definitions come from nmbd_subnetdb.c */
-BOOL create_subnets();
-BOOL we_are_a_wins_client();
+BOOL create_subnets(void);
+BOOL we_are_a_wins_client(void);
struct subnet_record *get_next_subnet_maybe_unicast(struct subnet_record *subrec);
struct subnet_record *get_next_subnet_maybe_unicast_or_wins_server(struct subnet_record *subrec);
/*The following definitions come from pcap.c */
BOOL pcap_printername_ok(char *pszPrintername, char *pszPrintcapname);
-void pcap_printer_fn(void (*fn)());
+void pcap_printer_fn(void (*fn)(char *, char *));
/*The following definitions come from pidfile.c */
/*The following definitions come from predict.c */
int read_predict(int fd,int offset,char *buf,char **ptr,int num);
-void do_read_prediction();
+void do_read_prediction(void);
void invalidate_read_prediction(int fd);
/*The following definitions come from print_svid.c */
-void sysv_printer_fn(void (*fn)());
+void sysv_printer_fn(void (*fn)(char *, char *));
int sysv_printername_ok(char *name);
/*The following definitions come from printing.c */
/*The following definitions come from reply.c */
int reply_special(char *inbuf,char *outbuf);
-int reply_tcon(char *inbuf,char *outbuf);
+int reply_tcon(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
int reply_tcon_and_X(char *inbuf,char *outbuf,int length,int bufsize);
int reply_unknown(char *inbuf,char *outbuf);
-int reply_ioctl(char *inbuf,char *outbuf);
+int reply_ioctl(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
int reply_sesssetup_and_X(char *inbuf,char *outbuf,int length,int bufsize);
-int reply_chkpth(char *inbuf,char *outbuf);
-int reply_getatr(char *inbuf,char *outbuf);
-int reply_setatr(char *inbuf,char *outbuf);
-int reply_dskattr(char *inbuf,char *outbuf);
-int reply_search(char *inbuf,char *outbuf);
-int reply_fclose(char *inbuf,char *outbuf);
-int reply_open(char *inbuf,char *outbuf);
+int reply_chkpth(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_getatr(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_setatr(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_dskattr(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_search(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_fclose(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_open(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
int reply_open_and_X(char *inbuf,char *outbuf,int length,int bufsize);
int reply_ulogoffX(char *inbuf,char *outbuf,int length,int bufsize);
-int reply_mknew(char *inbuf,char *outbuf);
-int reply_ctemp(char *inbuf,char *outbuf);
-int reply_unlink(char *inbuf,char *outbuf);
-int reply_readbraw(char *inbuf, char *outbuf);
-int reply_lockread(char *inbuf,char *outbuf);
-int reply_read(char *inbuf,char *outbuf);
+int reply_mknew(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_ctemp(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_unlink(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_readbraw(char *inbuf, char *outbuf, int dum_size, int dum_buffsize);
+int reply_lockread(char *inbuf,char *outbuf, int dum_size, int dum_buffsiz);
+int reply_read(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
int reply_read_and_X(char *inbuf,char *outbuf,int length,int bufsize);
-int reply_writebraw(char *inbuf,char *outbuf);
-int reply_writeunlock(char *inbuf,char *outbuf);
-int reply_write(char *inbuf,char *outbuf,int dum1,int dum2);
+int reply_writebraw(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_writeunlock(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_write(char *inbuf,char *outbuf,int dum_size,int dum_buffsize);
int reply_write_and_X(char *inbuf,char *outbuf,int length,int bufsize);
-int reply_lseek(char *inbuf,char *outbuf);
-int reply_flush(char *inbuf,char *outbuf);
-int reply_exit(char *inbuf,char *outbuf);
-int reply_close(char *inbuf,char *outbuf);
-int reply_writeclose(char *inbuf,char *outbuf);
-int reply_lock(char *inbuf,char *outbuf);
-int reply_unlock(char *inbuf,char *outbuf);
-int reply_tdis(char *inbuf,char *outbuf);
-int reply_echo(char *inbuf,char *outbuf);
-int reply_printopen(char *inbuf,char *outbuf);
-int reply_printclose(char *inbuf,char *outbuf);
-int reply_printqueue(char *inbuf,char *outbuf);
-int reply_printwrite(char *inbuf,char *outbuf);
-int reply_mkdir(char *inbuf,char *outbuf);
-int reply_rmdir(char *inbuf,char *outbuf);
-int reply_mv(char *inbuf,char *outbuf);
-int reply_copy(char *inbuf,char *outbuf);
-int reply_setdir(char *inbuf,char *outbuf);
+int reply_lseek(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_flush(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_exit(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_close(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_writeclose(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_lock(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_unlock(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_tdis(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_echo(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_printopen(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_printclose(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_printqueue(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_printwrite(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_mkdir(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_rmdir(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_mv(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_copy(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_setdir(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
int reply_lockingX(char *inbuf,char *outbuf,int length,int bufsize);
int reply_readbmpx(char *inbuf,char *outbuf,int length,int bufsize);
-int reply_writebmpx(char *inbuf,char *outbuf);
-int reply_writebs(char *inbuf,char *outbuf);
-int reply_setattrE(char *inbuf,char *outbuf);
-int reply_getattrE(char *inbuf,char *outbuf);
+int reply_writebmpx(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_writebs(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_setattrE(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
+int reply_getattrE(char *inbuf,char *outbuf, int dum_size, int dum_buffsize);
/*The following definitions come from server.c */
uint32 interpret_addr(char *str);
struct in_addr *interpret_addr2(char *str);
BOOL zero_ip(struct in_addr ip);
-void reset_globals_after_fork();
+void reset_globals_after_fork(void);
char *client_name(int fd);
char *client_addr(int fd);
char *automount_server(char *user_name);
void file_unlock(int fd);
BOOL is_myname(char *s);
void set_remote_arch(enum remote_arch_types type);
-enum remote_arch_types get_remote_arch();
+enum remote_arch_types get_remote_arch(void);
char *skip_unicode_string(char *buf,int n);
char *unistrn2(uint16 *buf, int len);
char *unistr2(uint16 *buf);
parm_type type;
parm_class class;
void *ptr;
- BOOL (*special)();
+ BOOL (*special)(char *, char **);
struct enum_list *enum_list;
unsigned flags;
union {
#define FAIL (-1)
/* Forward declarations. */
-static int list_match(char *list,char *item, int (*match_fn)());
+static int list_match(char *list,char *item, int (*match_fn)(char *, char *));
static int client_match(char *tok,char *item);
static int string_match(char *tok,char *s);
static int masked_match(char *tok, char *slash, char *s);
/* list_match - match an item against a list of tokens with exceptions */
/* (All modifications are marked with the initials "jkf") */
-static int list_match(char *list,char *item, int (*match_fn)())
+static int list_match(char *list,char *item, int (*match_fn)(char *, char *))
{
char *tok;
char *listcopy; /* jkf */
static char unix2dos[256];
static char dos2unix[256];
-static void initmaps() {
+static void initmaps(void) {
int k;
for (k = 0; k < 256; k++) unix2dos[k] = k;
}
}
-static void init_iso8859_1() {
+static void init_iso8859_1(void) {
int i;
if (!mapsinited) initmaps();
/* Init for eastern european languages. */
-static void init_iso8859_2() {
+static void init_iso8859_2(void) {
int i;
if (!mapsinited) initmaps();
/* Added by Max Khon <max@iclub.nsu.ru> */
-static void init_iso8859_5()
+static void init_iso8859_5(void)
{
int i;
if (!mapsinited) initmaps();
/* Init for russian language (koi8) */
-static void init_koi8_r()
+static void init_koi8_r(void)
{
if (!mapsinited) initmaps();
extern int DEBUGLEVEL;
-static void (*cont_fn)();
+static void (*cont_fn)(void *);
/*******************************************************************
/*******************************************************************
setup our fault handlers
********************************************************************/
-void fault_setup(void (*fn)())
+void fault_setup(void (*fn)(void *))
{
cont_fn = fn;
#else
- void getsmbpasswd_dummy() {;}
+ void getsmbpasswd_dummy(void) {;}
#endif
/****************************************************************************
True if we have two or more interfaces.
**************************************************************************/
-BOOL we_are_multihomed()
+BOOL we_are_multihomed(void)
{
static int multi = -1;
{
struct stat source_stats;
int ifd;
- int full_write();
- int safe_read();
int ofd;
char *buf;
int len; /* Number of bytes read into `buf'. */
extern int DEBUGLEVEL;
/* internal functions - modified versions of the ones in password.c */
-static struct passwd *uname_string_combinations(char *s, struct passwd * (*fn) (), int N);
-static struct passwd *uname_string_combinations2(char *s, int offset, struct passwd * (*fn) (), int N);
+static struct passwd *uname_string_combinations(char *s, struct passwd * (*fn) (char *), int N);
+static struct passwd *uname_string_combinations2(char *s, int offset, struct passwd * (*fn) (char *), int N);
/****************************************************************************
get a users home directory. tries as-is then lower case
offset is the first char to try and change (start with 0)
it assumes the string starts lowercased
****************************************************************************/
-static struct passwd *uname_string_combinations2(char *s,int offset,struct passwd *(*fn)(),int N)
+static struct passwd *uname_string_combinations2(char *s,int offset,struct passwd *(*fn)(char *),int N)
{
int len = strlen(s);
int i;
offset is the first char to try and change (start with 0)
it assumes the string starts lowercased
****************************************************************************/
-static struct passwd * uname_string_combinations(char *s,struct passwd * (*fn)(),int N)
+static struct passwd * uname_string_combinations(char *s,struct passwd * (*fn)(char *),int N)
{
int n;
struct passwd *ret;
static BOOL global_client_name_done = False;
static BOOL global_client_addr_done = False;
-void reset_globals_after_fork()
+void reset_globals_after_fork(void)
{
global_client_name_done = False;
global_client_addr_done = False;
/*******************************************************************
Get the remote_arch type.
********************************************************************/
-enum remote_arch_types get_remote_arch()
+enum remote_arch_types get_remote_arch(void)
{
return ra_type;
}
**************************************************************************/
BOOL name_status(int fd,char *name,int name_type,BOOL recurse,
struct in_addr to_ip,char *master,char *rname,
- void (*fn)())
+ void (*fn)(struct packet_struct *))
{
BOOL found=False;
int retries = 2;
returns an array of IP addresses or NULL if none
*count will be set to the number of addresses returned
****************************************************************************/
-struct in_addr *name_query(int fd,char *name,int name_type,
- BOOL bcast,BOOL recurse,
- struct in_addr to_ip, int *count, void (*fn)())
+struct in_addr *name_query(int fd,char *name,int name_type, BOOL bcast,BOOL recurse,
+ struct in_addr to_ip, int *count, void (*fn)(struct packet_struct *))
{
BOOL found=False;
int i, retries = 3;
WINS db that our parent is going to write.
**************************************************************************** */
-static int sig_term()
+static int sig_term(void)
{
_exit(0);
/* Keep compiler happy.. */
child so we don't get child async dns processes lying around, causing trouble.
****************************************************************************/
-void kill_async_dns_child()
+void kill_async_dns_child(void)
{
if(child_pid != 0 && child_pid != -1)
kill(child_pid, SIGTERM);
/***************************************************************************
With sync dns there is no child to kill on SIGTERM.
****************************************************************************/
-void kill_async_dns_child()
+void kill_async_dns_child(void)
{
return;
}
/**************************************************************************** **
catch a sigterm
**************************************************************************** */
-static int sig_term()
+static int sig_term(void)
{
BlockSignals(True,SIGTERM);
/**************************************************************************** **
initialise connect, service and file structs
**************************************************************************** */
-static BOOL init_structs()
+static BOOL init_structs(void)
{
extern fstring local_machine;
char *p, *ptr;
argc--;
}
- fault_setup( fault_continue );
+ fault_setup((void (*)(void *))fault_continue );
signal( SIGHUP, SIGNAL_CAST sig_hup );
signal( SIGTERM, SIGNAL_CAST sig_term );
Also add the magic Samba names.
**************************************************************************/
-BOOL register_my_workgroup_and_names()
+BOOL register_my_workgroup_and_names(void)
{
struct subnet_record *subrec;
struct work_record *work;
Remove all the names we registered.
**************************************************************************/
-void release_my_names()
+void release_my_names(void)
{
struct subnet_record *subrec;
into a file. Initiated by SIGHUP - used to debug the state of the namelists.
**************************************************************************/
-void dump_all_namelists()
+void dump_all_namelists(void)
{
fstring fname;
FILE *fp;
Run elements off the packet queue till its empty
******************************************************************/
-void run_packet_queue()
+void run_packet_queue(void)
{
struct packet_struct *p;
immediately.
****************************************************************************/
-void reset_announce_timer()
+void reset_announce_timer(void)
{
announce_timer_last = time(NULL) - (CHECK_TIME_MST_ANNOUNCE * 60);
}
Create subnet entries.
**************************************************************************/
-BOOL create_subnets()
+BOOL create_subnets(void)
{
int num_interfaces = iface_count();
int i;
Function to tell us if we can use the unicast subnet.
******************************************************************/
-BOOL we_are_a_wins_client()
+BOOL we_are_a_wins_client(void)
{
static int cache_we_are_a_wins_client = -1;
/* if it is a special case then go ahead */
if (parm_table[parmnum].special) {
- parm_table[parmnum].special(pszParmValue,parm_ptr);
+ parm_table[parmnum].special(pszParmValue,(char **)parm_ptr);
return(True);
}
Signal function to tell us we timed out.
****************************************************************/
-static void gotalarm_sig()
+static void gotalarm_sig(void)
{
gotalarm = 1;
}
run a function on each printer name in the printcap file. The function is
passed the primary name and the comment (if possible)
***************************************************************************/
-void pcap_printer_fn(void (*fn)())
+void pcap_printer_fn(void (*fn)(char *, char *))
{
pstring name,comment;
char *line;
} printer_t;
static printer_t *printers = NULL;
-static void populate_printers()
+static void populate_printers(void)
{
FILE *fp;
* names longer than 8 characters appear to work with my test
* clients (Win95/NT).
*/
-void sysv_printer_fn(void (*fn)())
+void sysv_printer_fn(void (*fn)(char *, char *))
{
printer_t *tmp;
{
char *name;
int id;
- BOOL (*fn)();
+ BOOL (*fn)(int,uint16,char *,char *,int,int,char **,char **,int *,int *);
int flags;
} api_commands[] = {
- {"RNetShareEnum", 0, (BOOL (*)())api_RNetShareEnum,0},
- {"RNetShareGetInfo", 1, (BOOL (*)())api_RNetShareGetInfo,0},
- {"RNetServerGetInfo", 13, (BOOL (*)())api_RNetServerGetInfo,0},
- {"RNetGroupGetUsers", 52, (BOOL (*)())api_RNetGroupGetUsers,0},
- {"RNetUserGetInfo", 56, (BOOL (*)())api_RNetUserGetInfo,0},
- {"NetUserGetGroups", 59, (BOOL (*)())api_NetUserGetGroups,0},
- {"NetWkstaGetInfo", 63, (BOOL (*)())api_NetWkstaGetInfo,0},
- {"DosPrintQEnum", 69, (BOOL (*)())api_DosPrintQEnum,0},
- {"DosPrintQGetInfo", 70, (BOOL (*)())api_DosPrintQGetInfo,0},
- {"WPrintJobEnumerate",76, (BOOL (*)())api_WPrintJobEnumerate,0},
- {"WPrintJobGetInfo", 77, (BOOL (*)())api_WPrintJobGetInfo,0},
- {"RDosPrintJobDel", 81, (BOOL (*)())api_RDosPrintJobDel,0},
- {"RDosPrintJobPause", 82, (BOOL (*)())api_RDosPrintJobDel,0},
- {"RDosPrintJobResume",83, (BOOL (*)())api_RDosPrintJobDel,0},
- {"WPrintDestEnum", 84, (BOOL (*)())api_WPrintDestEnum,0},
- {"WPrintDestGetInfo", 85, (BOOL (*)())api_WPrintDestGetInfo,0},
- {"NetRemoteTOD", 91, (BOOL (*)())api_NetRemoteTOD,0},
- {"WPrintQueuePurge", 103, (BOOL (*)())api_WPrintQueuePurge,0},
- {"NetServerEnum", 104, (BOOL (*)())api_RNetServerEnum,0},
- {"WAccessGetUserPerms",105, (BOOL (*)())api_WAccessGetUserPerms,0},
- {"SetUserPassword", 115, (BOOL (*)())api_SetUserPassword,0},
- {"WWkstaUserLogon", 132, (BOOL (*)())api_WWkstaUserLogon,0},
- {"PrintJobInfo", 147, (BOOL (*)())api_PrintJobInfo,0},
- {"WPrintDriverEnum", 205, (BOOL (*)())api_WPrintDriverEnum,0},
- {"WPrintQProcEnum", 206, (BOOL (*)())api_WPrintQProcEnum,0},
- {"WPrintPortEnum", 207, (BOOL (*)())api_WPrintPortEnum,0},
- {"SamOEMChangePassword", 214, (BOOL (*)())api_SamOEMChangePassword,0},
- {NULL, -1, (BOOL (*)())api_Unsupported,0}};
+ {"RNetShareEnum", 0, api_RNetShareEnum,0},
+ {"RNetShareGetInfo", 1, api_RNetShareGetInfo,0},
+ {"RNetServerGetInfo", 13, api_RNetServerGetInfo,0},
+ {"RNetGroupGetUsers", 52, api_RNetGroupGetUsers,0},
+ {"RNetUserGetInfo", 56, api_RNetUserGetInfo,0},
+ {"NetUserGetGroups", 59, api_NetUserGetGroups,0},
+ {"NetWkstaGetInfo", 63, api_NetWkstaGetInfo,0},
+ {"DosPrintQEnum", 69, api_DosPrintQEnum,0},
+ {"DosPrintQGetInfo", 70, api_DosPrintQGetInfo,0},
+ {"WPrintJobEnumerate",76, api_WPrintJobEnumerate,0},
+ {"WPrintJobGetInfo", 77, api_WPrintJobGetInfo,0},
+ {"RDosPrintJobDel", 81, api_RDosPrintJobDel,0},
+ {"RDosPrintJobPause", 82, api_RDosPrintJobDel,0},
+ {"RDosPrintJobResume",83, api_RDosPrintJobDel,0},
+ {"WPrintDestEnum", 84, api_WPrintDestEnum,0},
+ {"WPrintDestGetInfo", 85, api_WPrintDestGetInfo,0},
+ {"NetRemoteTOD", 91, api_NetRemoteTOD,0},
+ {"WPrintQueuePurge", 103, api_WPrintQueuePurge,0},
+ {"NetServerEnum", 104, api_RNetServerEnum,0},
+ {"WAccessGetUserPerms",105, api_WAccessGetUserPerms,0},
+ {"SetUserPassword", 115, api_SetUserPassword,0},
+ {"WWkstaUserLogon", 132, api_WWkstaUserLogon,0},
+ {"PrintJobInfo", 147, api_PrintJobInfo,0},
+ {"WPrintDriverEnum", 205, api_WPrintDriverEnum,0},
+ {"WPrintQProcEnum", 206, api_WPrintQProcEnum,0},
+ {"WPrintPortEnum", 207, api_WPrintPortEnum,0},
+ {"SamOEMChangePassword", 214, api_SamOEMChangePassword,0},
+ {NULL, -1, api_Unsupported,0}};
/****************************************************************************
/****************************************************************************
reply to a sends
****************************************************************************/
-int reply_sends(char *inbuf,char *outbuf)
+int reply_sends(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int len;
char *orig,*dest,*msg;
/****************************************************************************
reply to a sendstrt
****************************************************************************/
-int reply_sendstrt(char *inbuf,char *outbuf)
+int reply_sendstrt(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
char *orig,*dest;
int outsize = 0;
/****************************************************************************
reply to a sendtxt
****************************************************************************/
-int reply_sendtxt(char *inbuf,char *outbuf)
+int reply_sendtxt(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int len;
int outsize = 0;
/****************************************************************************
reply to a sendend
****************************************************************************/
-int reply_sendend(char *inbuf,char *outbuf)
+int reply_sendend(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int outsize = 0;
offset is the first char to try and change (start with 0)
it assumes the string starts lowercased
****************************************************************************/
-static BOOL string_combinations2(char *s,int offset,BOOL (*fn)(),int N)
+static BOOL string_combinations2(char *s,int offset,BOOL (*fn)(char *),int N)
{
int len = strlen(s);
int i;
offset is the first char to try and change (start with 0)
it assumes the string starts lowercased
****************************************************************************/
-static BOOL string_combinations(char *s,BOOL (*fn)(),int N)
+static BOOL string_combinations(char *s,BOOL (*fn)(char *),int N)
{
int n;
for (n=1;n<=N;n++)
/****************************************************************************
pre-read some data
****************************************************************************/
-void do_read_prediction()
+void do_read_prediction(void)
{
static int readsize = 0;
/****************************************************************************
reply to a tcon
****************************************************************************/
-int reply_tcon(char *inbuf,char *outbuf)
+int reply_tcon(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
pstring service;
pstring user;
/****************************************************************************
reply to an ioctl
****************************************************************************/
-int reply_ioctl(char *inbuf,char *outbuf)
+int reply_ioctl(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
DEBUG(3,("ignoring ioctl\n"));
#if 0
/****************************************************************************
reply to a chkpth
****************************************************************************/
-int reply_chkpth(char *inbuf,char *outbuf)
+int reply_chkpth(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int outsize = 0;
int cnum,mode;
/****************************************************************************
reply to a getatr
****************************************************************************/
-int reply_getatr(char *inbuf,char *outbuf)
+int reply_getatr(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
pstring fname;
int cnum;
/****************************************************************************
reply to a setatr
****************************************************************************/
-int reply_setatr(char *inbuf,char *outbuf)
+int reply_setatr(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
pstring fname;
int cnum;
/****************************************************************************
reply to a dskattr
****************************************************************************/
-int reply_dskattr(char *inbuf,char *outbuf)
+int reply_dskattr(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int cnum;
int outsize = 0;
reply to a search
Can be called from SMBsearch, SMBffirst or SMBfunique.
****************************************************************************/
-int reply_search(char *inbuf,char *outbuf)
+int reply_search(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
pstring mask;
pstring directory;
/****************************************************************************
reply to a fclose (stop directory search)
****************************************************************************/
-int reply_fclose(char *inbuf,char *outbuf)
+int reply_fclose(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int cnum;
int outsize = 0;
/****************************************************************************
reply to an open
****************************************************************************/
-int reply_open(char *inbuf,char *outbuf)
+int reply_open(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
pstring fname;
int cnum;
/****************************************************************************
reply to a mknew or a create
****************************************************************************/
-int reply_mknew(char *inbuf,char *outbuf)
+int reply_mknew(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
pstring fname;
int cnum,com;
/****************************************************************************
reply to a create temporary file
****************************************************************************/
-int reply_ctemp(char *inbuf,char *outbuf)
+int reply_ctemp(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
pstring fname;
pstring fname2;
/****************************************************************************
reply to a unlink
****************************************************************************/
-int reply_unlink(char *inbuf,char *outbuf)
+int reply_unlink(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int outsize = 0;
pstring name;
/****************************************************************************
reply to a readbraw (core+ protocol)
****************************************************************************/
-int reply_readbraw(char *inbuf, char *outbuf)
+int reply_readbraw(char *inbuf, char *outbuf, int dum_size, int dum_buffsize)
{
int cnum,maxcount,mincount,fnum;
int nread = 0;
/****************************************************************************
reply to a lockread (core+ protocol)
****************************************************************************/
-int reply_lockread(char *inbuf,char *outbuf)
+int reply_lockread(char *inbuf,char *outbuf, int dum_size, int dum_buffsiz)
{
int cnum,fnum;
int nread = -1;
/****************************************************************************
reply to a read
****************************************************************************/
-int reply_read(char *inbuf,char *outbuf)
+int reply_read(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int cnum,numtoread,fnum;
int nread = 0;
/****************************************************************************
reply to a writebraw (core+ or LANMAN1.0 protocol)
****************************************************************************/
-int reply_writebraw(char *inbuf,char *outbuf)
+int reply_writebraw(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int nwritten=0;
int total_written=0;
/****************************************************************************
reply to a writeunlock (core+)
****************************************************************************/
-int reply_writeunlock(char *inbuf,char *outbuf)
+int reply_writeunlock(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int cnum,fnum;
int nwritten = -1;
/****************************************************************************
reply to a write
****************************************************************************/
-int reply_write(char *inbuf,char *outbuf,int dum1,int dum2)
+int reply_write(char *inbuf,char *outbuf,int dum_size,int dum_buffsize)
{
int cnum,numtowrite,fnum;
int nwritten = -1;
int startpos;
char *data;
- dum1 = dum2 = 0;
-
-
cnum = SVAL(inbuf,smb_tid);
fnum = GETFNUM(inbuf,smb_vwv0);
/****************************************************************************
reply to a lseek
****************************************************************************/
-int reply_lseek(char *inbuf,char *outbuf)
+int reply_lseek(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int cnum,fnum;
uint32 startpos;
/****************************************************************************
reply to a flush
****************************************************************************/
-int reply_flush(char *inbuf,char *outbuf)
+int reply_flush(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int cnum, fnum;
int outsize = set_message(outbuf,0,0,True);
/****************************************************************************
reply to a exit
****************************************************************************/
-int reply_exit(char *inbuf,char *outbuf)
+int reply_exit(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int outsize = set_message(outbuf,0,0,True);
DEBUG(3,("%s exit\n",timestring()));
/****************************************************************************
reply to a close
****************************************************************************/
-int reply_close(char *inbuf,char *outbuf)
+int reply_close(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int fnum,cnum;
int outsize = 0;
/****************************************************************************
reply to a writeclose (Core+ protocol)
****************************************************************************/
-int reply_writeclose(char *inbuf,char *outbuf)
+int reply_writeclose(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int cnum,numtowrite,fnum;
int nwritten = -1;
/****************************************************************************
reply to a lock
****************************************************************************/
-int reply_lock(char *inbuf,char *outbuf)
+int reply_lock(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int fnum,cnum;
int outsize = set_message(outbuf,0,0,True);
/****************************************************************************
reply to a unlock
****************************************************************************/
-int reply_unlock(char *inbuf,char *outbuf)
+int reply_unlock(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int fnum,cnum;
int outsize = set_message(outbuf,0,0,True);
/****************************************************************************
reply to a tdis
****************************************************************************/
-int reply_tdis(char *inbuf,char *outbuf)
+int reply_tdis(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int cnum;
int outsize = set_message(outbuf,0,0,True);
/****************************************************************************
reply to a echo
****************************************************************************/
-int reply_echo(char *inbuf,char *outbuf)
+int reply_echo(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int cnum;
int smb_reverb = SVAL(inbuf,smb_vwv0);
/****************************************************************************
reply to a printopen
****************************************************************************/
-int reply_printopen(char *inbuf,char *outbuf)
+int reply_printopen(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
pstring fname;
pstring fname2;
/****************************************************************************
reply to a printclose
****************************************************************************/
-int reply_printclose(char *inbuf,char *outbuf)
+int reply_printclose(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int fnum,cnum;
int outsize = set_message(outbuf,0,0,True);
/****************************************************************************
reply to a printqueue
****************************************************************************/
-int reply_printqueue(char *inbuf,char *outbuf)
+int reply_printqueue(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int cnum;
int outsize = set_message(outbuf,2,3,True);
/****************************************************************************
reply to a printwrite
****************************************************************************/
-int reply_printwrite(char *inbuf,char *outbuf)
+int reply_printwrite(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int cnum,numtowrite,fnum;
int outsize = set_message(outbuf,0,0,True);
/****************************************************************************
reply to a mkdir
****************************************************************************/
-int reply_mkdir(char *inbuf,char *outbuf)
+int reply_mkdir(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
pstring directory;
int cnum;
/****************************************************************************
reply to a rmdir
****************************************************************************/
-int reply_rmdir(char *inbuf,char *outbuf)
+int reply_rmdir(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
pstring directory;
int cnum;
/****************************************************************************
reply to a mv
****************************************************************************/
-int reply_mv(char *inbuf,char *outbuf)
+int reply_mv(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int outsize = 0;
pstring name;
/****************************************************************************
reply to a file copy.
****************************************************************************/
-int reply_copy(char *inbuf,char *outbuf)
+int reply_copy(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int outsize = 0;
pstring name;
/****************************************************************************
reply to a setdir
****************************************************************************/
-int reply_setdir(char *inbuf,char *outbuf)
+int reply_setdir(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int cnum,snum;
int outsize = 0;
/****************************************************************************
reply to a SMBwritebmpx (write block multiplex primary) request
****************************************************************************/
-int reply_writebmpx(char *inbuf,char *outbuf)
+int reply_writebmpx(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int cnum,numtowrite,fnum;
int nwritten = -1;
/****************************************************************************
reply to a SMBwritebs (write block multiplex secondary) request
****************************************************************************/
-int reply_writebs(char *inbuf,char *outbuf)
+int reply_writebs(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int cnum,numtowrite,fnum;
int nwritten = -1;
/****************************************************************************
reply to a SMBsetattrE
****************************************************************************/
-int reply_setattrE(char *inbuf,char *outbuf)
+int reply_setattrE(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int cnum,fnum;
struct utimbuf unix_times;
/****************************************************************************
reply to a SMBgetattrE
****************************************************************************/
-int reply_getattrE(char *inbuf,char *outbuf)
+int reply_getattrE(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int cnum,fnum;
struct stat sbuf;
fd support routines - attempt to find a empty slot in the FileFd array.
Increments the ref_count of the returned entry.
****************************************************************************/
-static file_fd_struct *fd_get_new()
+static file_fd_struct *fd_get_new(void)
{
int i;
file_fd_struct *fd_ptr;
/****************************************************************************
this prevents zombie child processes
****************************************************************************/
-static int sig_cld()
+static int sig_cld(void)
{
static int depth = 0;
if (depth != 0)
/****************************************************************************
this is called when the client exits abruptly
**************************************************************************/
-static int sig_pipe()
+static int sig_pipe(void)
{
struct cli_state *cli;
BlockSignals(True,SIGPIPE);
/****************************************************************************
open the oplock IPC socket communication
****************************************************************************/
-static BOOL open_oplock_ipc()
+static BOOL open_oplock_ipc(void)
{
struct sockaddr_in sock_name;
int len = sizeof(sock_name);
/****************************************************************************
this prevents zombie child processes
****************************************************************************/
-static int sig_hup()
+static int sig_hup(void)
{
BlockSignals(True,SIGHUP);
DEBUG(0,("Got SIGHUP\n"));
/****************************************************************************
reply to a negprot
****************************************************************************/
-static int reply_negprot(char *inbuf,char *outbuf)
+static int reply_negprot(char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
{
int outsize = set_message(outbuf,1,0,True);
int Index=0;
{
int code;
char *name;
- int (*fn)();
+ int (*fn)(char *, char *, int, int);
int flags;
#if PROFILING
unsigned long time;
seteuid(0);
#endif
- fault_setup(exit_server);
+ fault_setup((void (*)(void *))exit_server);
signal(SIGTERM , SIGNAL_CAST dflt_sig);
/* we want total control over the permissions on created files,
return (value);
}
-void build_subdir()
+void build_subdir(void)
{
int i=0;
char *entry;