SMBD_OBJ1 = smbd/server.o smbd/chgpasswd.o smbd/connection.o \
smbd/dfree.o smbd/dir.o smbd/password.o \
- smbd/groupname.o smbd/ipc.o smbd/ldap.o smbd/mangle.o \
- smbd/message.o smbd/nispass.o smbd/nttrans.o \
+ smbd/groupname.o smbd/ipc.o passdb/ldap.o smbd/mangle.o \
+ smbd/message.o passdb/nispass.o smbd/nttrans.o \
smbd/pipes.o smbd/predict.o smbd/printing.o \
smbd/quotas.o smbd/reply.o smbd/ssl.o smbd/trans2.o smbd/uid.o
int clipfind(char **aret, int ret, char *tok);
int tar_parseargs(int argc, char *argv[], char *Optarg, int Optind);
+/*The following definitions come from lib/access.c */
+
+BOOL allow_access(char *deny_list,char *allow_list,
+ char *cname,char *caddr);
+BOOL check_access(int sock, char *allow_list, char *deny_list);
+
/*The following definitions come from lib/charcnv.c */
char *unix2dos_format(char *str,BOOL overwrite);
void setup_logging( char *pname, BOOL interactive );
void reopen_logs( void );
void force_check_log_size( void );
+void dbgflush( void );
BOOL dbghdr( int level, char *file, char *func, int line );
/*The following definitions come from lib/fault.c */
/*The following definitions come from locking/locking.c */
+BOOL push_blocking_lock_request( char *inbuf, int length, int lock_timeout, int lock_num);
+void process_blocking_lock_queue(time_t t);
BOOL is_locked(int fnum,int cnum,uint32 count,uint32 offset, int lock_type);
BOOL do_lock(int fnum,int cnum,uint32 count,uint32 offset,int lock_type,
int *eclass,uint32 *ecode);
BOOL pcap_printername_ok(char *pszPrintername, char *pszPrintcapname);
void pcap_printer_fn(void (*fn)(char *, char *));
+/*The following definitions come from passdb/ldap.c */
+
+struct passdb_ops *ldap_initialize_password_db(void);
+
+/*The following definitions come from passdb/nispass.c */
+
+struct passdb_ops *nisplus_initialize_password_db(void);
+
/*The following definitions come from passdb/pass_check.c */
void dfs_unlogin(void);
BOOL api_wkssvc_rpc(pipes_struct *p, prs_struct *data);
-/*The following definitions come from smbd/access.c */
-
-BOOL allow_access(char *deny_list,char *allow_list,
- char *cname,char *caddr);
-BOOL check_access(int sock, char *allow_list, char *deny_list);
-
/*The following definitions come from smbd/chgpasswd.c */
BOOL chat_with_program(char *passwordprogram,char *name,char *chatsequence, BOOL as_root);
int get_printerdrivernumber(int snum);
int reply_trans(char *inbuf,char *outbuf, int size, int bufsize);
-/*The following definitions come from smbd/ldap.c */
-
-struct passdb_ops *ldap_initialize_password_db(void);
-
/*The following definitions come from smbd/mangle.c */
BOOL is_mangled( char *s );
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 smbd/nispass.c */
-
-struct passdb_ops *nisplus_initialize_password_db(void);
-
/*The following definitions come from smbd/nttrans.c */
int reply_ntcreate_and_X(char *inbuf,char *outbuf,int length,int bufsize);
return(ret);
}
+/*********************************************************
+* Recursive routine that is called by unix_mask_match.
+* Does the actual matching. This is the 'original code'
+* used by the unix matcher.
+*********************************************************/
+static BOOL unix_do_match(char *str, char *regexp, int case_sig)
+{
+ char *p;
+
+ for( p = regexp; *p && *str; ) {
+ switch(*p) {
+ case '?':
+ str++; p++;
+ break;
+
+ case '*':
+ /* Look for a character matching
+ the one after the '*' */
+ p++;
+ if(!*p)
+ return True; /* Automatic match */
+ while(*str) {
+ while(*str && (case_sig ? (*p != *str) : (toupper(*p)!=toupper(*str))))
+ str++;
+ if(do_match(str,p,case_sig))
+ return True;
+ if(!*str)
+ return False;
+ else
+ str++;
+ }
+ return False;
+
+ default:
+ if(case_sig) {
+ if(*str != *p)
+ return False;
+ } else {
+ if(toupper(*str) != toupper(*p))
+ return False;
+ }
+ str++, p++;
+ break;
+ }
+ }
+ if(!*p && !*str)
+ return True;
+
+ if (!*p && str[0] == '.' && str[1] == 0)
+ return(True);
+
+ if (!*str && *p == '?')
+ {
+ while (*p == '?') p++;
+ return(!*p);
+ }
+
+ if(!*str && (*p == '*' && p[1] == '\0'))
+ return True;
+ return False;
+}
+
+
+/*********************************************************
+* Routine to match a given string with a regexp - uses
+* simplified regexp that takes * and ? only. Case can be
+* significant or not.
+* This is the 'original code' used by the unix matcher.
+*********************************************************/
+
+static BOOL unix_mask_match(char *str, char *regexp, int case_sig,BOOL trans2)
+{
+ char *p;
+ pstring p1, p2;
+ fstring ebase,eext,sbase,sext;
+
+ BOOL matched;
+
+ /* Make local copies of str and regexp */
+ StrnCpy(p1,regexp,sizeof(pstring)-1);
+ StrnCpy(p2,str,sizeof(pstring)-1);
+
+ if (!strchr(p2,'.')) {
+ pstrcat(p2,".");
+ }
+
+ /* Remove any *? and ** as they are meaningless */
+ for(p = p1; *p; p++)
+ while( *p == '*' && (p[1] == '?' ||p[1] == '*'))
+ (void)pstrcpy( &p[1], &p[2]);
+
+ if (strequal(p1,"*")) return(True);
+
+ DEBUG(8,("unix_mask_match str=<%s> regexp=<%s>, case_sig = %d\n", p2, p1, case_sig));
+
+ if (trans2) {
+ fstrcpy(ebase,p1);
+ fstrcpy(sbase,p2);
+ } else {
+ if ((p=strrchr(p1,'.'))) {
+ *p = 0;
+ fstrcpy(ebase,p1);
+ fstrcpy(eext,p+1);
+ } else {
+ fstrcpy(ebase,p1);
+ eext[0] = 0;
+ }
+
+ if (!strequal(p2,".") && !strequal(p2,"..") && (p=strrchr(p2,'.'))) {
+ *p = 0;
+ fstrcpy(sbase,p2);
+ fstrcpy(sext,p+1);
+ } else {
+ fstrcpy(sbase,p2);
+ fstrcpy(sext,"");
+ }
+ }
+
+ matched = do_match(sbase,ebase,case_sig) &&
+ (trans2 || do_match(sext,eext,case_sig));
+
+ DEBUG(8,("unix_mask_match returning %d\n", matched));
+
+ return matched;
+}
+
/*********************************************************
* Recursive routine that is called by mask_match.
* Does the actual matching. Returns True if matched,
-* False if failed.
+* False if failed. This is the 'new' NT style matcher.
*********************************************************/
BOOL do_match(char *str, char *regexp, int case_sig)
* simplified regexp that takes * and ? only. Case can be
* significant or not.
* The 8.3 handling was rewritten by Ums Harald <Harald.Ums@pro-sieben.de>
+* This is the new 'NT style' matcher.
*********************************************************/
BOOL mask_match(char *str, char *regexp, int case_sig,BOOL trans2)
{
if(namelist->is_wild)
{
- /* look for a wildcard match. */
- if (mask_match(last_component, namelist->name, case_sensitive, False))
+ /*
+ * Look for a wildcard match. Use the old
+ * 'unix style' mask match, rather than the
+ * new NT one.
+ */
+ if (unix_mask_match(last_component, namelist->name, case_sensitive, False))
{
DEBUG(8,("is_in_path: mask match succeeded\n"));
return True;
Return a blocking lock success SMB.
*****************************************************************************/
-void blocking_lock_reply_success(blocking_lock_record *blr)
+static void blocking_lock_reply_success(blocking_lock_record *blr)
{
extern int chain_size;
extern int chain_fnum;
Return a lock fail error. Undo all the locks we have obtained first.
*****************************************************************************/
-void blocking_lock_reply_error(blocking_lock_record *blr, int eclass, int32 ecode)
+static void blocking_lock_reply_error(blocking_lock_record *blr, int eclass, int32 ecode)
{
extern char *OutBuffer;
char *outbuf = OutBuffer;
Returns True if we want to be removed from the list.
*****************************************************************************/
-BOOL blocking_lock_record_process(blocking_lock_record *blr)
+static BOOL blocking_lock_record_process(blocking_lock_record *blr)
{
char *inbuf = blr->inbuf;
unsigned char locktype = CVAL(inbuf,smb_vwv3);
git.samba.org / nivanova / samba-autobuild / .git / commitdiff