/* 
   Unix SMB/Netbios implementation.
   Version 1.9.
   Main SMB reply routines
   Copyright (C) Andrew Tridgell 1992-1997
   
   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.
*/
/*
   This file handles most of the reply_ calls that the server
   makes to handle specific protocols
*/


#include "includes.h"
#include "trans2.h"
#include "nterr.h"

/* look in server.c for some explanation of these variables */
extern int Protocol;
extern int DEBUGLEVEL;
extern int max_send;
extern int max_recv;
extern int chain_fnum;
extern char magic_char;
extern connection_struct Connections[];
extern files_struct Files[];
extern BOOL case_sensitive;
extern BOOL case_preserve;
extern BOOL short_case_preserve;
extern pstring sesssetup_user;
extern fstring myworkgroup;
extern int Client;
extern int global_oplock_break;

/* this macro should always be used to extract an fnum (smb_fid) from
a packet to ensure chaining works correctly */
#define GETFNUM(buf,where) (chain_fnum!= -1?chain_fnum:SVAL(buf,where))


/****************************************************************************
report a possible attack via the password buffer overflow bug
****************************************************************************/
static void overflow_attack(int len)
{
	DEBUG(0,("ERROR: Invalid password length %d\n", len));
	DEBUG(0,("your machine may be under attack by a user exploiting an old bug\n"));
	DEBUG(0,("Attack was from IP=%s\n", client_addr()));
	exit_server("possible attack");
}


/****************************************************************************
  reply to an special message 
****************************************************************************/
int reply_special(char *inbuf,char *outbuf)
{
	int outsize = 4;
	int msg_type = CVAL(inbuf,0);
	int msg_flags = CVAL(inbuf,1);
	pstring name1,name2;
	extern fstring remote_machine;
	extern fstring local_machine;
	char *p;
	
	*name1 = *name2 = 0;
	
	smb_setlen(outbuf,0);
	
	switch (msg_type) {
    case 0x81: /* session request */
      CVAL(outbuf,0) = 0x82;
      CVAL(outbuf,3) = 0;
      if (name_len(inbuf+4) > 50 || name_len(inbuf+4 + name_len(inbuf + 4)) > 50) {
	      DEBUG(0,("Invalid name length in session request\n"));
	      return(0);
      }
      name_extract(inbuf,4,name1);
      name_extract(inbuf,4 + name_len(inbuf + 4),name2);
		DEBUG(2,("netbios connect: name1=%s name2=%s\n",
			 name1,name2));      

      fstrcpy(remote_machine,name2);
      trim_string(remote_machine," "," ");
      p = strchr(remote_machine,' ');
      strlower(remote_machine);
      if (p) *p = 0;

      fstrcpy(local_machine,name1);
      trim_string(local_machine," "," ");
      p = strchr(local_machine,' ');
      strlower(local_machine);
      if (p) *p = 0;

      add_session_user(remote_machine);

      reload_services(True);
      reopen_logs();

      break;
		
	case 0x89: /* session keepalive request 
		      (some old clients produce this?) */
		CVAL(outbuf,0) = 0x85;
		CVAL(outbuf,3) = 0;
		break;
		
	case 0x82: /* positive session response */
	case 0x83: /* negative session response */
	case 0x84: /* retarget session response */
		DEBUG(0,("Unexpected session response\n"));
		break;
		
	case 0x85: /* session keepalive */
	default:
		return(0);
	}
	
	DEBUG(5,("%s init msg_type=0x%x msg_flags=0x%x\n",
		 timestring(),msg_type,msg_flags));
	
	return(outsize);
}


/*******************************************************************
work out what error to give to a failed connection
********************************************************************/
static int connection_error(char *inbuf,char *outbuf,int connection_num)
{
  switch (connection_num)
    {
    case -8:
      return(ERROR(ERRSRV,ERRnoresource));
    case -7:
      return(ERROR(ERRSRV,ERRbaduid));
    case -6:
      return(ERROR(ERRSRV,ERRinvdevice));
    case -5:
      return(ERROR(ERRSRV,ERRinvnetname));
    case -4:
      return(ERROR(ERRSRV,ERRaccess));
    case -3:
      return(ERROR(ERRDOS,ERRnoipc));
    case -2:
      return(ERROR(ERRSRV,ERRinvnetname));
    }
  return(ERROR(ERRSRV,ERRbadpw));
}



/****************************************************************************
  parse a share descriptor string
****************************************************************************/
static void parse_connect(char *p,char *service,char *user,
			  char *password,int *pwlen,char *dev)
{
  char *p2;

  DEBUG(4,("parsing connect string %s\n",p));
    
  p2 = strrchr(p,'\\');
  if (p2 == NULL)
    fstrcpy(service,p);
  else
    fstrcpy(service,p2+1);
  
  p += strlen(p) + 2;
  
  fstrcpy(password,p);
  *pwlen = strlen(password);

  p += strlen(p) + 2;

  fstrcpy(dev,p);
  
  *user = 0;
  p = strchr(service,'%');
  if (p != NULL)
    {
      *p = 0;
      fstrcpy(user,p+1);
    }
}




/****************************************************************************
  reply to a tcon
****************************************************************************/
int reply_tcon(char *inbuf,char *outbuf)
{
  pstring service;
  pstring user;
  pstring password;
  pstring dev;
  int connection_num;
  int outsize = 0;
  uint16 vuid = SVAL(inbuf,smb_uid);
  int pwlen=0;

  *service = *user = *password = *dev = 0;

  parse_connect(smb_buf(inbuf)+1,service,user,password,&pwlen,dev);

  connection_num = make_connection(service,user,password,pwlen,dev,vuid);
  
  if (connection_num < 0)
    return(connection_error(inbuf,outbuf,connection_num));
  
  outsize = set_message(outbuf,2,0,True);
  SSVAL(outbuf,smb_vwv0,max_recv);
  SSVAL(outbuf,smb_vwv1,connection_num);
  SSVAL(outbuf,smb_tid,connection_num);
  
  DEBUG(3,("%s tcon service=%s user=%s cnum=%d\n",timestring(),service,user,connection_num));
  
  return(outsize);
}


/****************************************************************************
  reply to a tcon and X
****************************************************************************/
int reply_tcon_and_X(char *inbuf,char *outbuf,int length,int bufsize)
{
  pstring service;
  pstring user;
  pstring password;
  pstring devicename;
  int connection_num;
  uint16 vuid = SVAL(inbuf,smb_uid);
  int passlen = SVAL(inbuf,smb_vwv3);
  BOOL doencrypt = SMBENCRYPT();

  *service = *user = *password = *devicename = 0;

  /* we might have to close an old one */
  if ((SVAL(inbuf,smb_vwv2) & 0x1) != 0)
    close_cnum(SVAL(inbuf,smb_tid),vuid);

  if (passlen > MAX_PASS_LEN) {
	  overflow_attack(passlen);
  }
  
  {
    char *path;
    char *p;
    memcpy(password,smb_buf(inbuf),passlen);
    password[passlen]=0;    
    path = smb_buf(inbuf) + passlen;

    if (!doencrypt || passlen != 24) {
      if (strequal(password," "))
	*password = 0;
      passlen = strlen(password);
    }
    
    fstrcpy(service,path+2);
    p = strchr(service,'\\');
    if (!p)
      return(ERROR(ERRSRV,ERRinvnetname));
    *p = 0;
    fstrcpy(service,p+1);
    p = strchr(service,'%');
    if (p)
      {
	*p++ = 0;
	fstrcpy(user,p);
      }
    StrnCpy(devicename,path + strlen(path) + 1,6);
    DEBUG(4,("Got device type %s\n",devicename));
  }

  connection_num = make_connection(service,user,password,passlen,devicename,vuid);
  
  if (connection_num < 0)
    return(connection_error(inbuf,outbuf,connection_num));

  if (Protocol < PROTOCOL_NT1)
  {
    set_message(outbuf,2,strlen(devicename)+1,True);
    strcpy(smb_buf(outbuf),devicename);
  }
  else
  {
    char *fsname = "SAMBA";
    char *p;

    set_message(outbuf,3,3,True);

    p = smb_buf(outbuf);
    strcpy(p,devicename); p = skip_string(p,1); /* device name */
    strcpy(p,fsname); p = skip_string(p,1); /* filesystem type e.g NTFS */

    set_message(outbuf,3,PTR_DIFF(p,smb_buf(outbuf)),False);

    SSVAL(outbuf, smb_vwv2, 0x0); /* optional support */
  }
  
  DEBUG(3,("%s tconX service=%s user=%s cnum=%d\n",timestring(),service,user,connection_num));
  
  /* set the incoming and outgoing tid to the just created one */
  SSVAL(inbuf,smb_tid,connection_num);
  SSVAL(outbuf,smb_tid,connection_num);

  return chain_reply(inbuf,outbuf,length,bufsize);
}


/****************************************************************************
  reply to an unknown type
****************************************************************************/
int reply_unknown(char *inbuf,char *outbuf)
{
  int cnum;
  int type;
  cnum = SVAL(inbuf,smb_tid);
  type = CVAL(inbuf,smb_com);
  
  DEBUG(0,("%s unknown command type (%s): cnum=%d type=%d (0x%X)\n",
	timestring(),
	smb_fn_name(type),
	cnum,type,type));
  
  return(ERROR(ERRSRV,ERRunknownsmb));
}


/****************************************************************************
  reply to an ioctl
****************************************************************************/
int reply_ioctl(char *inbuf,char *outbuf)
{
  DEBUG(3,("ignoring ioctl\n"));
#if 0
  /* we just say it succeeds and hope its all OK. 
     some day it would be nice to interpret them individually */
  return set_message(outbuf,1,0,True); 
#else
  return(ERROR(ERRSRV,ERRnosupport));
#endif
}


/****************************************************************************
reply to a session setup command
****************************************************************************/
int reply_sesssetup_and_X(char *inbuf,char *outbuf,int length,int bufsize)
{
  uint16 sess_vuid;
  int gid;
  int uid;
  int   smb_bufsize;    
  int   smb_mpxmax;     
  int   smb_vc_num;     
  uint32   smb_sesskey;    
  int   smb_apasslen = 0;   
  pstring smb_apasswd;
  int   smb_ntpasslen = 0;   
  pstring smb_ntpasswd;
  BOOL valid_nt_password = False;
  pstring user;
  BOOL guest=False;
  BOOL computer_id=False;
  static BOOL done_sesssetup = False;
  BOOL doencrypt = SMBENCRYPT();

  *smb_apasswd = 0;
  
  smb_bufsize = SVAL(inbuf,smb_vwv2);
  smb_mpxmax = SVAL(inbuf,smb_vwv3);
  smb_vc_num = SVAL(inbuf,smb_vwv4);
  smb_sesskey = IVAL(inbuf,smb_vwv5);

  if (Protocol < PROTOCOL_NT1) {
    smb_apasslen = SVAL(inbuf,smb_vwv7);
    if (smb_apasslen > MAX_PASS_LEN)
    {
	    overflow_attack(smb_apasslen);
    }

    memcpy(smb_apasswd,smb_buf(inbuf),smb_apasslen);
    pstrcpy(user,smb_buf(inbuf)+smb_apasslen);

    if (lp_security() != SEC_SERVER && !doencrypt) {
	    smb_apasslen = strlen(smb_apasswd);
    }
  } else {
    uint16 passlen1 = SVAL(inbuf,smb_vwv7);
    uint16 passlen2 = SVAL(inbuf,smb_vwv8);
    uint32 client_caps = IVAL(inbuf,smb_vwv11);
    enum remote_arch_types ra_type = get_remote_arch();

    char *p = smb_buf(inbuf);    

    /* client_caps is used as final determination if client is NT or Win95. 
       This is needed to return the correct error codes in some
       circumstances.
     */
    
    if(ra_type == RA_WINNT || ra_type == RA_WIN95)
    {
      if(client_caps & (CAP_NT_SMBS | CAP_STATUS32))
        set_remote_arch( RA_WINNT);
      else
        set_remote_arch( RA_WIN95);
    }

    if (passlen1 != 24 && passlen2 != 24)
      doencrypt = False;

    if (passlen1 > MAX_PASS_LEN) {
	    overflow_attack(passlen1);
    }

    passlen1 = MIN(passlen1, MAX_PASS_LEN);
    passlen2 = MIN(passlen2, MAX_PASS_LEN);

    if(doencrypt) {
      /* Save the lanman2 password and the NT md4 password. */
      smb_apasslen = passlen1;
      memcpy(smb_apasswd,p,smb_apasslen);
      smb_ntpasslen = passlen2;
      memcpy(smb_ntpasswd,p+passlen1,smb_ntpasslen);
    } else {
      /* both Win95 and WinNT stuff up the password lengths for
	 non-encrypting systems. Uggh. 
      
	 if passlen1==24 its a win95 system, and its setting the
	 password length incorrectly. Luckily it still works with the
	 default code because Win95 will null terminate the password
	 anyway 

	 if passlen1>0 and passlen2>0 then maybe its a NT box and its
	 setting passlen2 to some random value which really stuffs
	 things up. we need to fix that one.  */
      if (passlen1 > 0 && passlen2 > 0 && passlen2 != 24 &&
	  passlen2 != 1) {
	passlen2 = 0;
      }
      /* we use the first password that they gave */
      smb_apasslen = passlen1;
      StrnCpy(smb_apasswd,p,smb_apasslen);      
      
      /* trim the password */
      smb_apasslen = strlen(smb_apasswd);

      /* wfwg sometimes uses a space instead of a null */
      if (strequal(smb_apasswd," ")) {
	smb_apasslen = 0;
	*smb_apasswd = 0;
      }
    }
    
    p += passlen1 + passlen2;
    fstrcpy(user,p); p = skip_string(p,1);
    DEBUG(3,("Domain=[%s]  NativeOS=[%s] NativeLanMan=[%s]\n",
	     p,skip_string(p,1),skip_string(p,2)));
  }


  DEBUG(3,("sesssetupX:name=[%s]\n",user));

  /* If name ends in $ then I think it's asking about whether a */
  /* computer with that name (minus the $) has access. For now */
  /* say yes to everything ending in $. */
  if (user[strlen(user) - 1] == '$') {
#ifdef NTDOMAIN
    struct smb_passwd *smb_pass; /* To check if machine account exists */
/* 
   PAXX: Ack. We don't want to do this. The workstation trust account
   with a $ on the end should exist in the local password database
   or be mapped to something generic, but not modified. For NT
   domain support we must reject this used in certain circumstances
   with a code to indicate to the client that it is an invalid use
   of a workstation trust account. NTWKS needs this error to join
   a domain. This may be the source of future bugs if we cannot
   be sure whether to reject this or not.
*/
   smb_pass = get_smbpwnam(user);
   if(smb_pass)
   {
     /* PAXX: This is the NO LOGON workstation trust account stuff */
     DEBUG(4,("Rejecting workstation trust account %s",user));
     SSVAL(outbuf, smb_flg2, 0xc003); /* PAXX: Someone please unhack this */
     CVAL(outbuf, smb_reh) = 1; /* PAXX: Someone please unhack this */
     return(ERROR(NT_STATUS_ALLOTTED_SPACE_EXCEEDED, 0xc000)); /* 0x99 NT error, 0xc00 */
   }
   computer_id = True;
#else /* not NTDOMAIN, leave this in. PAXX: Someone get rid of this */
    user[strlen(user) - 1] = '\0';
#endif
  }


  /* If no username is sent use the guest account */
  if (!*user)
    {
      strcpy(user,lp_guestaccount(-1));
      /* If no user and no password then set guest flag. */
      if( *smb_apasswd == 0)
        guest = True;
    }

  strlower(user);

  strcpy(sesssetup_user,user);

  reload_services(True);

  add_session_user(user);

  /* Check if the given username was the guest user with no password.
     We need to do this check after add_session_user() as that
     call can potentially change the username (via map_user).
   */

  if(!guest && strequal(user,lp_guestaccount(-1)) && (*smb_apasswd == 0))
    guest = True;

  if (!guest && !(lp_security() == SEC_SERVER && server_validate(inbuf)) &&
      !check_hosts_equiv(user))
    {

      /* now check if it's a valid username/password */
      /* If an NT password was supplied try and validate with that
	 first. This is superior as the passwords are mixed case 
         128 length unicode */
      if(smb_ntpasslen)
	{
	  if(!password_ok(user,smb_ntpasswd,smb_ntpasslen,NULL))
	    DEBUG(0,("NT Password did not match ! Defaulting to Lanman\n"));
	  else
	    valid_nt_password = True;
	} 
      if (!valid_nt_password && !password_ok(user,smb_apasswd,smb_apasslen,NULL))
	{
	  if (!computer_id && lp_security() >= SEC_USER) {
#if (GUEST_SESSSETUP == 0)
	    return(ERROR(ERRSRV,ERRbadpw));
#endif
#if (GUEST_SESSSETUP == 1)
	    if (Get_Pwnam(user,True))
	      return(ERROR(ERRSRV,ERRbadpw));
#endif
	  }
 	  if (*smb_apasswd || !Get_Pwnam(user,True))
	    strcpy(user,lp_guestaccount(-1));
	  DEBUG(3,("Registered username %s for guest access\n",user));
	  guest = True;
	}
    }

  if (!Get_Pwnam(user,True)) {
    DEBUG(3,("No such user %s - using guest account\n",user));
    strcpy(user,lp_guestaccount(-1));
    guest = True;
  }

  if (!strequal(user,lp_guestaccount(-1)) &&
      lp_servicenumber(user) < 0)      
    {
      int homes = lp_servicenumber(HOMES_NAME);
      char *home = get_home_dir(user);
      if (homes >= 0 && home)
	lp_add_home(user,homes,home);
    }


  /* it's ok - setup a reply */
  if (Protocol < PROTOCOL_NT1) {
    set_message(outbuf,3,0,True);
  } else {
    char *p;
    set_message(outbuf,3,3,True);
    p = smb_buf(outbuf);
    strcpy(p,"Unix"); p = skip_string(p,1);
    strcpy(p,"Samba "); strcat(p,VERSION); p = skip_string(p,1);
    strcpy(p,myworkgroup); p = skip_string(p,1);
    set_message(outbuf,3,PTR_DIFF(p,smb_buf(outbuf)),False);
    /* perhaps grab OS version here?? */
  }

  /* Set the correct uid in the outgoing and incoming packets
     We will use this on future requests to determine which
     user we should become.
     */
  {
    struct passwd *pw = Get_Pwnam(user,False);
    if (!pw) {
      DEBUG(1,("Username %s is invalid on this system\n",user));
      return(ERROR(ERRSRV,ERRbadpw));
    }
    gid = pw->pw_gid;
    uid = pw->pw_uid;
  }

  if (guest && !computer_id)
    SSVAL(outbuf,smb_vwv2,1);

  /* register the name and uid as being validated, so further connections
     to a uid can get through without a password, on the same VC */
  sess_vuid = register_vuid(uid,gid,user,guest);
 
  SSVAL(outbuf,smb_uid,sess_vuid);
  SSVAL(inbuf,smb_uid,sess_vuid);

  if (!done_sesssetup)
    max_send = MIN(max_send,smb_bufsize);

  DEBUG(6,("Client requested max send size of %d\n", max_send));

  done_sesssetup = True;

  return chain_reply(inbuf,outbuf,length,bufsize);
}


/****************************************************************************
  reply to a chkpth
****************************************************************************/
int reply_chkpth(char *inbuf,char *outbuf)
{
  int outsize = 0;
  int cnum,mode;
  pstring name;
  BOOL ok = False;
  BOOL bad_path = False;
 
  cnum = SVAL(inbuf,smb_tid);
  
  pstrcpy(name,smb_buf(inbuf) + 1);
  unix_convert(name,cnum,0,&bad_path);

  mode = SVAL(inbuf,smb_vwv0);

  if (check_name(name,cnum))
    ok = directory_exist(name,NULL);

  if (!ok)
  {
    /* We special case this - as when a Windows machine
       is parsing a path is steps through the components
       one at a time - if a component fails it expects
       ERRbadpath, not ERRbadfile.
     */
    if(errno == ENOENT)
    {
      unix_ERR_class = ERRDOS;
      unix_ERR_code = ERRbadpath;
    }

#if 0
    /* Ugly - NT specific hack - maybe not needed ? (JRA) */
    if((errno == ENOTDIR) && (Protocol >= PROTOCOL_NT1) &&
       (get_remote_arch() == RA_WINNT))
    {
      unix_ERR_class = ERRDOS;
      unix_ERR_code = ERRbaddirectory;
    }
#endif

    return(UNIXERROR(ERRDOS,ERRbadpath));
  }
 
  outsize = set_message(outbuf,0,0,True);
  
  DEBUG(3,("%s chkpth %s cnum=%d mode=%d\n",timestring(),name,cnum,mode));
  
  return(outsize);
}


/****************************************************************************
  reply to a getatr
****************************************************************************/
int reply_getatr(char *inbuf,char *outbuf)
{
  pstring fname;
  int cnum;
  int outsize = 0;
  struct stat sbuf;
  BOOL ok = False;
  int mode=0;
  uint32 size=0;
  time_t mtime=0;
  BOOL bad_path = False;
 
  cnum = SVAL(inbuf,smb_tid);

  pstrcpy(fname,smb_buf(inbuf) + 1);
  unix_convert(fname,cnum,0,&bad_path);

  /* dos smetimes asks for a stat of "" - it returns a "hidden directory"
     under WfWg - weird! */
  if (! (*fname))
    {
      mode = aHIDDEN | aDIR;
      if (!CAN_WRITE(cnum)) mode |= aRONLY;
      size = 0;
      mtime = 0;
      ok = True;
    }
  else
    if (check_name(fname,cnum))
    {
      if (sys_stat(fname,&sbuf) == 0)
      {
        mode = dos_mode(cnum,fname,&sbuf);
        size = sbuf.st_size;
        mtime = sbuf.st_mtime;
        if (mode & aDIR)
          size = 0;
        ok = True;
      }
      else
        DEBUG(3,("stat of %s failed (%s)\n",fname,strerror(errno)));
    }
  
  if (!ok)
  {
    if((errno == ENOENT) && bad_path)
    {
      unix_ERR_class = ERRDOS;
      unix_ERR_code = ERRbadpath;
    }

    return(UNIXERROR(ERRDOS,ERRbadfile));
  }
 
  outsize = set_message(outbuf,10,0,True);

  SSVAL(outbuf,smb_vwv0,mode);
  put_dos_date3(outbuf,smb_vwv1,mtime);
  SIVAL(outbuf,smb_vwv3,size);

  if (Protocol >= PROTOCOL_NT1) {
    char *p = strrchr(fname,'/');
    uint16 flg2 = SVAL(outbuf,smb_flg2);
    if (!p) p = fname;
    if (!is_8_3(fname, True))
      SSVAL(outbuf,smb_flg2,flg2 | 0x40); /* IS_LONG_NAME */
  }
  
  DEBUG(3,("%s getatr name=%s mode=%d size=%d\n",timestring(),fname,mode,size));
  
  return(outsize);
}


/****************************************************************************
  reply to a setatr
****************************************************************************/
int reply_setatr(char *inbuf,char *outbuf)
{
  pstring fname;
  int cnum;
  int outsize = 0;
  BOOL ok=False;
  int mode;
  time_t mtime;
  BOOL bad_path = False;
 
  cnum = SVAL(inbuf,smb_tid);
  
  pstrcpy(fname,smb_buf(inbuf) + 1);
  unix_convert(fname,cnum,0,&bad_path);

  mode = SVAL(inbuf,smb_vwv0);
  mtime = make_unix_date3(inbuf+smb_vwv1);
  
  if (directory_exist(fname,NULL))
    mode |= aDIR;
  if (check_name(fname,cnum))
    ok =  (dos_chmod(cnum,fname,mode,NULL) == 0);
  if (ok)
    ok = set_filetime(fname,mtime);
  
  if (!ok)
  {
    if((errno == ENOENT) && bad_path)
    {
      unix_ERR_class = ERRDOS;
      unix_ERR_code = ERRbadpath;
    }

    return(UNIXERROR(ERRDOS,ERRnoaccess));
  }
 
  outsize = set_message(outbuf,0,0,True);
  
  DEBUG(3,("%s setatr name=%s mode=%d\n",timestring(),fname,mode));
  
  return(outsize);
}


/****************************************************************************
  reply to a dskattr
****************************************************************************/
int reply_dskattr(char *inbuf,char *outbuf)
{
  int cnum;
  int outsize = 0;
  int dfree,dsize,bsize;
  
  cnum = SVAL(inbuf,smb_tid);
  
  sys_disk_free(".",&bsize,&dfree,&dsize);
  
  outsize = set_message(outbuf,5,0,True);
  
  SSVAL(outbuf,smb_vwv0,dsize);
  SSVAL(outbuf,smb_vwv1,bsize/512);
  SSVAL(outbuf,smb_vwv2,512);
  SSVAL(outbuf,smb_vwv3,dfree);
  
  DEBUG(3,("%s dskattr cnum=%d dfree=%d\n",timestring(),cnum,dfree));
  
  return(outsize);
}


/****************************************************************************
  reply to a search
  Can be called from SMBsearch, SMBffirst or SMBfunique.
****************************************************************************/
int reply_search(char *inbuf,char *outbuf)
{
  pstring mask;
  pstring directory;
  pstring fname;
  int size,mode;
  time_t date;
  int dirtype;
  int cnum;
  int outsize = 0;
  int numentries = 0;
  BOOL finished = False;
  int maxentries;
  int i;
  char *p;
  BOOL ok = False;
  int status_len;
  char *path;
  char status[21];
  int dptr_num= -1;
  BOOL check_descend = False;
  BOOL expect_close = False;
  BOOL can_open = True;
  BOOL bad_path = False;

  *mask = *directory = *fname = 0;

  /* If we were called as SMBffirst then we must expect close. */
  if(CVAL(inbuf,smb_com) == SMBffirst)
    expect_close = True;
  
  cnum = SVAL(inbuf,smb_tid);

  outsize = set_message(outbuf,1,3,True);
  maxentries = SVAL(inbuf,smb_vwv0); 
  dirtype = SVAL(inbuf,smb_vwv1);
  path = smb_buf(inbuf) + 1;
  status_len = SVAL(smb_buf(inbuf),3 + strlen(path));

  
  /* dirtype &= ~aDIR; */
  
  DEBUG(5,("path=%s status_len=%d\n",path,status_len));

  
  if (status_len == 0)
    {
      pstring dir2;

      pstrcpy(directory,smb_buf(inbuf)+1);
      pstrcpy(dir2,smb_buf(inbuf)+1);
      unix_convert(directory,cnum,0,&bad_path);
      unix_format(dir2);

      if (!check_name(directory,cnum))
        can_open = False;

      p = strrchr(dir2,'/');
      if (p == NULL) 
      {
        strcpy(mask,dir2);
        *dir2 = 0;
      }
      else
      {
        *p = 0;
        pstrcpy(mask,p+1);
      }

      p = strrchr(directory,'/');
      if (!p) 
        *directory = 0;
      else
        *p = 0;

      if (strlen(directory) == 0)
        strcpy(directory,"./");
      bzero(status,21);
      CVAL(status,0) = dirtype;
    }
  else
    {
      memcpy(status,smb_buf(inbuf) + 1 + strlen(path) + 4,21);
      memcpy(mask,status+1,11);
      mask[11] = 0;
      dirtype = CVAL(status,0) & 0x1F;
      Connections[cnum].dirptr = dptr_fetch(status+12,&dptr_num);      
      if (!Connections[cnum].dirptr)
	goto SearchEmpty;
      string_set(&Connections[cnum].dirpath,dptr_path(dptr_num));
      if (!case_sensitive)
	strnorm(mask);
    }

  /* turn strings of spaces into a . */  
  {
    trim_string(mask,NULL," ");
    if ((p = strrchr(mask,' ')))
      {
	fstring ext;
	fstrcpy(ext,p+1);
	*p = 0;
	trim_string(mask,NULL," ");
	strcat(mask,".");
	strcat(mask,ext);
      }
  }

  {
    for (p=mask; *p; p++)
      {
	if (*p != '?' && *p != '*' && !isdoschar(*p))
	  {
	    DEBUG(5,("Invalid char [%c] in search mask?\n",*p));
	    *p = '?';
	  }
      }
  }

  if (!strchr(mask,'.') && strlen(mask)>8)
    {
      fstring tmp;
      fstrcpy(tmp,&mask[8]);
      mask[8] = '.';
      mask[9] = 0;
      strcat(mask,tmp);
    }

  DEBUG(5,("mask=%s directory=%s\n",mask,directory));
  
  if (can_open)
    {
      p = smb_buf(outbuf) + 3;
      
      ok = True;
      
      if (status_len == 0)
	{
	  dptr_num = dptr_create(cnum,directory,expect_close,SVAL(inbuf,smb_pid));
	  if (dptr_num < 0)
        {
          if(dptr_num == -2)
          {
            if((errno == ENOENT) && bad_path)
            {
              unix_ERR_class = ERRDOS;
              unix_ERR_code = ERRbadpath;
            }
            return (UNIXERROR(ERRDOS,ERRnofids));
          }
          return(ERROR(ERRDOS,ERRnofids));
        }
	}

      DEBUG(4,("dptr_num is %d\n",dptr_num));

      if (ok)
	{
	  if ((dirtype&0x1F) == aVOLID)
	    {	  
	      memcpy(p,status,21);
	      make_dir_struct(p,"???????????",volume_label(SNUM(cnum)),0,aVOLID,0);
	      dptr_fill(p+12,dptr_num);
	      if (dptr_zero(p+12) && (status_len==0))
		numentries = 1;
	      else
		numentries = 0;
	      p += DIR_STRUCT_SIZE;
	    }
	  else 
	    {
	      DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",Connections[cnum].dirpath,lp_dontdescend(SNUM(cnum))));
	      if (in_list(Connections[cnum].dirpath,
			  lp_dontdescend(SNUM(cnum)),True))
		check_descend = True;

	      for (i=numentries;(i<maxentries) && !finished;i++)
		{
		  finished = 
		    !get_dir_entry(cnum,mask,dirtype,fname,&size,&mode,&date,check_descend);
		  if (!finished)
		    {
		      memcpy(p,status,21);
		      make_dir_struct(p,mask,fname,size,mode,date);
		      dptr_fill(p+12,dptr_num);
		      numentries++;
		    }
		  p += DIR_STRUCT_SIZE;
		}
	    }
	}
    }


 SearchEmpty:

  if (numentries == 0 || !ok)
    {
      CVAL(outbuf,smb_rcls) = ERRDOS;
      SSVAL(outbuf,smb_err,ERRnofiles);
    }

  /* If we were called as SMBffirst with smb_search_id == NULL
     and no entries were found then return error and close dirptr 
     (X/Open spec) */

  if(ok && expect_close && numentries == 0 && status_len == 0)
    {
      CVAL(outbuf,smb_rcls) = ERRDOS;
      SSVAL(outbuf,smb_err,ERRnofiles);
      /* Also close the dptr - we know it's gone */
      dptr_close(dptr_num);
    }

  /* If we were called as SMBfunique, then we can close the dirptr now ! */
  if(dptr_num >= 0 && CVAL(inbuf,smb_com) == SMBfunique)
    dptr_close(dptr_num);

  SSVAL(outbuf,smb_vwv0,numentries);
  SSVAL(outbuf,smb_vwv1,3 + numentries * DIR_STRUCT_SIZE);
  CVAL(smb_buf(outbuf),0) = 5;
  SSVAL(smb_buf(outbuf),1,numentries*DIR_STRUCT_SIZE);

  if (Protocol >= PROTOCOL_NT1) {
    uint16 flg2 = SVAL(outbuf,smb_flg2);
    SSVAL(outbuf,smb_flg2,flg2 | 0x40); /* IS_LONG_NAME */
  }
  
  outsize += DIR_STRUCT_SIZE*numentries;
  smb_setlen(outbuf,outsize - 4);
  
  if ((! *directory) && dptr_path(dptr_num))
    sprintf(directory,"(%s)",dptr_path(dptr_num));

  DEBUG(4,("%s %s mask=%s path=%s cnum=%d dtype=%d nument=%d of %d\n",
	timestring(),
	smb_fn_name(CVAL(inbuf,smb_com)), 
	mask,directory,cnum,dirtype,numentries,maxentries));

  return(outsize);
}


/****************************************************************************
  reply to a fclose (stop directory search)
****************************************************************************/
int reply_fclose(char *inbuf,char *outbuf)
{
  int cnum;
  int outsize = 0;
  int status_len;
  char *path;
  char status[21];
  int dptr_num= -1;

  cnum = SVAL(inbuf,smb_tid);

  outsize = set_message(outbuf,1,0,True);
  path = smb_buf(inbuf) + 1;
  status_len = SVAL(smb_buf(inbuf),3 + strlen(path));

  
  if (status_len == 0)
    return(ERROR(ERRSRV,ERRsrverror));

  memcpy(status,smb_buf(inbuf) + 1 + strlen(path) + 4,21);

  if(dptr_fetch(status+12,&dptr_num)) {
    /*  Close the dptr - we know it's gone */
    dptr_close(dptr_num);
  }

  SSVAL(outbuf,smb_vwv0,0);

  DEBUG(3,("%s search close cnum=%d\n",timestring(),cnum));

  return(outsize);
}


/****************************************************************************
  reply to an open
****************************************************************************/
int reply_open(char *inbuf,char *outbuf)
{
  pstring fname;
  int cnum;
  int fnum = -1;
  int outsize = 0;
  int fmode=0;
  int share_mode;
  int size = 0;
  time_t mtime=0;
  int unixmode;
  int rmode=0;
  struct stat sbuf;
  BOOL bad_path = False;
  files_struct *fsp;
  int oplock_request = CORE_OPLOCK_REQUEST(inbuf);
 
  cnum = SVAL(inbuf,smb_tid);

  share_mode = SVAL(inbuf,smb_vwv0);

  pstrcpy(fname,smb_buf(inbuf)+1);
  unix_convert(fname,cnum,0,&bad_path);
    
  fnum = find_free_file();
  if (fnum < 0)
    return(ERROR(ERRSRV,ERRnofids));

  if (!check_name(fname,cnum))
  {
    if((errno == ENOENT) && bad_path)
    {
      unix_ERR_class = ERRDOS;
      unix_ERR_code = ERRbadpath;
    }
    return(UNIXERROR(ERRDOS,ERRnoaccess));
  }
 
  unixmode = unix_mode(cnum,aARCH);
      
  open_file_shared(fnum,cnum,fname,share_mode,3,unixmode,
                   oplock_request,&rmode,NULL);

  fsp = &Files[fnum];

  if (!fsp->open)
  {
    if((errno == ENOENT) && bad_path)
    {
      unix_ERR_class = ERRDOS;
      unix_ERR_code = ERRbadpath;
    }
    return(UNIXERROR(ERRDOS,ERRnoaccess));
  }

  if (fstat(fsp->fd_ptr->fd,&sbuf) != 0) {
    close_file(fnum,False);
    return(ERROR(ERRDOS,ERRnoaccess));
  }
    
  size = sbuf.st_size;
  fmode = dos_mode(cnum,fname,&sbuf);
  mtime = sbuf.st_mtime;

  if (fmode & aDIR) {
    DEBUG(3,("attempt to open a directory %s\n",fname));
    close_file(fnum,False);
    return(ERROR(ERRDOS,ERRnoaccess));
  }
  
  outsize = set_message(outbuf,7,0,True);
  SSVAL(outbuf,smb_vwv0,fnum);
  SSVAL(outbuf,smb_vwv1,fmode);
  put_dos_date3(outbuf,smb_vwv2,mtime);
  SIVAL(outbuf,smb_vwv4,size);
  SSVAL(outbuf,smb_vwv6,rmode);

  if (oplock_request && lp_fake_oplocks(SNUM(cnum))) {
    CVAL(outbuf,smb_flg) |= CORE_OPLOCK_GRANTED;
  }
    
  if(fsp->granted_oplock)
    CVAL(outbuf,smb_flg) |= CORE_OPLOCK_GRANTED;
  return(outsize);
}


/****************************************************************************
  reply to an open and X
****************************************************************************/
int reply_open_and_X(char *inbuf,char *outbuf,int length,int bufsize)
{
  pstring fname;
  int cnum = SVAL(inbuf,smb_tid);
  int fnum = -1;
  int smb_mode = SVAL(inbuf,smb_vwv3);
  int smb_attr = SVAL(inbuf,smb_vwv5);
  BOOL oplock_request = EXTENDED_OPLOCK_REQUEST(inbuf);
#if 0
  int open_flags = SVAL(inbuf,smb_vwv2);
  int smb_sattr = SVAL(inbuf,smb_vwv4); 
  uint32 smb_time = make_unix_date3(inbuf+smb_vwv6);
#endif
  int smb_ofun = SVAL(inbuf,smb_vwv8);
  int unixmode;
  int size=0,fmode=0,mtime=0,rmode=0;
  struct stat sbuf;
  int smb_action = 0;
  BOOL bad_path = False;
  files_struct *fsp;

  /* If it's an IPC, pass off the pipe handler. */
  if (IS_IPC(cnum))
    return reply_open_pipe_and_X(inbuf,outbuf,length,bufsize);

  /* XXXX we need to handle passed times, sattr and flags */

  pstrcpy(fname,smb_buf(inbuf));
  unix_convert(fname,cnum,0,&bad_path);
    
  fnum = find_free_file();
  if (fnum < 0)
    return(ERROR(ERRSRV,ERRnofids));

  if (!check_name(fname,cnum))
  {
    if((errno == ENOENT) && bad_path)
    {
      unix_ERR_class = ERRDOS;
      unix_ERR_code = ERRbadpath;
    }
    return(UNIXERROR(ERRDOS,ERRnoaccess));
  }

  unixmode = unix_mode(cnum,smb_attr | aARCH);
      
  open_file_shared(fnum,cnum,fname,smb_mode,smb_ofun,unixmode,
		   oplock_request, &rmode,&smb_action);
      
  fsp = &Files[fnum];

  if (!fsp->open)
  {
    if((errno == ENOENT) && bad_path)
    {
      unix_ERR_class = ERRDOS;
      unix_ERR_code = ERRbadpath;
    }
    return(UNIXERROR(ERRDOS,ERRnoaccess));
  }

  if (fstat(fsp->fd_ptr->fd,&sbuf) != 0) {
    close_file(fnum,False);
    return(ERROR(ERRDOS,ERRnoaccess));
  }

  size = sbuf.st_size;
  fmode = dos_mode(cnum,fname,&sbuf);
  mtime = sbuf.st_mtime;
  if (fmode & aDIR) {
    close_file(fnum,False);
    return(ERROR(ERRDOS,ERRnoaccess));
  }

  if (oplock_request && lp_fake_oplocks(SNUM(cnum))) {
    smb_action |= EXTENDED_OPLOCK_GRANTED;
    CVAL(outbuf,smb_flg) |= CORE_OPLOCK_GRANTED;
  }

  if(fsp->granted_oplock) {
    smb_action |= EXTENDED_OPLOCK_GRANTED;
    CVAL(outbuf,smb_flg) |= CORE_OPLOCK_GRANTED;
  }

  set_message(outbuf,15,0,True);
  SSVAL(outbuf,smb_vwv2,fnum);
  SSVAL(outbuf,smb_vwv3,fmode);
  put_dos_date3(outbuf,smb_vwv4,mtime);
  SIVAL(outbuf,smb_vwv6,size);
  SSVAL(outbuf,smb_vwv8,rmode);
  SSVAL(outbuf,smb_vwv11,smb_action);

  chain_fnum = fnum;

  return chain_reply(inbuf,outbuf,length,bufsize);
}


/****************************************************************************
  reply to a SMBulogoffX
****************************************************************************/
int reply_ulogoffX(char *inbuf,char *outbuf,int length,int bufsize)
{
  uint16 vuid = SVAL(inbuf,smb_uid);
  user_struct *vuser = get_valid_user_struct(vuid);

  if(vuser == 0) {
    DEBUG(3,("ulogoff, vuser id %d does not map to user.\n", vuid));
  }

  /* in user level security we are supposed to close any files
     open by this user */
  if ((vuser != 0) && (lp_security() != SEC_SHARE)) {
    int i;
    for (i=0;i<MAX_OPEN_FILES;i++)
      if (Files[i].uid == vuser->uid && Files[i].open) {
	close_file(i,False);
      }
  }

  invalidate_vuid(vuid);

  set_message(outbuf,2,0,True);

  DEBUG(3,("%s ulogoffX vuid=%d\n",timestring(),vuid));

  return chain_reply(inbuf,outbuf,length,bufsize);
}


/****************************************************************************
  reply to a mknew or a create
****************************************************************************/
int reply_mknew(char *inbuf,char *outbuf)
{
  pstring fname;
  int cnum,com;
  int fnum = -1;
  int outsize = 0;
  int createmode;
  mode_t unixmode;
  int ofun = 0;
  BOOL bad_path = False;
  files_struct *fsp;
  int oplock_request = CORE_OPLOCK_REQUEST(inbuf);
 
  com = SVAL(inbuf,smb_com);
  cnum = SVAL(inbuf,smb_tid);

  createmode = SVAL(inbuf,smb_vwv0);
  pstrcpy(fname,smb_buf(inbuf)+1);
  unix_convert(fname,cnum,0,&bad_path);

  if (createmode & aVOLID)
    {
      DEBUG(0,("Attempt to create file (%s) with volid set - please report this\n",fname));
    }
  
  unixmode = unix_mode(cnum,createmode);
  
  fnum = find_free_file();
  if (fnum < 0)
    return(ERROR(ERRSRV,ERRnofids));

  if (!check_name(fname,cnum))
  {
    if((errno == ENOENT) && bad_path)
    {
      unix_ERR_class = ERRDOS;
      unix_ERR_code = ERRbadpath;
    }
    return(UNIXERROR(ERRDOS,ERRnoaccess));
  }

  if(com == SMBmknew)
  {
    /* We should fail if file exists. */
    ofun = 0x10;
  }
  else
  {
    /* SMBcreate - Create if file doesn't exist, truncate if it does. */
    ofun = 0x12;
  }

  /* Open file in dos compatibility share mode. */
  open_file_shared(fnum,cnum,fname,(DENY_FCB<<4)|0xF, ofun, unixmode, 
                   oplock_request, NULL, NULL);
  
  fsp = &Files[fnum];

  if (!fsp->open)
  {
    if((errno == ENOENT) && bad_path) 
    {
      unix_ERR_class = ERRDOS;
      unix_ERR_code = ERRbadpath;
    }
    return(UNIXERROR(ERRDOS,ERRnoaccess));
  }
 
  outsize = set_message(outbuf,1,0,True);
  SSVAL(outbuf,smb_vwv0,fnum);

  if (oplock_request && lp_fake_oplocks(SNUM(cnum))) {
    CVAL(outbuf,smb_flg) |= CORE_OPLOCK_GRANTED;
  }
 
  if(fsp->granted_oplock)
    CVAL(outbuf,smb_flg) |= CORE_OPLOCK_GRANTED;
 
  DEBUG(2,("new file %s\n",fname));
  DEBUG(3,("%s mknew %s fd=%d fnum=%d cnum=%d dmode=%d umode=%o\n",timestring(),fname,Files[fnum].fd_ptr->fd,fnum,cnum,createmode,unixmode));
  
  return(outsize);
}


/****************************************************************************
  reply to a create temporary file
****************************************************************************/
int reply_ctemp(char *inbuf,char *outbuf)
{
  pstring fname;
  pstring fname2;
  int cnum;
  int fnum = -1;
  int outsize = 0;
  int createmode;
  mode_t unixmode;
  BOOL bad_path = False;
  files_struct *fsp;
  int oplock_request = CORE_OPLOCK_REQUEST(inbuf);
 
  cnum = SVAL(inbuf,smb_tid);
  createmode = SVAL(inbuf,smb_vwv0);
  pstrcpy(fname,smb_buf(inbuf)+1);
  strcat(fname,"/TMXXXXXX");
  unix_convert(fname,cnum,0,&bad_path);
  
  unixmode = unix_mode(cnum,createmode);
  
  fnum = find_free_file();
  if (fnum < 0)
    return(ERROR(ERRSRV,ERRnofids));

  if (!check_name(fname,cnum))
  {
    if((errno == ENOENT) && bad_path)
    {
      unix_ERR_class = ERRDOS;
      unix_ERR_code = ERRbadpath;
    }
    return(UNIXERROR(ERRDOS,ERRnoaccess));
  }

  strcpy(fname2,(char *)mktemp(fname));

  /* Open file in dos compatibility share mode. */
  /* We should fail if file exists. */
  open_file_shared(fnum,cnum,fname2,(DENY_FCB<<4)|0xF, 0x10, unixmode, 
                   oplock_request, NULL, NULL);

  fsp = &Files[fnum];

  if (!fsp->open)
  {
    if((errno == ENOENT) && bad_path)
    {
      unix_ERR_class = ERRDOS;
      unix_ERR_code = ERRbadpath;
    }
    return(UNIXERROR(ERRDOS,ERRnoaccess));
  }

  outsize = set_message(outbuf,1,2 + strlen(fname2),True);
  SSVAL(outbuf,smb_vwv0,fnum);
  CVAL(smb_buf(outbuf),0) = 4;
  strcpy(smb_buf(outbuf) + 1,fname2);

  if (oplock_request && lp_fake_oplocks(SNUM(cnum))) {
    CVAL(outbuf,smb_flg) |= CORE_OPLOCK_GRANTED;
  }
  
  if(fsp->granted_oplock)
    CVAL(outbuf,smb_flg) |= CORE_OPLOCK_GRANTED;

  DEBUG(2,("created temp file %s\n",fname2));
  DEBUG(3,("%s ctemp %s fd=%d fnum=%d cnum=%d dmode=%d umode=%o\n",timestring(),fname2,Files[fnum].fd_ptr->fd,fnum,cnum,createmode,unixmode));
  
  return(outsize);
}


/*******************************************************************
check if a user is allowed to delete a file
********************************************************************/
static BOOL can_delete(char *fname,int cnum,int dirtype)
{
  struct stat sbuf;
  int fmode;

  if (!CAN_WRITE(cnum)) return(False);

  if (sys_lstat(fname,&sbuf) != 0) return(False);
  fmode = dos_mode(cnum,fname,&sbuf);
  if (fmode & aDIR) return(False);
  if (!lp_delete_readonly(SNUM(cnum))) {
    if (fmode & aRONLY) return(False);
  }
  if ((fmode & ~dirtype) & (aHIDDEN | aSYSTEM))
    return(False);
  if (!check_file_sharing(cnum,fname)) return(False);
  return(True);
}

/****************************************************************************
  reply to a unlink
****************************************************************************/
int reply_unlink(char *inbuf,char *outbuf)
{
  int outsize = 0;
  pstring name;
  int cnum;
  int dirtype;
  pstring directory;
  pstring mask;
  char *p;
  int count=0;
  int error = ERRnoaccess;
  BOOL has_wild;
  BOOL exists=False;
  BOOL bad_path = False;

  *directory = *mask = 0;

  cnum = SVAL(inbuf,smb_tid);
  dirtype = SVAL(inbuf,smb_vwv0);
  
  pstrcpy(name,smb_buf(inbuf) + 1);
   
  DEBUG(3,("reply_unlink : %s\n",name));
   
  unix_convert(name,cnum,0,&bad_path);

  p = strrchr(name,'/');
  if (!p) {
    strcpy(directory,"./");
    strcpy(mask,name);
  } else {
    *p = 0;
    strcpy(directory,name);
    strcpy(mask,p+1);
  }

  if (is_mangled(mask))
    check_mangled_stack(mask);

  has_wild = strchr(mask,'*') || strchr(mask,'?');

  if (!has_wild) {
    strcat(directory,"/");
    strcat(directory,mask);
    if (can_delete(directory,cnum,dirtype) && !sys_unlink(directory)) count++;
    if (!count) exists = file_exist(directory,NULL);    
  } else {
    void *dirptr = NULL;
    char *dname;

    if (check_name(directory,cnum))
      dirptr = OpenDir(cnum, directory, True);

    /* XXXX the CIFS spec says that if bit0 of the flags2 field is set then
       the pattern matches against the long name, otherwise the short name 
       We don't implement this yet XXXX
       */

    if (dirptr)
      {
	error = ERRbadfile;

	if (strequal(mask,"????????.???"))
	  strcpy(mask,"*");

	while ((dname = ReadDirName(dirptr)))
	  {
	    pstring fname;
	    pstrcpy(fname,dname);
	    
	    if(!mask_match(fname, mask, case_sensitive, False)) continue;

	    error = ERRnoaccess;
	    sprintf(fname,"%s/%s",directory,dname);
	    if (!can_delete(fname,cnum,dirtype)) continue;
	    if (!sys_unlink(fname)) count++;
	    DEBUG(3,("reply_unlink : doing unlink on %s\n",fname));
	  }
	CloseDir(dirptr);
      }
  }
  
  if (count == 0) {
    if (exists)
      return(ERROR(ERRDOS,error));
    else
    {
      if((errno == ENOENT) && bad_path)
      {
        unix_ERR_class = ERRDOS;
        unix_ERR_code = ERRbadpath;
      }
      return(UNIXERROR(ERRDOS,error));
    }
  }
  
  outsize = set_message(outbuf,0,0,True);
  
  return(outsize);
}


/****************************************************************************
   reply to a readbraw (core+ protocol)
****************************************************************************/
int reply_readbraw(char *inbuf, char *outbuf)
{
  int cnum,maxcount,mincount,fnum;
  int nread = 0;
  uint32 startpos;
  char *header = outbuf;
  int ret=0;
  int fd;
  char *fname;

  /*
   * Special check if an oplock break has been issued
   * and the readraw request croses on the wire, we must
   * return a zero length response here.
   */

  if(global_oplock_break)
  {
    _smb_setlen(header,0);
    transfer_file(0,Client,0,header,4,0);
    DEBUG(5,("readbraw - oplock break finished\n"));
    return -1;
  }

  cnum = SVAL(inbuf,smb_tid);
  fnum = GETFNUM(inbuf,smb_vwv0);

  startpos = IVAL(inbuf,smb_vwv1);
  maxcount = SVAL(inbuf,smb_vwv3);
  mincount = SVAL(inbuf,smb_vwv4);

  /* ensure we don't overrun the packet size */
  maxcount = MIN(65535,maxcount);
  maxcount = MAX(mincount,maxcount);

  if (!FNUM_OK(fnum,cnum) || !Files[fnum].can_read)
    {
      DEBUG(3,("fnum %d not open in readbraw - cache prime?\n",fnum));
      _smb_setlen(header,0);
      transfer_file(0,Client,0,header,4,0);
      return(-1);
    }
  else
    {
      fd = Files[fnum].fd_ptr->fd;
      fname = Files[fnum].name;
    }


  if (!is_locked(fnum,cnum,maxcount,startpos))
    {
      int size = Files[fnum].size;
      int sizeneeded = startpos + maxcount;
	    
      if (size < sizeneeded) {
	struct stat st;
	if (fstat(Files[fnum].fd_ptr->fd,&st) == 0)
	  size = st.st_size;
	if (!Files[fnum].can_write) 
	  Files[fnum].size = size;
      }

      nread = MIN(maxcount,(int)(size - startpos));	  
    }

  if (nread < mincount)
    nread = 0;
  
  DEBUG(3,("%s readbraw fnum=%d cnum=%d start=%d max=%d min=%d nread=%d\n",
	   timestring(),
	   fnum,cnum,startpos,
	   maxcount,mincount,nread));
  
#if UNSAFE_READRAW
  {
    int predict=0;
    _smb_setlen(header,nread);

    if (!Files[fnum].can_write)
      predict = read_predict(fd,startpos,header+4,NULL,nread);

    if ((nread-predict) > 0)
      seek_file(fnum,startpos + predict);
    
    ret = transfer_file(fd,Client,nread-predict,header,4+predict,
			startpos+predict);
  }

  if (ret != nread+4)
    DEBUG(0,("ERROR: file read failure on %s at %d for %d bytes (%d)\n",
	     fname,startpos,nread,ret));

#else
  ret = read_file(fnum,header+4,startpos,nread);
  if (ret < mincount) ret = 0;

  _smb_setlen(header,ret);
  transfer_file(0,Client,0,header,4+ret,0);
#endif

  DEBUG(5,("readbraw finished\n"));
  return -1;
}


/****************************************************************************
  reply to a lockread (core+ protocol)
****************************************************************************/
int reply_lockread(char *inbuf,char *outbuf)
{
  int cnum,fnum;
  int nread = -1;
  char *data;
  int outsize = 0;
  uint32 startpos, numtoread;
  int eclass;
  uint32 ecode;
  
  cnum = SVAL(inbuf,smb_tid);
  fnum = GETFNUM(inbuf,smb_vwv0);

  CHECK_FNUM(fnum,cnum);
  CHECK_READ(fnum);
  CHECK_ERROR(fnum);

  numtoread = SVAL(inbuf,smb_vwv1);
  startpos = IVAL(inbuf,smb_vwv2);
  
  outsize = set_message(outbuf,5,3,True);
  numtoread = MIN(BUFFER_SIZE-outsize,numtoread);
  data = smb_buf(outbuf) + 3;
  
  if(!do_lock( fnum, cnum, numtoread, startpos, &eclass, &ecode))
    return (ERROR(eclass,ecode));

  nread = read_file(fnum,data,startpos,numtoread);
  
  if (nread < 0)
    return(UNIXERROR(ERRDOS,ERRnoaccess));
  
  outsize += nread;
  SSVAL(outbuf,smb_vwv0,nread);
  SSVAL(outbuf,smb_vwv5,nread+3);
  SSVAL(smb_buf(outbuf),1,nread);
  
  DEBUG(3,("%s lockread fnum=%d cnum=%d num=%d nread=%d\n",timestring(),fnum,cnum,numtoread,nread));
  
  return(outsize);
}


/****************************************************************************
  reply to a read
****************************************************************************/
int reply_read(char *inbuf,char *outbuf)
{
  int cnum,numtoread,fnum;
  int nread = 0;
  char *data;
  uint32 startpos;
  int outsize = 0;
  
  cnum = SVAL(inbuf,smb_tid);
  fnum = GETFNUM(inbuf,smb_vwv0);

  CHECK_FNUM(fnum,cnum);
  CHECK_READ(fnum);
  CHECK_ERROR(fnum);

  numtoread = SVAL(inbuf,smb_vwv1);
  startpos = IVAL(inbuf,smb_vwv2);
  
  outsize = set_message(outbuf,5,3,True);
  numtoread = MIN(BUFFER_SIZE-outsize,numtoread);
  data = smb_buf(outbuf) + 3;
  
  if (is_locked(fnum,cnum,numtoread,startpos))
    return(ERROR(ERRDOS,ERRlock));	

  if (numtoread > 0)
    nread = read_file(fnum,data,startpos,numtoread);
  
  if (nread < 0)
    return(UNIXERROR(ERRDOS,ERRnoaccess));
  
  outsize += nread;
  SSVAL(outbuf,smb_vwv0,nread);
  SSVAL(outbuf,smb_vwv5,nread+3);
  CVAL(smb_buf(outbuf),0) = 1;
  SSVAL(smb_buf(outbuf),1,nread);
  
  DEBUG(3,("%s read fnum=%d cnum=%d num=%d nread=%d\n",timestring(),fnum,cnum,numtoread,nread));
  
  return(outsize);
}


/****************************************************************************
  reply to a read and X
****************************************************************************/
int reply_read_and_X(char *inbuf,char *outbuf,int length,int bufsize)
{
  int fnum = GETFNUM(inbuf,smb_vwv2);
  uint32 smb_offs = IVAL(inbuf,smb_vwv3);
  int smb_maxcnt = SVAL(inbuf,smb_vwv5);
  int smb_mincnt = SVAL(inbuf,smb_vwv6);
  int cnum;
  int nread = -1;
  char *data;
  BOOL ok = False;

  cnum = SVAL(inbuf,smb_tid);

  CHECK_FNUM(fnum,cnum);
  CHECK_READ(fnum);
  CHECK_ERROR(fnum);

  set_message(outbuf,12,0,True);
  data = smb_buf(outbuf);

  if (is_locked(fnum,cnum,smb_maxcnt,smb_offs))
    return(ERROR(ERRDOS,ERRlock));
  nread = read_file(fnum,data,smb_offs,smb_maxcnt);
  ok = True;
  
  if (nread < 0)
    return(UNIXERROR(ERRDOS,ERRnoaccess));
  
  SSVAL(outbuf,smb_vwv5,nread);
  SSVAL(outbuf,smb_vwv6,smb_offset(data,outbuf));
  SSVAL(smb_buf(outbuf),-2,nread);
  
  DEBUG(3,("%s readX fnum=%d cnum=%d min=%d max=%d nread=%d\n",
	timestring(),fnum,cnum,
	smb_mincnt,smb_maxcnt,nread));

  chain_fnum = fnum;

  return chain_reply(inbuf,outbuf,length,bufsize);
}


/****************************************************************************
  reply to a writebraw (core+ or LANMAN1.0 protocol)
****************************************************************************/
int reply_writebraw(char *inbuf,char *outbuf)
{
  int nwritten=0;
  int total_written=0;
  int numtowrite=0;
  int cnum,fnum;
  int outsize = 0;
  long startpos;
  char *data=NULL;
  BOOL write_through;
  int tcount;

  cnum = SVAL(inbuf,smb_tid);
  fnum = GETFNUM(inbuf,smb_vwv0);

  CHECK_FNUM(fnum,cnum);
  CHECK_WRITE(fnum);
  CHECK_ERROR(fnum);
  
  tcount = IVAL(inbuf,smb_vwv1);
  startpos = IVAL(inbuf,smb_vwv3);
  write_through = BITSETW(inbuf+smb_vwv7,0);

  /* We have to deal with slightly different formats depending
     on whether we are using the core+ or lanman1.0 protocol */
  if(Protocol <= PROTOCOL_COREPLUS) {
    numtowrite = SVAL(smb_buf(inbuf),-2);
    data = smb_buf(inbuf);
  } else {
    numtowrite = SVAL(inbuf,smb_vwv10);
    data = smb_base(inbuf) + SVAL(inbuf, smb_vwv11);
  }

  /* force the error type */
  CVAL(inbuf,smb_com) = SMBwritec;
  CVAL(outbuf,smb_com) = SMBwritec;

  if (is_locked(fnum,cnum,tcount,startpos))
    return(ERROR(ERRDOS,ERRlock));

  if (seek_file(fnum,startpos) != startpos)
    DEBUG(0,("couldn't seek to %d in writebraw\n",startpos));

  if (numtowrite>0)
    nwritten = write_file(fnum,data,numtowrite);
  
  DEBUG(3,("%s writebraw1 fnum=%d cnum=%d start=%d num=%d wrote=%d sync=%d\n",
	   timestring(),fnum,cnum,startpos,numtowrite,nwritten,write_through));

  if (nwritten < numtowrite) 
    return(UNIXERROR(ERRHRD,ERRdiskfull));

  total_written = nwritten;

  /* Return a message to the redirector to tell it
     to send more bytes */
  CVAL(outbuf,smb_com) = SMBwritebraw;
  SSVALS(outbuf,smb_vwv0,-1);
  outsize = set_message(outbuf,Protocol>PROTOCOL_COREPLUS?1:0,0,True);
  send_smb(Client,outbuf);
  
  /* Now read the raw data into the buffer and write it */
  if (read_smb_length(Client,inbuf,SMB_SECONDARY_WAIT) == -1) {
    exit_server("secondary writebraw failed");
  }
  
  /* Even though this is not an smb message, smb_len
     returns the generic length of an smb message */
  numtowrite = smb_len(inbuf);

  if (tcount > nwritten+numtowrite) {
    DEBUG(3,("Client overestimated the write %d %d %d\n",
	     tcount,nwritten,numtowrite));
  }

  nwritten = transfer_file(Client,Files[fnum].fd_ptr->fd,numtowrite,NULL,0,
			   startpos+nwritten);
  total_written += nwritten;
  
  /* Set up outbuf to return the correct return */
  outsize = set_message(outbuf,1,0,True);
  CVAL(outbuf,smb_com) = SMBwritec;
  SSVAL(outbuf,smb_vwv0,total_written);

  if (nwritten < numtowrite) {
    CVAL(outbuf,smb_rcls) = ERRHRD;
    SSVAL(outbuf,smb_err,ERRdiskfull);      
  }

  if (lp_syncalways(SNUM(cnum)) || write_through)
    sync_file(fnum);

  DEBUG(3,("%s writebraw2 fnum=%d cnum=%d start=%d num=%d wrote=%d\n",
	   timestring(),fnum,cnum,startpos,numtowrite,total_written));

  /* we won't return a status if write through is not selected - this 
     follows what WfWg does */
  if (!write_through && total_written==tcount)
    return(-1);

  return(outsize);
}


/****************************************************************************
  reply to a writeunlock (core+)
****************************************************************************/
int reply_writeunlock(char *inbuf,char *outbuf)
{
  int cnum,fnum;
  int nwritten = -1;
  int outsize = 0;
  char *data;
  uint32 numtowrite,startpos;
  int eclass;
  uint32 ecode;
  
  cnum = SVAL(inbuf,smb_tid);
  fnum = GETFNUM(inbuf,smb_vwv0);

  CHECK_FNUM(fnum,cnum);
  CHECK_WRITE(fnum);
  CHECK_ERROR(fnum);

  numtowrite = SVAL(inbuf,smb_vwv1);
  startpos = IVAL(inbuf,smb_vwv2);
  data = smb_buf(inbuf) + 3;
  
  if (is_locked(fnum,cnum,numtowrite,startpos))
    return(ERROR(ERRDOS,ERRlock));

  seek_file(fnum,startpos);

  /* The special X/Open SMB protocol handling of
     zero length writes is *NOT* done for
     this call */
  if(numtowrite == 0)
    nwritten = 0;
  else
    nwritten = write_file(fnum,data,numtowrite);
  
  if (lp_syncalways(SNUM(cnum)))
    sync_file(fnum);

  if(((nwritten == 0) && (numtowrite != 0))||(nwritten < 0))
    return(UNIXERROR(ERRDOS,ERRnoaccess));

  if(!do_unlock(fnum, cnum, numtowrite, startpos, &eclass, &ecode))
    return(ERROR(eclass,ecode));

  outsize = set_message(outbuf,1,0,True);
  
  SSVAL(outbuf,smb_vwv0,nwritten);
  
  DEBUG(3,("%s writeunlock fnum=%d cnum=%d num=%d wrote=%d\n",
	   timestring(),fnum,cnum,numtowrite,nwritten));
  
  return(outsize);
}


/****************************************************************************
  reply to a write
****************************************************************************/
int reply_write(char *inbuf,char *outbuf,int dum1,int dum2)
{
  int cnum,numtowrite,fnum;
  int nwritten = -1;
  int outsize = 0;
  int startpos;
  char *data;

  dum1 = dum2 = 0;

  
  cnum = SVAL(inbuf,smb_tid);
  fnum = GETFNUM(inbuf,smb_vwv0);

  CHECK_FNUM(fnum,cnum);
  CHECK_WRITE(fnum);
  CHECK_ERROR(fnum);

  numtowrite = SVAL(inbuf,smb_vwv1);
  startpos = IVAL(inbuf,smb_vwv2);
  data = smb_buf(inbuf) + 3;
  
  if (is_locked(fnum,cnum,numtowrite,startpos))
    return(ERROR(ERRDOS,ERRlock));

  seek_file(fnum,startpos);

  /* X/Open SMB protocol says that if smb_vwv1 is
     zero then the file size should be extended or
     truncated to the size given in smb_vwv[2-3] */
  if(numtowrite == 0)
    nwritten = set_filelen(Files[fnum].fd_ptr->fd, startpos);
  else
    nwritten = write_file(fnum,data,numtowrite);
  
  if (lp_syncalways(SNUM(cnum)))
    sync_file(fnum);

  if(((nwritten == 0) && (numtowrite != 0))||(nwritten < 0))
    return(UNIXERROR(ERRDOS,ERRnoaccess));

  outsize = set_message(outbuf,1,0,True);
  
  SSVAL(outbuf,smb_vwv0,nwritten);

  if (nwritten < numtowrite) {
    CVAL(outbuf,smb_rcls) = ERRHRD;
    SSVAL(outbuf,smb_err,ERRdiskfull);      
  }
  
  DEBUG(3,("%s write fnum=%d cnum=%d num=%d wrote=%d\n",timestring(),fnum,cnum,numtowrite,nwritten));
  
  return(outsize);
}


/****************************************************************************
  reply to a write and X
****************************************************************************/
int reply_write_and_X(char *inbuf,char *outbuf,int length,int bufsize)
{
  int fnum = GETFNUM(inbuf,smb_vwv2);
  uint32 smb_offs = IVAL(inbuf,smb_vwv3);
  int smb_dsize = SVAL(inbuf,smb_vwv10);
  int smb_doff = SVAL(inbuf,smb_vwv11);
  BOOL write_through = BITSETW(inbuf+smb_vwv7,0);
  int cnum;
  int nwritten = -1;
  char *data;

  cnum = SVAL(inbuf,smb_tid);

  CHECK_FNUM(fnum,cnum);
  CHECK_WRITE(fnum);
  CHECK_ERROR(fnum);

  data = smb_base(inbuf) + smb_doff;

  if (is_locked(fnum,cnum,smb_dsize,smb_offs))
    return(ERROR(ERRDOS,ERRlock));

  seek_file(fnum,smb_offs);
  
  /* X/Open SMB protocol says that, unlike SMBwrite
     if the length is zero then NO truncation is
     done, just a write of zero. To truncate a file,
     use SMBwrite. */
  if(smb_dsize == 0)
    nwritten = 0;
  else
    nwritten = write_file(fnum,data,smb_dsize);
  
  if(((nwritten == 0) && (smb_dsize != 0))||(nwritten < 0))
    return(UNIXERROR(ERRDOS,ERRnoaccess));

  set_message(outbuf,6,0,True);
  
  SSVAL(outbuf,smb_vwv2,nwritten);
  
  if (nwritten < smb_dsize) {
    CVAL(outbuf,smb_rcls) = ERRHRD;
    SSVAL(outbuf,smb_err,ERRdiskfull);      
  }

  DEBUG(3,("%s writeX fnum=%d cnum=%d num=%d wrote=%d\n",timestring(),fnum,cnum,smb_dsize,nwritten));

  chain_fnum = fnum;

  if (lp_syncalways(SNUM(cnum)) || write_through)
    sync_file(fnum);

  return chain_reply(inbuf,outbuf,length,bufsize);
}


/****************************************************************************
  reply to a lseek
****************************************************************************/
int reply_lseek(char *inbuf,char *outbuf)
{
  int cnum,fnum;
  uint32 startpos;
  int32 res= -1;
  int mode,umode;
  int outsize = 0;
  
  cnum = SVAL(inbuf,smb_tid);
  fnum = GETFNUM(inbuf,smb_vwv0);

  CHECK_FNUM(fnum,cnum);
  CHECK_ERROR(fnum);

  mode = SVAL(inbuf,smb_vwv1) & 3;
  startpos = IVAL(inbuf,smb_vwv2);

  switch (mode & 3) 
    {
    case 0: umode = SEEK_SET; break;
    case 1: umode = SEEK_CUR; break;
    case 2: umode = SEEK_END; break;
    default:
      umode = SEEK_SET; break;
    }
  
  res = lseek(Files[fnum].fd_ptr->fd,startpos,umode);
  Files[fnum].pos = res;
  
  outsize = set_message(outbuf,2,0,True);
  SIVALS(outbuf,smb_vwv0,res);
  
  DEBUG(3,("%s lseek fnum=%d cnum=%d ofs=%d mode=%d\n",timestring(),fnum,cnum,startpos,mode));
  
  return(outsize);
}


/****************************************************************************
  reply to a flush
****************************************************************************/
int reply_flush(char *inbuf,char *outbuf)
{
  int cnum, fnum;
  int outsize = set_message(outbuf,0,0,True);

  cnum = SVAL(inbuf,smb_tid);
  fnum = GETFNUM(inbuf,smb_vwv0);

  if (fnum != 0xFFFF) {
    CHECK_FNUM(fnum,cnum);
    CHECK_ERROR(fnum);
  }

  if (fnum == 0xFFFF)
    {
      int i;
      for (i=0;i<MAX_OPEN_FILES;i++)
	if (OPEN_FNUM(i))
	  sync_file(i);
    }
  else
    sync_file(fnum);

  DEBUG(3,("%s flush fnum=%d\n",timestring(),fnum));
  return(outsize);
}


/****************************************************************************
  reply to a exit
****************************************************************************/
int reply_exit(char *inbuf,char *outbuf)
{
  int outsize = set_message(outbuf,0,0,True);
  DEBUG(3,("%s exit\n",timestring()));
  
  return(outsize);
}


/****************************************************************************
  reply to a close
****************************************************************************/
int reply_close(char *inbuf,char *outbuf)
{
  int fnum,cnum;
  int outsize = 0;
  time_t mtime;
  int32 eclass = 0, err = 0;

  outsize = set_message(outbuf,0,0,True);

  cnum = SVAL(inbuf,smb_tid);

  fnum = GETFNUM(inbuf,smb_vwv0);
  CHECK_FNUM(fnum,cnum);

  if(HAS_CACHED_ERROR(fnum)) {
    eclass = Files[fnum].wbmpx_ptr->wr_errclass;
    err = Files[fnum].wbmpx_ptr->wr_error;
  }

  mtime = make_unix_date3(inbuf+smb_vwv1);

  /* try and set the date */
  set_filetime(Files[fnum].name,mtime);

  close_file(fnum,True);

  /* We have a cached error */
  if(eclass || err)
    return(ERROR(eclass,err));

  DEBUG(3,("%s close fd=%d fnum=%d cnum=%d (numopen=%d)\n",
	   timestring(),Files[fnum].fd_ptr->fd,fnum,cnum,
	   Connections[cnum].num_files_open));
  
  return(outsize);
}


/****************************************************************************
  reply to a writeclose (Core+ protocol)
****************************************************************************/
int reply_writeclose(char *inbuf,char *outbuf)
{
  int cnum,numtowrite,fnum;
  int nwritten = -1;
  int outsize = 0;
  int startpos;
  char *data;
  time_t mtime;
  
  cnum = SVAL(inbuf,smb_tid);
  fnum = GETFNUM(inbuf,smb_vwv0);

  CHECK_FNUM(fnum,cnum);
  CHECK_WRITE(fnum);
  CHECK_ERROR(fnum);

  numtowrite = SVAL(inbuf,smb_vwv1);
  startpos = IVAL(inbuf,smb_vwv2);
  mtime = make_unix_date3(inbuf+smb_vwv4);
  data = smb_buf(inbuf) + 1;
  
  if (is_locked(fnum,cnum,numtowrite,startpos))
    return(ERROR(ERRDOS,ERRlock));
      
  seek_file(fnum,startpos);
      
  nwritten = write_file(fnum,data,numtowrite);

  set_filetime(Files[fnum].name,mtime);
  
  close_file(fnum,True);

  DEBUG(3,("%s writeclose fnum=%d cnum=%d num=%d wrote=%d (numopen=%d)\n",
	   timestring(),fnum,cnum,numtowrite,nwritten,
	   Connections[cnum].num_files_open));
  
  if (nwritten <= 0)
    return(UNIXERROR(ERRDOS,ERRnoaccess));
  
  outsize = set_message(outbuf,1,0,True);
  
  SSVAL(outbuf,smb_vwv0,nwritten);
  return(outsize);
}


/****************************************************************************
  reply to a lock
****************************************************************************/
int reply_lock(char *inbuf,char *outbuf)
{
  int fnum,cnum;
  int outsize = set_message(outbuf,0,0,True);
  uint32 count,offset;
  int eclass;
  uint32 ecode;

  cnum = SVAL(inbuf,smb_tid);
  fnum = GETFNUM(inbuf,smb_vwv0);

  CHECK_FNUM(fnum,cnum);
  CHECK_ERROR(fnum);

  count = IVAL(inbuf,smb_vwv1);
  offset = IVAL(inbuf,smb_vwv3);

  DEBUG(3,("%s lock fd=%d fnum=%d cnum=%d ofs=%d cnt=%d\n",timestring(),Files[fnum].fd_ptr->fd,fnum,cnum,offset,count));

  if(!do_lock( fnum, cnum, count, offset, &eclass, &ecode))
    return (ERROR(eclass,ecode));
  
  return(outsize);
}


/****************************************************************************
  reply to a unlock
****************************************************************************/
int reply_unlock(char *inbuf,char *outbuf)
{
  int fnum,cnum;
  int outsize = set_message(outbuf,0,0,True);
  uint32 count,offset;
  int eclass;
  uint32 ecode;
  
  cnum = SVAL(inbuf,smb_tid);
  fnum = GETFNUM(inbuf,smb_vwv0);

  CHECK_FNUM(fnum,cnum);
  CHECK_ERROR(fnum);

  count = IVAL(inbuf,smb_vwv1);
  offset = IVAL(inbuf,smb_vwv3);

  if(!do_unlock(fnum, cnum, count, offset, &eclass, &ecode))
    return (ERROR(eclass,ecode));

  DEBUG(3,("%s unlock fd=%d fnum=%d cnum=%d ofs=%d cnt=%d\n",timestring(),Files[fnum].fd_ptr->fd,fnum,cnum,offset,count));
  
  return(outsize);
}


/****************************************************************************
  reply to a tdis
****************************************************************************/
int reply_tdis(char *inbuf,char *outbuf)
{
  int cnum;
  int outsize = set_message(outbuf,0,0,True);
  uint16 vuid;

  cnum = SVAL(inbuf,smb_tid);
  vuid = SVAL(inbuf,smb_uid);

  if (!OPEN_CNUM(cnum)) {
    DEBUG(4,("Invalid cnum in tdis (%d)\n",cnum));
    return(ERROR(ERRSRV,ERRinvnid));
  }

  Connections[cnum].used = False;

  close_cnum(cnum,vuid);
  
  DEBUG(3,("%s tdis cnum=%d\n",timestring(),cnum));

  return outsize;
}



/****************************************************************************
  reply to a echo
****************************************************************************/
int reply_echo(char *inbuf,char *outbuf)
{
  int cnum;
  int smb_reverb = SVAL(inbuf,smb_vwv0);
  int seq_num;
  int data_len = smb_buflen(inbuf);
  int outsize = set_message(outbuf,1,data_len,True);

  cnum = SVAL(inbuf,smb_tid);

  /* According to the latest CIFS spec we shouldn't
     care what the TID is.
   */

#if 0
  if (cnum != 0xFFFF && !OPEN_CNUM(cnum))
    {
      DEBUG(4,("Invalid cnum in echo (%d)\n",cnum));
      return(ERROR(ERRSRV,ERRinvnid));
    }
#endif

  /* copy any incoming data back out */
  if (data_len > 0)
    memcpy(smb_buf(outbuf),smb_buf(inbuf),data_len);

  if (smb_reverb > 100)
    {
      DEBUG(0,("large reverb (%d)?? Setting to 100\n",smb_reverb));
      smb_reverb = 100;
    }

  for (seq_num =1 ; seq_num <= smb_reverb ; seq_num++)
    {
      SSVAL(outbuf,smb_vwv0,seq_num);

      smb_setlen(outbuf,outsize - 4);

      send_smb(Client,outbuf);
    }

  DEBUG(3,("%s echo %d times cnum=%d\n",timestring(),smb_reverb,cnum));

  return -1;
}


/****************************************************************************
  reply to a printopen
****************************************************************************/
int reply_printopen(char *inbuf,char *outbuf)
{
  pstring fname;
  pstring fname2;
  int cnum;
  int fnum = -1;
  int outsize = 0;

  *fname = *fname2 = 0;

  cnum = SVAL(inbuf,smb_tid);

  if (!CAN_PRINT(cnum))
    return(ERROR(ERRDOS,ERRnoaccess));

  {
    pstring s;
    char *p;
    pstrcpy(s,smb_buf(inbuf)+1);
    p = s;
    while (*p)
      {
	if (!(isalnum(*p) || strchr("._-",*p)))
	  *p = 'X';
	p++;
      }

    if (strlen(s) > 10) s[10] = 0;

    sprintf(fname,"%s.XXXXXX",s);  
  }

  fnum = find_free_file();
  if (fnum < 0)
    return(ERROR(ERRSRV,ERRnofids));

  strcpy(fname2,(char *)mktemp(fname));

  if (!check_name(fname2,cnum))
    return(ERROR(ERRDOS,ERRnoaccess));

  /* Open for exclusive use, write only. */
  open_file_shared(fnum,cnum,fname2,(DENY_ALL<<4)|1, 0x12, unix_mode(cnum,0), 
                   0, NULL, NULL);

  if (!Files[fnum].open)
    return(UNIXERROR(ERRDOS,ERRnoaccess));

  /* force it to be a print file */
  Files[fnum].print_file = True;
  
  outsize = set_message(outbuf,1,0,True);
  SSVAL(outbuf,smb_vwv0,fnum);
  
  DEBUG(3,("%s openprint %s fd=%d fnum=%d cnum=%d\n",timestring(),fname2,Files[fnum].fd_ptr->fd,fnum,cnum));
  
  return(outsize);
}


/****************************************************************************
  reply to a printclose
****************************************************************************/
int reply_printclose(char *inbuf,char *outbuf)
{
  int fnum,cnum;
  int outsize = set_message(outbuf,0,0,True);
  
  cnum = SVAL(inbuf,smb_tid);
  fnum = GETFNUM(inbuf,smb_vwv0);

  CHECK_FNUM(fnum,cnum);
  CHECK_ERROR(fnum);

  if (!CAN_PRINT(cnum))
    return(ERROR(ERRDOS,ERRnoaccess));
  
  close_file(fnum,True);
  
  DEBUG(3,("%s printclose fd=%d fnum=%d cnum=%d\n",timestring(),Files[fnum].fd_ptr->fd,fnum,cnum));
  
  return(outsize);
}


/****************************************************************************
  reply to a printqueue
****************************************************************************/
int reply_printqueue(char *inbuf,char *outbuf)
{
  int cnum;
  int outsize = set_message(outbuf,2,3,True);
  int max_count = SVAL(inbuf,smb_vwv0);
  int start_index = SVAL(inbuf,smb_vwv1);
  uint16 vuid;

  cnum = SVAL(inbuf,smb_tid);
  vuid = SVAL(inbuf,smb_uid);

/* allow checking the queue for anyone */
#if 0
  if (!CAN_PRINT(cnum))
    return(ERROR(ERRDOS,ERRnoaccess));
#endif

  SSVAL(outbuf,smb_vwv0,0);
  SSVAL(outbuf,smb_vwv1,0);
  CVAL(smb_buf(outbuf),0) = 1;
  SSVAL(smb_buf(outbuf),1,0);
  
  DEBUG(3,("%s printqueue cnum=%d start_index=%d max_count=%d\n",
	timestring(),cnum,start_index,max_count));

  if (!OPEN_CNUM(cnum) || !Connections[cnum].printer)
    {
      int i;
      cnum = -1;

      for (i=0;i<MAX_CONNECTIONS;i++)
	if (CAN_PRINT(i) && Connections[i].printer)
	  cnum = i;

      if (cnum == -1)
	for (i=0;i<MAX_CONNECTIONS;i++)
	  if (OPEN_CNUM(i))
	    cnum = i;

      if (!OPEN_CNUM(cnum))
	return(ERROR(ERRSRV,ERRinvnid));

      DEBUG(5,("connection not open or not a printer, using cnum %d\n",cnum));
    }

  if (!become_user(cnum,vuid))
    return(ERROR(ERRSRV,ERRinvnid));

  {
    print_queue_struct *queue = NULL;
    char *p = smb_buf(outbuf) + 3;
    int count = get_printqueue(SNUM(cnum),cnum,&queue,NULL);
    int num_to_get = ABS(max_count);
    int first = (max_count>0?start_index:start_index+max_count+1);
    int i;

    if (first >= count)
      num_to_get = 0;
    else
      num_to_get = MIN(num_to_get,count-first);
    

    for (i=first;i<first+num_to_get;i++)
      {
	put_dos_date2(p,0,queue[i].time);
	CVAL(p,4) = (queue[i].status==LPQ_PRINTING?2:3);
	SSVAL(p,5,printjob_encode(SNUM(cnum), queue[i].job));
	SIVAL(p,7,queue[i].size);
	CVAL(p,11) = 0;
	StrnCpy(p+12,queue[i].user,16);
	p += 28;
      }

    if (count > 0)
      {
	outsize = set_message(outbuf,2,28*count+3,False);	  
	SSVAL(outbuf,smb_vwv0,count);
	SSVAL(outbuf,smb_vwv1,(max_count>0?first+count:first-1));
	CVAL(smb_buf(outbuf),0) = 1;
	SSVAL(smb_buf(outbuf),1,28*count);
      }

    if (queue) free(queue);
	  
    DEBUG(3,("%d entries returned in queue\n",count));
  }
  
  return(outsize);
}


/****************************************************************************
  reply to a printwrite
****************************************************************************/
int reply_printwrite(char *inbuf,char *outbuf)
{
  int cnum,numtowrite,fnum;
  int outsize = set_message(outbuf,0,0,True);
  char *data;
  
  cnum = SVAL(inbuf,smb_tid);

  if (!CAN_PRINT(cnum))
    return(ERROR(ERRDOS,ERRnoaccess));

  fnum = GETFNUM(inbuf,smb_vwv0);

  CHECK_FNUM(fnum,cnum);
  CHECK_WRITE(fnum);
  CHECK_ERROR(fnum);

  numtowrite = SVAL(smb_buf(inbuf),1);
  data = smb_buf(inbuf) + 3;
  
  if (write_file(fnum,data,numtowrite) != numtowrite)
    return(UNIXERROR(ERRDOS,ERRnoaccess));
  
  DEBUG(3,("%s printwrite fnum=%d cnum=%d num=%d\n",timestring(),fnum,cnum,numtowrite));
  
  return(outsize);
}


/****************************************************************************
  reply to a mkdir
****************************************************************************/
int reply_mkdir(char *inbuf,char *outbuf)
{
  pstring directory;
  int cnum;
  int outsize,ret= -1;
  BOOL bad_path = False;
 
  pstrcpy(directory,smb_buf(inbuf) + 1);
  cnum = SVAL(inbuf,smb_tid);
  unix_convert(directory,cnum,0,&bad_path);
  
  if (check_name(directory,cnum))
    ret = sys_mkdir(directory,unix_mode(cnum,aDIR));
  
  if (ret < 0)
  {
    if((errno == ENOENT) && bad_path)
    {
      unix_ERR_class = ERRDOS;
      unix_ERR_code = ERRbadpath;
    }
    return(UNIXERROR(ERRDOS,ERRnoaccess));
  }
 
  outsize = set_message(outbuf,0,0,True);
  
  DEBUG(3,("%s mkdir %s cnum=%d ret=%d\n",timestring(),directory,cnum,ret));
  
  return(outsize);
}

/****************************************************************************
Static function used by reply_rmdir to delete an entire directory
tree recursively.
****************************************************************************/
static BOOL recursive_rmdir(char *directory)
{
  char *dname = NULL;
  BOOL ret = False;
  void *dirptr = OpenDir(-1, directory, False);

  if(dirptr == NULL)
    return True;

  while((dname = ReadDirName(dirptr)))
  {
    pstring fullname;
    struct stat st;

    if((strcmp(dname, ".") == 0) || (strcmp(dname, "..")==0))
      continue;

    /* Construct the full name. */
    if(strlen(directory) + strlen(dname) + 1 >= sizeof(fullname))
    {
      errno = ENOMEM;
      ret = True;
      break;
    }
    strcpy(fullname, directory);
    strcat(fullname, "/");
    strcat(fullname, dname);

    if(sys_lstat(fullname, &st) != 0)
    {
      ret = True;
      break;
    }

    if(st.st_mode & S_IFDIR)
    {
      if(recursive_rmdir(fullname)!=0)
      {
        ret = True;
        break;
      }
      if(sys_rmdir(fullname) != 0)
      {
        ret = True;
        break;
      }
    }
    else if(sys_unlink(fullname) != 0)
    {
      ret = True;
      break;
    }
  }
  CloseDir(dirptr);
  return ret;
}

/****************************************************************************
  reply to a rmdir
****************************************************************************/
int reply_rmdir(char *inbuf,char *outbuf)
{
  pstring directory;
  int cnum;
  int outsize = 0;
  BOOL ok = False;
  BOOL bad_path = False;

  cnum = SVAL(inbuf,smb_tid);
  pstrcpy(directory,smb_buf(inbuf) + 1);
  unix_convert(directory,cnum,0,&bad_path);
  
  if (check_name(directory,cnum))
    {

      dptr_closepath(directory,SVAL(inbuf,smb_pid));
      ok = (sys_rmdir(directory) == 0);
      if(!ok && (errno == ENOTEMPTY) && lp_veto_files(SNUM(cnum)))
        {
          /* Check to see if the only thing in this directory are
             vetoed files/directories. If so then delete them and
             retry. If we fail to delete any of them (and we *don't*
             do a recursive delete) then fail the rmdir. */
          BOOL all_veto_files = True;
          char *dname;
          void *dirptr = OpenDir(cnum, directory, False);

          if(dirptr != NULL)
            {
              int dirpos = TellDir(dirptr);
	          while ((dname = ReadDirName(dirptr)))
	            {
                  if((strcmp(dname, ".") == 0) || (strcmp(dname, "..")==0))
                    continue;
                  if(!IS_VETO_PATH(cnum, dname))
                    {
                      all_veto_files = False;
                      break;
                    }
                }
              if(all_veto_files)
                {
                  SeekDir(dirptr,dirpos);
                  while ((dname = ReadDirName(dirptr)))
                    {
                      pstring fullname;
                      struct stat st;

                      if((strcmp(dname, ".") == 0) || (strcmp(dname, "..")==0))
                        continue;

                      /* Construct the full name. */
                      if(strlen(directory) + strlen(dname) + 1 >= sizeof(fullname))
                        {
                          errno = ENOMEM;
                          break;
                        }
                      pstrcpy(fullname, directory);
                      strcat(fullname, "/");
                      strcat(fullname, dname);
                      
                      if(sys_lstat(fullname, &st) != 0)
                        break;
                      if(st.st_mode & S_IFDIR)
                      {
                        if(lp_recursive_veto_delete(SNUM(cnum)))
                        {
                          if(recursive_rmdir(fullname) != 0)
                            break;
                        }
                        if(sys_rmdir(fullname) != 0)
                          break;
                      }
                      else if(sys_unlink(fullname) != 0)
                        break;
                    }
                  CloseDir(dirptr);
                  /* Retry the rmdir */
                  ok = (sys_rmdir(directory) == 0);
                }
              else
                CloseDir(dirptr);
            }
          else
            errno = ENOTEMPTY;
         }
          
      if (!ok)
        DEBUG(3,("couldn't remove directory %s : %s\n",
		 directory,strerror(errno)));
    }
  
  if (!ok)
  {
    if((errno == ENOENT) && bad_path)
    {
      unix_ERR_class = ERRDOS;
      unix_ERR_code = ERRbadpath;
    }
    return(UNIXERROR(ERRDOS,ERRbadpath));
  }
 
  outsize = set_message(outbuf,0,0,True);
  
  DEBUG(3,("%s rmdir %s\n",timestring(),directory));
  
  return(outsize);
}


/*******************************************************************
resolve wildcards in a filename rename
********************************************************************/
static BOOL resolve_wildcards(char *name1,char *name2)
{
  fstring root1,root2;
  fstring ext1,ext2;
  char *p,*p2;

  name1 = strrchr(name1,'/');
  name2 = strrchr(name2,'/');

  if (!name1 || !name2) return(False);
  
  fstrcpy(root1,name1);
  fstrcpy(root2,name2);
  p = strrchr(root1,'.');
  if (p) {
    *p = 0;
    fstrcpy(ext1,p+1);
  } else {
    fstrcpy(ext1,"");    
  }
  p = strrchr(root2,'.');
  if (p) {
    *p = 0;
    fstrcpy(ext2,p+1);
  } else {
    fstrcpy(ext2,"");    
  }

  p = root1;
  p2 = root2;
  while (*p2) {
    if (*p2 == '?') {
      *p2 = *p;
      p2++;
    } else {
      p2++;
    }
    if (*p) p++;
  }

  p = ext1;
  p2 = ext2;
  while (*p2) {
    if (*p2 == '?') {
      *p2 = *p;
      p2++;
    } else {
      p2++;
    }
    if (*p) p++;
  }

  strcpy(name2,root2);
  if (ext2[0]) {
    strcat(name2,".");
    strcat(name2,ext2);
  }

  return(True);
}

/*******************************************************************
check if a user is allowed to rename a file
********************************************************************/
static BOOL can_rename(char *fname,int cnum)
{
  struct stat sbuf;

  if (!CAN_WRITE(cnum)) return(False);

  if (sys_lstat(fname,&sbuf) != 0) return(False);
  if (!check_file_sharing(cnum,fname)) return(False);

  return(True);
}

/****************************************************************************
  reply to a mv
****************************************************************************/
int reply_mv(char *inbuf,char *outbuf)
{
  int outsize = 0;
  pstring name;
  int cnum;
  pstring directory;
  pstring mask,newname;
  pstring newname_last_component;
  char *p;
  int count=0;
  int error = ERRnoaccess;
  BOOL has_wild;
  BOOL exists=False;
  BOOL bad_path1 = False;
  BOOL bad_path2 = False;

  *directory = *mask = 0;

  cnum = SVAL(inbuf,smb_tid);
  
  pstrcpy(name,smb_buf(inbuf) + 1);
  pstrcpy(newname,smb_buf(inbuf) + 3 + strlen(name));
   
  DEBUG(3,("reply_mv : %s -> %s\n",name,newname));
   
  unix_convert(name,cnum,0,&bad_path1);
  unix_convert(newname,cnum,newname_last_component,&bad_path2);

  /*
   * Split the old name into directory and last component
   * strings. Note that unix_convert may have stripped off a 
   * leading ./ from both name and newname if the rename is 
   * at the root of the share. We need to make sure either both
   * name and newname contain a / character or neither of them do
   * as this is checked in resolve_wildcards().
   */

  p = strrchr(name,'/');
  if (!p) {
    strcpy(directory,".");
    strcpy(mask,name);
  } else {
    *p = 0;
    strcpy(directory,name);
    strcpy(mask,p+1);
    *p = '/'; /* Replace needed for exceptional test below. */
  }

  if (is_mangled(mask))
    check_mangled_stack(mask);

  has_wild = strchr(mask,'*') || strchr(mask,'?');

  if (!has_wild) {
    BOOL is_short_name = is_8_3(name, True);

    /* Add a terminating '/' to the directory name. */
    strcat(directory,"/");
    strcat(directory,mask);

    /* Ensure newname contains a '/' also */
    if(strrchr(newname,'/') == 0) {
      pstring tmpstr;

      strcpy(tmpstr, "./");
      strcat(tmpstr, newname);
      strcpy(newname, tmpstr);
    }
  
    DEBUG(3,("reply_mv : case_sensitive = %d, case_preserve = %d, short case preserve = %d, directory = %s, newname = %s, newname_last_component = %s, is_8_3 = %d\n", 
            case_sensitive, case_preserve, short_case_preserve, directory, 
            newname, newname_last_component, is_short_name));

    /*
     * Check for special case with case preserving and not
     * case sensitive, if directory and newname are identical,
     * and the old last component differs from the original
     * last component only by case, then we should allow
     * the rename (user is trying to change the case of the
     * filename).
     */
    if((case_sensitive == False) && ( ((case_preserve == True) && (is_short_name == False)) || 
            ((short_case_preserve == True) && (is_short_name == True))) &&
       strcsequal(directory, newname)) {
      pstring newname_modified_last_component;

      /*
       * Get the last component of the modified name.
       * Note that we guarantee that newname contains a '/'
       * character above.
       */
      p = strrchr(newname,'/');
      strcpy(newname_modified_last_component,p+1);

      if(strcsequal(newname_modified_last_component, 
		    newname_last_component) == False) {
	/*
	 * Replace the modified last component with
	 * the original.
	 */
        strcpy(p+1, newname_last_component);
      }
    }

    if (resolve_wildcards(directory,newname) && 
	can_rename(directory,cnum) && 
	!file_exist(newname,NULL) &&
	!sys_rename(directory,newname)) count++;

    DEBUG(3,("reply_mv : %s doing rename on %s -> %s\n",(count != 0) ? "succeeded" : "failed",
                         directory,newname));

    if (!count) exists = file_exist(directory,NULL);
    if (!count && exists && file_exist(newname,NULL)) {
      exists = True;
      error = 183;
    }
  } else {
    void *dirptr = NULL;
    char *dname;
    pstring destname;

    if (check_name(directory,cnum))
      dirptr = OpenDir(cnum, directory, True);

    if (dirptr)
      {
	error = ERRbadfile;

	if (strequal(mask,"????????.???"))
	  strcpy(mask,"*");

	while ((dname = ReadDirName(dirptr)))
	  {
	    pstring fname;
	    pstrcpy(fname,dname);
	    
	    if(!mask_match(fname, mask, case_sensitive, False)) continue;

	    error = ERRnoaccess;
	    sprintf(fname,"%s/%s",directory,dname);
	    if (!can_rename(fname,cnum)) continue;
	    pstrcpy(destname,newname);

	    if (!resolve_wildcards(fname,destname)) continue;

	    if (file_exist(destname,NULL)) {
	      error = 183;
	      continue;
	    }
	    if (!sys_rename(fname,destname)) count++;
	    DEBUG(3,("reply_mv : doing rename on %s -> %s\n",fname,destname));
	  }
	CloseDir(dirptr);
      }
  }
  
  if (count == 0) {
    if (exists)
      return(ERROR(ERRDOS,error));
    else
    {
      if((errno == ENOENT) && (bad_path1 || bad_path2))
      {
        unix_ERR_class = ERRDOS;
        unix_ERR_code = ERRbadpath;
      }
      return(UNIXERROR(ERRDOS,error));
    }
  }
  
  outsize = set_message(outbuf,0,0,True);
  
  return(outsize);
}

/*******************************************************************
  copy a file as part of a reply_copy
  ******************************************************************/
static BOOL copy_file(char *src,char *dest1,int cnum,int ofun,
		      int count,BOOL target_is_directory)
{
  int Access,action;
  struct stat st;
  int ret=0;
  int fnum1,fnum2;
  pstring dest;
  
  pstrcpy(dest,dest1);
  if (target_is_directory) {
    char *p = strrchr(src,'/');
    if (p) 
      p++;
    else
      p = src;
    strcat(dest,"/");
    strcat(dest,p);
  }

  if (!file_exist(src,&st)) return(False);

  fnum1 = find_free_file();
  if (fnum1<0) return(False);
  open_file_shared(fnum1,cnum,src,(DENY_NONE<<4),
		   1,0,0,&Access,&action);

  if (!Files[fnum1].open) return(False);

  if (!target_is_directory && count)
    ofun = 1;

  fnum2 = find_free_file();
  if (fnum2<0) {
    close_file(fnum1,False);
    return(False);
  }
  open_file_shared(fnum2,cnum,dest,(DENY_NONE<<4)|1,
		   ofun,st.st_mode,0,&Access,&action);

  if (!Files[fnum2].open) {
    close_file(fnum1,False);
    return(False);
  }

  if ((ofun&3) == 1) {
    lseek(Files[fnum2].fd_ptr->fd,0,SEEK_END);
  }
  
  if (st.st_size)
    ret = transfer_file(Files[fnum1].fd_ptr->fd,Files[fnum2].fd_ptr->fd,st.st_size,NULL,0,0);

  close_file(fnum1,False);
  close_file(fnum2,False);

  return(ret == st.st_size);
}



/****************************************************************************
  reply to a file copy.
  ****************************************************************************/
int reply_copy(char *inbuf,char *outbuf)
{
  int outsize = 0;
  pstring name;
  int cnum;
  pstring directory;
  pstring mask,newname;
  char *p;
  int count=0;
  int error = ERRnoaccess;
  BOOL has_wild;
  BOOL exists=False;
  int tid2 = SVAL(inbuf,smb_vwv0);
  int ofun = SVAL(inbuf,smb_vwv1);
  int flags = SVAL(inbuf,smb_vwv2);
  BOOL target_is_directory=False;
  BOOL bad_path1 = False;
  BOOL bad_path2 = False;

  *directory = *mask = 0;

  cnum = SVAL(inbuf,smb_tid);
  
  pstrcpy(name,smb_buf(inbuf));
  pstrcpy(newname,smb_buf(inbuf) + 1 + strlen(name));
   
  DEBUG(3,("reply_copy : %s -> %s\n",name,newname));
   
  if (tid2 != cnum) {
    /* can't currently handle inter share copies XXXX */
    DEBUG(3,("Rejecting inter-share copy\n"));
    return(ERROR(ERRSRV,ERRinvdevice));
  }

  unix_convert(name,cnum,0,&bad_path1);
  unix_convert(newname,cnum,0,&bad_path2);

  target_is_directory = directory_exist(newname,NULL);

  if ((flags&1) && target_is_directory) {
    return(ERROR(ERRDOS,ERRbadfile));
  }

  if ((flags&2) && !target_is_directory) {
    return(ERROR(ERRDOS,ERRbadpath));
  }

  if ((flags&(1<<5)) && directory_exist(name,NULL)) {
    /* wants a tree copy! XXXX */
    DEBUG(3,("Rejecting tree copy\n"));
    return(ERROR(ERRSRV,ERRerror));    
  }

  p = strrchr(name,'/');
  if (!p) {
    strcpy(directory,"./");
    strcpy(mask,name);
  } else {
    *p = 0;
    strcpy(directory,name);
    strcpy(mask,p+1);
  }

  if (is_mangled(mask))
    check_mangled_stack(mask);

  has_wild = strchr(mask,'*') || strchr(mask,'?');

  if (!has_wild) {
    strcat(directory,"/");
    strcat(directory,mask);
    if (resolve_wildcards(directory,newname) && 
	copy_file(directory,newname,cnum,ofun,
		  count,target_is_directory)) count++;
    if (!count) exists = file_exist(directory,NULL);
  } else {
    void *dirptr = NULL;
    char *dname;
    pstring destname;

    if (check_name(directory,cnum))
      dirptr = OpenDir(cnum, directory, True);

    if (dirptr)
      {
	error = ERRbadfile;

	if (strequal(mask,"????????.???"))
	  strcpy(mask,"*");

	while ((dname = ReadDirName(dirptr)))
	  {
	    pstring fname;
	    pstrcpy(fname,dname);
	    
	    if(!mask_match(fname, mask, case_sensitive, False)) continue;

	    error = ERRnoaccess;
	    sprintf(fname,"%s/%s",directory,dname);
	    strcpy(destname,newname);
	    if (resolve_wildcards(fname,destname) && 
		copy_file(directory,newname,cnum,ofun,
			  count,target_is_directory)) count++;
	    DEBUG(3,("reply_copy : doing copy on %s -> %s\n",fname,destname));
	  }
	CloseDir(dirptr);
      }
  }
  
  if (count == 0) {
    if (exists)
      return(ERROR(ERRDOS,error));
    else
    {
      if((errno == ENOENT) && (bad_path1 || bad_path2))
      {
        unix_ERR_class = ERRDOS;
        unix_ERR_code = ERRbadpath;
      }
      return(UNIXERROR(ERRDOS,error));
    }
  }
  
  outsize = set_message(outbuf,1,0,True);
  SSVAL(outbuf,smb_vwv0,count);

  return(outsize);
}



/****************************************************************************
  reply to a setdir
****************************************************************************/
int reply_setdir(char *inbuf,char *outbuf)
{
  int cnum,snum;
  int outsize = 0;
  BOOL ok = False;
  pstring newdir;
  
  cnum = SVAL(inbuf,smb_tid);
  
  snum = Connections[cnum].service;
  if (!CAN_SETDIR(snum))
    return(ERROR(ERRDOS,ERRnoaccess));
  
  pstrcpy(newdir,smb_buf(inbuf) + 1);
  strlower(newdir);
  
  if (strlen(newdir) == 0)
    ok = True;
  else
    {
      ok = directory_exist(newdir,NULL);
      if (ok)
	string_set(&Connections[cnum].connectpath,newdir);
    }
  
  if (!ok)
    return(ERROR(ERRDOS,ERRbadpath));
  
  outsize = set_message(outbuf,0,0,True);
  CVAL(outbuf,smb_reh) = CVAL(inbuf,smb_reh);
  
  DEBUG(3,("%s setdir %s cnum=%d\n",timestring(),newdir,cnum));
  
  return(outsize);
}


/****************************************************************************
  reply to a lockingX request
****************************************************************************/
int reply_lockingX(char *inbuf,char *outbuf,int length,int bufsize)
{
  int fnum = GETFNUM(inbuf,smb_vwv2);
  unsigned char locktype = CVAL(inbuf,smb_vwv3);
#if 0
  unsigned char oplocklevel = CVAL(inbuf,smb_vwv3+1);
#endif
  uint16 num_ulocks = SVAL(inbuf,smb_vwv6);
  uint16 num_locks = SVAL(inbuf,smb_vwv7);
  uint32 count, offset;

  int cnum;
  int i;
  char *data;
  uint32 ecode=0, dummy2;
  int eclass=0, dummy1;

  cnum = SVAL(inbuf,smb_tid);

  CHECK_FNUM(fnum,cnum);
  CHECK_ERROR(fnum);

  data = smb_buf(inbuf);

  /* Check if this is an oplock break on a file
     we have granted an oplock on.
   */
  if((locktype == LOCKING_ANDX_OPLOCK_RELEASE) && 
     (num_ulocks == 0) && (num_locks == 0) &&
     (CVAL(inbuf,smb_vwv0) == 0xFF))
  {
    int token;
    files_struct *fsp = &Files[fnum];
    uint32 dev = fsp->fd_ptr->dev;
    uint32 inode = fsp->fd_ptr->inode;

    DEBUG(5,("reply_lockingX: oplock break reply from client for fnum = %d\n",
              fnum));
    /*
     * Make sure we have granted an oplock on this file.
     */
    if(!fsp->granted_oplock)
    {
      DEBUG(0,("reply_lockingX: Error : oplock break from client for fnum = %d and \
no oplock granted on this file.\n", fnum));
      return ERROR(ERRDOS,ERRlock);
    }

    /* Remove the oplock flag from the sharemode. */
    lock_share_entry(fsp->cnum, dev, inode, &token);
    if(remove_share_oplock( fnum, token)==False)
    {
      DEBUG(0,("reply_lockingX: failed to remove share oplock for fnum %d, \
dev = %x, inode = %x\n", fnum, dev, inode));
      unlock_share_entry(fsp->cnum, dev, inode, token);
      return -1;
    }
    unlock_share_entry(fsp->cnum, dev, inode, token);

    /* Clear the granted flag and return. */

    fsp->granted_oplock = False;
    return -1;
  }

  /* Data now points at the beginning of the list
     of smb_unlkrng structs */
  for(i = 0; i < (int)num_ulocks; i++) {
    count = IVAL(data,SMB_LKLEN_OFFSET(i));
    offset = IVAL(data,SMB_LKOFF_OFFSET(i));
    if(!do_unlock(fnum,cnum,count,offset,&eclass, &ecode))
      return ERROR(eclass,ecode);
  }

  /* Now do any requested locks */
  data += 10*num_ulocks;
  /* Data now points at the beginning of the list
     of smb_lkrng structs */
  for(i = 0; i < (int)num_locks; i++) {
    count = IVAL(data,SMB_LKLEN_OFFSET(i)); 
    offset = IVAL(data,SMB_LKOFF_OFFSET(i)); 
    if(!do_lock(fnum,cnum,count,offset, &eclass, &ecode))
      break;
  }

  /* If any of the above locks failed, then we must unlock
     all of the previous locks (X/Open spec). */
  if(i != num_locks && num_locks != 0) {
    for(; i >= 0; i--) {
      count = IVAL(data,SMB_LKLEN_OFFSET(i));  
      offset = IVAL(data,SMB_LKOFF_OFFSET(i)); 
      do_unlock(fnum,cnum,count,offset,&dummy1,&dummy2);
    }
    return ERROR(eclass,ecode);
  }

  set_message(outbuf,2,0,True);
  
  DEBUG(3,("%s lockingX fnum=%d cnum=%d type=%d num_locks=%d num_ulocks=%d\n",
	timestring(),fnum,cnum,(unsigned int)locktype,num_locks,num_ulocks));

  chain_fnum = fnum;

  return chain_reply(inbuf,outbuf,length,bufsize);
}


/****************************************************************************
  reply to a SMBreadbmpx (read block multiplex) request
****************************************************************************/
int reply_readbmpx(char *inbuf,char *outbuf,int length,int bufsize)
{
  int cnum,fnum;
  int nread = -1;
  int total_read;
  char *data;
  uint32 startpos;
  int outsize, mincount, maxcount;
  int max_per_packet;
  int tcount;
  int pad;

  /* this function doesn't seem to work - disable by default */
  if (!lp_readbmpx())
    return(ERROR(ERRSRV,ERRuseSTD));

  outsize = set_message(outbuf,8,0,True);

  cnum = SVAL(inbuf,smb_tid);
  fnum = GETFNUM(inbuf,smb_vwv0);

  CHECK_FNUM(fnum,cnum);
  CHECK_READ(fnum);
  CHECK_ERROR(fnum);

  startpos = IVAL(inbuf,smb_vwv1);
  maxcount = SVAL(inbuf,smb_vwv3);
  mincount = SVAL(inbuf,smb_vwv4);

  data = smb_buf(outbuf);
  pad = ((long)data)%4;
  if (pad) pad = 4 - pad;
  data += pad;

  max_per_packet = bufsize-(outsize+pad);
  tcount = maxcount;
  total_read = 0;

  if (is_locked(fnum,cnum,maxcount,startpos))
    return(ERROR(ERRDOS,ERRlock));
	
  do
    {
      int N = MIN(max_per_packet,tcount-total_read);
  
      nread = read_file(fnum,data,startpos,N);

      if (nread <= 0) nread = 0;

      if (nread < N)
	tcount = total_read + nread;

      set_message(outbuf,8,nread,False);
      SIVAL(outbuf,smb_vwv0,startpos);
      SSVAL(outbuf,smb_vwv2,tcount);
      SSVAL(outbuf,smb_vwv6,nread);
      SSVAL(outbuf,smb_vwv7,smb_offset(data,outbuf));

      send_smb(Client,outbuf);

      total_read += nread;
      startpos += nread;
    }
  while (total_read < tcount);

  return(-1);
}


/****************************************************************************
  reply to a SMBwritebmpx (write block multiplex primary) request
****************************************************************************/
int reply_writebmpx(char *inbuf,char *outbuf)
{
  int cnum,numtowrite,fnum;
  int nwritten = -1;
  int outsize = 0;
  uint32 startpos;
  int tcount, write_through, smb_doff;
  char *data;
  
  cnum = SVAL(inbuf,smb_tid);
  fnum = GETFNUM(inbuf,smb_vwv0);

  CHECK_FNUM(fnum,cnum);
  CHECK_WRITE(fnum);
  CHECK_ERROR(fnum);

  tcount = SVAL(inbuf,smb_vwv1);
  startpos = IVAL(inbuf,smb_vwv3);
  write_through = BITSETW(inbuf+smb_vwv7,0);
  numtowrite = SVAL(inbuf,smb_vwv10);
  smb_doff = SVAL(inbuf,smb_vwv11);

  data = smb_base(inbuf) + smb_doff;

  /* If this fails we need to send an SMBwriteC response,
     not an SMBwritebmpx - set this up now so we don't forget */
  CVAL(outbuf,smb_com) = SMBwritec;

  if (is_locked(fnum,cnum,tcount,startpos))
    return(ERROR(ERRDOS,ERRlock));

  seek_file(fnum,startpos);
  nwritten = write_file(fnum,data,numtowrite);

  if(lp_syncalways(SNUM(cnum)) || write_through)
    sync_file(fnum);
  
  if(nwritten < numtowrite)
    return(UNIXERROR(ERRHRD,ERRdiskfull));

  /* If the maximum to be written to this file
     is greater than what we just wrote then set
     up a secondary struct to be attached to this
     fd, we will use this to cache error messages etc. */
  if(tcount > nwritten) 
    {
      write_bmpx_struct *wbms;
      if(Files[fnum].wbmpx_ptr != NULL)
	wbms = Files[fnum].wbmpx_ptr; /* Use an existing struct */
      else
	wbms = (write_bmpx_struct *)malloc(sizeof(write_bmpx_struct));
      if(!wbms)
	{
	  DEBUG(0,("Out of memory in reply_readmpx\n"));
	  return(ERROR(ERRSRV,ERRnoresource));
	}
      wbms->wr_mode = write_through;
      wbms->wr_discard = False; /* No errors yet */
      wbms->wr_total_written = nwritten;
      wbms->wr_errclass = 0;
      wbms->wr_error = 0;
      Files[fnum].wbmpx_ptr = wbms;
    }

  /* We are returning successfully, set the message type back to
     SMBwritebmpx */
  CVAL(outbuf,smb_com) = SMBwriteBmpx;
  
  outsize = set_message(outbuf,1,0,True);
  
  SSVALS(outbuf,smb_vwv0,-1); /* We don't support smb_remaining */
  
  DEBUG(3,("%s writebmpx fnum=%d cnum=%d num=%d wrote=%d\n",
	timestring(),fnum,cnum,numtowrite,nwritten));
  
  if (write_through && tcount==nwritten) {
    /* we need to send both a primary and a secondary response */
    smb_setlen(outbuf,outsize - 4);
    send_smb(Client,outbuf);

    /* now the secondary */
    outsize = set_message(outbuf,1,0,True);
    CVAL(outbuf,smb_com) = SMBwritec;
    SSVAL(outbuf,smb_vwv0,nwritten);
  }

  return(outsize);
}


/****************************************************************************
  reply to a SMBwritebs (write block multiplex secondary) request
****************************************************************************/
int reply_writebs(char *inbuf,char *outbuf)
{
  int cnum,numtowrite,fnum;
  int nwritten = -1;
  int outsize = 0;
  int32 startpos;
  int tcount, write_through, smb_doff;
  char *data;
  write_bmpx_struct *wbms;
  BOOL send_response = False;
  
  cnum = SVAL(inbuf,smb_tid);
  fnum = GETFNUM(inbuf,smb_vwv0);
  CHECK_FNUM(fnum,cnum);
  CHECK_WRITE(fnum);

  tcount = SVAL(inbuf,smb_vwv1);
  startpos = IVAL(inbuf,smb_vwv2);
  numtowrite = SVAL(inbuf,smb_vwv6);
  smb_doff = SVAL(inbuf,smb_vwv7);

  data = smb_base(inbuf) + smb_doff;

  /* We need to send an SMBwriteC response, not an SMBwritebs */
  CVAL(outbuf,smb_com) = SMBwritec;

  /* This fd should have an auxiliary struct attached,
     check that it does */
  wbms = Files[fnum].wbmpx_ptr;
  if(!wbms) return(-1);

  /* If write through is set we can return errors, else we must
     cache them */
  write_through = wbms->wr_mode;

  /* Check for an earlier error */
  if(wbms->wr_discard)
    return -1; /* Just discard the packet */

  seek_file(fnum,startpos);
  nwritten = write_file(fnum,data,numtowrite);

  if(lp_syncalways(SNUM(cnum)) || write_through)
    sync_file(fnum);
  
  if (nwritten < numtowrite)
    {
      if(write_through)	{
	/* We are returning an error - we can delete the aux struct */
	if (wbms) free((char *)wbms);
	Files[fnum].wbmpx_ptr = NULL;
	return(ERROR(ERRHRD,ERRdiskfull));
      }
      return(CACHE_ERROR(wbms,ERRHRD,ERRdiskfull));
    }

  /* Increment the total written, if this matches tcount
     we can discard the auxiliary struct (hurrah !) and return a writeC */
  wbms->wr_total_written += nwritten;
  if(wbms->wr_total_written >= tcount)
    {
      if (write_through) {
	outsize = set_message(outbuf,1,0,True);
	SSVAL(outbuf,smb_vwv0,wbms->wr_total_written);    
	send_response = True;
      }

      free((char *)wbms);
      Files[fnum].wbmpx_ptr = NULL;
    }

  if(send_response)
    return(outsize);

  return(-1);
}


/****************************************************************************
  reply to a SMBsetattrE
****************************************************************************/
int reply_setattrE(char *inbuf,char *outbuf)
{
  int cnum,fnum;
  struct utimbuf unix_times;
  int outsize = 0;

  outsize = set_message(outbuf,0,0,True);

  cnum = SVAL(inbuf,smb_tid);
  fnum = GETFNUM(inbuf,smb_vwv0);

  CHECK_FNUM(fnum,cnum);
  CHECK_ERROR(fnum);

  /* Convert the DOS times into unix times. Ignore create
     time as UNIX can't set this.
     */
  unix_times.actime = make_unix_date2(inbuf+smb_vwv3);
  unix_times.modtime = make_unix_date2(inbuf+smb_vwv5);
  
  /* 
   * Patch from Ray Frush <frush@engr.colostate.edu>
   * Sometimes times are sent as zero - ignore them.
   */

  if ((unix_times.actime == 0) && (unix_times.modtime == 0)) 
  {
    /* Ignore request */
    DEBUG(3,("%s reply_setattrE fnum=%d cnum=%d ignoring zero request - \
not setting timestamps of 0\n",
          timestring(), fnum,cnum,unix_times.actime,unix_times.modtime));
    return(outsize);
  }
  else if ((unix_times.actime != 0) && (unix_times.modtime == 0)) 
  {
    /* set modify time = to access time if modify time was 0 */
    unix_times.modtime = unix_times.actime;
  }

  /* Set the date on this file */
  if(sys_utime(Files[fnum].name, &unix_times))
    return(ERROR(ERRDOS,ERRnoaccess));
  
  DEBUG(3,("%s reply_setattrE fnum=%d cnum=%d actime=%d modtime=%d\n",
    timestring(), fnum,cnum,unix_times.actime,unix_times.modtime));

  return(outsize);
}


/****************************************************************************
  reply to a SMBgetattrE
****************************************************************************/
int reply_getattrE(char *inbuf,char *outbuf)
{
  int cnum,fnum;
  struct stat sbuf;
  int outsize = 0;
  int mode;

  outsize = set_message(outbuf,11,0,True);

  cnum = SVAL(inbuf,smb_tid);
  fnum = GETFNUM(inbuf,smb_vwv0);

  CHECK_FNUM(fnum,cnum);
  CHECK_ERROR(fnum);

  /* Do an fstat on this file */
  if(fstat(Files[fnum].fd_ptr->fd, &sbuf))
    return(UNIXERROR(ERRDOS,ERRnoaccess));
  
  mode = dos_mode(cnum,Files[fnum].name,&sbuf);
  
  /* Convert the times into dos times. Set create
     date to be last modify date as UNIX doesn't save
     this */
  put_dos_date2(outbuf,smb_vwv0,sbuf.st_mtime);
  put_dos_date2(outbuf,smb_vwv2,sbuf.st_atime);
  put_dos_date2(outbuf,smb_vwv4,sbuf.st_mtime);
  if (mode & aDIR)
    {
      SIVAL(outbuf,smb_vwv6,0);
      SIVAL(outbuf,smb_vwv8,0);
    }
  else
    {
      SIVAL(outbuf,smb_vwv6,sbuf.st_size);
      SIVAL(outbuf,smb_vwv8,ROUNDUP(sbuf.st_size,1024));
    }
  SSVAL(outbuf,smb_vwv10, mode);
  
  DEBUG(3,("%s reply_getattrE fnum=%d cnum=%d\n",timestring(),fnum,cnum));
  
  return(outsize);
}
9' href='#n2649'>2649</a>
<a id='n2650' href='#n2650'>2650</a>
<a id='n2651' href='#n2651'>2651</a>
<a id='n2652' href='#n2652'>2652</a>
<a id='n2653' href='#n2653'>2653</a>
<a id='n2654' href='#n2654'>2654</a>
<a id='n2655' href='#n2655'>2655</a>
<a id='n2656' href='#n2656'>2656</a>
<a id='n2657' href='#n2657'>2657</a>
<a id='n2658' href='#n2658'>2658</a>
<a id='n2659' href='#n2659'>2659</a>
<a id='n2660' href='#n2660'>2660</a>
<a id='n2661' href='#n2661'>2661</a>
<a id='n2662' href='#n2662'>2662</a>
<a id='n2663' href='#n2663'>2663</a>
<a id='n2664' href='#n2664'>2664</a>
<a id='n2665' href='#n2665'>2665</a>
<a id='n2666' href='#n2666'>2666</a>
<a id='n2667' href='#n2667'>2667</a>
<a id='n2668' href='#n2668'>2668</a>
<a id='n2669' href='#n2669'>2669</a>
<a id='n2670' href='#n2670'>2670</a>
<a id='n2671' href='#n2671'>2671</a>
<a id='n2672' href='#n2672'>2672</a>
<a id='n2673' href='#n2673'>2673</a>
<a id='n2674' href='#n2674'>2674</a>
<a id='n2675' href='#n2675'>2675</a>
<a id='n2676' href='#n2676'>2676</a>
<a id='n2677' href='#n2677'>2677</a>
<a id='n2678' href='#n2678'>2678</a>
<a id='n2679' href='#n2679'>2679</a>
<a id='n2680' href='#n2680'>2680</a>
<a id='n2681' href='#n2681'>2681</a>
<a id='n2682' href='#n2682'>2682</a>
<a id='n2683' href='#n2683'>2683</a>
<a id='n2684' href='#n2684'>2684</a>
<a id='n2685' href='#n2685'>2685</a>
<a id='n2686' href='#n2686'>2686</a>
<a id='n2687' href='#n2687'>2687</a>
<a id='n2688' href='#n2688'>2688</a>
<a id='n2689' href='#n2689'>2689</a>
<a id='n2690' href='#n2690'>2690</a>
<a id='n2691' href='#n2691'>2691</a>
<a id='n2692' href='#n2692'>2692</a>
<a id='n2693' href='#n2693'>2693</a>
<a id='n2694' href='#n2694'>2694</a>
<a id='n2695' href='#n2695'>2695</a>
<a id='n2696' href='#n2696'>2696</a>
<a id='n2697' href='#n2697'>2697</a>
<a id='n2698' href='#n2698'>2698</a>
<a id='n2699' href='#n2699'>2699</a>
<a id='n2700' href='#n2700'>2700</a>
<a id='n2701' href='#n2701'>2701</a>
<a id='n2702' href='#n2702'>2702</a>
<a id='n2703' href='#n2703'>2703</a>
<a id='n2704' href='#n2704'>2704</a>
<a id='n2705' href='#n2705'>2705</a>
<a id='n2706' href='#n2706'>2706</a>
<a id='n2707' href='#n2707'>2707</a>
<a id='n2708' href='#n2708'>2708</a>
<a id='n2709' href='#n2709'>2709</a>
<a id='n2710' href='#n2710'>2710</a>
<a id='n2711' href='#n2711'>2711</a>
<a id='n2712' href='#n2712'>2712</a>
<a id='n2713' href='#n2713'>2713</a>
<a id='n2714' href='#n2714'>2714</a>
<a id='n2715' href='#n2715'>2715</a>
<a id='n2716' href='#n2716'>2716</a>
<a id='n2717' href='#n2717'>2717</a>
<a id='n2718' href='#n2718'>2718</a>
<a id='n2719' href='#n2719'>2719</a>
<a id='n2720' href='#n2720'>2720</a>
<a id='n2721' href='#n2721'>2721</a>
<a id='n2722' href='#n2722'>2722</a>
<a id='n2723' href='#n2723'>2723</a>
<a id='n2724' href='#n2724'>2724</a>
<a id='n2725' href='#n2725'>2725</a>
<a id='n2726' href='#n2726'>2726</a>
<a id='n2727' href='#n2727'>2727</a>
<a id='n2728' href='#n2728'>2728</a>
<a id='n2729' href='#n2729'>2729</a>
<a id='n2730' href='#n2730'>2730</a>
<a id='n2731' href='#n2731'>2731</a>
<a id='n2732' href='#n2732'>2732</a>
<a id='n2733' href='#n2733'>2733</a>
<a id='n2734' href='#n2734'>2734</a>
<a id='n2735' href='#n2735'>2735</a>
<a id='n2736' href='#n2736'>2736</a>
<a id='n2737' href='#n2737'>2737</a>
<a id='n2738' href='#n2738'>2738</a>
<a id='n2739' href='#n2739'>2739</a>
<a id='n2740' href='#n2740'>2740</a>
<a id='n2741' href='#n2741'>2741</a>
<a id='n2742' href='#n2742'>2742</a>
<a id='n2743' href='#n2743'>2743</a>
<a id='n2744' href='#n2744'>2744</a>
<a id='n2745' href='#n2745'>2745</a>
<a id='n2746' href='#n2746'>2746</a>
<a id='n2747' href='#n2747'>2747</a>
<a id='n2748' href='#n2748'>2748</a>
<a id='n2749' href='#n2749'>2749</a>
<a id='n2750' href='#n2750'>2750</a>
<a id='n2751' href='#n2751'>2751</a>
<a id='n2752' href='#n2752'>2752</a>
<a id='n2753' href='#n2753'>2753</a>
<a id='n2754' href='#n2754'>2754</a>
<a id='n2755' href='#n2755'>2755</a>
<a id='n2756' href='#n2756'>2756</a>
<a id='n2757' href='#n2757'>2757</a>
<a id='n2758' href='#n2758'>2758</a>
<a id='n2759' href='#n2759'>2759</a>
<a id='n2760' href='#n2760'>2760</a>
<a id='n2761' href='#n2761'>2761</a>
<a id='n2762' href='#n2762'>2762</a>
<a id='n2763' href='#n2763'>2763</a>
<a id='n2764' href='#n2764'>2764</a>
<a id='n2765' href='#n2765'>2765</a>
<a id='n2766' href='#n2766'>2766</a>
<a id='n2767' href='#n2767'>2767</a>
<a id='n2768' href='#n2768'>2768</a>
<a id='n2769' href='#n2769'>2769</a>
<a id='n2770' href='#n2770'>2770</a>
<a id='n2771' href='#n2771'>2771</a>
<a id='n2772' href='#n2772'>2772</a>
<a id='n2773' href='#n2773'>2773</a>
<a id='n2774' href='#n2774'>2774</a>
<a id='n2775' href='#n2775'>2775</a>
<a id='n2776' href='#n2776'>2776</a>
<a id='n2777' href='#n2777'>2777</a>
<a id='n2778' href='#n2778'>2778</a>
<a id='n2779' href='#n2779'>2779</a>
<a id='n2780' href='#n2780'>2780</a>
<a id='n2781' href='#n2781'>2781</a>
<a id='n2782' href='#n2782'>2782</a>
<a id='n2783' href='#n2783'>2783</a>
<a id='n2784' href='#n2784'>2784</a>
<a id='n2785' href='#n2785'>2785</a>
<a id='n2786' href='#n2786'>2786</a>
<a id='n2787' href='#n2787'>2787</a>
<a id='n2788' href='#n2788'>2788</a>
<a id='n2789' href='#n2789'>2789</a>
<a id='n2790' href='#n2790'>2790</a>
<a id='n2791' href='#n2791'>2791</a>
<a id='n2792' href='#n2792'>2792</a>
<a id='n2793' href='#n2793'>2793</a>
<a id='n2794' href='#n2794'>2794</a>
<a id='n2795' href='#n2795'>2795</a>
<a id='n2796' href='#n2796'>2796</a>
<a id='n2797' href='#n2797'>2797</a>
<a id='n2798' href='#n2798'>2798</a>
<a id='n2799' href='#n2799'>2799</a>
<a id='n2800' href='#n2800'>2800</a>
<a id='n2801' href='#n2801'>2801</a>
<a id='n2802' href='#n2802'>2802</a>
<a id='n2803' href='#n2803'>2803</a>
<a id='n2804' href='#n2804'>2804</a>
<a id='n2805' href='#n2805'>2805</a>
<a id='n2806' href='#n2806'>2806</a>
<a id='n2807' href='#n2807'>2807</a>
<a id='n2808' href='#n2808'>2808</a>
<a id='n2809' href='#n2809'>2809</a>
<a id='n2810' href='#n2810'>2810</a>
<a id='n2811' href='#n2811'>2811</a>
<a id='n2812' href='#n2812'>2812</a>
<a id='n2813' href='#n2813'>2813</a>
<a id='n2814' href='#n2814'>2814</a>
<a id='n2815' href='#n2815'>2815</a>
<a id='n2816' href='#n2816'>2816</a>
<a id='n2817' href='#n2817'>2817</a>
<a id='n2818' href='#n2818'>2818</a>
<a id='n2819' href='#n2819'>2819</a>
<a id='n2820' href='#n2820'>2820</a>
<a id='n2821' href='#n2821'>2821</a>
<a id='n2822' href='#n2822'>2822</a>
<a id='n2823' href='#n2823'>2823</a>
<a id='n2824' href='#n2824'>2824</a>
<a id='n2825' href='#n2825'>2825</a>
<a id='n2826' href='#n2826'>2826</a>
<a id='n2827' href='#n2827'>2827</a>
<a id='n2828' href='#n2828'>2828</a>
<a id='n2829' href='#n2829'>2829</a>
<a id='n2830' href='#n2830'>2830</a>
<a id='n2831' href='#n2831'>2831</a>
<a id='n2832' href='#n2832'>2832</a>
<a id='n2833' href='#n2833'>2833</a>
<a id='n2834' href='#n2834'>2834</a>
<a id='n2835' href='#n2835'>2835</a>
<a id='n2836' href='#n2836'>2836</a>
<a id='n2837' href='#n2837'>2837</a>
<a id='n2838' href='#n2838'>2838</a>
<a id='n2839' href='#n2839'>2839</a>
<a id='n2840' href='#n2840'>2840</a>
<a id='n2841' href='#n2841'>2841</a>
<a id='n2842' href='#n2842'>2842</a>
<a id='n2843' href='#n2843'>2843</a>
<a id='n2844' href='#n2844'>2844</a>
<a id='n2845' href='#n2845'>2845</a>
<a id='n2846' href='#n2846'>2846</a>
<a id='n2847' href='#n2847'>2847</a>
<a id='n2848' href='#n2848'>2848</a>
<a id='n2849' href='#n2849'>2849</a>
<a id='n2850' href='#n2850'>2850</a>
<a id='n2851' href='#n2851'>2851</a>
<a id='n2852' href='#n2852'>2852</a>
<a id='n2853' href='#n2853'>2853</a>
<a id='n2854' href='#n2854'>2854</a>
<a id='n2855' href='#n2855'>2855</a>
<a id='n2856' href='#n2856'>2856</a>
<a id='n2857' href='#n2857'>2857</a>
<a id='n2858' href='#n2858'>2858</a>
<a id='n2859' href='#n2859'>2859</a>
<a id='n2860' href='#n2860'>2860</a>
<a id='n2861' href='#n2861'>2861</a>
<a id='n2862' href='#n2862'>2862</a>
<a id='n2863' href='#n2863'>2863</a>
<a id='n2864' href='#n2864'>2864</a>
<a id='n2865' href='#n2865'>2865</a>
<a id='n2866' href='#n2866'>2866</a>
<a id='n2867' href='#n2867'>2867</a>
<a id='n2868' href='#n2868'>2868</a>
<a id='n2869' href='#n2869'>2869</a>
<a id='n2870' href='#n2870'>2870</a>
<a id='n2871' href='#n2871'>2871</a>
<a id='n2872' href='#n2872'>2872</a>
<a id='n2873' href='#n2873'>2873</a>
<a id='n2874' href='#n2874'>2874</a>
<a id='n2875' href='#n2875'>2875</a>
<a id='n2876' href='#n2876'>2876</a>
<a id='n2877' href='#n2877'>2877</a>
<a id='n2878' href='#n2878'>2878</a>
<a id='n2879' href='#n2879'>2879</a>
<a id='n2880' href='#n2880'>2880</a>
<a id='n2881' href='#n2881'>2881</a>
<a id='n2882' href='#n2882'>2882</a>
<a id='n2883' href='#n2883'>2883</a>
<a id='n2884' href='#n2884'>2884</a>
<a id='n2885' href='#n2885'>2885</a>
<a id='n2886' href='#n2886'>2886</a>
<a id='n2887' href='#n2887'>2887</a>
<a id='n2888' href='#n2888'>2888</a>
<a id='n2889' href='#n2889'>2889</a>
<a id='n2890' href='#n2890'>2890</a>
<a id='n2891' href='#n2891'>2891</a>
<a id='n2892' href='#n2892'>2892</a>
<a id='n2893' href='#n2893'>2893</a>
<a id='n2894' href='#n2894'>2894</a>
<a id='n2895' href='#n2895'>2895</a>
<a id='n2896' href='#n2896'>2896</a>
<a id='n2897' href='#n2897'>2897</a>
<a id='n2898' href='#n2898'>2898</a>
<a id='n2899' href='#n2899'>2899</a>
<a id='n2900' href='#n2900'>2900</a>
<a id='n2901' href='#n2901'>2901</a>
<a id='n2902' href='#n2902'>2902</a>
<a id='n2903' href='#n2903'>2903</a>
<a id='n2904' href='#n2904'>2904</a>
<a id='n2905' href='#n2905'>2905</a>
<a id='n2906' href='#n2906'>2906</a>
<a id='n2907' href='#n2907'>2907</a>
<a id='n2908' href='#n2908'>2908</a>
<a id='n2909' href='#n2909'>2909</a>
<a id='n2910' href='#n2910'>2910</a>
<a id='n2911' href='#n2911'>2911</a>
<a id='n2912' href='#n2912'>2912</a>
<a id='n2913' href='#n2913'>2913</a>
<a id='n2914' href='#n2914'>2914</a>
<a id='n2915' href='#n2915'>2915</a>
<a id='n2916' href='#n2916'>2916</a>
<a id='n2917' href='#n2917'>2917</a>
<a id='n2918' href='#n2918'>2918</a>
<a id='n2919' href='#n2919'>2919</a>
<a id='n2920' href='#n2920'>2920</a>
<a id='n2921' href='#n2921'>2921</a>
<a id='n2922' href='#n2922'>2922</a>
<a id='n2923' href='#n2923'>2923</a>
<a id='n2924' href='#n2924'>2924</a>
<a id='n2925' href='#n2925'>2925</a>
<a id='n2926' href='#n2926'>2926</a>
<a id='n2927' href='#n2927'>2927</a>
<a id='n2928' href='#n2928'>2928</a>
<a id='n2929' href='#n2929'>2929</a>
<a id='n2930' href='#n2930'>2930</a>
<a id='n2931' href='#n2931'>2931</a>
<a id='n2932' href='#n2932'>2932</a>
<a id='n2933' href='#n2933'>2933</a>
<a id='n2934' href='#n2934'>2934</a>
<a id='n2935' href='#n2935'>2935</a>
<a id='n2936' href='#n2936'>2936</a>
<a id='n2937' href='#n2937'>2937</a>
<a id='n2938' href='#n2938'>2938</a>
<a id='n2939' href='#n2939'>2939</a>
<a id='n2940' href='#n2940'>2940</a>
<a id='n2941' href='#n2941'>2941</a>
<a id='n2942' href='#n2942'>2942</a>
<a id='n2943' href='#n2943'>2943</a>
<a id='n2944' href='#n2944'>2944</a>
<a id='n2945' href='#n2945'>2945</a>
<a id='n2946' href='#n2946'>2946</a>
<a id='n2947' href='#n2947'>2947</a>
<a id='n2948' href='#n2948'>2948</a>
<a id='n2949' href='#n2949'>2949</a>
<a id='n2950' href='#n2950'>2950</a>
<a id='n2951' href='#n2951'>2951</a>
<a id='n2952' href='#n2952'>2952</a>
<a id='n2953' href='#n2953'>2953</a>
<a id='n2954' href='#n2954'>2954</a>
<a id='n2955' href='#n2955'>2955</a>
<a id='n2956' href='#n2956'>2956</a>
<a id='n2957' href='#n2957'>2957</a>
<a id='n2958' href='#n2958'>2958</a>
<a id='n2959' href='#n2959'>2959</a>
<a id='n2960' href='#n2960'>2960</a>
<a id='n2961' href='#n2961'>2961</a>
<a id='n2962' href='#n2962'>2962</a>
<a id='n2963' href='#n2963'>2963</a>
<a id='n2964' href='#n2964'>2964</a>
<a id='n2965' href='#n2965'>2965</a>
<a id='n2966' href='#n2966'>2966</a>
<a id='n2967' href='#n2967'>2967</a>
<a id='n2968' href='#n2968'>2968</a>
<a id='n2969' href='#n2969'>2969</a>
<a id='n2970' href='#n2970'>2970</a>
<a id='n2971' href='#n2971'>2971</a>
<a id='n2972' href='#n2972'>2972</a>
<a id='n2973' href='#n2973'>2973</a>
<a id='n2974' href='#n2974'>2974</a>
<a id='n2975' href='#n2975'>2975</a>
<a id='n2976' href='#n2976'>2976</a>
<a id='n2977' href='#n2977'>2977</a>
<a id='n2978' href='#n2978'>2978</a>
<a id='n2979' href='#n2979'>2979</a>
<a id='n2980' href='#n2980'>2980</a>
<a id='n2981' href='#n2981'>2981</a>
<a id='n2982' href='#n2982'>2982</a>
<a id='n2983' href='#n2983'>2983</a>
<a id='n2984' href='#n2984'>2984</a>
<a id='n2985' href='#n2985'>2985</a>
<a id='n2986' href='#n2986'>2986</a>
<a id='n2987' href='#n2987'>2987</a>
<a id='n2988' href='#n2988'>2988</a>
<a id='n2989' href='#n2989'>2989</a>
<a id='n2990' href='#n2990'>2990</a>
<a id='n2991' href='#n2991'>2991</a>
<a id='n2992' href='#n2992'>2992</a>
<a id='n2993' href='#n2993'>2993</a>
<a id='n2994' href='#n2994'>2994</a>
<a id='n2995' href='#n2995'>2995</a>
<a id='n2996' href='#n2996'>2996</a>
<a id='n2997' href='#n2997'>2997</a>
<a id='n2998' href='#n2998'>2998</a>
<a id='n2999' href='#n2999'>2999</a>
<a id='n3000' href='#n3000'>3000</a>
<a id='n3001' href='#n3001'>3001</a>
<a id='n3002' href='#n3002'>3002</a>
<a id='n3003' href='#n3003'>3003</a>
<a id='n3004' href='#n3004'>3004</a>
<a id='n3005' href='#n3005'>3005</a>
<a id='n3006' href='#n3006'>3006</a>
<a id='n3007' href='#n3007'>3007</a>
<a id='n3008' href='#n3008'>3008</a>
<a id='n3009' href='#n3009'>3009</a>
<a id='n3010' href='#n3010'>3010</a>
<a id='n3011' href='#n3011'>3011</a>
<a id='n3012' href='#n3012'>3012</a>
<a id='n3013' href='#n3013'>3013</a>
<a id='n3014' href='#n3014'>3014</a>
<a id='n3015' href='#n3015'>3015</a>
<a id='n3016' href='#n3016'>3016</a>
<a id='n3017' href='#n3017'>3017</a>
<a id='n3018' href='#n3018'>3018</a>
<a id='n3019' href='#n3019'>3019</a>
<a id='n3020' href='#n3020'>3020</a>
<a id='n3021' href='#n3021'>3021</a>
<a id='n3022' href='#n3022'>3022</a>
<a id='n3023' href='#n3023'>3023</a>
<a id='n3024' href='#n3024'>3024</a>
<a id='n3025' href='#n3025'>3025</a>
<a id='n3026' href='#n3026'>3026</a>
<a id='n3027' href='#n3027'>3027</a>
<a id='n3028' href='#n3028'>3028</a>
<a id='n3029' href='#n3029'>3029</a>
<a id='n3030' href='#n3030'>3030</a>
<a id='n3031' href='#n3031'>3031</a>
<a id='n3032' href='#n3032'>3032</a>
<a id='n3033' href='#n3033'>3033</a>
<a id='n3034' href='#n3034'>3034</a>
<a id='n3035' href='#n3035'>3035</a>
<a id='n3036' href='#n3036'>3036</a>
<a id='n3037' href='#n3037'>3037</a>
<a id='n3038' href='#n3038'>3038</a>
<a id='n3039' href='#n3039'>3039</a>
<a id='n3040' href='#n3040'>3040</a>
<a id='n3041' href='#n3041'>3041</a>
<a id='n3042' href='#n3042'>3042</a>
<a id='n3043' href='#n3043'>3043</a>
<a id='n3044' href='#n3044'>3044</a>
<a id='n3045' href='#n3045'>3045</a>
<a id='n3046' href='#n3046'>3046</a>
<a id='n3047' href='#n3047'>3047</a>
<a id='n3048' href='#n3048'>3048</a>
<a id='n3049' href='#n3049'>3049</a>
<a id='n3050' href='#n3050'>3050</a>
<a id='n3051' href='#n3051'>3051</a>
<a id='n3052' href='#n3052'>3052</a>
<a id='n3053' href='#n3053'>3053</a>
<a id='n3054' href='#n3054'>3054</a>
<a id='n3055' href='#n3055'>3055</a>
<a id='n3056' href='#n3056'>3056</a>
<a id='n3057' href='#n3057'>3057</a>
<a id='n3058' href='#n3058'>3058</a>
<a id='n3059' href='#n3059'>3059</a>
<a id='n3060' href='#n3060'>3060</a>
<a id='n3061' href='#n3061'>3061</a>
<a id='n3062' href='#n3062'>3062</a>
<a id='n3063' href='#n3063'>3063</a>
<a id='n3064' href='#n3064'>3064</a>
<a id='n3065' href='#n3065'>3065</a>
<a id='n3066' href='#n3066'>3066</a>
<a id='n3067' href='#n3067'>3067</a>
<a id='n3068' href='#n3068'>3068</a>
<a id='n3069' href='#n3069'>3069</a>
<a id='n3070' href='#n3070'>3070</a>
<a id='n3071' href='#n3071'>3071</a>
<a id='n3072' href='#n3072'>3072</a>
<a id='n3073' href='#n3073'>3073</a>
<a id='n3074' href='#n3074'>3074</a>
<a id='n3075' href='#n3075'>3075</a>
<a id='n3076' href='#n3076'>3076</a>
<a id='n3077' href='#n3077'>3077</a>
<a id='n3078' href='#n3078'>3078</a>
<a id='n3079' href='#n3079'>3079</a>
<a id='n3080' href='#n3080'>3080</a>
<a id='n3081' href='#n3081'>3081</a>
<a id='n3082' href='#n3082'>3082</a>
<a id='n3083' href='#n3083'>3083</a>
<a id='n3084' href='#n3084'>3084</a>
<a id='n3085' href='#n3085'>3085</a>
<a id='n3086' href='#n3086'>3086</a>
<a id='n3087' href='#n3087'>3087</a>
<a id='n3088' href='#n3088'>3088</a>
<a id='n3089' href='#n3089'>3089</a>
<a id='n3090' href='#n3090'>3090</a>
<a id='n3091' href='#n3091'>3091</a>
<a id='n3092' href='#n3092'>3092</a>
<a id='n3093' href='#n3093'>3093</a>
<a id='n3094' href='#n3094'>3094</a>
<a id='n3095' href='#n3095'>3095</a>
<a id='n3096' href='#n3096'>3096</a>
<a id='n3097' href='#n3097'>3097</a>
<a id='n3098' href='#n3098'>3098</a>
<a id='n3099' href='#n3099'>3099</a>
<a id='n3100' href='#n3100'>3100</a>
<a id='n3101' href='#n3101'>3101</a>
<a id='n3102' href='#n3102'>3102</a>
<a id='n3103' href='#n3103'>3103</a>
<a id='n3104' href='#n3104'>3104</a>
<a id='n3105' href='#n3105'>3105</a>
<a id='n3106' href='#n3106'>3106</a>
<a id='n3107' href='#n3107'>3107</a>
<a id='n3108' href='#n3108'>3108</a>
<a id='n3109' href='#n3109'>3109</a>
<a id='n3110' href='#n3110'>3110</a>
<a id='n3111' href='#n3111'>3111</a>
<a id='n3112' href='#n3112'>3112</a>
<a id='n3113' href='#n3113'>3113</a>
<a id='n3114' href='#n3114'>3114</a>
<a id='n3115' href='#n3115'>3115</a>
<a id='n3116' href='#n3116'>3116</a>
<a id='n3117' href='#n3117'>3117</a>
<a id='n3118' href='#n3118'>3118</a>
<a id='n3119' href='#n3119'>3119</a>
<a id='n3120' href='#n3120'>3120</a>
<a id='n3121' href='#n3121'>3121</a>
<a id='n3122' href='#n3122'>3122</a>
<a id='n3123' href='#n3123'>3123</a>
<a id='n3124' href='#n3124'>3124</a>
<a id='n3125' href='#n3125'>3125</a>
<a id='n3126' href='#n3126'>3126</a>
<a id='n3127' href='#n3127'>3127</a>
<a id='n3128' href='#n3128'>3128</a>
<a id='n3129' href='#n3129'>3129</a>
<a id='n3130' href='#n3130'>3130</a>
<a id='n3131' href='#n3131'>3131</a>
<a id='n3132' href='#n3132'>3132</a>
<a id='n3133' href='#n3133'>3133</a>
<a id='n3134' href='#n3134'>3134</a>
<a id='n3135' href='#n3135'>3135</a>
<a id='n3136' href='#n3136'>3136</a>
<a id='n3137' href='#n3137'>3137</a>
<a id='n3138' href='#n3138'>3138</a>
<a id='n3139' href='#n3139'>3139</a>
<a id='n3140' href='#n3140'>3140</a>
<a id='n3141' href='#n3141'>3141</a>
<a id='n3142' href='#n3142'>3142</a>
<a id='n3143' href='#n3143'>3143</a>
<a id='n3144' href='#n3144'>3144</a>
<a id='n3145' href='#n3145'>3145</a>
<a id='n3146' href='#n3146'>3146</a>
<a id='n3147' href='#n3147'>3147</a>
<a id='n3148' href='#n3148'>3148</a>
<a id='n3149' href='#n3149'>3149</a>
<a id='n3150' href='#n3150'>3150</a>
<a id='n3151' href='#n3151'>3151</a>
<a id='n3152' href='#n3152'>3152</a>
<a id='n3153' href='#n3153'>3153</a>
<a id='n3154' href='#n3154'>3154</a>
<a id='n3155' href='#n3155'>3155</a>
<a id='n3156' href='#n3156'>3156</a>
<a id='n3157' href='#n3157'>3157</a>
<a id='n3158' href='#n3158'>3158</a>
<a id='n3159' href='#n3159'>3159</a>
<a id='n3160' href='#n3160'>3160</a>
<a id='n3161' href='#n3161'>3161</a>
<a id='n3162' href='#n3162'>3162</a>
<a id='n3163' href='#n3163'>3163</a>
<a id='n3164' href='#n3164'>3164</a>
<a id='n3165' href='#n3165'>3165</a>
<a id='n3166' href='#n3166'>3166</a>
<a id='n3167' href='#n3167'>3167</a>
<a id='n3168' href='#n3168'>3168</a>
<a id='n3169' href='#n3169'>3169</a>
<a id='n3170' href='#n3170'>3170</a>
<a id='n3171' href='#n3171'>3171</a>
<a id='n3172' href='#n3172'>3172</a>
<a id='n3173' href='#n3173'>3173</a>
<a id='n3174' href='#n3174'>3174</a>
<a id='n3175' href='#n3175'>3175</a>
<a id='n3176' href='#n3176'>3176</a>
<a id='n3177' href='#n3177'>3177</a>
<a id='n3178' href='#n3178'>3178</a>
<a id='n3179' href='#n3179'>3179</a>
<a id='n3180' href='#n3180'>3180</a>
<a id='n3181' href='#n3181'>3181</a>
<a id='n3182' href='#n3182'>3182</a>
<a id='n3183' href='#n3183'>3183</a>
<a id='n3184' href='#n3184'>3184</a>
<a id='n3185' href='#n3185'>3185</a>
<a id='n3186' href='#n3186'>3186</a>
<a id='n3187' href='#n3187'>3187</a>
<a id='n3188' href='#n3188'>3188</a>
<a id='n3189' href='#n3189'>3189</a>
<a id='n3190' href='#n3190'>3190</a>
<a id='n3191' href='#n3191'>3191</a>
<a id='n3192' href='#n3192'>3192</a>
<a id='n3193' href='#n3193'>3193</a>
<a id='n3194' href='#n3194'>3194</a>
<a id='n3195' href='#n3195'>3195</a>
<a id='n3196' href='#n3196'>3196</a>
<a id='n3197' href='#n3197'>3197</a>
<a id='n3198' href='#n3198'>3198</a>
<a id='n3199' href='#n3199'>3199</a>
<a id='n3200' href='#n3200'>3200</a>
<a id='n3201' href='#n3201'>3201</a>
<a id='n3202' href='#n3202'>3202</a>
<a id='n3203' href='#n3203'>3203</a>
<a id='n3204' href='#n3204'>3204</a>
<a id='n3205' href='#n3205'>3205</a>
<a id='n3206' href='#n3206'>3206</a>
<a id='n3207' href='#n3207'>3207</a>
<a id='n3208' href='#n3208'>3208</a>
<a id='n3209' href='#n3209'>3209</a>
<a id='n3210' href='#n3210'>3210</a>
<a id='n3211' href='#n3211'>3211</a>
<a id='n3212' href='#n3212'>3212</a>
<a id='n3213' href='#n3213'>3213</a>
<a id='n3214' href='#n3214'>3214</a>
<a id='n3215' href='#n3215'>3215</a>
<a id='n3216' href='#n3216'>3216</a>
<a id='n3217' href='#n3217'>3217</a>
<a id='n3218' href='#n3218'>3218</a>
<a id='n3219' href='#n3219'>3219</a>
<a id='n3220' href='#n3220'>3220</a>
<a id='n3221' href='#n3221'>3221</a>
<a id='n3222' href='#n3222'>3222</a>
<a id='n3223' href='#n3223'>3223</a>
<a id='n3224' href='#n3224'>3224</a>
<a id='n3225' href='#n3225'>3225</a>
<a id='n3226' href='#n3226'>3226</a>
<a id='n3227' href='#n3227'>3227</a>
<a id='n3228' href='#n3228'>3228</a>
<a id='n3229' href='#n3229'>3229</a>
<a id='n3230' href='#n3230'>3230</a>
<a id='n3231' href='#n3231'>3231</a>
<a id='n3232' href='#n3232'>3232</a>
<a id='n3233' href='#n3233'>3233</a>
<a id='n3234' href='#n3234'>3234</a>
<a id='n3235' href='#n3235'>3235</a>
<a id='n3236' href='#n3236'>3236</a>
<a id='n3237' href='#n3237'>3237</a>
<a id='n3238' href='#n3238'>3238</a>
<a id='n3239' href='#n3239'>3239</a>
<a id='n3240' href='#n3240'>3240</a>
<a id='n3241' href='#n3241'>3241</a>
<a id='n3242' href='#n3242'>3242</a>
<a id='n3243' href='#n3243'>3243</a>
<a id='n3244' href='#n3244'>3244</a>
<a id='n3245' href='#n3245'>3245</a>
<a id='n3246' href='#n3246'>3246</a>
<a id='n3247' href='#n3247'>3247</a>
<a id='n3248' href='#n3248'>3248</a>
<a id='n3249' href='#n3249'>3249</a>
<a id='n3250' href='#n3250'>3250</a>
<a id='n3251' href='#n3251'>3251</a>
<a id='n3252' href='#n3252'>3252</a>
<a id='n3253' href='#n3253'>3253</a>
<a id='n3254' href='#n3254'>3254</a>
<a id='n3255' href='#n3255'>3255</a>
<a id='n3256' href='#n3256'>3256</a>
<a id='n3257' href='#n3257'>3257</a>
<a id='n3258' href='#n3258'>3258</a>
<a id='n3259' href='#n3259'>3259</a>
<a id='n3260' href='#n3260'>3260</a>
<a id='n3261' href='#n3261'>3261</a>
<a id='n3262' href='#n3262'>3262</a>
<a id='n3263' href='#n3263'>3263</a>
<a id='n3264' href='#n3264'>3264</a>
<a id='n3265' href='#n3265'>3265</a>
<a id='n3266' href='#n3266'>3266</a>
<a id='n3267' href='#n3267'>3267</a>
<a id='n3268' href='#n3268'>3268</a>
<a id='n3269' href='#n3269'>3269</a>
<a id='n3270' href='#n3270'>3270</a>
<a id='n3271' href='#n3271'>3271</a>
<a id='n3272' href='#n3272'>3272</a>
<a id='n3273' href='#n3273'>3273</a>
<a id='n3274' href='#n3274'>3274</a>
<a id='n3275' href='#n3275'>3275</a>
<a id='n3276' href='#n3276'>3276</a>
<a id='n3277' href='#n3277'>3277</a>
<a id='n3278' href='#n3278'>3278</a>
<a id='n3279' href='#n3279'>3279</a>
<a id='n3280' href='#n3280'>3280</a>
<a id='n3281' href='#n3281'>3281</a>
<a id='n3282' href='#n3282'>3282</a>
<a id='n3283' href='#n3283'>3283</a>
<a id='n3284' href='#n3284'>3284</a>
<a id='n3285' href='#n3285'>3285</a>
<a id='n3286' href='#n3286'>3286</a>
<a id='n3287' href='#n3287'>3287</a>
<a id='n3288' href='#n3288'>3288</a>
<a id='n3289' href='#n3289'>3289</a>
<a id='n3290' href='#n3290'>3290</a>
<a id='n3291' href='#n3291'>3291</a>
<a id='n3292' href='#n3292'>3292</a>
<a id='n3293' href='#n3293'>3293</a>
<a id='n3294' href='#n3294'>3294</a>
<a id='n3295' href='#n3295'>3295</a>
<a id='n3296' href='#n3296'>3296</a>
<a id='n3297' href='#n3297'>3297</a>
<a id='n3298' href='#n3298'>3298</a>
<a id='n3299' href='#n3299'>3299</a>
<a id='n3300' href='#n3300'>3300</a>
<a id='n3301' href='#n3301'>3301</a>
<a id='n3302' href='#n3302'>3302</a>
<a id='n3303' href='#n3303'>3303</a>
<a id='n3304' href='#n3304'>3304</a>
<a id='n3305' href='#n3305'>3305</a>
<a id='n3306' href='#n3306'>3306</a>
<a id='n3307' href='#n3307'>3307</a>
<a id='n3308' href='#n3308'>3308</a>
<a id='n3309' href='#n3309'>3309</a>
<a id='n3310' href='#n3310'>3310</a>
<a id='n3311' href='#n3311'>3311</a>
<a id='n3312' href='#n3312'>3312</a>
<a id='n3313' href='#n3313'>3313</a>
<a id='n3314' href='#n3314'>3314</a>
<a id='n3315' href='#n3315'>3315</a>
<a id='n3316' href='#n3316'>3316</a>
<a id='n3317' href='#n3317'>3317</a>
<a id='n3318' href='#n3318'>3318</a>
<a id='n3319' href='#n3319'>3319</a>
<a id='n3320' href='#n3320'>3320</a>
<a id='n3321' href='#n3321'>3321</a>
<a id='n3322' href='#n3322'>3322</a>
<a id='n3323' href='#n3323'>3323</a>
<a id='n3324' href='#n3324'>3324</a>
<a id='n3325' href='#n3325'>3325</a>
<a id='n3326' href='#n3326'>3326</a>
<a id='n3327' href='#n3327'>3327</a>
<a id='n3328' href='#n3328'>3328</a>
<a id='n3329' href='#n3329'>3329</a>
<a id='n3330' href='#n3330'>3330</a>
<a id='n3331' href='#n3331'>3331</a>
<a id='n3332' href='#n3332'>3332</a>
<a id='n3333' href='#n3333'>3333</a>
<a id='n3334' href='#n3334'>3334</a>
<a id='n3335' href='#n3335'>3335</a>
<a id='n3336' href='#n3336'>3336</a>
<a id='n3337' href='#n3337'>3337</a>
<a id='n3338' href='#n3338'>3338</a>
<a id='n3339' href='#n3339'>3339</a>
<a id='n3340' href='#n3340'>3340</a>
<a id='n3341' href='#n3341'>3341</a>
<a id='n3342' href='#n3342'>3342</a>
<a id='n3343' href='#n3343'>3343</a>
<a id='n3344' href='#n3344'>3344</a>
<a id='n3345' href='#n3345'>3345</a>
<a id='n3346' href='#n3346'>3346</a>
<a id='n3347' href='#n3347'>3347</a>
<a id='n3348' href='#n3348'>3348</a>
<a id='n3349' href='#n3349'>3349</a>
<a id='n3350' href='#n3350'>3350</a>
<a id='n3351' href='#n3351'>3351</a>
<a id='n3352' href='#n3352'>3352</a>
<a id='n3353' href='#n3353'>3353</a>
<a id='n3354' href='#n3354'>3354</a>
<a id='n3355' href='#n3355'>3355</a>
<a id='n3356' href='#n3356'>3356</a>
<a id='n3357' href='#n3357'>3357</a>
<a id='n3358' href='#n3358'>3358</a>
<a id='n3359' href='#n3359'>3359</a>
<a id='n3360' href='#n3360'>3360</a>
<a id='n3361' href='#n3361'>3361</a>
<a id='n3362' href='#n3362'>3362</a>
<a id='n3363' href='#n3363'>3363</a>
<a id='n3364' href='#n3364'>3364</a>
<a id='n3365' href='#n3365'>3365</a>
<a id='n3366' href='#n3366'>3366</a>
<a id='n3367' href='#n3367'>3367</a>
<a id='n3368' href='#n3368'>3368</a>
<a id='n3369' href='#n3369'>3369</a>
<a id='n3370' href='#n3370'>3370</a>
<a id='n3371' href='#n3371'>3371</a>
<a id='n3372' href='#n3372'>3372</a>
<a id='n3373' href='#n3373'>3373</a>
<a id='n3374' href='#n3374'>3374</a>
<a id='n3375' href='#n3375'>3375</a>
<a id='n3376' href='#n3376'>3376</a>
<a id='n3377' href='#n3377'>3377</a>
<a id='n3378' href='#n3378'>3378</a>
<a id='n3379' href='#n3379'>3379</a>
<a id='n3380' href='#n3380'>3380</a>
<a id='n3381' href='#n3381'>3381</a>
<a id='n3382' href='#n3382'>3382</a>
<a id='n3383' href='#n3383'>3383</a>
<a id='n3384' href='#n3384'>3384</a>
<a id='n3385' href='#n3385'>3385</a>
<a id='n3386' href='#n3386'>3386</a>
<a id='n3387' href='#n3387'>3387</a>
<a id='n3388' href='#n3388'>3388</a>
<a id='n3389' href='#n3389'>3389</a>
<a id='n3390' href='#n3390'>3390</a>
<a id='n3391' href='#n3391'>3391</a>
<a id='n3392' href='#n3392'>3392</a>
<a id='n3393' href='#n3393'>3393</a>
<a id='n3394' href='#n3394'>3394</a>
<a id='n3395' href='#n3395'>3395</a>
<a id='n3396' href='#n3396'>3396</a>
<a id='n3397' href='#n3397'>3397</a>
<a id='n3398' href='#n3398'>3398</a>
<a id='n3399' href='#n3399'>3399</a>
<a id='n3400' href='#n3400'>3400</a>
<a id='n3401' href='#n3401'>3401</a>
<a id='n3402' href='#n3402'>3402</a>
<a id='n3403' href='#n3403'>3403</a>
<a id='n3404' href='#n3404'>3404</a>
<a id='n3405' href='#n3405'>3405</a>
<a id='n3406' href='#n3406'>3406</a>
<a id='n3407' href='#n3407'>3407</a>
<a id='n3408' href='#n3408'>3408</a>
<a id='n3409' href='#n3409'>3409</a>
<a id='n3410' href='#n3410'>3410</a>
<a id='n3411' href='#n3411'>3411</a>
<a id='n3412' href='#n3412'>3412</a>
<a id='n3413' href='#n3413'>3413</a>
<a id='n3414' href='#n3414'>3414</a>
<a id='n3415' href='#n3415'>3415</a>
<a id='n3416' href='#n3416'>3416</a>
<a id='n3417' href='#n3417'>3417</a>
<a id='n3418' href='#n3418'>3418</a>
<a id='n3419' href='#n3419'>3419</a>
<a id='n3420' href='#n3420'>3420</a>
<a id='n3421' href='#n3421'>3421</a>
<a id='n3422' href='#n3422'>3422</a>
<a id='n3423' href='#n3423'>3423</a>
<a id='n3424' href='#n3424'>3424</a>
<a id='n3425' href='#n3425'>3425</a>
<a id='n3426' href='#n3426'>3426</a>
<a id='n3427' href='#n3427'>3427</a>
<a id='n3428' href='#n3428'>3428</a>
<a id='n3429' href='#n3429'>3429</a>
<a id='n3430' href='#n3430'>3430</a>
<a id='n3431' href='#n3431'>3431</a>
<a id='n3432' href='#n3432'>3432</a>
<a id='n3433' href='#n3433'>3433</a>
<a id='n3434' href='#n3434'>3434</a>
<a id='n3435' href='#n3435'>3435</a>
<a id='n3436' href='#n3436'>3436</a>
<a id='n3437' href='#n3437'>3437</a>
<a id='n3438' href='#n3438'>3438</a>
<a id='n3439' href='#n3439'>3439</a>
<a id='n3440' href='#n3440'>3440</a>
<a id='n3441' href='#n3441'>3441</a>
<a id='n3442' href='#n3442'>3442</a>
<a id='n3443' href='#n3443'>3443</a>
<a id='n3444' href='#n3444'>3444</a>
<a id='n3445' href='#n3445'>3445</a>
<a id='n3446' href='#n3446'>3446</a>
<a id='n3447' href='#n3447'>3447</a>
<a id='n3448' href='#n3448'>3448</a>
<a id='n3449' href='#n3449'>3449</a>
<a id='n3450' href='#n3450'>3450</a>
<a id='n3451' href='#n3451'>3451</a>
<a id='n3452' href='#n3452'>3452</a>
<a id='n3453' href='#n3453'>3453</a>
<a id='n3454' href='#n3454'>3454</a>
<a id='n3455' href='#n3455'>3455</a>
<a id='n3456' href='#n3456'>3456</a>
<a id='n3457' href='#n3457'>3457</a>
<a id='n3458' href='#n3458'>3458</a>
<a id='n3459' href='#n3459'>3459</a>
<a id='n3460' href='#n3460'>3460</a>
<a id='n3461' href='#n3461'>3461</a>
<a id='n3462' href='#n3462'>3462</a>
<a id='n3463' href='#n3463'>3463</a>
<a id='n3464' href='#n3464'>3464</a>
<a id='n3465' href='#n3465'>3465</a>
<a id='n3466' href='#n3466'>3466</a>
<a id='n3467' href='#n3467'>3467</a>
<a id='n3468' href='#n3468'>3468</a>
<a id='n3469' href='#n3469'>3469</a>
<a id='n3470' href='#n3470'>3470</a>
<a id='n3471' href='#n3471'>3471</a>
<a id='n3472' href='#n3472'>3472</a>
<a id='n3473' href='#n3473'>3473</a>
<a id='n3474' href='#n3474'>3474</a>
<a id='n3475' href='#n3475'>3475</a>
<a id='n3476' href='#n3476'>3476</a>
<a id='n3477' href='#n3477'>3477</a>
<a id='n3478' href='#n3478'>3478</a>
<a id='n3479' href='#n3479'>3479</a>
<a id='n3480' href='#n3480'>3480</a>
<a id='n3481' href='#n3481'>3481</a>
<a id='n3482' href='#n3482'>3482</a>
<a id='n3483' href='#n3483'>3483</a>
<a id='n3484' href='#n3484'>3484</a>
<a id='n3485' href='#n3485'>3485</a>
<a id='n3486' href='#n3486'>3486</a>
<a id='n3487' href='#n3487'>3487</a>
<a id='n3488' href='#n3488'>3488</a>
<a id='n3489' href='#n3489'>3489</a>
<a id='n3490' href='#n3490'>3490</a>
<a id='n3491' href='#n3491'>3491</a>
<a id='n3492' href='#n3492'>3492</a>
<a id='n3493' href='#n3493'>3493</a>
<a id='n3494' href='#n3494'>3494</a>
<a id='n3495' href='#n3495'>3495</a>
<a id='n3496' href='#n3496'>3496</a>
<a id='n3497' href='#n3497'>3497</a>
<a id='n3498' href='#n3498'>3498</a>
<a id='n3499' href='#n3499'>3499</a>
<a id='n3500' href='#n3500'>3500</a>
<a id='n3501' href='#n3501'>3501</a>
<a id='n3502' href='#n3502'>3502</a>
<a id='n3503' href='#n3503'>3503</a>
<a id='n3504' href='#n3504'>3504</a>
<a id='n3505' href='#n3505'>3505</a>
<a id='n3506' href='#n3506'>3506</a>
<a id='n3507' href='#n3507'>3507</a>
<a id='n3508' href='#n3508'>3508</a>
<a id='n3509' href='#n3509'>3509</a>
<a id='n3510' href='#n3510'>3510</a>
<a id='n3511' href='#n3511'>3511</a>
<a id='n3512' href='#n3512'>3512</a>
<a id='n3513' href='#n3513'>3513</a>
<a id='n3514' href='#n3514'>3514</a>
<a id='n3515' href='#n3515'>3515</a>
<a id='n3516' href='#n3516'>3516</a>
<a id='n3517' href='#n3517'>3517</a>
<a id='n3518' href='#n3518'>3518</a>
<a id='n3519' href='#n3519'>3519</a>
<a id='n3520' href='#n3520'>3520</a>
<a id='n3521' href='#n3521'>3521</a>
<a id='n3522' href='#n3522'>3522</a>
<a id='n3523' href='#n3523'>3523</a>
<a id='n3524' href='#n3524'>3524</a>
<a id='n3525' href='#n3525'>3525</a>
<a id='n3526' href='#n3526'>3526</a>
<a id='n3527' href='#n3527'>3527</a>
<a id='n3528' href='#n3528'>3528</a>
<a id='n3529' href='#n3529'>3529</a>
<a id='n3530' href='#n3530'>3530</a>
<a id='n3531' href='#n3531'>3531</a>
<a id='n3532' href='#n3532'>3532</a>
<a id='n3533' href='#n3533'>3533</a>
<a id='n3534' href='#n3534'>3534</a>
<a id='n3535' href='#n3535'>3535</a>
<a id='n3536' href='#n3536'>3536</a>
<a id='n3537' href='#n3537'>3537</a>
<a id='n3538' href='#n3538'>3538</a>
<a id='n3539' href='#n3539'>3539</a>
<a id='n3540' href='#n3540'>3540</a>
<a id='n3541' href='#n3541'>3541</a>
<a id='n3542' href='#n3542'>3542</a>
<a id='n3543' href='#n3543'>3543</a>
<a id='n3544' href='#n3544'>3544</a>
<a id='n3545' href='#n3545'>3545</a>
<a id='n3546' href='#n3546'>3546</a>
<a id='n3547' href='#n3547'>3547</a>
<a id='n3548' href='#n3548'>3548</a>
<a id='n3549' href='#n3549'>3549</a>
<a id='n3550' href='#n3550'>3550</a>
<a id='n3551' href='#n3551'>3551</a>
<a id='n3552' href='#n3552'>3552</a>
<a id='n3553' href='#n3553'>3553</a>
<a id='n3554' href='#n3554'>3554</a>
<a id='n3555' href='#n3555'>3555</a>
<a id='n3556' href='#n3556'>3556</a>
<a id='n3557' href='#n3557'>3557</a>
<a id='n3558' href='#n3558'>3558</a>
<a id='n3559' href='#n3559'>3559</a>
<a id='n3560' href='#n3560'>3560</a>
<a id='n3561' href='#n3561'>3561</a>
<a id='n3562' href='#n3562'>3562</a>
<a id='n3563' href='#n3563'>3563</a>
<a id='n3564' href='#n3564'>3564</a>
<a id='n3565' href='#n3565'>3565</a>
<a id='n3566' href='#n3566'>3566</a>
<a id='n3567' href='#n3567'>3567</a>
<a id='n3568' href='#n3568'>3568</a>
<a id='n3569' href='#n3569'>3569</a>
<a id='n3570' href='#n3570'>3570</a>
<a id='n3571' href='#n3571'>3571</a>
<a id='n3572' href='#n3572'>3572</a>
<a id='n3573' href='#n3573'>3573</a>
<a id='n3574' href='#n3574'>3574</a>
<a id='n3575' href='#n3575'>3575</a>
<a id='n3576' href='#n3576'>3576</a>
<a id='n3577' href='#n3577'>3577</a>
<a id='n3578' href='#n3578'>3578</a>
<a id='n3579' href='#n3579'>3579</a>
<a id='n3580' href='#n3580'>3580</a>
<a id='n3581' href='#n3581'>3581</a>
<a id='n3582' href='#n3582'>3582</a>
<a id='n3583' href='#n3583'>3583</a>
<a id='n3584' href='#n3584'>3584</a>
<a id='n3585' href='#n3585'>3585</a>
<a id='n3586' href='#n3586'>3586</a>
<a id='n3587' href='#n3587'>3587</a>
<a id='n3588' href='#n3588'>3588</a>
<a id='n3589' href='#n3589'>3589</a>
<a id='n3590' href='#n3590'>3590</a>
<a id='n3591' href='#n3591'>3591</a>
<a id='n3592' href='#n3592'>3592</a>
<a id='n3593' href='#n3593'>3593</a>
<a id='n3594' href='#n3594'>3594</a>
<a id='n3595' href='#n3595'>3595</a>
<a id='n3596' href='#n3596'>3596</a>
<a id='n3597' href='#n3597'>3597</a>
<a id='n3598' href='#n3598'>3598</a>
<a id='n3599' href='#n3599'>3599</a>
<a id='n3600' href='#n3600'>3600</a>
<a id='n3601' href='#n3601'>3601</a>
<a id='n3602' href='#n3602'>3602</a>
<a id='n3603' href='#n3603'>3603</a>
<a id='n3604' href='#n3604'>3604</a>
<a id='n3605' href='#n3605'>3605</a>
<a id='n3606' href='#n3606'>3606</a>
<a id='n3607' href='#n3607'>3607</a>
<a id='n3608' href='#n3608'>3608</a>
<a id='n3609' href='#n3609'>3609</a>
<a id='n3610' href='#n3610'>3610</a>
<a id='n3611' href='#n3611'>3611</a>
<a id='n3612' href='#n3612'>3612</a>
<a id='n3613' href='#n3613'>3613</a>
<a id='n3614' href='#n3614'>3614</a>
<a id='n3615' href='#n3615'>3615</a>
<a id='n3616' href='#n3616'>3616</a>
<a id='n3617' href='#n3617'>3617</a>
<a id='n3618' href='#n3618'>3618</a>
<a id='n3619' href='#n3619'>3619</a>
<a id='n3620' href='#n3620'>3620</a>
<a id='n3621' href='#n3621'>3621</a>
<a id='n3622' href='#n3622'>3622</a>
<a id='n3623' href='#n3623'>3623</a>
<a id='n3624' href='#n3624'>3624</a>
<a id='n3625' href='#n3625'>3625</a>
<a id='n3626' href='#n3626'>3626</a>
<a id='n3627' href='#n3627'>3627</a>
<a id='n3628' href='#n3628'>3628</a>
<a id='n3629' href='#n3629'>3629</a>
<a id='n3630' href='#n3630'>3630</a>
<a id='n3631' href='#n3631'>3631</a>
<a id='n3632' href='#n3632'>3632</a>
<a id='n3633' href='#n3633'>3633</a>
<a id='n3634' href='#n3634'>3634</a>
<a id='n3635' href='#n3635'>3635</a>
<a id='n3636' href='#n3636'>3636</a>
<a id='n3637' href='#n3637'>3637</a>
<a id='n3638' href='#n3638'>3638</a>
<a id='n3639' href='#n3639'>3639</a>
<a id='n3640' href='#n3640'>3640</a>
<a id='n3641' href='#n3641'>3641</a>
<a id='n3642' href='#n3642'>3642</a>
<a id='n3643' href='#n3643'>3643</a>
<a id='n3644' href='#n3644'>3644</a>
<a id='n3645' href='#n3645'>3645</a>
<a id='n3646' href='#n3646'>3646</a>
<a id='n3647' href='#n3647'>3647</a>
<a id='n3648' href='#n3648'>3648</a>
<a id='n3649' href='#n3649'>3649</a>
<a id='n3650' href='#n3650'>3650</a>
<a id='n3651' href='#n3651'>3651</a>
<a id='n3652' href='#n3652'>3652</a>
<a id='n3653' href='#n3653'>3653</a>
<a id='n3654' href='#n3654'>3654</a>
<a id='n3655' href='#n3655'>3655</a>
<a id='n3656' href='#n3656'>3656</a>
<a id='n3657' href='#n3657'>3657</a>
<a id='n3658' href='#n3658'>3658</a>
<a id='n3659' href='#n3659'>3659</a>
<a id='n3660' href='#n3660'>3660</a>
<a id='n3661' href='#n3661'>3661</a>
<a id='n3662' href='#n3662'>3662</a>
<a id='n3663' href='#n3663'>3663</a>
<a id='n3664' href='#n3664'>3664</a>
<a id='n3665' href='#n3665'>3665</a>
<a id='n3666' href='#n3666'>3666</a>
<a id='n3667' href='#n3667'>3667</a>
<a id='n3668' href='#n3668'>3668</a>
<a id='n3669' href='#n3669'>3669</a>
<a id='n3670' href='#n3670'>3670</a>
<a id='n3671' href='#n3671'>3671</a>
<a id='n3672' href='#n3672'>3672</a>
<a id='n3673' href='#n3673'>3673</a>
<a id='n3674' href='#n3674'>3674</a>
<a id='n3675' href='#n3675'>3675</a>
<a id='n3676' href='#n3676'>3676</a>
<a id='n3677' href='#n3677'>3677</a>
<a id='n3678' href='#n3678'>3678</a>
<a id='n3679' href='#n3679'>3679</a>
<a id='n3680' href='#n3680'>3680</a>
<a id='n3681' href='#n3681'>3681</a>
<a id='n3682' href='#n3682'>3682</a>
<a id='n3683' href='#n3683'>3683</a>
<a id='n3684' href='#n3684'>3684</a>
<a id='n3685' href='#n3685'>3685</a>
<a id='n3686' href='#n3686'>3686</a>
<a id='n3687' href='#n3687'>3687</a>
<a id='n3688' href='#n3688'>3688</a>
<a id='n3689' href='#n3689'>3689</a>
<a id='n3690' href='#n3690'>3690</a>
<a id='n3691' href='#n3691'>3691</a>
<a id='n3692' href='#n3692'>3692</a>
<a id='n3693' href='#n3693'>3693</a>
<a id='n3694' href='#n3694'>3694</a>
<a id='n3695' href='#n3695'>3695</a>
<a id='n3696' href='#n3696'>3696</a>
<a id='n3697' href='#n3697'>3697</a>
<a id='n3698' href='#n3698'>3698</a>
<a id='n3699' href='#n3699'>3699</a>
<a id='n3700' href='#n3700'>3700</a>
<a id='n3701' href='#n3701'>3701</a>
<a id='n3702' href='#n3702'>3702</a>
<a id='n3703' href='#n3703'>3703</a>
<a id='n3704' href='#n3704'>3704</a>
<a id='n3705' href='#n3705'>3705</a>
<a id='n3706' href='#n3706'>3706</a>
<a id='n3707' href='#n3707'>3707</a>
<a id='n3708' href='#n3708'>3708</a>
<a id='n3709' href='#n3709'>3709</a>
<a id='n3710' href='#n3710'>3710</a>
<a id='n3711' href='#n3711'>3711</a>
<a id='n3712' href='#n3712'>3712</a>
<a id='n3713' href='#n3713'>3713</a>
<a id='n3714' href='#n3714'>3714</a>
<a id='n3715' href='#n3715'>3715</a>
<a id='n3716' href='#n3716'>3716</a>
<a id='n3717' href='#n3717'>3717</a>
<a id='n3718' href='#n3718'>3718</a>
<a id='n3719' href='#n3719'>3719</a>
<a id='n3720' href='#n3720'>3720</a>
<a id='n3721' href='#n3721'>3721</a>
<a id='n3722' href='#n3722'>3722</a>
<a id='n3723' href='#n3723'>3723</a>
<a id='n3724' href='#n3724'>3724</a>
<a id='n3725' href='#n3725'>3725</a>
<a id='n3726' href='#n3726'>3726</a>
<a id='n3727' href='#n3727'>3727</a>
<a id='n3728' href='#n3728'>3728</a>
<a id='n3729' href='#n3729'>3729</a>
<a id='n3730' href='#n3730'>3730</a>
<a id='n3731' href='#n3731'>3731</a>
<a id='n3732' href='#n3732'>3732</a>
<a id='n3733' href='#n3733'>3733</a>
<a id='n3734' href='#n3734'>3734</a>
<a id='n3735' href='#n3735'>3735</a>
<a id='n3736' href='#n3736'>3736</a>
<a id='n3737' href='#n3737'>3737</a>
<a id='n3738' href='#n3738'>3738</a>
<a id='n3739' href='#n3739'>3739</a>
<a id='n3740' href='#n3740'>3740</a>
<a id='n3741' href='#n3741'>3741</a>
<a id='n3742' href='#n3742'>3742</a>
<a id='n3743' href='#n3743'>3743</a>
<a id='n3744' href='#n3744'>3744</a>
<a id='n3745' href='#n3745'>3745</a>
<a id='n3746' href='#n3746'>3746</a>
<a id='n3747' href='#n3747'>3747</a>
<a id='n3748' href='#n3748'>3748</a>
<a id='n3749' href='#n3749'>3749</a>
<a id='n3750' href='#n3750'>3750</a>
<a id='n3751' href='#n3751'>3751</a>
<a id='n3752' href='#n3752'>3752</a>
<a id='n3753' href='#n3753'>3753</a>
<a id='n3754' href='#n3754'>3754</a>
<a id='n3755' href='#n3755'>3755</a>
<a id='n3756' href='#n3756'>3756</a>
<a id='n3757' href='#n3757'>3757</a>
<a id='n3758' href='#n3758'>3758</a>
<a id='n3759' href='#n3759'>3759</a>
<a id='n3760' href='#n3760'>3760</a>
<a id='n3761' href='#n3761'>3761</a>
<a id='n3762' href='#n3762'>3762</a>
<a id='n3763' href='#n3763'>3763</a>
<a id='n3764' href='#n3764'>3764</a>
<a id='n3765' href='#n3765'>3765</a>
<a id='n3766' href='#n3766'>3766</a>
<a id='n3767' href='#n3767'>3767</a>
<a id='n3768' href='#n3768'>3768</a>
<a id='n3769' href='#n3769'>3769</a>
<a id='n3770' href='#n3770'>3770</a>
<a id='n3771' href='#n3771'>3771</a>
<a id='n3772' href='#n3772'>3772</a>
<a id='n3773' href='#n3773'>3773</a>
<a id='n3774' href='#n3774'>3774</a>
<a id='n3775' href='#n3775'>3775</a>
<a id='n3776' href='#n3776'>3776</a>
<a id='n3777' href='#n3777'>3777</a>
<a id='n3778' href='#n3778'>3778</a>
<a id='n3779' href='#n3779'>3779</a>
<a id='n3780' href='#n3780'>3780</a>
<a id='n3781' href='#n3781'>3781</a>
<a id='n3782' href='#n3782'>3782</a>
<a id='n3783' href='#n3783'>3783</a>
<a id='n3784' href='#n3784'>3784</a>
<a id='n3785' href='#n3785'>3785</a>
<a id='n3786' href='#n3786'>3786</a>
<a id='n3787' href='#n3787'>3787</a>
<a id='n3788' href='#n3788'>3788</a>
<a id='n3789' href='#n3789'>3789</a>
<a id='n3790' href='#n3790'>3790</a>
<a id='n3791' href='#n3791'>3791</a>
<a id='n3792' href='#n3792'>3792</a>
<a id='n3793' href='#n3793'>3793</a>
<a id='n3794' href='#n3794'>3794</a>
<a id='n3795' href='#n3795'>3795</a>
<a id='n3796' href='#n3796'>3796</a>
<a id='n3797' href='#n3797'>3797</a>
<a id='n3798' href='#n3798'>3798</a>
<a id='n3799' href='#n3799'>3799</a>
<a id='n3800' href='#n3800'>3800</a>
<a id='n3801' href='#n3801'>3801</a>
<a id='n3802' href='#n3802'>3802</a>
<a id='n3803' href='#n3803'>3803</a>
<a id='n3804' href='#n3804'>3804</a>
<a id='n3805' href='#n3805'>3805</a>
<a id='n3806' href='#n3806'>3806</a>
<a id='n3807' href='#n3807'>3807</a>
<a id='n3808' href='#n3808'>3808</a>
<a id='n3809' href='#n3809'>3809</a>
<a id='n3810' href='#n3810'>3810</a>
<a id='n3811' href='#n3811'>3811</a>
<a id='n3812' href='#n3812'>3812</a>
<a id='n3813' href='#n3813'>3813</a>
<a id='n3814' href='#n3814'>3814</a>
<a id='n3815' href='#n3815'>3815</a>
<a id='n3816' href='#n3816'>3816</a>
<a id='n3817' href='#n3817'>3817</a>
<a id='n3818' href='#n3818'>3818</a>
<a id='n3819' href='#n3819'>3819</a>
<a id='n3820' href='#n3820'>3820</a>
<a id='n3821' href='#n3821'>3821</a>
<a id='n3822' href='#n3822'>3822</a>
<a id='n3823' href='#n3823'>3823</a>
<a id='n3824' href='#n3824'>3824</a>
<a id='n3825' href='#n3825'>3825</a>
<a id='n3826' href='#n3826'>3826</a>
<a id='n3827' href='#n3827'>3827</a>
<a id='n3828' href='#n3828'>3828</a>
<a id='n3829' href='#n3829'>3829</a>
<a id='n3830' href='#n3830'>3830</a>
<a id='n3831' href='#n3831'>3831</a>
<a id='n3832' href='#n3832'>3832</a>
<a id='n3833' href='#n3833'>3833</a>
<a id='n3834' href='#n3834'>3834</a>
<a id='n3835' href='#n3835'>3835</a>
<a id='n3836' href='#n3836'>3836</a>
<a id='n3837' href='#n3837'>3837</a>
<a id='n3838' href='#n3838'>3838</a>
<a id='n3839' href='#n3839'>3839</a>
<a id='n3840' href='#n3840'>3840</a>
<a id='n3841' href='#n3841'>3841</a>
<a id='n3842' href='#n3842'>3842</a>
<a id='n3843' href='#n3843'>3843</a>
<a id='n3844' href='#n3844'>3844</a>
<a id='n3845' href='#n3845'>3845</a>
<a id='n3846' href='#n3846'>3846</a>
<a id='n3847' href='#n3847'>3847</a>
<a id='n3848' href='#n3848'>3848</a>
<a id='n3849' href='#n3849'>3849</a>
<a id='n3850' href='#n3850'>3850</a>
<a id='n3851' href='#n3851'>3851</a>
<a id='n3852' href='#n3852'>3852</a>
<a id='n3853' href='#n3853'>3853</a>
<a id='n3854' href='#n3854'>3854</a>
<a id='n3855' href='#n3855'>3855</a>
<a id='n3856' href='#n3856'>3856</a>
<a id='n3857' href='#n3857'>3857</a>
<a id='n3858' href='#n3858'>3858</a>
<a id='n3859' href='#n3859'>3859</a>
<a id='n3860' href='#n3860'>3860</a>
<a id='n3861' href='#n3861'>3861</a>
<a id='n3862' href='#n3862'>3862</a>
<a id='n3863' href='#n3863'>3863</a>
<a id='n3864' href='#n3864'>3864</a>
<a id='n3865' href='#n3865'>3865</a>
<a id='n3866' href='#n3866'>3866</a>
<a id='n3867' href='#n3867'>3867</a>
<a id='n3868' href='#n3868'>3868</a>
<a id='n3869' href='#n3869'>3869</a>
<a id='n3870' href='#n3870'>3870</a>
<a id='n3871' href='#n3871'>3871</a>
<a id='n3872' href='#n3872'>3872</a>
<a id='n3873' href='#n3873'>3873</a>
<a id='n3874' href='#n3874'>3874</a>
<a id='n3875' href='#n3875'>3875</a>
<a id='n3876' href='#n3876'>3876</a>
<a id='n3877' href='#n3877'>3877</a>
<a id='n3878' href='#n3878'>3878</a>
<a id='n3879' href='#n3879'>3879</a>
<a id='n3880' href='#n3880'>3880</a>
<a id='n3881' href='#n3881'>3881</a>
<a id='n3882' href='#n3882'>3882</a>
<a id='n3883' href='#n3883'>3883</a>
<a id='n3884' href='#n3884'>3884</a>
<a id='n3885' href='#n3885'>3885</a>
<a id='n3886' href='#n3886'>3886</a>
<a id='n3887' href='#n3887'>3887</a>
<a id='n3888' href='#n3888'>3888</a>
<a id='n3889' href='#n3889'>3889</a>
<a id='n3890' href='#n3890'>3890</a>
<a id='n3891' href='#n3891'>3891</a>
<a id='n3892' href='#n3892'>3892</a>
<a id='n3893' href='#n3893'>3893</a>
<a id='n3894' href='#n3894'>3894</a>
<a id='n3895' href='#n3895'>3895</a>
<a id='n3896' href='#n3896'>3896</a>
<a id='n3897' href='#n3897'>3897</a>
<a id='n3898' href='#n3898'>3898</a>
<a id='n3899' href='#n3899'>3899</a>
<a id='n3900' href='#n3900'>3900</a>
<a id='n3901' href='#n3901'>3901</a>
<a id='n3902' href='#n3902'>3902</a>
<a id='n3903' href='#n3903'>3903</a>
<a id='n3904' href='#n3904'>3904</a>
<a id='n3905' href='#n3905'>3905</a>
<a id='n3906' href='#n3906'>3906</a>
<a id='n3907' href='#n3907'>3907</a>
<a id='n3908' href='#n3908'>3908</a>
<a id='n3909' href='#n3909'>3909</a>
<a id='n3910' href='#n3910'>3910</a>
<a id='n3911' href='#n3911'>3911</a>
<a id='n3912' href='#n3912'>3912</a>
<a id='n3913' href='#n3913'>3913</a>
<a id='n3914' href='#n3914'>3914</a>
<a id='n3915' href='#n3915'>3915</a>
<a id='n3916' href='#n3916'>3916</a>
<a id='n3917' href='#n3917'>3917</a>
<a id='n3918' href='#n3918'>3918</a>
<a id='n3919' href='#n3919'>3919</a>
<a id='n3920' href='#n3920'>3920</a>
<a id='n3921' href='#n3921'>3921</a>
<a id='n3922' href='#n3922'>3922</a>
<a id='n3923' href='#n3923'>3923</a>
<a id='n3924' href='#n3924'>3924</a>
<a id='n3925' href='#n3925'>3925</a>
<a id='n3926' href='#n3926'>3926</a>
<a id='n3927' href='#n3927'>3927</a>
<a id='n3928' href='#n3928'>3928</a>
<a id='n3929' href='#n3929'>3929</a>
<a id='n3930' href='#n3930'>3930</a>
<a id='n3931' href='#n3931'>3931</a>
<a id='n3932' href='#n3932'>3932</a>
<a id='n3933' href='#n3933'>3933</a>
<a id='n3934' href='#n3934'>3934</a>
<a id='n3935' href='#n3935'>3935</a>
<a id='n3936' href='#n3936'>3936</a>
<a id='n3937' href='#n3937'>3937</a>
<a id='n3938' href='#n3938'>3938</a>
<a id='n3939' href='#n3939'>3939</a>
<a id='n3940' href='#n3940'>3940</a>
<a id='n3941' href='#n3941'>3941</a>
<a id='n3942' href='#n3942'>3942</a>
<a id='n3943' href='#n3943'>3943</a>
<a id='n3944' href='#n3944'>3944</a>
<a id='n3945' href='#n3945'>3945</a>
<a id='n3946' href='#n3946'>3946</a>
<a id='n3947' href='#n3947'>3947</a>
<a id='n3948' href='#n3948'>3948</a>
<a id='n3949' href='#n3949'>3949</a>
<a id='n3950' href='#n3950'>3950</a>
<a id='n3951' href='#n3951'>3951</a>
<a id='n3952' href='#n3952'>3952</a>
<a id='n3953' href='#n3953'>3953</a>
<a id='n3954' href='#n3954'>3954</a>
<a id='n3955' href='#n3955'>3955</a>
<a id='n3956' href='#n3956'>3956</a>
<a id='n3957' href='#n3957'>3957</a>
<a id='n3958' href='#n3958'>3958</a>
<a id='n3959' href='#n3959'>3959</a>
<a id='n3960' href='#n3960'>3960</a>
<a id='n3961' href='#n3961'>3961</a>
<a id='n3962' href='#n3962'>3962</a>
<a id='n3963' href='#n3963'>3963</a>
<a id='n3964' href='#n3964'>3964</a>
<a id='n3965' href='#n3965'>3965</a>
<a id='n3966' href='#n3966'>3966</a>
<a id='n3967' href='#n3967'>3967</a>
<a id='n3968' href='#n3968'>3968</a>
<a id='n3969' href='#n3969'>3969</a>
<a id='n3970' href='#n3970'>3970</a>
<a id='n3971' href='#n3971'>3971</a>
<a id='n3972' href='#n3972'>3972</a>
<a id='n3973' href='#n3973'>3973</a>
<a id='n3974' href='#n3974'>3974</a>
<a id='n3975' href='#n3975'>3975</a>
<a id='n3976' href='#n3976'>3976</a>
<a id='n3977' href='#n3977'>3977</a>
<a id='n3978' href='#n3978'>3978</a>
<a id='n3979' href='#n3979'>3979</a>
<a id='n3980' href='#n3980'>3980</a>
<a id='n3981' href='#n3981'>3981</a>
<a id='n3982' href='#n3982'>3982</a>
<a id='n3983' href='#n3983'>3983</a>
<a id='n3984' href='#n3984'>3984</a>
<a id='n3985' href='#n3985'>3985</a>
<a id='n3986' href='#n3986'>3986</a>
<a id='n3987' href='#n3987'>3987</a>
<a id='n3988' href='#n3988'>3988</a>
<a id='n3989' href='#n3989'>3989</a>
<a id='n3990' href='#n3990'>3990</a>
<a id='n3991' href='#n3991'>3991</a>
<a id='n3992' href='#n3992'>3992</a>
<a id='n3993' href='#n3993'>3993</a>
<a id='n3994' href='#n3994'>3994</a>
<a id='n3995' href='#n3995'>3995</a>
<a id='n3996' href='#n3996'>3996</a>
<a id='n3997' href='#n3997'>3997</a>
<a id='n3998' href='#n3998'>3998</a>
<a id='n3999' href='#n3999'>3999</a>
<a id='n4000' href='#n4000'>4000</a>
<a id='n4001' href='#n4001'>4001</a>
<a id='n4002' href='#n4002'>4002</a>
<a id='n4003' href='#n4003'>4003</a>
<a id='n4004' href='#n4004'>4004</a>
<a id='n4005' href='#n4005'>4005</a>
<a id='n4006' href='#n4006'>4006</a>
<a id='n4007' href='#n4007'>4007</a>
<a id='n4008' href='#n4008'>4008</a>
<a id='n4009' href='#n4009'>4009</a>
<a id='n4010' href='#n4010'>4010</a>
<a id='n4011' href='#n4011'>4011</a>
<a id='n4012' href='#n4012'>4012</a>
<a id='n4013' href='#n4013'>4013</a>
<a id='n4014' href='#n4014'>4014</a>
<a id='n4015' href='#n4015'>4015</a>
<a id='n4016' href='#n4016'>4016</a>
<a id='n4017' href='#n4017'>4017</a>
<a id='n4018' href='#n4018'>4018</a>
<a id='n4019' href='#n4019'>4019</a>
<a id='n4020' href='#n4020'>4020</a>
<a id='n4021' href='#n4021'>4021</a>
<a id='n4022' href='#n4022'>4022</a>
<a id='n4023' href='#n4023'>4023</a>
<a id='n4024' href='#n4024'>4024</a>
<a id='n4025' href='#n4025'>4025</a>
<a id='n4026' href='#n4026'>4026</a>
<a id='n4027' href='#n4027'>4027</a>
<a id='n4028' href='#n4028'>4028</a>
<a id='n4029' href='#n4029'>4029</a>
<a id='n4030' href='#n4030'>4030</a>
<a id='n4031' href='#n4031'>4031</a>
<a id='n4032' href='#n4032'>4032</a>
<a id='n4033' href='#n4033'>4033</a>
<a id='n4034' href='#n4034'>4034</a>
<a id='n4035' href='#n4035'>4035</a>
<a id='n4036' href='#n4036'>4036</a>
<a id='n4037' href='#n4037'>4037</a>
<a id='n4038' href='#n4038'>4038</a>
<a id='n4039' href='#n4039'>4039</a>
<a id='n4040' href='#n4040'>4040</a>
<a id='n4041' href='#n4041'>4041</a>
<a id='n4042' href='#n4042'>4042</a>
<a id='n4043' href='#n4043'>4043</a>
<a id='n4044' href='#n4044'>4044</a>
<a id='n4045' href='#n4045'>4045</a>
<a id='n4046' href='#n4046'>4046</a>
<a id='n4047' href='#n4047'>4047</a>
<a id='n4048' href='#n4048'>4048</a>
<a id='n4049' href='#n4049'>4049</a>
<a id='n4050' href='#n4050'>4050</a>
<a id='n4051' href='#n4051'>4051</a>
<a id='n4052' href='#n4052'>4052</a>
<a id='n4053' href='#n4053'>4053</a>
<a id='n4054' href='#n4054'>4054</a>
<a id='n4055' href='#n4055'>4055</a>
<a id='n4056' href='#n4056'>4056</a>
<a id='n4057' href='#n4057'>4057</a>
<a id='n4058' href='#n4058'>4058</a>
<a id='n4059' href='#n4059'>4059</a>
<a id='n4060' href='#n4060'>4060</a>
<a id='n4061' href='#n4061'>4061</a>
<a id='n4062' href='#n4062'>4062</a>
<a id='n4063' href='#n4063'>4063</a>
<a id='n4064' href='#n4064'>4064</a>
<a id='n4065' href='#n4065'>4065</a>
<a id='n4066' href='#n4066'>4066</a>
<a id='n4067' href='#n4067'>4067</a>
<a id='n4068' href='#n4068'>4068</a>
<a id='n4069' href='#n4069'>4069</a>
<a id='n4070' href='#n4070'>4070</a>
<a id='n4071' href='#n4071'>4071</a>
<a id='n4072' href='#n4072'>4072</a>
<a id='n4073' href='#n4073'>4073</a>
<a id='n4074' href='#n4074'>4074</a>
<a id='n4075' href='#n4075'>4075</a>
<a id='n4076' href='#n4076'>4076</a>
<a id='n4077' href='#n4077'>4077</a>
<a id='n4078' href='#n4078'>4078</a>
<a id='n4079' href='#n4079'>4079</a>
<a id='n4080' href='#n4080'>4080</a>
<a id='n4081' href='#n4081'>4081</a>
<a id='n4082' href='#n4082'>4082</a>
<a id='n4083' href='#n4083'>4083</a>
<a id='n4084' href='#n4084'>4084</a>
<a id='n4085' href='#n4085'>4085</a>
<a id='n4086' href='#n4086'>4086</a>
<a id='n4087' href='#n4087'>4087</a>
<a id='n4088' href='#n4088'>4088</a>
<a id='n4089' href='#n4089'>4089</a>
<a id='n4090' href='#n4090'>4090</a>
<a id='n4091' href='#n4091'>4091</a>
<a id='n4092' href='#n4092'>4092</a>
<a id='n4093' href='#n4093'>4093</a>
<a id='n4094' href='#n4094'>4094</a>
<a id='n4095' href='#n4095'>4095</a>
<a id='n4096' href='#n4096'>4096</a>
<a id='n4097' href='#n4097'>4097</a>
<a id='n4098' href='#n4098'>4098</a>
<a id='n4099' href='#n4099'>4099</a>
<a id='n4100' href='#n4100'>4100</a>
<a id='n4101' href='#n4101'>4101</a>
<a id='n4102' href='#n4102'>4102</a>
<a id='n4103' href='#n4103'>4103</a>
<a id='n4104' href='#n4104'>4104</a>
<a id='n4105' href='#n4105'>4105</a>
<a id='n4106' href='#n4106'>4106</a>
<a id='n4107' href='#n4107'>4107</a>
<a id='n4108' href='#n4108'>4108</a>
<a id='n4109' href='#n4109'>4109</a>
<a id='n4110' href='#n4110'>4110</a>
<a id='n4111' href='#n4111'>4111</a>
<a id='n4112' href='#n4112'>4112</a>
<a id='n4113' href='#n4113'>4113</a>
<a id='n4114' href='#n4114'>4114</a>
<a id='n4115' href='#n4115'>4115</a>
<a id='n4116' href='#n4116'>4116</a>
<a id='n4117' href='#n4117'>4117</a>
<a id='n4118' href='#n4118'>4118</a>
<a id='n4119' href='#n4119'>4119</a>
<a id='n4120' href='#n4120'>4120</a>
<a id='n4121' href='#n4121'>4121</a>
<a id='n4122' href='#n4122'>4122</a>
<a id='n4123' href='#n4123'>4123</a>
<a id='n4124' href='#n4124'>4124</a>
<a id='n4125' href='#n4125'>4125</a>
<a id='n4126' href='#n4126'>4126</a>
<a id='n4127' href='#n4127'>4127</a>
<a id='n4128' href='#n4128'>4128</a>
<a id='n4129' href='#n4129'>4129</a>
<a id='n4130' href='#n4130'>4130</a>
<a id='n4131' href='#n4131'>4131</a>
<a id='n4132' href='#n4132'>4132</a>
<a id='n4133' href='#n4133'>4133</a>
<a id='n4134' href='#n4134'>4134</a>
<a id='n4135' href='#n4135'>4135</a>
<a id='n4136' href='#n4136'>4136</a>
<a id='n4137' href='#n4137'>4137</a>
<a id='n4138' href='#n4138'>4138</a>
<a id='n4139' href='#n4139'>4139</a>
<a id='n4140' href='#n4140'>4140</a>
<a id='n4141' href='#n4141'>4141</a>
<a id='n4142' href='#n4142'>4142</a>
<a id='n4143' href='#n4143'>4143</a>
<a id='n4144' href='#n4144'>4144</a>
<a id='n4145' href='#n4145'>4145</a>
<a id='n4146' href='#n4146'>4146</a>
<a id='n4147' href='#n4147'>4147</a>
<a id='n4148' href='#n4148'>4148</a>
<a id='n4149' href='#n4149'>4149</a>
<a id='n4150' href='#n4150'>4150</a>
<a id='n4151' href='#n4151'>4151</a>
<a id='n4152' href='#n4152'>4152</a>
<a id='n4153' href='#n4153'>4153</a>
<a id='n4154' href='#n4154'>4154</a>
<a id='n4155' href='#n4155'>4155</a>
<a id='n4156' href='#n4156'>4156</a>
<a id='n4157' href='#n4157'>4157</a>
<a id='n4158' href='#n4158'>4158</a>
<a id='n4159' href='#n4159'>4159</a>
<a id='n4160' href='#n4160'>4160</a>
<a id='n4161' href='#n4161'>4161</a>
<a id='n4162' href='#n4162'>4162</a>
<a id='n4163' href='#n4163'>4163</a>
<a id='n4164' href='#n4164'>4164</a>
<a id='n4165' href='#n4165'>4165</a>
<a id='n4166' href='#n4166'>4166</a>
<a id='n4167' href='#n4167'>4167</a>
<a id='n4168' href='#n4168'>4168</a>
<a id='n4169' href='#n4169'>4169</a>
<a id='n4170' href='#n4170'>4170</a>
<a id='n4171' href='#n4171'>4171</a>
<a id='n4172' href='#n4172'>4172</a>
<a id='n4173' href='#n4173'>4173</a>
<a id='n4174' href='#n4174'>4174</a>
<a id='n4175' href='#n4175'>4175</a>
<a id='n4176' href='#n4176'>4176</a>
<a id='n4177' href='#n4177'>4177</a>
<a id='n4178' href='#n4178'>4178</a>
<a id='n4179' href='#n4179'>4179</a>
<a id='n4180' href='#n4180'>4180</a>
<a id='n4181' href='#n4181'>4181</a>
<a id='n4182' href='#n4182'>4182</a>
<a id='n4183' href='#n4183'>4183</a>
<a id='n4184' href='#n4184'>4184</a>
<a id='n4185' href='#n4185'>4185</a>
<a id='n4186' href='#n4186'>4186</a>
<a id='n4187' href='#n4187'>4187</a>
<a id='n4188' href='#n4188'>4188</a>
<a id='n4189' href='#n4189'>4189</a>
<a id='n4190' href='#n4190'>4190</a>
<a id='n4191' href='#n4191'>4191</a>
<a id='n4192' href='#n4192'>4192</a>
<a id='n4193' href='#n4193'>4193</a>
<a id='n4194' href='#n4194'>4194</a>
<a id='n4195' href='#n4195'>4195</a>
<a id='n4196' href='#n4196'>4196</a>
<a id='n4197' href='#n4197'>4197</a>
<a id='n4198' href='#n4198'>4198</a>
<a id='n4199' href='#n4199'>4199</a>
<a id='n4200' href='#n4200'>4200</a>
<a id='n4201' href='#n4201'>4201</a>
<a id='n4202' href='#n4202'>4202</a>
<a id='n4203' href='#n4203'>4203</a>
<a id='n4204' href='#n4204'>4204</a>
<a id='n4205' href='#n4205'>4205</a>
<a id='n4206' href='#n4206'>4206</a>
<a id='n4207' href='#n4207'>4207</a>
<a id='n4208' href='#n4208'>4208</a>
<a id='n4209' href='#n4209'>4209</a>
<a id='n4210' href='#n4210'>4210</a>
<a id='n4211' href='#n4211'>4211</a>
<a id='n4212' href='#n4212'>4212</a>
<a id='n4213' href='#n4213'>4213</a>
<a id='n4214' href='#n4214'>4214</a>
<a id='n4215' href='#n4215'>4215</a>
<a id='n4216' href='#n4216'>4216</a>
<a id='n4217' href='#n4217'>4217</a>
<a id='n4218' href='#n4218'>4218</a>
<a id='n4219' href='#n4219'>4219</a>
<a id='n4220' href='#n4220'>4220</a>
<a id='n4221' href='#n4221'>4221</a>
<a id='n4222' href='#n4222'>4222</a>
<a id='n4223' href='#n4223'>4223</a>
<a id='n4224' href='#n4224'>4224</a>
<a id='n4225' href='#n4225'>4225</a>
<a id='n4226' href='#n4226'>4226</a>
<a id='n4227' href='#n4227'>4227</a>
<a id='n4228' href='#n4228'>4228</a>
<a id='n4229' href='#n4229'>4229</a>
<a id='n4230' href='#n4230'>4230</a>
<a id='n4231' href='#n4231'>4231</a>
<a id='n4232' href='#n4232'>4232</a>
<a id='n4233' href='#n4233'>4233</a>
<a id='n4234' href='#n4234'>4234</a>
<a id='n4235' href='#n4235'>4235</a>
<a id='n4236' href='#n4236'>4236</a>
<a id='n4237' href='#n4237'>4237</a>
<a id='n4238' href='#n4238'>4238</a>
<a id='n4239' href='#n4239'>4239</a>
<a id='n4240' href='#n4240'>4240</a>
<a id='n4241' href='#n4241'>4241</a>
<a id='n4242' href='#n4242'>4242</a>
<a id='n4243' href='#n4243'>4243</a>
<a id='n4244' href='#n4244'>4244</a>
<a id='n4245' href='#n4245'>4245</a>
<a id='n4246' href='#n4246'>4246</a>
<a id='n4247' href='#n4247'>4247</a>
<a id='n4248' href='#n4248'>4248</a>
<a id='n4249' href='#n4249'>4249</a>
<a id='n4250' href='#n4250'>4250</a>
<a id='n4251' href='#n4251'>4251</a>
<a id='n4252' href='#n4252'>4252</a>
<a id='n4253' href='#n4253'>4253</a>
<a id='n4254' href='#n4254'>4254</a>
<a id='n4255' href='#n4255'>4255</a>
<a id='n4256' href='#n4256'>4256</a>
<a id='n4257' href='#n4257'>4257</a>
<a id='n4258' href='#n4258'>4258</a>
<a id='n4259' href='#n4259'>4259</a>
<a id='n4260' href='#n4260'>4260</a>
<a id='n4261' href='#n4261'>4261</a>
<a id='n4262' href='#n4262'>4262</a>
<a id='n4263' href='#n4263'>4263</a>
<a id='n4264' href='#n4264'>4264</a>
<a id='n4265' href='#n4265'>4265</a>
<a id='n4266' href='#n4266'>4266</a>
<a id='n4267' href='#n4267'>4267</a>
<a id='n4268' href='#n4268'>4268</a>
<a id='n4269' href='#n4269'>4269</a>
<a id='n4270' href='#n4270'>4270</a>
<a id='n4271' href='#n4271'>4271</a>
<a id='n4272' href='#n4272'>4272</a>
<a id='n4273' href='#n4273'>4273</a>
<a id='n4274' href='#n4274'>4274</a>
<a id='n4275' href='#n4275'>4275</a>
<a id='n4276' href='#n4276'>4276</a>
<a id='n4277' href='#n4277'>4277</a>
<a id='n4278' href='#n4278'>4278</a>
<a id='n4279' href='#n4279'>4279</a>
<a id='n4280' href='#n4280'>4280</a>
<a id='n4281' href='#n4281'>4281</a>
<a id='n4282' href='#n4282'>4282</a>
<a id='n4283' href='#n4283'>4283</a>
<a id='n4284' href='#n4284'>4284</a>
<a id='n4285' href='#n4285'>4285</a>
<a id='n4286' href='#n4286'>4286</a>
<a id='n4287' href='#n4287'>4287</a>
<a id='n4288' href='#n4288'>4288</a>
<a id='n4289' href='#n4289'>4289</a>
<a id='n4290' href='#n4290'>4290</a>
<a id='n4291' href='#n4291'>4291</a>
<a id='n4292' href='#n4292'>4292</a>
<a id='n4293' href='#n4293'>4293</a>
<a id='n4294' href='#n4294'>4294</a>
<a id='n4295' href='#n4295'>4295</a>
<a id='n4296' href='#n4296'>4296</a>
<a id='n4297' href='#n4297'>4297</a>
<a id='n4298' href='#n4298'>4298</a>
<a id='n4299' href='#n4299'>4299</a>
<a id='n4300' href='#n4300'>4300</a>
<a id='n4301' href='#n4301'>4301</a>
<a id='n4302' href='#n4302'>4302</a>
<a id='n4303' href='#n4303'>4303</a>
<a id='n4304' href='#n4304'>4304</a>
<a id='n4305' href='#n4305'>4305</a>
<a id='n4306' href='#n4306'>4306</a>
<a id='n4307' href='#n4307'>4307</a>
<a id='n4308' href='#n4308'>4308</a>
<a id='n4309' href='#n4309'>4309</a>
<a id='n4310' href='#n4310'>4310</a>
<a id='n4311' href='#n4311'>4311</a>
<a id='n4312' href='#n4312'>4312</a>
<a id='n4313' href='#n4313'>4313</a>
<a id='n4314' href='#n4314'>4314</a>
<a id='n4315' href='#n4315'>4315</a>
<a id='n4316' href='#n4316'>4316</a>
<a id='n4317' href='#n4317'>4317</a>
<a id='n4318' href='#n4318'>4318</a>
<a id='n4319' href='#n4319'>4319</a>
<a id='n4320' href='#n4320'>4320</a>
<a id='n4321' href='#n4321'>4321</a>
<a id='n4322' href='#n4322'>4322</a>
<a id='n4323' href='#n4323'>4323</a>
<a id='n4324' href='#n4324'>4324</a>
<a id='n4325' href='#n4325'>4325</a>
<a id='n4326' href='#n4326'>4326</a>
<a id='n4327' href='#n4327'>4327</a>
<a id='n4328' href='#n4328'>4328</a>
<a id='n4329' href='#n4329'>4329</a>
<a id='n4330' href='#n4330'>4330</a>
<a id='n4331' href='#n4331'>4331</a>
<a id='n4332' href='#n4332'>4332</a>
<a id='n4333' href='#n4333'>4333</a>
<a id='n4334' href='#n4334'>4334</a>
<a id='n4335' href='#n4335'>4335</a>
<a id='n4336' href='#n4336'>4336</a>
<a id='n4337' href='#n4337'>4337</a>
<a id='n4338' href='#n4338'>4338</a>
<a id='n4339' href='#n4339'>4339</a>
<a id='n4340' href='#n4340'>4340</a>
<a id='n4341' href='#n4341'>4341</a>
<a id='n4342' href='#n4342'>4342</a>
<a id='n4343' href='#n4343'>4343</a>
<a id='n4344' href='#n4344'>4344</a>
<a id='n4345' href='#n4345'>4345</a>
<a id='n4346' href='#n4346'>4346</a>
<a id='n4347' href='#n4347'>4347</a>
<a id='n4348' href='#n4348'>4348</a>
<a id='n4349' href='#n4349'>4349</a>
<a id='n4350' href='#n4350'>4350</a>
<a id='n4351' href='#n4351'>4351</a>
<a id='n4352' href='#n4352'>4352</a>
<a id='n4353' href='#n4353'>4353</a>
<a id='n4354' href='#n4354'>4354</a>
<a id='n4355' href='#n4355'>4355</a>
<a id='n4356' href='#n4356'>4356</a>
<a id='n4357' href='#n4357'>4357</a>
<a id='n4358' href='#n4358'>4358</a>
<a id='n4359' href='#n4359'>4359</a>
<a id='n4360' href='#n4360'>4360</a>
<a id='n4361' href='#n4361'>4361</a>
<a id='n4362' href='#n4362'>4362</a>
<a id='n4363' href='#n4363'>4363</a>
<a id='n4364' href='#n4364'>4364</a>
<a id='n4365' href='#n4365'>4365</a>
<a id='n4366' href='#n4366'>4366</a>
<a id='n4367' href='#n4367'>4367</a>
<a id='n4368' href='#n4368'>4368</a>
<a id='n4369' href='#n4369'>4369</a>
<a id='n4370' href='#n4370'>4370</a>
<a id='n4371' href='#n4371'>4371</a>
<a id='n4372' href='#n4372'>4372</a>
<a id='n4373' href='#n4373'>4373</a>
<a id='n4374' href='#n4374'>4374</a>
<a id='n4375' href='#n4375'>4375</a>
<a id='n4376' href='#n4376'>4376</a>
<a id='n4377' href='#n4377'>4377</a>
<a id='n4378' href='#n4378'>4378</a>
<a id='n4379' href='#n4379'>4379</a>
<a id='n4380' href='#n4380'>4380</a>
<a id='n4381' href='#n4381'>4381</a>
<a id='n4382' href='#n4382'>4382</a>
<a id='n4383' href='#n4383'>4383</a>
<a id='n4384' href='#n4384'>4384</a>
<a id='n4385' href='#n4385'>4385</a>
<a id='n4386' href='#n4386'>4386</a>
<a id='n4387' href='#n4387'>4387</a>
<a id='n4388' href='#n4388'>4388</a>
<a id='n4389' href='#n4389'>4389</a>
<a id='n4390' href='#n4390'>4390</a>
<a id='n4391' href='#n4391'>4391</a>
<a id='n4392' href='#n4392'>4392</a>
<a id='n4393' href='#n4393'>4393</a>
<a id='n4394' href='#n4394'>4394</a>
<a id='n4395' href='#n4395'>4395</a>
<a id='n4396' href='#n4396'>4396</a>
<a id='n4397' href='#n4397'>4397</a>
<a id='n4398' href='#n4398'>4398</a>
<a id='n4399' href='#n4399'>4399</a>
<a id='n4400' href='#n4400'>4400</a>
<a id='n4401' href='#n4401'>4401</a>
<a id='n4402' href='#n4402'>4402</a>
<a id='n4403' href='#n4403'>4403</a>
<a id='n4404' href='#n4404'>4404</a>
<a id='n4405' href='#n4405'>4405</a>
<a id='n4406' href='#n4406'>4406</a>
<a id='n4407' href='#n4407'>4407</a>
<a id='n4408' href='#n4408'>4408</a>
<a id='n4409' href='#n4409'>4409</a>
<a id='n4410' href='#n4410'>4410</a>
<a id='n4411' href='#n4411'>4411</a>
<a id='n4412' href='#n4412'>4412</a>
<a id='n4413' href='#n4413'>4413</a>
<a id='n4414' href='#n4414'>4414</a>
<a id='n4415' href='#n4415'>4415</a>
<a id='n4416' href='#n4416'>4416</a>
<a id='n4417' href='#n4417'>4417</a>
<a id='n4418' href='#n4418'>4418</a>
<a id='n4419' href='#n4419'>4419</a>
<a id='n4420' href='#n4420'>4420</a>
<a id='n4421' href='#n4421'>4421</a>
<a id='n4422' href='#n4422'>4422</a>
<a id='n4423' href='#n4423'>4423</a>
<a id='n4424' href='#n4424'>4424</a>
<a id='n4425' href='#n4425'>4425</a>
<a id='n4426' href='#n4426'>4426</a>
<a id='n4427' href='#n4427'>4427</a>
<a id='n4428' href='#n4428'>4428</a>
<a id='n4429' href='#n4429'>4429</a>
<a id='n4430' href='#n4430'>4430</a>
<a id='n4431' href='#n4431'>4431</a>
<a id='n4432' href='#n4432'>4432</a>
<a id='n4433' href='#n4433'>4433</a>
<a id='n4434' href='#n4434'>4434</a>
<a id='n4435' href='#n4435'>4435</a>
<a id='n4436' href='#n4436'>4436</a>
<a id='n4437' href='#n4437'>4437</a>
<a id='n4438' href='#n4438'>4438</a>
<a id='n4439' href='#n4439'>4439</a>
<a id='n4440' href='#n4440'>4440</a>
<a id='n4441' href='#n4441'>4441</a>
<a id='n4442' href='#n4442'>4442</a>
<a id='n4443' href='#n4443'>4443</a>
<a id='n4444' href='#n4444'>4444</a>
<a id='n4445' href='#n4445'>4445</a>
<a id='n4446' href='#n4446'>4446</a>
<a id='n4447' href='#n4447'>4447</a>
<a id='n4448' href='#n4448'>4448</a>
<a id='n4449' href='#n4449'>4449</a>
<a id='n4450' href='#n4450'>4450</a>
<a id='n4451' href='#n4451'>4451</a>
<a id='n4452' href='#n4452'>4452</a>
<a id='n4453' href='#n4453'>4453</a>
<a id='n4454' href='#n4454'>4454</a>
<a id='n4455' href='#n4455'>4455</a>
<a id='n4456' href='#n4456'>4456</a>
<a id='n4457' href='#n4457'>4457</a>
<a id='n4458' href='#n4458'>4458</a>
<a id='n4459' href='#n4459'>4459</a>
<a id='n4460' href='#n4460'>4460</a>
<a id='n4461' href='#n4461'>4461</a>
<a id='n4462' href='#n4462'>4462</a>
<a id='n4463' href='#n4463'>4463</a>
<a id='n4464' href='#n4464'>4464</a>
<a id='n4465' href='#n4465'>4465</a>
<a id='n4466' href='#n4466'>4466</a>
<a id='n4467' href='#n4467'>4467</a>
<a id='n4468' href='#n4468'>4468</a>
<a id='n4469' href='#n4469'>4469</a>
<a id='n4470' href='#n4470'>4470</a>
<a id='n4471' href='#n4471'>4471</a>
<a id='n4472' href='#n4472'>4472</a>
<a id='n4473' href='#n4473'>4473</a>
<a id='n4474' href='#n4474'>4474</a>
<a id='n4475' href='#n4475'>4475</a>
<a id='n4476' href='#n4476'>4476</a>
<a id='n4477' href='#n4477'>4477</a>
<a id='n4478' href='#n4478'>4478</a>
<a id='n4479' href='#n4479'>4479</a>
<a id='n4480' href='#n4480'>4480</a>
<a id='n4481' href='#n4481'>4481</a>
<a id='n4482' href='#n4482'>4482</a>
<a id='n4483' href='#n4483'>4483</a>
<a id='n4484' href='#n4484'>4484</a>
<a id='n4485' href='#n4485'>4485</a>
<a id='n4486' href='#n4486'>4486</a>
<a id='n4487' href='#n4487'>4487</a>
<a id='n4488' href='#n4488'>4488</a>
<a id='n4489' href='#n4489'>4489</a>
<a id='n4490' href='#n4490'>4490</a>
<a id='n4491' href='#n4491'>4491</a>
<a id='n4492' href='#n4492'>4492</a>
<a id='n4493' href='#n4493'>4493</a>
<a id='n4494' href='#n4494'>4494</a>
<a id='n4495' href='#n4495'>4495</a>
<a id='n4496' href='#n4496'>4496</a>
<a id='n4497' href='#n4497'>4497</a>
<a id='n4498' href='#n4498'>4498</a>
<a id='n4499' href='#n4499'>4499</a>
<a id='n4500' href='#n4500'>4500</a>
<a id='n4501' href='#n4501'>4501</a>
<a id='n4502' href='#n4502'>4502</a>
<a id='n4503' href='#n4503'>4503</a>
<a id='n4504' href='#n4504'>4504</a>
<a id='n4505' href='#n4505'>4505</a>
<a id='n4506' href='#n4506'>4506</a>
<a id='n4507' href='#n4507'>4507</a>
<a id='n4508' href='#n4508'>4508</a>
<a id='n4509' href='#n4509'>4509</a>
<a id='n4510' href='#n4510'>4510</a>
<a id='n4511' href='#n4511'>4511</a>
<a id='n4512' href='#n4512'>4512</a>
<a id='n4513' href='#n4513'>4513</a>
<a id='n4514' href='#n4514'>4514</a>
<a id='n4515' href='#n4515'>4515</a>
<a id='n4516' href='#n4516'>4516</a>
<a id='n4517' href='#n4517'>4517</a>
<a id='n4518' href='#n4518'>4518</a>
<a id='n4519' href='#n4519'>4519</a>
<a id='n4520' href='#n4520'>4520</a>
<a id='n4521' href='#n4521'>4521</a>
<a id='n4522' href='#n4522'>4522</a>
<a id='n4523' href='#n4523'>4523</a>
<a id='n4524' href='#n4524'>4524</a>
<a id='n4525' href='#n4525'>4525</a>
<a id='n4526' href='#n4526'>4526</a>
<a id='n4527' href='#n4527'>4527</a>
<a id='n4528' href='#n4528'>4528</a>
<a id='n4529' href='#n4529'>4529</a>
<a id='n4530' href='#n4530'>4530</a>
<a id='n4531' href='#n4531'>4531</a>
<a id='n4532' href='#n4532'>4532</a>
<a id='n4533' href='#n4533'>4533</a>
<a id='n4534' href='#n4534'>4534</a>
<a id='n4535' href='#n4535'>4535</a>
<a id='n4536' href='#n4536'>4536</a>
<a id='n4537' href='#n4537'>4537</a>
<a id='n4538' href='#n4538'>4538</a>
<a id='n4539' href='#n4539'>4539</a>
<a id='n4540' href='#n4540'>4540</a>
<a id='n4541' href='#n4541'>4541</a>
<a id='n4542' href='#n4542'>4542</a>
<a id='n4543' href='#n4543'>4543</a>
<a id='n4544' href='#n4544'>4544</a>
<a id='n4545' href='#n4545'>4545</a>
<a id='n4546' href='#n4546'>4546</a>
<a id='n4547' href='#n4547'>4547</a>
<a id='n4548' href='#n4548'>4548</a>
<a id='n4549' href='#n4549'>4549</a>
<a id='n4550' href='#n4550'>4550</a>
<a id='n4551' href='#n4551'>4551</a>
<a id='n4552' href='#n4552'>4552</a>
<a id='n4553' href='#n4553'>4553</a>
<a id='n4554' href='#n4554'>4554</a>
<a id='n4555' href='#n4555'>4555</a>
<a id='n4556' href='#n4556'>4556</a>
<a id='n4557' href='#n4557'>4557</a>
<a id='n4558' href='#n4558'>4558</a>
<a id='n4559' href='#n4559'>4559</a>
<a id='n4560' href='#n4560'>4560</a>
<a id='n4561' href='#n4561'>4561</a>
<a id='n4562' href='#n4562'>4562</a>
<a id='n4563' href='#n4563'>4563</a>
<a id='n4564' href='#n4564'>4564</a>
<a id='n4565' href='#n4565'>4565</a>
<a id='n4566' href='#n4566'>4566</a>
<a id='n4567' href='#n4567'>4567</a>
<a id='n4568' href='#n4568'>4568</a>
<a id='n4569' href='#n4569'>4569</a>
<a id='n4570' href='#n4570'>4570</a>
<a id='n4571' href='#n4571'>4571</a>
<a id='n4572' href='#n4572'>4572</a>
<a id='n4573' href='#n4573'>4573</a>
<a id='n4574' href='#n4574'>4574</a>
<a id='n4575' href='#n4575'>4575</a>
<a id='n4576' href='#n4576'>4576</a>
<a id='n4577' href='#n4577'>4577</a>
<a id='n4578' href='#n4578'>4578</a>
<a id='n4579' href='#n4579'>4579</a>
<a id='n4580' href='#n4580'>4580</a>
<a id='n4581' href='#n4581'>4581</a>
<a id='n4582' href='#n4582'>4582</a>
<a id='n4583' href='#n4583'>4583</a>
<a id='n4584' href='#n4584'>4584</a>
<a id='n4585' href='#n4585'>4585</a>
<a id='n4586' href='#n4586'>4586</a>
<a id='n4587' href='#n4587'>4587</a>
<a id='n4588' href='#n4588'>4588</a>
<a id='n4589' href='#n4589'>4589</a>
<a id='n4590' href='#n4590'>4590</a>
<a id='n4591' href='#n4591'>4591</a>
<a id='n4592' href='#n4592'>4592</a>
<a id='n4593' href='#n4593'>4593</a>
<a id='n4594' href='#n4594'>4594</a>
<a id='n4595' href='#n4595'>4595</a>
<a id='n4596' href='#n4596'>4596</a>
<a id='n4597' href='#n4597'>4597</a>
<a id='n4598' href='#n4598'>4598</a>
<a id='n4599' href='#n4599'>4599</a>
<a id='n4600' href='#n4600'>4600</a>
<a id='n4601' href='#n4601'>4601</a>
<a id='n4602' href='#n4602'>4602</a>
<a id='n4603' href='#n4603'>4603</a>
<a id='n4604' href='#n4604'>4604</a>
<a id='n4605' href='#n4605'>4605</a>
<a id='n4606' href='#n4606'>4606</a>
<a id='n4607' href='#n4607'>4607</a>
<a id='n4608' href='#n4608'>4608</a>
<a id='n4609' href='#n4609'>4609</a>
<a id='n4610' href='#n4610'>4610</a>
<a id='n4611' href='#n4611'>4611</a>
<a id='n4612' href='#n4612'>4612</a>
<a id='n4613' href='#n4613'>4613</a>
<a id='n4614' href='#n4614'>4614</a>
<a id='n4615' href='#n4615'>4615</a>
<a id='n4616' href='#n4616'>4616</a>
<a id='n4617' href='#n4617'>4617</a>
<a id='n4618' href='#n4618'>4618</a>
<a id='n4619' href='#n4619'>4619</a>
<a id='n4620' href='#n4620'>4620</a>
<a id='n4621' href='#n4621'>4621</a>
<a id='n4622' href='#n4622'>4622</a>
<a id='n4623' href='#n4623'>4623</a>
<a id='n4624' href='#n4624'>4624</a>
<a id='n4625' href='#n4625'>4625</a>
<a id='n4626' href='#n4626'>4626</a>
<a id='n4627' href='#n4627'>4627</a>
<a id='n4628' href='#n4628'>4628</a>
<a id='n4629' href='#n4629'>4629</a>
<a id='n4630' href='#n4630'>4630</a>
<a id='n4631' href='#n4631'>4631</a>
<a id='n4632' href='#n4632'>4632</a>
<a id='n4633' href='#n4633'>4633</a>
<a id='n4634' href='#n4634'>4634</a>
<a id='n4635' href='#n4635'>4635</a>
<a id='n4636' href='#n4636'>4636</a>
<a id='n4637' href='#n4637'>4637</a>
<a id='n4638' href='#n4638'>4638</a>
<a id='n4639' href='#n4639'>4639</a>
<a id='n4640' href='#n4640'>4640</a>
<a id='n4641' href='#n4641'>4641</a>
<a id='n4642' href='#n4642'>4642</a>
<a id='n4643' href='#n4643'>4643</a>
<a id='n4644' href='#n4644'>4644</a>
<a id='n4645' href='#n4645'>4645</a>
<a id='n4646' href='#n4646'>4646</a>
<a id='n4647' href='#n4647'>4647</a>
<a id='n4648' href='#n4648'>4648</a>
<a id='n4649' href='#n4649'>4649</a>
<a id='n4650' href='#n4650'>4650</a>
<a id='n4651' href='#n4651'>4651</a>
<a id='n4652' href='#n4652'>4652</a>
<a id='n4653' href='#n4653'>4653</a>
<a id='n4654' href='#n4654'>4654</a>
<a id='n4655' href='#n4655'>4655</a>
<a id='n4656' href='#n4656'>4656</a>
<a id='n4657' href='#n4657'>4657</a>
<a id='n4658' href='#n4658'>4658</a>
<a id='n4659' href='#n4659'>4659</a>
<a id='n4660' href='#n4660'>4660</a>
<a id='n4661' href='#n4661'>4661</a>
<a id='n4662' href='#n4662'>4662</a>
<a id='n4663' href='#n4663'>4663</a>
<a id='n4664' href='#n4664'>4664</a>
<a id='n4665' href='#n4665'>4665</a>
<a id='n4666' href='#n4666'>4666</a>
<a id='n4667' href='#n4667'>4667</a>
<a id='n4668' href='#n4668'>4668</a>
<a id='n4669' href='#n4669'>4669</a>
<a id='n4670' href='#n4670'>4670</a>
<a id='n4671' href='#n4671'>4671</a>
<a id='n4672' href='#n4672'>4672</a>
<a id='n4673' href='#n4673'>4673</a>
<a id='n4674' href='#n4674'>4674</a>
<a id='n4675' href='#n4675'>4675</a>
<a id='n4676' href='#n4676'>4676</a>
<a id='n4677' href='#n4677'>4677</a>
<a id='n4678' href='#n4678'>4678</a>
<a id='n4679' href='#n4679'>4679</a>
<a id='n4680' href='#n4680'>4680</a>
<a id='n4681' href='#n4681'>4681</a>
<a id='n4682' href='#n4682'>4682</a>
<a id='n4683' href='#n4683'>4683</a>
<a id='n4684' href='#n4684'>4684</a>
<a id='n4685' href='#n4685'>4685</a>
<a id='n4686' href='#n4686'>4686</a>
<a id='n4687' href='#n4687'>4687</a>
<a id='n4688' href='#n4688'>4688</a>
<a id='n4689' href='#n4689'>4689</a>
<a id='n4690' href='#n4690'>4690</a>
<a id='n4691' href='#n4691'>4691</a>
<a id='n4692' href='#n4692'>4692</a>
<a id='n4693' href='#n4693'>4693</a>
<a id='n4694' href='#n4694'>4694</a>
<a id='n4695' href='#n4695'>4695</a>
<a id='n4696' href='#n4696'>4696</a>
<a id='n4697' href='#n4697'>4697</a>
<a id='n4698' href='#n4698'>4698</a>
<a id='n4699' href='#n4699'>4699</a>
<a id='n4700' href='#n4700'>4700</a>
<a id='n4701' href='#n4701'>4701</a>
<a id='n4702' href='#n4702'>4702</a>
<a id='n4703' href='#n4703'>4703</a>
<a id='n4704' href='#n4704'>4704</a>
<a id='n4705' href='#n4705'>4705</a>
<a id='n4706' href='#n4706'>4706</a>
<a id='n4707' href='#n4707'>4707</a>
<a id='n4708' href='#n4708'>4708</a>
<a id='n4709' href='#n4709'>4709</a>
<a id='n4710' href='#n4710'>4710</a>
<a id='n4711' href='#n4711'>4711</a>
<a id='n4712' href='#n4712'>4712</a>
<a id='n4713' href='#n4713'>4713</a>
<a id='n4714' href='#n4714'>4714</a>
<a id='n4715' href='#n4715'>4715</a>
<a id='n4716' href='#n4716'>4716</a>
<a id='n4717' href='#n4717'>4717</a>
<a id='n4718' href='#n4718'>4718</a>
<a id='n4719' href='#n4719'>4719</a>
<a id='n4720' href='#n4720'>4720</a>
<a id='n4721' href='#n4721'>4721</a>
<a id='n4722' href='#n4722'>4722</a>
<a id='n4723' href='#n4723'>4723</a>
<a id='n4724' href='#n4724'>4724</a>
<a id='n4725' href='#n4725'>4725</a>
<a id='n4726' href='#n4726'>4726</a>
<a id='n4727' href='#n4727'>4727</a>
<a id='n4728' href='#n4728'>4728</a>
<a id='n4729' href='#n4729'>4729</a>
<a id='n4730' href='#n4730'>4730</a>
<a id='n4731' href='#n4731'>4731</a>
<a id='n4732' href='#n4732'>4732</a>
<a id='n4733' href='#n4733'>4733</a>
<a id='n4734' href='#n4734'>4734</a>
<a id='n4735' href='#n4735'>4735</a>
<a id='n4736' href='#n4736'>4736</a>
<a id='n4737' href='#n4737'>4737</a>
<a id='n4738' href='#n4738'>4738</a>
<a id='n4739' href='#n4739'>4739</a>
<a id='n4740' href='#n4740'>4740</a>
<a id='n4741' href='#n4741'>4741</a>
<a id='n4742' href='#n4742'>4742</a>
<a id='n4743' href='#n4743'>4743</a>
<a id='n4744' href='#n4744'>4744</a>
<a id='n4745' href='#n4745'>4745</a>
<a id='n4746' href='#n4746'>4746</a>
<a id='n4747' href='#n4747'>4747</a>
<a id='n4748' href='#n4748'>4748</a>
<a id='n4749' href='#n4749'>4749</a>
<a id='n4750' href='#n4750'>4750</a>
<a id='n4751' href='#n4751'>4751</a>
<a id='n4752' href='#n4752'>4752</a>
<a id='n4753' href='#n4753'>4753</a>
<a id='n4754' href='#n4754'>4754</a>
<a id='n4755' href='#n4755'>4755</a>
<a id='n4756' href='#n4756'>4756</a>
<a id='n4757' href='#n4757'>4757</a>
<a id='n4758' href='#n4758'>4758</a>
<a id='n4759' href='#n4759'>4759</a>
<a id='n4760' href='#n4760'>4760</a>
<a id='n4761' href='#n4761'>4761</a>
<a id='n4762' href='#n4762'>4762</a>
<a id='n4763' href='#n4763'>4763</a>
<a id='n4764' href='#n4764'>4764</a>
<a id='n4765' href='#n4765'>4765</a>
<a id='n4766' href='#n4766'>4766</a>
<a id='n4767' href='#n4767'>4767</a>
<a id='n4768' href='#n4768'>4768</a>
<a id='n4769' href='#n4769'>4769</a>
<a id='n4770' href='#n4770'>4770</a>
<a id='n4771' href='#n4771'>4771</a>
<a id='n4772' href='#n4772'>4772</a>
<a id='n4773' href='#n4773'>4773</a>
<a id='n4774' href='#n4774'>4774</a>
<a id='n4775' href='#n4775'>4775</a>
<a id='n4776' href='#n4776'>4776</a>
<a id='n4777' href='#n4777'>4777</a>
<a id='n4778' href='#n4778'>4778</a>
<a id='n4779' href='#n4779'>4779</a>
<a id='n4780' href='#n4780'>4780</a>
<a id='n4781' href='#n4781'>4781</a>
<a id='n4782' href='#n4782'>4782</a>
<a id='n4783' href='#n4783'>4783</a>
<a id='n4784' href='#n4784'>4784</a>
<a id='n4785' href='#n4785'>4785</a>
<a id='n4786' href='#n4786'>4786</a>
<a id='n4787' href='#n4787'>4787</a>
<a id='n4788' href='#n4788'>4788</a>
<a id='n4789' href='#n4789'>4789</a>
<a id='n4790' href='#n4790'>4790</a>
<a id='n4791' href='#n4791'>4791</a>
<a id='n4792' href='#n4792'>4792</a>
<a id='n4793' href='#n4793'>4793</a>
<a id='n4794' href='#n4794'>4794</a>
<a id='n4795' href='#n4795'>4795</a>
<a id='n4796' href='#n4796'>4796</a>
<a id='n4797' href='#n4797'>4797</a>
<a id='n4798' href='#n4798'>4798</a>
<a id='n4799' href='#n4799'>4799</a>
<a id='n4800' href='#n4800'>4800</a>
<a id='n4801' href='#n4801'>4801</a>
<a id='n4802' href='#n4802'>4802</a>
<a id='n4803' href='#n4803'>4803</a>
<a id='n4804' href='#n4804'>4804</a>
<a id='n4805' href='#n4805'>4805</a>
<a id='n4806' href='#n4806'>4806</a>
<a id='n4807' href='#n4807'>4807</a>
<a id='n4808' href='#n4808'>4808</a>
<a id='n4809' href='#n4809'>4809</a>
<a id='n4810' href='#n4810'>4810</a>
<a id='n4811' href='#n4811'>4811</a>
<a id='n4812' href='#n4812'>4812</a>
<a id='n4813' href='#n4813'>4813</a>
<a id='n4814' href='#n4814'>4814</a>
<a id='n4815' href='#n4815'>4815</a>
<a id='n4816' href='#n4816'>4816</a>
<a id='n4817' href='#n4817'>4817</a>
<a id='n4818' href='#n4818'>4818</a>
<a id='n4819' href='#n4819'>4819</a>
<a id='n4820' href='#n4820'>4820</a>
<a id='n4821' href='#n4821'>4821</a>
<a id='n4822' href='#n4822'>4822</a>
<a id='n4823' href='#n4823'>4823</a>
<a id='n4824' href='#n4824'>4824</a>
<a id='n4825' href='#n4825'>4825</a>
<a id='n4826' href='#n4826'>4826</a>
<a id='n4827' href='#n4827'>4827</a>
<a id='n4828' href='#n4828'>4828</a>
<a id='n4829' href='#n4829'>4829</a>
<a id='n4830' href='#n4830'>4830</a>
<a id='n4831' href='#n4831'>4831</a>
<a id='n4832' href='#n4832'>4832</a>
<a id='n4833' href='#n4833'>4833</a>
<a id='n4834' href='#n4834'>4834</a>
<a id='n4835' href='#n4835'>4835</a>
<a id='n4836' href='#n4836'>4836</a>
<a id='n4837' href='#n4837'>4837</a>
<a id='n4838' href='#n4838'>4838</a>
<a id='n4839' href='#n4839'>4839</a>
<a id='n4840' href='#n4840'>4840</a>
<a id='n4841' href='#n4841'>4841</a>
<a id='n4842' href='#n4842'>4842</a>
<a id='n4843' href='#n4843'>4843</a>
<a id='n4844' href='#n4844'>4844</a>
<a id='n4845' href='#n4845'>4845</a>
<a id='n4846' href='#n4846'>4846</a>
<a id='n4847' href='#n4847'>4847</a>
<a id='n4848' href='#n4848'>4848</a>
<a id='n4849' href='#n4849'>4849</a>
<a id='n4850' href='#n4850'>4850</a>
<a id='n4851' href='#n4851'>4851</a>
<a id='n4852' href='#n4852'>4852</a>
<a id='n4853' href='#n4853'>4853</a>
<a id='n4854' href='#n4854'>4854</a>
<a id='n4855' href='#n4855'>4855</a>
<a id='n4856' href='#n4856'>4856</a>
<a id='n4857' href='#n4857'>4857</a>
<a id='n4858' href='#n4858'>4858</a>
<a id='n4859' href='#n4859'>4859</a>
<a id='n4860' href='#n4860'>4860</a>
<a id='n4861' href='#n4861'>4861</a>
<a id='n4862' href='#n4862'>4862</a>
<a id='n4863' href='#n4863'>4863</a>
<a id='n4864' href='#n4864'>4864</a>
<a id='n4865' href='#n4865'>4865</a>
<a id='n4866' href='#n4866'>4866</a>
<a id='n4867' href='#n4867'>4867</a>
<a id='n4868' href='#n4868'>4868</a>
<a id='n4869' href='#n4869'>4869</a>
<a id='n4870' href='#n4870'>4870</a>
<a id='n4871' href='#n4871'>4871</a>
<a id='n4872' href='#n4872'>4872</a>
<a id='n4873' href='#n4873'>4873</a>
<a id='n4874' href='#n4874'>4874</a>
<a id='n4875' href='#n4875'>4875</a>
<a id='n4876' href='#n4876'>4876</a>
<a id='n4877' href='#n4877'>4877</a>
<a id='n4878' href='#n4878'>4878</a>
<a id='n4879' href='#n4879'>4879</a>
<a id='n4880' href='#n4880'>4880</a>
<a id='n4881' href='#n4881'>4881</a>
<a id='n4882' href='#n4882'>4882</a>
<a id='n4883' href='#n4883'>4883</a>
<a id='n4884' href='#n4884'>4884</a>
<a id='n4885' href='#n4885'>4885</a>
<a id='n4886' href='#n4886'>4886</a>
<a id='n4887' href='#n4887'>4887</a>
<a id='n4888' href='#n4888'>4888</a>
<a id='n4889' href='#n4889'>4889</a>
<a id='n4890' href='#n4890'>4890</a>
<a id='n4891' href='#n4891'>4891</a>
<a id='n4892' href='#n4892'>4892</a>
<a id='n4893' href='#n4893'>4893</a>
<a id='n4894' href='#n4894'>4894</a>
<a id='n4895' href='#n4895'>4895</a>
<a id='n4896' href='#n4896'>4896</a>
<a id='n4897' href='#n4897'>4897</a>
<a id='n4898' href='#n4898'>4898</a>
<a id='n4899' href='#n4899'>4899</a>
<a id='n4900' href='#n4900'>4900</a>
<a id='n4901' href='#n4901'>4901</a>
<a id='n4902' href='#n4902'>4902</a>
<a id='n4903' href='#n4903'>4903</a>
<a id='n4904' href='#n4904'>4904</a>
<a id='n4905' href='#n4905'>4905</a>
<a id='n4906' href='#n4906'>4906</a>
<a id='n4907' href='#n4907'>4907</a>
<a id='n4908' href='#n4908'>4908</a>
<a id='n4909' href='#n4909'>4909</a>
<a id='n4910' href='#n4910'>4910</a>
<a id='n4911' href='#n4911'>4911</a>
<a id='n4912' href='#n4912'>4912</a>
<a id='n4913' href='#n4913'>4913</a>
<a id='n4914' href='#n4914'>4914</a>
<a id='n4915' href='#n4915'>4915</a>
<a id='n4916' href='#n4916'>4916</a>
<a id='n4917' href='#n4917'>4917</a>
<a id='n4918' href='#n4918'>4918</a>
<a id='n4919' href='#n4919'>4919</a>
<a id='n4920' href='#n4920'>4920</a>
<a id='n4921' href='#n4921'>4921</a>
<a id='n4922' href='#n4922'>4922</a>
<a id='n4923' href='#n4923'>4923</a>
<a id='n4924' href='#n4924'>4924</a>
<a id='n4925' href='#n4925'>4925</a>
<a id='n4926' href='#n4926'>4926</a>
<a id='n4927' href='#n4927'>4927</a>
<a id='n4928' href='#n4928'>4928</a>
<a id='n4929' href='#n4929'>4929</a>
<a id='n4930' href='#n4930'>4930</a>
<a id='n4931' href='#n4931'>4931</a>
<a id='n4932' href='#n4932'>4932</a>
<a id='n4933' href='#n4933'>4933</a>
<a id='n4934' href='#n4934'>4934</a>
<a id='n4935' href='#n4935'>4935</a>
<a id='n4936' href='#n4936'>4936</a>
<a id='n4937' href='#n4937'>4937</a>
<a id='n4938' href='#n4938'>4938</a>
<a id='n4939' href='#n4939'>4939</a>
<a id='n4940' href='#n4940'>4940</a>
<a id='n4941' href='#n4941'>4941</a>
<a id='n4942' href='#n4942'>4942</a>
<a id='n4943' href='#n4943'>4943</a>
<a id='n4944' href='#n4944'>4944</a>
<a id='n4945' href='#n4945'>4945</a>
<a id='n4946' href='#n4946'>4946</a>
<a id='n4947' href='#n4947'>4947</a>
<a id='n4948' href='#n4948'>4948</a>
<a id='n4949' href='#n4949'>4949</a>
<a id='n4950' href='#n4950'>4950</a>
<a id='n4951' href='#n4951'>4951</a>
<a id='n4952' href='#n4952'>4952</a>
<a id='n4953' href='#n4953'>4953</a>
<a id='n4954' href='#n4954'>4954</a>
<a id='n4955' href='#n4955'>4955</a>
<a id='n4956' href='#n4956'>4956</a>
<a id='n4957' href='#n4957'>4957</a>
<a id='n4958' href='#n4958'>4958</a>
<a id='n4959' href='#n4959'>4959</a>
<a id='n4960' href='#n4960'>4960</a>
<a id='n4961' href='#n4961'>4961</a>
<a id='n4962' href='#n4962'>4962</a>
<a id='n4963' href='#n4963'>4963</a>
<a id='n4964' href='#n4964'>4964</a>
<a id='n4965' href='#n4965'>4965</a>
<a id='n4966' href='#n4966'>4966</a>
<a id='n4967' href='#n4967'>4967</a>
<a id='n4968' href='#n4968'>4968</a>
<a id='n4969' href='#n4969'>4969</a>
<a id='n4970' href='#n4970'>4970</a>
<a id='n4971' href='#n4971'>4971</a>
<a id='n4972' href='#n4972'>4972</a>
<a id='n4973' href='#n4973'>4973</a>
<a id='n4974' href='#n4974'>4974</a>
<a id='n4975' href='#n4975'>4975</a>
<a id='n4976' href='#n4976'>4976</a>
<a id='n4977' href='#n4977'>4977</a>
<a id='n4978' href='#n4978'>4978</a>
<a id='n4979' href='#n4979'>4979</a>
<a id='n4980' href='#n4980'>4980</a>
<a id='n4981' href='#n4981'>4981</a>
<a id='n4982' href='#n4982'>4982</a>
<a id='n4983' href='#n4983'>4983</a>
<a id='n4984' href='#n4984'>4984</a>
<a id='n4985' href='#n4985'>4985</a>
<a id='n4986' href='#n4986'>4986</a>
<a id='n4987' href='#n4987'>4987</a>
<a id='n4988' href='#n4988'>4988</a>
<a id='n4989' href='#n4989'>4989</a>
<a id='n4990' href='#n4990'>4990</a>
<a id='n4991' href='#n4991'>4991</a>
<a id='n4992' href='#n4992'>4992</a>
<a id='n4993' href='#n4993'>4993</a>
<a id='n4994' href='#n4994'>4994</a>
<a id='n4995' href='#n4995'>4995</a>
<a id='n4996' href='#n4996'>4996</a>
<a id='n4997' href='#n4997'>4997</a>
<a id='n4998' href='#n4998'>4998</a>
<a id='n4999' href='#n4999'>4999</a>
<a id='n5000' href='#n5000'>5000</a>
<a id='n5001' href='#n5001'>5001</a>
<a id='n5002' href='#n5002'>5002</a>
<a id='n5003' href='#n5003'>5003</a>
<a id='n5004' href='#n5004'>5004</a>
<a id='n5005' href='#n5005'>5005</a>
<a id='n5006' href='#n5006'>5006</a>
<a id='n5007' href='#n5007'>5007</a>
<a id='n5008' href='#n5008'>5008</a>
<a id='n5009' href='#n5009'>5009</a>
<a id='n5010' href='#n5010'>5010</a>
<a id='n5011' href='#n5011'>5011</a>
<a id='n5012' href='#n5012'>5012</a>
<a id='n5013' href='#n5013'>5013</a>
<a id='n5014' href='#n5014'>5014</a>
<a id='n5015' href='#n5015'>5015</a>
<a id='n5016' href='#n5016'>5016</a>
<a id='n5017' href='#n5017'>5017</a>
<a id='n5018' href='#n5018'>5018</a>
<a id='n5019' href='#n5019'>5019</a>
<a id='n5020' href='#n5020'>5020</a>
<a id='n5021' href='#n5021'>5021</a>
<a id='n5022' href='#n5022'>5022</a>
<a id='n5023' href='#n5023'>5023</a>
<a id='n5024' href='#n5024'>5024</a>
<a id='n5025' href='#n5025'>5025</a>
<a id='n5026' href='#n5026'>5026</a>
<a id='n5027' href='#n5027'>5027</a>
<a id='n5028' href='#n5028'>5028</a>
<a id='n5029' href='#n5029'>5029</a>
<a id='n5030' href='#n5030'>5030</a>
<a id='n5031' href='#n5031'>5031</a>
<a id='n5032' href='#n5032'>5032</a>
<a id='n5033' href='#n5033'>5033</a>
<a id='n5034' href='#n5034'>5034</a>
<a id='n5035' href='#n5035'>5035</a>
<a id='n5036' href='#n5036'>5036</a>
<a id='n5037' href='#n5037'>5037</a>
<a id='n5038' href='#n5038'>5038</a>
<a id='n5039' href='#n5039'>5039</a>
<a id='n5040' href='#n5040'>5040</a>
<a id='n5041' href='#n5041'>5041</a>
<a id='n5042' href='#n5042'>5042</a>
<a id='n5043' href='#n5043'>5043</a>
<a id='n5044' href='#n5044'>5044</a>
<a id='n5045' href='#n5045'>5045</a>
<a id='n5046' href='#n5046'>5046</a>
<a id='n5047' href='#n5047'>5047</a>
<a id='n5048' href='#n5048'>5048</a>
<a id='n5049' href='#n5049'>5049</a>
<a id='n5050' href='#n5050'>5050</a>
<a id='n5051' href='#n5051'>5051</a>
<a id='n5052' href='#n5052'>5052</a>
<a id='n5053' href='#n5053'>5053</a>
<a id='n5054' href='#n5054'>5054</a>
<a id='n5055' href='#n5055'>5055</a>
<a id='n5056' href='#n5056'>5056</a>
<a id='n5057' href='#n5057'>5057</a>
<a id='n5058' href='#n5058'>5058</a>
<a id='n5059' href='#n5059'>5059</a>
<a id='n5060' href='#n5060'>5060</a>
<a id='n5061' href='#n5061'>5061</a>
<a id='n5062' href='#n5062'>5062</a>
<a id='n5063' href='#n5063'>5063</a>
<a id='n5064' href='#n5064'>5064</a>
<a id='n5065' href='#n5065'>5065</a>
<a id='n5066' href='#n5066'>5066</a>
<a id='n5067' href='#n5067'>5067</a>
<a id='n5068' href='#n5068'>5068</a>
<a id='n5069' href='#n5069'>5069</a>
<a id='n5070' href='#n5070'>5070</a>
<a id='n5071' href='#n5071'>5071</a>
<a id='n5072' href='#n5072'>5072</a>
<a id='n5073' href='#n5073'>5073</a>
<a id='n5074' href='#n5074'>5074</a>
<a id='n5075' href='#n5075'>5075</a>
<a id='n5076' href='#n5076'>5076</a>
<a id='n5077' href='#n5077'>5077</a>
<a id='n5078' href='#n5078'>5078</a>
<a id='n5079' href='#n5079'>5079</a>
<a id='n5080' href='#n5080'>5080</a>
<a id='n5081' href='#n5081'>5081</a>
<a id='n5082' href='#n5082'>5082</a>
<a id='n5083' href='#n5083'>5083</a>
<a id='n5084' href='#n5084'>5084</a>
<a id='n5085' href='#n5085'>5085</a>
<a id='n5086' href='#n5086'>5086</a>
<a id='n5087' href='#n5087'>5087</a>
<a id='n5088' href='#n5088'>5088</a>
<a id='n5089' href='#n5089'>5089</a>
<a id='n5090' href='#n5090'>5090</a>
<a id='n5091' href='#n5091'>5091</a>
<a id='n5092' href='#n5092'>5092</a>
<a id='n5093' href='#n5093'>5093</a>
<a id='n5094' href='#n5094'>5094</a>
<a id='n5095' href='#n5095'>5095</a>
<a id='n5096' href='#n5096'>5096</a>
<a id='n5097' href='#n5097'>5097</a>
<a id='n5098' href='#n5098'>5098</a>
<a id='n5099' href='#n5099'>5099</a>
<a id='n5100' href='#n5100'>5100</a>
<a id='n5101' href='#n5101'>5101</a>
<a id='n5102' href='#n5102'>5102</a>
<a id='n5103' href='#n5103'>5103</a>
<a id='n5104' href='#n5104'>5104</a>
<a id='n5105' href='#n5105'>5105</a>
<a id='n5106' href='#n5106'>5106</a>
<a id='n5107' href='#n5107'>5107</a>
<a id='n5108' href='#n5108'>5108</a>
<a id='n5109' href='#n5109'>5109</a>
<a id='n5110' href='#n5110'>5110</a>
<a id='n5111' href='#n5111'>5111</a>
<a id='n5112' href='#n5112'>5112</a>
<a id='n5113' href='#n5113'>5113</a>
<a id='n5114' href='#n5114'>5114</a>
<a id='n5115' href='#n5115'>5115</a>
<a id='n5116' href='#n5116'>5116</a>
<a id='n5117' href='#n5117'>5117</a>
<a id='n5118' href='#n5118'>5118</a>
<a id='n5119' href='#n5119'>5119</a>
<a id='n5120' href='#n5120'>5120</a>
<a id='n5121' href='#n5121'>5121</a>
<a id='n5122' href='#n5122'>5122</a>
<a id='n5123' href='#n5123'>5123</a>
<a id='n5124' href='#n5124'>5124</a>
<a id='n5125' href='#n5125'>5125</a>
<a id='n5126' href='#n5126'>5126</a>
<a id='n5127' href='#n5127'>5127</a>
<a id='n5128' href='#n5128'>5128</a>
<a id='n5129' href='#n5129'>5129</a>
<a id='n5130' href='#n5130'>5130</a>
<a id='n5131' href='#n5131'>5131</a>
<a id='n5132' href='#n5132'>5132</a>
<a id='n5133' href='#n5133'>5133</a>
<a id='n5134' href='#n5134'>5134</a>
<a id='n5135' href='#n5135'>5135</a>
<a id='n5136' href='#n5136'>5136</a>
<a id='n5137' href='#n5137'>5137</a>
<a id='n5138' href='#n5138'>5138</a>
<a id='n5139' href='#n5139'>5139</a>
<a id='n5140' href='#n5140'>5140</a>
<a id='n5141' href='#n5141'>5141</a>
<a id='n5142' href='#n5142'>5142</a>
<a id='n5143' href='#n5143'>5143</a>
<a id='n5144' href='#n5144'>5144</a>
<a id='n5145' href='#n5145'>5145</a>
<a id='n5146' href='#n5146'>5146</a>
<a id='n5147' href='#n5147'>5147</a>
<a id='n5148' href='#n5148'>5148</a>
<a id='n5149' href='#n5149'>5149</a>
<a id='n5150' href='#n5150'>5150</a>
<a id='n5151' href='#n5151'>5151</a>
<a id='n5152' href='#n5152'>5152</a>
<a id='n5153' href='#n5153'>5153</a>
<a id='n5154' href='#n5154'>5154</a>
<a id='n5155' href='#n5155'>5155</a>
<a id='n5156' href='#n5156'>5156</a>
<a id='n5157' href='#n5157'>5157</a>
<a id='n5158' href='#n5158'>5158</a>
<a id='n5159' href='#n5159'>5159</a>
<a id='n5160' href='#n5160'>5160</a>
<a id='n5161' href='#n5161'>5161</a>
<a id='n5162' href='#n5162'>5162</a>
<a id='n5163' href='#n5163'>5163</a>
<a id='n5164' href='#n5164'>5164</a>
<a id='n5165' href='#n5165'>5165</a>
<a id='n5166' href='#n5166'>5166</a>
<a id='n5167' href='#n5167'>5167</a>
<a id='n5168' href='#n5168'>5168</a>
<a id='n5169' href='#n5169'>5169</a>
<a id='n5170' href='#n5170'>5170</a>
<a id='n5171' href='#n5171'>5171</a>
<a id='n5172' href='#n5172'>5172</a>
<a id='n5173' href='#n5173'>5173</a>
<a id='n5174' href='#n5174'>5174</a>
<a id='n5175' href='#n5175'>5175</a>
<a id='n5176' href='#n5176'>5176</a>
<a id='n5177' href='#n5177'>5177</a>
<a id='n5178' href='#n5178'>5178</a>
<a id='n5179' href='#n5179'>5179</a>
<a id='n5180' href='#n5180'>5180</a>
<a id='n5181' href='#n5181'>5181</a>
<a id='n5182' href='#n5182'>5182</a>
<a id='n5183' href='#n5183'>5183</a>
<a id='n5184' href='#n5184'>5184</a>
<a id='n5185' href='#n5185'>5185</a>
<a id='n5186' href='#n5186'>5186</a>
<a id='n5187' href='#n5187'>5187</a>
<a id='n5188' href='#n5188'>5188</a>
<a id='n5189' href='#n5189'>5189</a>
<a id='n5190' href='#n5190'>5190</a>
<a id='n5191' href='#n5191'>5191</a>
<a id='n5192' href='#n5192'>5192</a>
<a id='n5193' href='#n5193'>5193</a>
<a id='n5194' href='#n5194'>5194</a>
<a id='n5195' href='#n5195'>5195</a>
<a id='n5196' href='#n5196'>5196</a>
<a id='n5197' href='#n5197'>5197</a>
<a id='n5198' href='#n5198'>5198</a>
<a id='n5199' href='#n5199'>5199</a>
<a id='n5200' href='#n5200'>5200</a>
<a id='n5201' href='#n5201'>5201</a>
<a id='n5202' href='#n5202'>5202</a>
<a id='n5203' href='#n5203'>5203</a>
<a id='n5204' href='#n5204'>5204</a>
<a id='n5205' href='#n5205'>5205</a>
<a id='n5206' href='#n5206'>5206</a>
<a id='n5207' href='#n5207'>5207</a>
<a id='n5208' href='#n5208'>5208</a>
<a id='n5209' href='#n5209'>5209</a>
<a id='n5210' href='#n5210'>5210</a>
<a id='n5211' href='#n5211'>5211</a>
<a id='n5212' href='#n5212'>5212</a>
<a id='n5213' href='#n5213'>5213</a>
<a id='n5214' href='#n5214'>5214</a>
<a id='n5215' href='#n5215'>5215</a>
<a id='n5216' href='#n5216'>5216</a>
<a id='n5217' href='#n5217'>5217</a>
<a id='n5218' href='#n5218'>5218</a>
<a id='n5219' href='#n5219'>5219</a>
<a id='n5220' href='#n5220'>5220</a>
<a id='n5221' href='#n5221'>5221</a>
<a id='n5222' href='#n5222'>5222</a>
<a id='n5223' href='#n5223'>5223</a>
<a id='n5224' href='#n5224'>5224</a>
<a id='n5225' href='#n5225'>5225</a>
<a id='n5226' href='#n5226'>5226</a>
<a id='n5227' href='#n5227'>5227</a>
<a id='n5228' href='#n5228'>5228</a>
<a id='n5229' href='#n5229'>5229</a>
<a id='n5230' href='#n5230'>5230</a>
<a id='n5231' href='#n5231'>5231</a>
<a id='n5232' href='#n5232'>5232</a>
<a id='n5233' href='#n5233'>5233</a>
<a id='n5234' href='#n5234'>5234</a>
<a id='n5235' href='#n5235'>5235</a>
<a id='n5236' href='#n5236'>5236</a>
<a id='n5237' href='#n5237'>5237</a>
<a id='n5238' href='#n5238'>5238</a>
<a id='n5239' href='#n5239'>5239</a>
<a id='n5240' href='#n5240'>5240</a>
<a id='n5241' href='#n5241'>5241</a>
<a id='n5242' href='#n5242'>5242</a>
<a id='n5243' href='#n5243'>5243</a>
<a id='n5244' href='#n5244'>5244</a>
<a id='n5245' href='#n5245'>5245</a>
<a id='n5246' href='#n5246'>5246</a>
<a id='n5247' href='#n5247'>5247</a>
<a id='n5248' href='#n5248'>5248</a>
<a id='n5249' href='#n5249'>5249</a>
<a id='n5250' href='#n5250'>5250</a>
<a id='n5251' href='#n5251'>5251</a>
<a id='n5252' href='#n5252'>5252</a>
<a id='n5253' href='#n5253'>5253</a>
<a id='n5254' href='#n5254'>5254</a>
<a id='n5255' href='#n5255'>5255</a>
<a id='n5256' href='#n5256'>5256</a>
<a id='n5257' href='#n5257'>5257</a>
<a id='n5258' href='#n5258'>5258</a>
<a id='n5259' href='#n5259'>5259</a>
<a id='n5260' href='#n5260'>5260</a>
<a id='n5261' href='#n5261'>5261</a>
<a id='n5262' href='#n5262'>5262</a>
<a id='n5263' href='#n5263'>5263</a>
<a id='n5264' href='#n5264'>5264</a>
<a id='n5265' href='#n5265'>5265</a>
<a id='n5266' href='#n5266'>5266</a>
<a id='n5267' href='#n5267'>5267</a>
<a id='n5268' href='#n5268'>5268</a>
<a id='n5269' href='#n5269'>5269</a>
<a id='n5270' href='#n5270'>5270</a>
<a id='n5271' href='#n5271'>5271</a>
<a id='n5272' href='#n5272'>5272</a>
<a id='n5273' href='#n5273'>5273</a>
<a id='n5274' href='#n5274'>5274</a>
<a id='n5275' href='#n5275'>5275</a>
<a id='n5276' href='#n5276'>5276</a>
<a id='n5277' href='#n5277'>5277</a>
<a id='n5278' href='#n5278'>5278</a>
<a id='n5279' href='#n5279'>5279</a>
<a id='n5280' href='#n5280'>5280</a>
<a id='n5281' href='#n5281'>5281</a>
<a id='n5282' href='#n5282'>5282</a>
<a id='n5283' href='#n5283'>5283</a>
<a id='n5284' href='#n5284'>5284</a>
<a id='n5285' href='#n5285'>5285</a>
<a id='n5286' href='#n5286'>5286</a>
<a id='n5287' href='#n5287'>5287</a>
<a id='n5288' href='#n5288'>5288</a>
<a id='n5289' href='#n5289'>5289</a>
<a id='n5290' href='#n5290'>5290</a>
<a id='n5291' href='#n5291'>5291</a>
<a id='n5292' href='#n5292'>5292</a>
<a id='n5293' href='#n5293'>5293</a>
<a id='n5294' href='#n5294'>5294</a>
<a id='n5295' href='#n5295'>5295</a>
<a id='n5296' href='#n5296'>5296</a>
<a id='n5297' href='#n5297'>5297</a>
<a id='n5298' href='#n5298'>5298</a>
<a id='n5299' href='#n5299'>5299</a>
<a id='n5300' href='#n5300'>5300</a>
<a id='n5301' href='#n5301'>5301</a>
<a id='n5302' href='#n5302'>5302</a>
<a id='n5303' href='#n5303'>5303</a>
<a id='n5304' href='#n5304'>5304</a>
<a id='n5305' href='#n5305'>5305</a>
<a id='n5306' href='#n5306'>5306</a>
<a id='n5307' href='#n5307'>5307</a>
<a id='n5308' href='#n5308'>5308</a>
<a id='n5309' href='#n5309'>5309</a>
<a id='n5310' href='#n5310'>5310</a>
<a id='n5311' href='#n5311'>5311</a>
<a id='n5312' href='#n5312'>5312</a>
<a id='n5313' href='#n5313'>5313</a>
<a id='n5314' href='#n5314'>5314</a>
<a id='n5315' href='#n5315'>5315</a>
<a id='n5316' href='#n5316'>5316</a>
<a id='n5317' href='#n5317'>5317</a>
<a id='n5318' href='#n5318'>5318</a>
<a id='n5319' href='#n5319'>5319</a>
<a id='n5320' href='#n5320'>5320</a>
<a id='n5321' href='#n5321'>5321</a>
<a id='n5322' href='#n5322'>5322</a>
<a id='n5323' href='#n5323'>5323</a>
<a id='n5324' href='#n5324'>5324</a>
<a id='n5325' href='#n5325'>5325</a>
<a id='n5326' href='#n5326'>5326</a>
<a id='n5327' href='#n5327'>5327</a>
<a id='n5328' href='#n5328'>5328</a>
<a id='n5329' href='#n5329'>5329</a>
<a id='n5330' href='#n5330'>5330</a>
<a id='n5331' href='#n5331'>5331</a>
<a id='n5332' href='#n5332'>5332</a>
<a id='n5333' href='#n5333'>5333</a>
<a id='n5334' href='#n5334'>5334</a>
<a id='n5335' href='#n5335'>5335</a>
<a id='n5336' href='#n5336'>5336</a>
<a id='n5337' href='#n5337'>5337</a>
<a id='n5338' href='#n5338'>5338</a>
<a id='n5339' href='#n5339'>5339</a>
<a id='n5340' href='#n5340'>5340</a>
<a id='n5341' href='#n5341'>5341</a>
<a id='n5342' href='#n5342'>5342</a>
<a id='n5343' href='#n5343'>5343</a>
<a id='n5344' href='#n5344'>5344</a>
<a id='n5345' href='#n5345'>5345</a>
<a id='n5346' href='#n5346'>5346</a>
<a id='n5347' href='#n5347'>5347</a>
<a id='n5348' href='#n5348'>5348</a>
<a id='n5349' href='#n5349'>5349</a>
<a id='n5350' href='#n5350'>5350</a>
<a id='n5351' href='#n5351'>5351</a>
<a id='n5352' href='#n5352'>5352</a>
<a id='n5353' href='#n5353'>5353</a>
<a id='n5354' href='#n5354'>5354</a>
<a id='n5355' href='#n5355'>5355</a>
<a id='n5356' href='#n5356'>5356</a>
<a id='n5357' href='#n5357'>5357</a>
<a id='n5358' href='#n5358'>5358</a>
<a id='n5359' href='#n5359'>5359</a>
<a id='n5360' href='#n5360'>5360</a>
<a id='n5361' href='#n5361'>5361</a>
<a id='n5362' href='#n5362'>5362</a>
<a id='n5363' href='#n5363'>5363</a>
<a id='n5364' href='#n5364'>5364</a>
<a id='n5365' href='#n5365'>5365</a>
<a id='n5366' href='#n5366'>5366</a>
<a id='n5367' href='#n5367'>5367</a>
<a id='n5368' href='#n5368'>5368</a>
<a id='n5369' href='#n5369'>5369</a>
<a id='n5370' href='#n5370'>5370</a>
<a id='n5371' href='#n5371'>5371</a>
<a id='n5372' href='#n5372'>5372</a>
<a id='n5373' href='#n5373'>5373</a>
<a id='n5374' href='#n5374'>5374</a>
<a id='n5375' href='#n5375'>5375</a>
<a id='n5376' href='#n5376'>5376</a>
<a id='n5377' href='#n5377'>5377</a>
<a id='n5378' href='#n5378'>5378</a>
<a id='n5379' href='#n5379'>5379</a>
<a id='n5380' href='#n5380'>5380</a>
<a id='n5381' href='#n5381'>5381</a>
<a id='n5382' href='#n5382'>5382</a>
<a id='n5383' href='#n5383'>5383</a>
<a id='n5384' href='#n5384'>5384</a>
<a id='n5385' href='#n5385'>5385</a>
<a id='n5386' href='#n5386'>5386</a>
<a id='n5387' href='#n5387'>5387</a>
<a id='n5388' href='#n5388'>5388</a>
<a id='n5389' href='#n5389'>5389</a>
<a id='n5390' href='#n5390'>5390</a>
<a id='n5391' href='#n5391'>5391</a>
<a id='n5392' href='#n5392'>5392</a>
<a id='n5393' href='#n5393'>5393</a>
<a id='n5394' href='#n5394'>5394</a>
<a id='n5395' href='#n5395'>5395</a>
<a id='n5396' href='#n5396'>5396</a>
<a id='n5397' href='#n5397'>5397</a>
<a id='n5398' href='#n5398'>5398</a>
</pre></td>
<td class='lines'><pre><code><span class="hl com">/* </span>
<span class="hl com">   Unix SMB/Netbios implementation.</span>
<span class="hl com">   SMB client library implementation</span>
<span class="hl com">   Copyright (C) Andrew Tridgell 1998</span>
<span class="hl com">   Copyright (C) Richard Sharpe 2000, 2002</span>
<span class="hl com">   Copyright (C) John Terpstra 2000</span>
<span class="hl com">   Copyright (C) Tom Jansen (Ninja ISD) 2002 </span>
<span class="hl com">   Copyright (C) Derrell Lipman 2003, 2004</span>
<span class="hl com">   </span>
<span class="hl com">   This program is free software; you can redistribute it and/or modify</span>
<span class="hl com">   it under the terms of the GNU General Public License as published by</span>
<span class="hl com">   the Free Software Foundation; either version 2 of the License, or</span>
<span class="hl com">   (at your option) any later version.</span>
<span class="hl com">   </span>
<span class="hl com">   This program is distributed in the hope that it will be useful,</span>
<span class="hl com">   but WITHOUT ANY WARRANTY; without even the implied warranty of</span>
<span class="hl com">   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the</span>
<span class="hl com">   GNU General Public License for more details.</span>
<span class="hl com">   </span>
<span class="hl com">   You should have received a copy of the GNU General Public License</span>
<span class="hl com">   along with this program; if not, write to the Free Software</span>
<span class="hl com">   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.</span>
<span class="hl com">*/</span>

<span class="hl ppc">#include</span> <span class="hl pps">&quot;includes.h&quot;</span><span class="hl ppc"></span>

<span class="hl ppc">#include</span> <span class="hl pps">&quot;include/libsmb_internal.h&quot;</span><span class="hl ppc"></span>


<span class="hl com">/*</span>
<span class="hl com"> * DOS Attribute values (used internally)</span>
<span class="hl com"> */</span>
<span class="hl kwc">typedef</span> <span class="hl kwb">struct</span> DOS_ATTR_DESC
<span class="hl opt">{</span>
    <span class="hl kwb">int</span> mode<span class="hl opt">;</span>
    <span class="hl kwb">unsigned long long</span> size<span class="hl opt">;</span>
    <span class="hl kwb">time_t</span> a_time<span class="hl opt">;</span>
    <span class="hl kwb">time_t</span> c_time<span class="hl opt">;</span>
    <span class="hl kwb">time_t</span> m_time<span class="hl opt">;</span>
    <span class="hl kwb">unsigned long long</span> inode<span class="hl opt">;</span>
<span class="hl opt">}</span> DOS_ATTR_DESC<span class="hl opt">;</span>


<span class="hl com">/*</span>
<span class="hl com"> * Internal flags for extended attributes</span>
<span class="hl com"> */</span>

<span class="hl com">/* internal mode values */</span>
<span class="hl ppc">#define SMBC_XATTR_MODE_ADD          1</span>
<span class="hl ppc">#define SMBC_XATTR_MODE_REMOVE       2</span>
<span class="hl ppc">#define SMBC_XATTR_MODE_REMOVE_ALL   3</span>
<span class="hl ppc">#define SMBC_XATTR_MODE_SET          4</span>
<span class="hl ppc">#define SMBC_XATTR_MODE_CHOWN        5</span>
<span class="hl ppc">#define SMBC_XATTR_MODE_CHGRP        6</span>

<span class="hl ppc">#define CREATE_ACCESS_READ      READ_CONTROL_ACCESS</span>

<span class="hl com">/*We should test for this in configure ... */</span>
<span class="hl ppc">#ifndef ENOTSUP</span>
<span class="hl ppc">#define ENOTSUP EOPNOTSUPP</span>
<span class="hl ppc">#endif</span>

<span class="hl com">/*</span>
<span class="hl com"> * Functions exported by libsmb_cache.c that we need here</span>
<span class="hl com"> */</span>
<span class="hl kwb">int</span> <span class="hl kwd">smbc_default_cache_functions</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">);</span>

<span class="hl com">/* </span>
<span class="hl com"> * check if an element is part of the list. </span>
<span class="hl com"> * FIXME: Does not belong here !  </span>
<span class="hl com"> * Can anyone put this in a macro in dlinklist.h ?</span>
<span class="hl com"> * -- Tom</span>
<span class="hl com"> */</span>
<span class="hl kwb">static int</span> <span class="hl kwd">DLIST_CONTAINS</span><span class="hl opt">(</span>SMBCFILE <span class="hl opt">*</span> list<span class="hl opt">,</span> SMBCFILE <span class="hl opt">*</span>p<span class="hl opt">) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(!</span>p <span class="hl opt">|| !</span>list<span class="hl opt">)</span> <span class="hl kwa">return</span> False<span class="hl opt">;</span>
	<span class="hl kwa">do</span> <span class="hl opt">{</span>
		<span class="hl kwa">if</span> <span class="hl opt">(</span>p <span class="hl opt">==</span> list<span class="hl opt">)</span> <span class="hl kwa">return</span> True<span class="hl opt">;</span>
		list <span class="hl opt">=</span> list<span class="hl opt">-&gt;</span>next<span class="hl opt">;</span>
	<span class="hl opt">}</span> <span class="hl kwa">while</span> <span class="hl opt">(</span>list<span class="hl opt">);</span>
	<span class="hl kwa">return</span> False<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">static int</span> <span class="hl kwd">smbc_close_ctx</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">,</span> SMBCFILE <span class="hl opt">*</span>file<span class="hl opt">);</span>
<span class="hl kwb">static</span> off_t <span class="hl kwd">smbc_lseek_ctx</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">,</span> SMBCFILE <span class="hl opt">*</span>file<span class="hl opt">,</span> off_t offset<span class="hl opt">,</span> <span class="hl kwb">int</span> whence<span class="hl opt">);</span>

<span class="hl kwc">extern</span> BOOL in_client<span class="hl opt">;</span>

<span class="hl com">/*</span>
<span class="hl com"> * Is the logging working / configfile read ? </span>
<span class="hl com"> */</span>
<span class="hl kwb">static int</span> smbc_initialized <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>

<span class="hl kwb">static int</span> 
<span class="hl kwd">hex2int</span><span class="hl opt">(</span> <span class="hl kwb">unsigned int</span> _char <span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span> _char <span class="hl opt">&gt;=</span> <span class="hl str">&#39;A&#39;</span> <span class="hl opt">&amp;&amp;</span> _char <span class="hl opt">&lt;=</span><span class="hl str">&#39;F&#39;</span><span class="hl opt">)</span>
	<span class="hl kwa">return</span> _char <span class="hl opt">-</span> <span class="hl str">&#39;A&#39;</span> <span class="hl opt">+</span> <span class="hl num">10</span><span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span> _char <span class="hl opt">&gt;=</span> <span class="hl str">&#39;a&#39;</span> <span class="hl opt">&amp;&amp;</span> _char <span class="hl opt">&lt;=</span><span class="hl str">&#39;f&#39;</span><span class="hl opt">)</span>
	<span class="hl kwa">return</span> _char <span class="hl opt">-</span> <span class="hl str">&#39;a&#39;</span> <span class="hl opt">+</span> <span class="hl num">10</span><span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span> _char <span class="hl opt">&gt;=</span> <span class="hl str">&#39;0&#39;</span> <span class="hl opt">&amp;&amp;</span> _char <span class="hl opt">&lt;=</span><span class="hl str">&#39;9&#39;</span><span class="hl opt">)</span>
	<span class="hl kwa">return</span> _char <span class="hl opt">-</span> <span class="hl str">&#39;0&#39;</span><span class="hl opt">;</span>
    <span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * smbc_urldecode()</span>
<span class="hl com"> *</span>
<span class="hl com"> * Convert strings of %xx to their single character equivalent.  Each &#39;x&#39; must</span>
<span class="hl com"> * be a valid hexadecimal digit, or that % sequence is left undecoded.</span>
<span class="hl com"> *</span>
<span class="hl com"> * dest may, but need not be, the same pointer as src.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Returns the number of % sequences which could not be converted due to lack</span>
<span class="hl com"> * of two following hexadecimal digits.</span>
<span class="hl com"> */</span>
<span class="hl kwb">int</span>
<span class="hl kwd">smbc_urldecode</span><span class="hl opt">(</span><span class="hl kwb">char</span> <span class="hl opt">*</span>dest<span class="hl opt">,</span> <span class="hl kwb">char</span> <span class="hl opt">*</span> src<span class="hl opt">,</span> <span class="hl kwb">size_t</span> max_dest_len<span class="hl opt">)</span>
<span class="hl opt">{</span>
        <span class="hl kwb">int</span> old_length <span class="hl opt">=</span> <span class="hl kwd">strlen</span><span class="hl opt">(</span>src<span class="hl opt">);</span>
        <span class="hl kwb">int</span> i <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
        <span class="hl kwb">int</span> err_count <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
        pstring temp<span class="hl opt">;</span>
        <span class="hl kwb">char</span> <span class="hl opt">*</span> p<span class="hl opt">;</span>

        <span class="hl kwa">if</span> <span class="hl opt">(</span> old_length <span class="hl opt">==</span> <span class="hl num">0</span> <span class="hl opt">) {</span>
                <span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>
        <span class="hl opt">}</span>

        p <span class="hl opt">=</span> temp<span class="hl opt">;</span>
        <span class="hl kwa">while</span> <span class="hl opt">(</span> i <span class="hl opt">&lt;</span> old_length <span class="hl opt">) {</span>
                <span class="hl kwb">unsigned char</span> character <span class="hl opt">=</span> src<span class="hl opt">[</span> i<span class="hl opt">++ ];</span>

                <span class="hl kwa">if</span> <span class="hl opt">(</span>character <span class="hl opt">==</span> <span class="hl str">&#39;%&#39;</span><span class="hl opt">) {</span>
                        <span class="hl kwb">int</span> a <span class="hl opt">=</span> i<span class="hl opt">+</span><span class="hl num">1</span> <span class="hl opt">&lt;</span> old_length <span class="hl opt">?</span> <span class="hl kwd">hex2int</span><span class="hl opt">(</span> src<span class="hl opt">[</span>i<span class="hl opt">] ) : -</span><span class="hl num">1</span><span class="hl opt">;</span>
                        <span class="hl kwb">int</span> b <span class="hl opt">=</span> i<span class="hl opt">+</span><span class="hl num">1</span> <span class="hl opt">&lt;</span> old_length <span class="hl opt">?</span> <span class="hl kwd">hex2int</span><span class="hl opt">(</span> src<span class="hl opt">[</span>i<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">] ) : -</span><span class="hl num">1</span><span class="hl opt">;</span>

                        <span class="hl com">/* Replace valid sequence */</span>
                        <span class="hl kwa">if</span> <span class="hl opt">(</span>a <span class="hl opt">!= -</span><span class="hl num">1</span> <span class="hl opt">&amp;&amp;</span> b <span class="hl opt">!= -</span><span class="hl num">1</span><span class="hl opt">) {</span>

                                <span class="hl com">/* Replace valid %xx sequence with %dd */</span>
                                character <span class="hl opt">= (</span>a <span class="hl opt">*</span> <span class="hl num">16</span><span class="hl opt">) +</span> b<span class="hl opt">;</span>

                                <span class="hl kwa">if</span> <span class="hl opt">(</span>character <span class="hl opt">==</span> <span class="hl str">&#39;\0&#39;</span><span class="hl opt">) {</span>
                                        <span class="hl kwa">break</span><span class="hl opt">;</span> <span class="hl com">/* Stop at %00 */</span>
                                <span class="hl opt">}</span>

                                i <span class="hl opt">+=</span> <span class="hl num">2</span><span class="hl opt">;</span>
                        <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>

                                err_count<span class="hl opt">++;</span>
                        <span class="hl opt">}</span>
                <span class="hl opt">}</span>

                <span class="hl opt">*</span>p<span class="hl opt">++ =</span> character<span class="hl opt">;</span>
        <span class="hl opt">}</span>

        <span class="hl opt">*</span>p <span class="hl opt">=</span> <span class="hl str">&#39;\0&#39;</span><span class="hl opt">;</span>

        <span class="hl kwd">strncpy</span><span class="hl opt">(</span>dest<span class="hl opt">,</span> temp<span class="hl opt">,</span> max_dest_len<span class="hl opt">);</span>

        <span class="hl kwa">return</span> err_count<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * smbc_urlencode()</span>
<span class="hl com"> *</span>
<span class="hl com"> * Convert any characters not specifically allowed in a URL into their %xx</span>
<span class="hl com"> * equivalent.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Returns the remaining buffer length.</span>
<span class="hl com"> */</span>
<span class="hl kwb">int</span>
<span class="hl kwd">smbc_urlencode</span><span class="hl opt">(</span><span class="hl kwb">char</span> <span class="hl opt">*</span> dest<span class="hl opt">,</span> <span class="hl kwb">char</span> <span class="hl opt">*</span> src<span class="hl opt">,</span> <span class="hl kwb">int</span> max_dest_len<span class="hl opt">)</span>
<span class="hl opt">{</span>
        <span class="hl kwb">char</span> hex<span class="hl opt">[] =</span> <span class="hl str">&quot;0123456789ABCDEF&quot;</span><span class="hl opt">;</span>

        <span class="hl kwa">for</span> <span class="hl opt">(; *</span>src <span class="hl opt">!=</span> <span class="hl str">&#39;\0&#39;</span> <span class="hl opt">&amp;&amp;</span> max_dest_len <span class="hl opt">&gt;=</span> <span class="hl num">3</span><span class="hl opt">;</span> src<span class="hl opt">++) {</span>

                <span class="hl kwa">if</span> <span class="hl opt">((*</span>src <span class="hl opt">&lt;</span> <span class="hl str">&#39;0&#39;</span> <span class="hl opt">&amp;&amp;</span>
                     <span class="hl opt">*</span>src <span class="hl opt">!=</span> <span class="hl str">&#39;-&#39;</span> <span class="hl opt">&amp;&amp;</span>
                     <span class="hl opt">*</span>src <span class="hl opt">!=</span> <span class="hl str">&#39;.&#39;</span><span class="hl opt">) ||</span>
                    <span class="hl opt">(*</span>src <span class="hl opt">&gt;</span> <span class="hl str">&#39;9&#39;</span> <span class="hl opt">&amp;&amp;</span>
                     <span class="hl opt">*</span>src <span class="hl opt">&lt;</span> <span class="hl str">&#39;A&#39;</span><span class="hl opt">) ||</span>
                    <span class="hl opt">(*</span>src <span class="hl opt">&gt;</span> <span class="hl str">&#39;Z&#39;</span> <span class="hl opt">&amp;&amp;</span>
                     <span class="hl opt">*</span>src <span class="hl opt">&lt;</span> <span class="hl str">&#39;a&#39;</span> <span class="hl opt">&amp;&amp;</span>
                     <span class="hl opt">*</span>src <span class="hl opt">!=</span> <span class="hl str">&#39;_&#39;</span><span class="hl opt">) ||</span>
                    <span class="hl opt">(*</span>src <span class="hl opt">&gt;</span> <span class="hl str">&#39;z&#39;</span><span class="hl opt">)) {</span>
                        <span class="hl opt">*</span>dest<span class="hl opt">++ =</span> <span class="hl str">&#39;%&#39;</span><span class="hl opt">;</span>
                        <span class="hl opt">*</span>dest<span class="hl opt">++ =</span> hex<span class="hl opt">[(*</span>src <span class="hl opt">&gt;&gt;</span> <span class="hl num">4</span><span class="hl opt">) &amp;</span> <span class="hl num">0x0f</span><span class="hl opt">];</span>
                        <span class="hl opt">*</span>dest<span class="hl opt">++ =</span> hex<span class="hl opt">[*</span>src <span class="hl opt">&amp;</span> <span class="hl num">0x0f</span><span class="hl opt">];</span>
                        max_dest_len <span class="hl opt">-=</span> <span class="hl num">3</span><span class="hl opt">;</span>
                <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
                        <span class="hl opt">*</span>dest<span class="hl opt">++ = *</span>src<span class="hl opt">;</span>
                        max_dest_len<span class="hl opt">--;</span>
                <span class="hl opt">}</span>
        <span class="hl opt">}</span>

        <span class="hl opt">*</span>dest<span class="hl opt">++ =</span> <span class="hl str">&#39;\0&#39;</span><span class="hl opt">;</span>
        max_dest_len<span class="hl opt">--;</span>
        
        <span class="hl kwa">return</span> max_dest_len<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * Function to parse a path and turn it into components</span>
<span class="hl com"> *</span>
<span class="hl com"> * The general format of an SMB URI is explain in Christopher Hertel&#39;s CIFS</span>
<span class="hl com"> * book, at http://ubiqx.org/cifs/Appendix-D.html.  We accept a subset of the</span>
<span class="hl com"> * general format (&quot;smb:&quot; only; we do not look for &quot;cifs:&quot;).</span>
<span class="hl com"> *</span>
<span class="hl com"> *</span>
<span class="hl com"> * We accept:</span>
<span class="hl com"> *  smb://[[[domain;]user[:password&#64;]]server[/share[/path[/file]]]][?options]</span>
<span class="hl com"> *</span>
<span class="hl com"> * Meaning of URLs:</span>
<span class="hl com"> *</span>
<span class="hl com"> * smb://           Show all workgroups.</span>
<span class="hl com"> *</span>
<span class="hl com"> *                  The method of locating the list of workgroups varies</span>
<span class="hl com"> *                  depending upon the setting of the context variable</span>
<span class="hl com"> *                  context-&gt;options.browse_max_lmb_count.  This value</span>
<span class="hl com"> *                  determine the maximum number of local master browsers to</span>
<span class="hl com"> *                  query for the list of workgroups.  In order to ensure that</span>
<span class="hl com"> *                  a complete list of workgroups is obtained, all master</span>
<span class="hl com"> *                  browsers must be queried, but if there are many</span>
<span class="hl com"> *                  workgroups, the time spent querying can begin to add up.</span>
<span class="hl com"> *                  For small networks (not many workgroups), it is suggested</span>
<span class="hl com"> *                  that this variable be set to 0, indicating query all local</span>
<span class="hl com"> *                  master browsers.  When the network has many workgroups, a</span>
<span class="hl com"> *                  reasonable setting for this variable might be around 3.</span>
<span class="hl com"> *</span>
<span class="hl com"> * smb://name/      if name&lt;1D&gt; or name&lt;1B&gt; exists, list servers in</span>
<span class="hl com"> *                  workgroup, else, if name&lt;20&gt; exists, list all shares</span>
<span class="hl com"> *                  for server ...</span>
<span class="hl com"> *</span>
<span class="hl com"> * If &quot;options&quot; are provided, this function returns the entire option list as a</span>
<span class="hl com"> * string, for later parsing by the caller.  Note that currently, no options</span>
<span class="hl com"> * are supported.</span>
<span class="hl com"> */</span>

<span class="hl kwb">static const char</span> <span class="hl opt">*</span>smbc_prefix <span class="hl opt">=</span> <span class="hl str">&quot;smb:&quot;</span><span class="hl opt">;</span>

<span class="hl kwb">static int</span>
<span class="hl kwd">smbc_parse_path</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">,</span>
                <span class="hl kwb">const char</span> <span class="hl opt">*</span>fname<span class="hl opt">,</span>
                <span class="hl kwb">char</span> <span class="hl opt">*</span>server<span class="hl opt">,</span> <span class="hl kwb">int</span> server_len<span class="hl opt">,</span>
                <span class="hl kwb">char</span> <span class="hl opt">*</span>share<span class="hl opt">,</span> <span class="hl kwb">int</span> share_len<span class="hl opt">,</span>
                <span class="hl kwb">char</span> <span class="hl opt">*</span>path<span class="hl opt">,</span> <span class="hl kwb">int</span> path_len<span class="hl opt">,</span>
		<span class="hl kwb">char</span> <span class="hl opt">*</span>user<span class="hl opt">,</span> <span class="hl kwb">int</span> user_len<span class="hl opt">,</span>
                <span class="hl kwb">char</span> <span class="hl opt">*</span>password<span class="hl opt">,</span> <span class="hl kwb">int</span> password_len<span class="hl opt">,</span>
                <span class="hl kwb">char</span> <span class="hl opt">*</span>options<span class="hl opt">,</span> <span class="hl kwb">int</span> options_len<span class="hl opt">)</span>
<span class="hl opt">{</span>
	<span class="hl kwb">static</span> pstring s<span class="hl opt">;</span>
	pstring userinfo<span class="hl opt">;</span>
	<span class="hl kwb">const char</span> <span class="hl opt">*</span>p<span class="hl opt">;</span>
	<span class="hl kwb">char</span> <span class="hl opt">*</span>q<span class="hl opt">, *</span>r<span class="hl opt">;</span>
	<span class="hl kwb">int</span> len<span class="hl opt">;</span>

	server<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] =</span> share<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] =</span> path<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] =</span> user<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] =</span> password<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] = (</span><span class="hl kwb">char</span><span class="hl opt">)</span><span class="hl num">0</span><span class="hl opt">;</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>options <span class="hl opt">!=</span> NULL <span class="hl opt">&amp;&amp;</span> options_len <span class="hl opt">&gt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>
                options<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] = (</span><span class="hl kwb">char</span><span class="hl opt">)</span><span class="hl num">0</span><span class="hl opt">;</span>
        <span class="hl opt">}</span>
	<span class="hl kwd">pstrcpy</span><span class="hl opt">(</span>s<span class="hl opt">,</span> fname<span class="hl opt">);</span>

	<span class="hl com">/* see if it has the right prefix */</span>
	len <span class="hl opt">=</span> <span class="hl kwd">strlen</span><span class="hl opt">(</span>smbc_prefix<span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">strncmp</span><span class="hl opt">(</span>s<span class="hl opt">,</span>smbc_prefix<span class="hl opt">,</span>len<span class="hl opt">) || (</span>s<span class="hl opt">[</span>len<span class="hl opt">] !=</span> <span class="hl str">&#39;/&#39;</span> <span class="hl opt">&amp;&amp;</span> s<span class="hl opt">[</span>len<span class="hl opt">] !=</span> <span class="hl num">0</span><span class="hl opt">)) {</span>
                <span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span> <span class="hl com">/* What about no smb: ? */</span>
        <span class="hl opt">}</span>

	p <span class="hl opt">=</span> s <span class="hl opt">+</span> len<span class="hl opt">;</span>

	<span class="hl com">/* Watch the test below, we are testing to see if we should exit */</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">strncmp</span><span class="hl opt">(</span>p<span class="hl opt">,</span> <span class="hl str">&quot;//&quot;</span><span class="hl opt">,</span> <span class="hl num">2</span><span class="hl opt">) &amp;&amp;</span> <span class="hl kwd">strncmp</span><span class="hl opt">(</span>p<span class="hl opt">,</span> <span class="hl str">&quot;</span><span class="hl esc">\\\\</span><span class="hl str">&quot;</span><span class="hl opt">,</span> <span class="hl num">2</span><span class="hl opt">)) {</span>

                <span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">1</span><span class="hl opt">, (</span><span class="hl str">&quot;Invalid path (does not begin with smb://&quot;</span><span class="hl opt">));</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	p <span class="hl opt">+=</span> <span class="hl num">2</span><span class="hl opt">;</span>  <span class="hl com">/* Skip the double slash */</span>

        <span class="hl com">/* See if any options were specified */</span>
        <span class="hl kwa">if</span> <span class="hl opt">((</span>q <span class="hl opt">=</span> <span class="hl kwd">strrchr</span><span class="hl opt">(</span>p<span class="hl opt">,</span> <span class="hl str">&#39;?&#39;</span><span class="hl opt">)) !=</span> NULL <span class="hl opt">) {</span>
                <span class="hl com">/* There are options.  Null terminate here and point to them */</span>
                <span class="hl opt">*</span>q<span class="hl opt">++ =</span> <span class="hl str">&#39;\0&#39;</span><span class="hl opt">;</span>
                
                <span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">, (</span><span class="hl str">&quot;Found options &#39;</span><span class="hl ipl">%s</span><span class="hl str">&#39;&quot;</span><span class="hl opt">,</span> q<span class="hl opt">));</span>

                <span class="hl com">/* Copy the options */</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>options <span class="hl opt">!=</span> NULL <span class="hl opt">&amp;&amp;</span> options_len <span class="hl opt">&gt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>
                        <span class="hl kwd">safe_strcpy</span><span class="hl opt">(</span>options<span class="hl opt">,</span> q<span class="hl opt">,</span> options_len <span class="hl opt">-</span> <span class="hl num">1</span><span class="hl opt">);</span>
                <span class="hl opt">}</span>
        <span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(*</span>p <span class="hl opt">== (</span><span class="hl kwb">char</span><span class="hl opt">)</span><span class="hl num">0</span><span class="hl opt">)</span>
	    <span class="hl kwa">goto</span> decoding<span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(*</span>p <span class="hl opt">==</span> <span class="hl str">&#39;/&#39;</span><span class="hl opt">) {</span>

		<span class="hl kwd">strncpy</span><span class="hl opt">(</span>server<span class="hl opt">,</span> context<span class="hl opt">-&gt;</span>workgroup<span class="hl opt">,</span> 
			<span class="hl opt">(</span><span class="hl kwd">strlen</span><span class="hl opt">(</span>context<span class="hl opt">-&gt;</span>workgroup<span class="hl opt">) &lt;</span> <span class="hl num">16</span><span class="hl opt">)?</span><span class="hl kwd">strlen</span><span class="hl opt">(</span>context<span class="hl opt">-&gt;</span>workgroup<span class="hl opt">):</span><span class="hl num">16</span><span class="hl opt">);</span>
		<span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>
		
	<span class="hl opt">}</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * ok, its for us. Now parse out the server, share etc. </span>
<span class="hl com">	 *</span>
<span class="hl com">	 * However, we want to parse out [[domain;]user[:password]&#64;] if it</span>
<span class="hl com">	 * exists ...</span>
<span class="hl com">	 */</span>

	<span class="hl com">/* check that &#39;&#64;&#39; occurs before &#39;/&#39;, if &#39;/&#39; exists at all */</span>
	q <span class="hl opt">=</span> <span class="hl kwd">strchr_m</span><span class="hl opt">(</span>p<span class="hl opt">,</span> <span class="hl str">&#39;&#64;&#39;</span><span class="hl opt">);</span>
	r <span class="hl opt">=</span> <span class="hl kwd">strchr_m</span><span class="hl opt">(</span>p<span class="hl opt">,</span> <span class="hl str">&#39;/&#39;</span><span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>q <span class="hl opt">&amp;&amp; (!</span>r <span class="hl opt">||</span> q <span class="hl opt">&lt;</span> r<span class="hl opt">)) {</span>
		pstring username<span class="hl opt">,</span> passwd<span class="hl opt">,</span> domain<span class="hl opt">;</span>
		<span class="hl kwb">const char</span> <span class="hl opt">*</span>u <span class="hl opt">=</span> userinfo<span class="hl opt">;</span>

		<span class="hl kwd">next_token</span><span class="hl opt">(&amp;</span>p<span class="hl opt">,</span> userinfo<span class="hl opt">,</span> <span class="hl str">&quot;&#64;&quot;</span><span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>fstring<span class="hl opt">));</span>

		username<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] =</span> passwd<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] =</span> domain<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] =</span> <span class="hl num">0</span><span class="hl opt">;</span>

		<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">strchr_m</span><span class="hl opt">(</span>u<span class="hl opt">,</span> <span class="hl str">&#39;;&#39;</span><span class="hl opt">)) {</span>
      
			<span class="hl kwd">next_token</span><span class="hl opt">(&amp;</span>u<span class="hl opt">,</span> domain<span class="hl opt">,</span> <span class="hl str">&quot;;&quot;</span><span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>fstring<span class="hl opt">));</span>

		<span class="hl opt">}</span>

		<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">strchr_m</span><span class="hl opt">(</span>u<span class="hl opt">,</span> <span class="hl str">&#39;:&#39;</span><span class="hl opt">)) {</span>

			<span class="hl kwd">next_token</span><span class="hl opt">(&amp;</span>u<span class="hl opt">,</span> username<span class="hl opt">,</span> <span class="hl str">&quot;:&quot;</span><span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>fstring<span class="hl opt">));</span>

			<span class="hl kwd">pstrcpy</span><span class="hl opt">(</span>passwd<span class="hl opt">,</span> u<span class="hl opt">);</span>

		<span class="hl opt">}</span>
		<span class="hl kwa">else</span> <span class="hl opt">{</span>

			<span class="hl kwd">pstrcpy</span><span class="hl opt">(</span>username<span class="hl opt">,</span> u<span class="hl opt">);</span>

		<span class="hl opt">}</span>

		<span class="hl kwa">if</span> <span class="hl opt">(</span>username<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">])</span>
			<span class="hl kwd">strncpy</span><span class="hl opt">(</span>user<span class="hl opt">,</span> username<span class="hl opt">,</span> user_len<span class="hl opt">);</span>  <span class="hl com">/* FIXME, domain */</span>

		<span class="hl kwa">if</span> <span class="hl opt">(</span>passwd<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">])</span>
			<span class="hl kwd">strncpy</span><span class="hl opt">(</span>password<span class="hl opt">,</span> passwd<span class="hl opt">,</span> password_len<span class="hl opt">);</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">next_token</span><span class="hl opt">(&amp;</span>p<span class="hl opt">,</span> server<span class="hl opt">,</span> <span class="hl str">&quot;/&quot;</span><span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>fstring<span class="hl opt">))) {</span>

		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(*</span>p <span class="hl opt">== (</span><span class="hl kwb">char</span><span class="hl opt">)</span><span class="hl num">0</span><span class="hl opt">)</span> <span class="hl kwa">goto</span> decoding<span class="hl opt">;</span>  <span class="hl com">/* That&#39;s it ... */</span>
  
	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">next_token</span><span class="hl opt">(&amp;</span>p<span class="hl opt">,</span> share<span class="hl opt">,</span> <span class="hl str">&quot;/&quot;</span><span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>fstring<span class="hl opt">))) {</span>

		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

        <span class="hl kwd">safe_strcpy</span><span class="hl opt">(</span>path<span class="hl opt">,</span> p<span class="hl opt">,</span> path_len <span class="hl opt">-</span> <span class="hl num">1</span><span class="hl opt">);</span>

	<span class="hl kwd">all_string_sub</span><span class="hl opt">(</span>path<span class="hl opt">,</span> <span class="hl str">&quot;/&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;</span><span class="hl esc">\\</span><span class="hl str">&quot;</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">);</span>

 decoding<span class="hl opt">:</span>
	<span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">)</span> <span class="hl kwd">smbc_urldecode</span><span class="hl opt">(</span>path<span class="hl opt">,</span> path<span class="hl opt">,</span> path_len<span class="hl opt">);</span>
	<span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">)</span> <span class="hl kwd">smbc_urldecode</span><span class="hl opt">(</span>server<span class="hl opt">,</span> server<span class="hl opt">,</span> server_len<span class="hl opt">);</span>
	<span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">)</span> <span class="hl kwd">smbc_urldecode</span><span class="hl opt">(</span>share<span class="hl opt">,</span> share<span class="hl opt">,</span> share_len<span class="hl opt">);</span>
	<span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">)</span> <span class="hl kwd">smbc_urldecode</span><span class="hl opt">(</span>user<span class="hl opt">,</span> user<span class="hl opt">,</span> user_len<span class="hl opt">);</span>
	<span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">)</span> <span class="hl kwd">smbc_urldecode</span><span class="hl opt">(</span>password<span class="hl opt">,</span> password<span class="hl opt">,</span> password_len<span class="hl opt">);</span>

	<span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * Verify that the options specified in a URL are valid</span>
<span class="hl com"> */</span>
<span class="hl kwb">static int</span> <span class="hl kwd">smbc_check_options</span><span class="hl opt">(</span><span class="hl kwb">char</span> <span class="hl opt">*</span>server<span class="hl opt">,</span> <span class="hl kwb">char</span> <span class="hl opt">*</span>share<span class="hl opt">,</span> <span class="hl kwb">char</span> <span class="hl opt">*</span>path<span class="hl opt">,</span> <span class="hl kwb">char</span> <span class="hl opt">*</span>options<span class="hl opt">)</span>
<span class="hl opt">{</span>
        <span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">, (</span><span class="hl str">&quot;smbc_check_options(): server=&#39;</span><span class="hl ipl">%s</span><span class="hl str">&#39; share=&#39;</span><span class="hl ipl">%s</span><span class="hl str">&#39; path=&#39;</span><span class="hl ipl">%s</span><span class="hl str">&#39; options=&#39;</span><span class="hl ipl">%s</span><span class="hl str">&#39;</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> server<span class="hl opt">,</span> share<span class="hl opt">,</span> path<span class="hl opt">,</span> options<span class="hl opt">));</span>

        <span class="hl com">/* No options at all is always ok */</span>
        <span class="hl kwa">if</span> <span class="hl opt">(! *</span>options<span class="hl opt">)</span> <span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>

        <span class="hl com">/* Currently, we don&#39;t support any options. */</span>
        <span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * Convert an SMB error into a UNIX error ...</span>
<span class="hl com"> */</span>
<span class="hl kwb">static int</span> <span class="hl kwd">smbc_errno</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">,</span> <span class="hl kwb">struct</span> cli_state <span class="hl opt">*</span>c<span class="hl opt">)</span>
<span class="hl opt">{</span>
	<span class="hl kwb">int</span> ret <span class="hl opt">=</span> <span class="hl kwd">cli_errno</span><span class="hl opt">(</span>c<span class="hl opt">);</span>
	
        <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">cli_is_dos_error</span><span class="hl opt">(</span>c<span class="hl opt">)) {</span>
                uint8 eclass<span class="hl opt">;</span>
                uint32 ecode<span class="hl opt">;</span>

                <span class="hl kwd">cli_dos_error</span><span class="hl opt">(</span>c<span class="hl opt">, &amp;</span>eclass<span class="hl opt">, &amp;</span>ecode<span class="hl opt">);</span>
                
                <span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">3</span><span class="hl opt">,(</span><span class="hl str">&quot;smbc_error</span> <span class="hl ipl">%d %d</span> <span class="hl str">(0x</span><span class="hl ipl">%x</span><span class="hl str">) -&gt;</span> <span class="hl ipl">%d</span><span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> 
                         <span class="hl opt">(</span><span class="hl kwb">int</span><span class="hl opt">)</span>eclass<span class="hl opt">, (</span><span class="hl kwb">int</span><span class="hl opt">)</span>ecode<span class="hl opt">, (</span><span class="hl kwb">int</span><span class="hl opt">)</span>ecode<span class="hl opt">,</span> ret<span class="hl opt">));</span>
        <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
                NTSTATUS status<span class="hl opt">;</span>

                status <span class="hl opt">=</span> <span class="hl kwd">cli_nt_error</span><span class="hl opt">(</span>c<span class="hl opt">);</span>

                <span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">3</span><span class="hl opt">,(</span><span class="hl str">&quot;smbc errno</span> <span class="hl ipl">%s</span> <span class="hl str">-&gt;</span> <span class="hl ipl">%d</span><span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span>
                         <span class="hl kwd">nt_errstr</span><span class="hl opt">(</span>status<span class="hl opt">),</span> ret<span class="hl opt">));</span>
        <span class="hl opt">}</span>

	<span class="hl kwa">return</span> ret<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/* </span>
<span class="hl com"> * Check a server for being alive and well.</span>
<span class="hl com"> * returns 0 if the server is in shape. Returns 1 on error </span>
<span class="hl com"> * </span>
<span class="hl com"> * Also useable outside libsmbclient to enable external cache</span>
<span class="hl com"> * to do some checks too.</span>
<span class="hl com"> */</span>
<span class="hl kwb">int</span> <span class="hl kwd">smbc_check_server</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span> context<span class="hl opt">,</span> SMBCSRV <span class="hl opt">*</span> server<span class="hl opt">)</span> 
<span class="hl opt">{</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span> <span class="hl kwd">send_keepalive</span><span class="hl opt">(</span>server<span class="hl opt">-&gt;</span>cli<span class="hl opt">.</span>fd<span class="hl opt">) ==</span> False <span class="hl opt">)</span>
		<span class="hl kwa">return</span> <span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl com">/* connection is ok */</span>
	<span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/* </span>
<span class="hl com"> * Remove a server from the cached server list it&#39;s unused.</span>
<span class="hl com"> * On success, 0 is returned. 1 is returned if the server could not be removed.</span>
<span class="hl com"> * </span>
<span class="hl com"> * Also useable outside libsmbclient</span>
<span class="hl com"> */</span>
<span class="hl kwb">int</span> <span class="hl kwd">smbc_remove_unused_server</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span> context<span class="hl opt">,</span> SMBCSRV <span class="hl opt">*</span> srv<span class="hl opt">)</span>
<span class="hl opt">{</span>
	SMBCFILE <span class="hl opt">*</span> file<span class="hl opt">;</span>

	<span class="hl com">/* are we being fooled ? */</span>
	<span class="hl kwa">if</span> <span class="hl opt">(!</span>context <span class="hl opt">|| !</span>context<span class="hl opt">-&gt;</span>internal <span class="hl opt">||</span>
	    <span class="hl opt">!</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_initialized <span class="hl opt">|| !</span>srv<span class="hl opt">)</span> <span class="hl kwa">return</span> <span class="hl num">1</span><span class="hl opt">;</span>

	
	<span class="hl com">/* Check all open files/directories for a relation with this server */</span>
	<span class="hl kwa">for</span> <span class="hl opt">(</span>file <span class="hl opt">=</span> context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_files<span class="hl opt">;</span> file<span class="hl opt">;</span> file<span class="hl opt">=</span>file<span class="hl opt">-&gt;</span>next<span class="hl opt">) {</span>
		<span class="hl kwa">if</span> <span class="hl opt">(</span>file<span class="hl opt">-&gt;</span>srv <span class="hl opt">==</span> srv<span class="hl opt">) {</span>
			<span class="hl com">/* Still used */</span>
			<span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">3</span><span class="hl opt">, (</span><span class="hl str">&quot;smbc_remove_usused_server:</span> <span class="hl ipl">%p</span> <span class="hl str">still used by</span> <span class="hl ipl">%p</span><span class="hl str">.</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> 
				  srv<span class="hl opt">,</span> file<span class="hl opt">));</span>
			<span class="hl kwa">return</span> <span class="hl num">1</span><span class="hl opt">;</span>
		<span class="hl opt">}</span>
	<span class="hl opt">}</span>

	<span class="hl kwd">DLIST_REMOVE</span><span class="hl opt">(</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_servers<span class="hl opt">,</span> srv<span class="hl opt">);</span>

	<span class="hl kwd">cli_shutdown</span><span class="hl opt">(&amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">);</span>

	<span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">3</span><span class="hl opt">, (</span><span class="hl str">&quot;smbc_remove_usused_server:</span> <span class="hl ipl">%p</span> <span class="hl str">removed.</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> srv<span class="hl opt">));</span>

	context<span class="hl opt">-&gt;</span>callbacks<span class="hl opt">.</span><span class="hl kwd">remove_cached_srv_fn</span><span class="hl opt">(</span>context<span class="hl opt">,</span> srv<span class="hl opt">);</span>
	
	<span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>
<span class="hl opt">}</span>

SMBCSRV <span class="hl opt">*</span><span class="hl kwd">find_server</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">,</span>
                     <span class="hl kwb">const char</span> <span class="hl opt">*</span>server<span class="hl opt">,</span>
                     <span class="hl kwb">const char</span> <span class="hl opt">*</span>share<span class="hl opt">,</span>
                     fstring workgroup<span class="hl opt">,</span>
                     fstring username<span class="hl opt">,</span>
                     fstring password<span class="hl opt">)</span>
<span class="hl opt">{</span>
        SMBCSRV <span class="hl opt">*</span>srv<span class="hl opt">;</span>
        <span class="hl kwb">int</span> auth_called <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
        
 check_server_cache<span class="hl opt">:</span>

	srv <span class="hl opt">=</span> context<span class="hl opt">-&gt;</span>callbacks<span class="hl opt">.</span><span class="hl kwd">get_cached_srv_fn</span><span class="hl opt">(</span>context<span class="hl opt">,</span> server<span class="hl opt">,</span> share<span class="hl opt">,</span> 
						   workgroup<span class="hl opt">,</span> username<span class="hl opt">);</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>auth_called <span class="hl opt">&amp;&amp; !</span>srv <span class="hl opt">&amp;&amp; (!</span>username<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] || !</span>password<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">])) {</span>
		context<span class="hl opt">-&gt;</span>callbacks<span class="hl opt">.</span><span class="hl kwd">auth_fn</span><span class="hl opt">(</span>server<span class="hl opt">,</span> share<span class="hl opt">,</span>
                                           workgroup<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>fstring<span class="hl opt">),</span>
                                           username<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>fstring<span class="hl opt">),</span>
                                           password<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>fstring<span class="hl opt">));</span>
		<span class="hl com">/*</span>
<span class="hl com">                 * However, smbc_auth_fn may have picked up info relating to</span>
<span class="hl com">                 * an existing connection, so try for an existing connection</span>
<span class="hl com">                 * again ...</span>
<span class="hl com">                 */</span>
		auth_called <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
		<span class="hl kwa">goto</span> check_server_cache<span class="hl opt">;</span>
		
	<span class="hl opt">}</span>
	
	<span class="hl kwa">if</span> <span class="hl opt">(</span>srv<span class="hl opt">) {</span>
		<span class="hl kwa">if</span> <span class="hl opt">(</span>context<span class="hl opt">-&gt;</span>callbacks<span class="hl opt">.</span><span class="hl kwd">check_server_fn</span><span class="hl opt">(</span>context<span class="hl opt">,</span> srv<span class="hl opt">)) {</span>
			<span class="hl com">/*</span>
<span class="hl com">                         * This server is no good anymore </span>
<span class="hl com">                         * Try to remove it and check for more possible</span>
<span class="hl com">                         * servers in the cache</span>
<span class="hl com">                         */</span>
			<span class="hl kwa">if</span> <span class="hl opt">(</span>context<span class="hl opt">-&gt;</span>callbacks<span class="hl opt">.</span><span class="hl kwd">remove_unused_server_fn</span><span class="hl opt">(</span>context<span class="hl opt">,</span>
                                                                       srv<span class="hl opt">)) {</span> 
                                <span class="hl com">/*</span>
<span class="hl com">                                 * We could not remove the server completely,</span>
<span class="hl com">                                 * remove it from the cache so we will not get</span>
<span class="hl com">                                 * it again. It will be removed when the last</span>
<span class="hl com">                                 * file/dir is closed.</span>
<span class="hl com">                                 */</span>
				context<span class="hl opt">-&gt;</span>callbacks<span class="hl opt">.</span><span class="hl kwd">remove_cached_srv_fn</span><span class="hl opt">(</span>context<span class="hl opt">,</span>
                                                                        srv<span class="hl opt">);</span>
			<span class="hl opt">}</span>
			
			<span class="hl com">/*</span>
<span class="hl com">                         * Maybe there are more cached connections to this</span>
<span class="hl com">                         * server</span>
<span class="hl com">                         */</span>
			<span class="hl kwa">goto</span> check_server_cache<span class="hl opt">;</span> 
		<span class="hl opt">}</span>

		<span class="hl kwa">return</span> srv<span class="hl opt">;</span>
 	<span class="hl opt">}</span>

        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * Connect to a server, possibly on an existing connection</span>
<span class="hl com"> *</span>
<span class="hl com"> * Here, what we want to do is: If the server and username</span>
<span class="hl com"> * match an existing connection, reuse that, otherwise, establish a </span>
<span class="hl com"> * new connection.</span>
<span class="hl com"> *</span>
<span class="hl com"> * If we have to create a new connection, call the auth_fn to get the</span>
<span class="hl com"> * info we need, unless the username and password were passed in.</span>
<span class="hl com"> */</span>

SMBCSRV <span class="hl opt">*</span><span class="hl kwd">smbc_server</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">,</span>
		     <span class="hl kwb">const char</span> <span class="hl opt">*</span>server<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>share<span class="hl opt">,</span> 
		     fstring workgroup<span class="hl opt">,</span> fstring username<span class="hl opt">,</span> 
		     fstring password<span class="hl opt">)</span>
<span class="hl opt">{</span>
	SMBCSRV <span class="hl opt">*</span>srv<span class="hl opt">=</span>NULL<span class="hl opt">;</span>
	<span class="hl kwb">struct</span> cli_state c<span class="hl opt">;</span>
	<span class="hl kwb">struct</span> nmb_name called<span class="hl opt">,</span> calling<span class="hl opt">;</span>
	<span class="hl kwb">const char</span> <span class="hl opt">*</span>server_n <span class="hl opt">=</span> server<span class="hl opt">;</span>
	pstring ipenv<span class="hl opt">;</span>
	<span class="hl kwb">struct</span> in_addr ip<span class="hl opt">;</span>
	<span class="hl kwb">int</span> tried_reverse <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
        <span class="hl kwb">int</span> port_try_first<span class="hl opt">;</span>
        <span class="hl kwb">int</span> port_try_next<span class="hl opt">;</span>
        <span class="hl kwb">const char</span> <span class="hl opt">*</span>username_used<span class="hl opt">;</span>
  
	<span class="hl kwd">zero_ip</span><span class="hl opt">(&amp;</span>ip<span class="hl opt">);</span>
	<span class="hl kwd">ZERO_STRUCT</span><span class="hl opt">(</span>c<span class="hl opt">);</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>server<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] ==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
		errno <span class="hl opt">=</span> EPERM<span class="hl opt">;</span>
		<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
	<span class="hl opt">}</span>

        srv <span class="hl opt">=</span> <span class="hl kwd">find_server</span><span class="hl opt">(</span>context<span class="hl opt">,</span> server<span class="hl opt">,</span> share<span class="hl opt">,</span>
                          workgroup<span class="hl opt">,</span> username<span class="hl opt">,</span> password<span class="hl opt">);</span>

        <span class="hl com">/*</span>
<span class="hl com">         * If we found a connection and we&#39;re only allowed one share per</span>
<span class="hl com">         * server...</span>
<span class="hl com">         */</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>srv <span class="hl opt">&amp;&amp; *</span>share <span class="hl opt">!=</span> <span class="hl str">&#39;\0&#39;</span> <span class="hl opt">&amp;&amp;</span> context<span class="hl opt">-&gt;</span>options<span class="hl opt">.</span>one_share_per_server<span class="hl opt">) {</span>

                <span class="hl com">/*</span>
<span class="hl com">                 * ... then if there&#39;s no current connection to the share,</span>
<span class="hl com">                 * connect to it.  find_server(), or rather the function</span>
<span class="hl com">                 * pointed to by context-&gt;callbacks.get_cached_srv_fn which</span>
<span class="hl com">                 * was called by find_server(), will have issued a tree</span>
<span class="hl com">                 * disconnect if the requested share is not the same as the</span>
<span class="hl com">                 * one that was already connected.</span>
<span class="hl com">                 */</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">.</span>cnum <span class="hl opt">== (</span>uint16<span class="hl opt">) -</span><span class="hl num">1</span><span class="hl opt">) {</span>
                        <span class="hl com">/* Ensure we have accurate auth info */</span>
                        context<span class="hl opt">-&gt;</span>callbacks<span class="hl opt">.</span><span class="hl kwd">auth_fn</span><span class="hl opt">(</span>server<span class="hl opt">,</span> share<span class="hl opt">,</span>
                                                   workgroup<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>fstring<span class="hl opt">),</span>
                                                   username<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>fstring<span class="hl opt">),</span>
                                                   password<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>fstring<span class="hl opt">));</span>

                        <span class="hl kwa">if</span> <span class="hl opt">(!</span> <span class="hl kwd">cli_send_tconX</span><span class="hl opt">(&amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> share<span class="hl opt">,</span> <span class="hl str">&quot;?????&quot;</span><span class="hl opt">,</span>
                                             password<span class="hl opt">,</span> <span class="hl kwd">strlen</span><span class="hl opt">(</span>password<span class="hl opt">)+</span><span class="hl num">1</span><span class="hl opt">)) {</span>
                        
                                errno <span class="hl opt">=</span> <span class="hl kwd">smbc_errno</span><span class="hl opt">(</span>context<span class="hl opt">, &amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">);</span>
                                <span class="hl kwd">cli_shutdown</span><span class="hl opt">(&amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">);</span>
                                context<span class="hl opt">-&gt;</span>callbacks<span class="hl opt">.</span><span class="hl kwd">remove_cached_srv_fn</span><span class="hl opt">(</span>context<span class="hl opt">,</span> srv<span class="hl opt">);</span>
                                srv <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
                        <span class="hl opt">}</span>

                        <span class="hl com">/* Regenerate the dev value since it&#39;s based on both server and share */</span>
                        <span class="hl kwa">if</span> <span class="hl opt">(</span>srv<span class="hl opt">) {</span>
                                srv<span class="hl opt">-&gt;</span>dev <span class="hl opt">= (</span>dev_t<span class="hl opt">)(</span><span class="hl kwd">str_checksum</span><span class="hl opt">(</span>server<span class="hl opt">) ^</span> <span class="hl kwd">str_checksum</span><span class="hl opt">(</span>share<span class="hl opt">));</span>
                        <span class="hl opt">}</span>
                <span class="hl opt">}</span>
        <span class="hl opt">}</span>
        
        <span class="hl com">/* If we have a connection... */</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>srv<span class="hl opt">) {</span>

                <span class="hl com">/* ... then we&#39;re done here.  Give &#39;em what they came for. */</span>
                <span class="hl kwa">return</span> srv<span class="hl opt">;</span>
        <span class="hl opt">}</span>

	<span class="hl kwd">make_nmb_name</span><span class="hl opt">(&amp;</span>calling<span class="hl opt">,</span> context<span class="hl opt">-&gt;</span>netbios_name<span class="hl opt">,</span> <span class="hl num">0x0</span><span class="hl opt">);</span>
	<span class="hl kwd">make_nmb_name</span><span class="hl opt">(&amp;</span>called <span class="hl opt">,</span> server<span class="hl opt">,</span> <span class="hl num">0x20</span><span class="hl opt">);</span>

	<span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">,(</span><span class="hl str">&quot;smbc_server: server_n=[</span><span class="hl ipl">%s</span><span class="hl str">] server=[</span><span class="hl ipl">%s</span><span class="hl str">]</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> server_n<span class="hl opt">,</span> server<span class="hl opt">));</span>
  
	<span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">,(</span><span class="hl str">&quot; -&gt; server_n=[</span><span class="hl ipl">%s</span><span class="hl str">] server=[</span><span class="hl ipl">%s</span><span class="hl str">]</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> server_n<span class="hl opt">,</span> server<span class="hl opt">));</span>

 again<span class="hl opt">:</span>
	<span class="hl kwd">slprintf</span><span class="hl opt">(</span>ipenv<span class="hl opt">,</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span>ipenv<span class="hl opt">)-</span><span class="hl num">1</span><span class="hl opt">,</span><span class="hl str">&quot;HOST_</span><span class="hl ipl">%s</span><span class="hl str">&quot;</span><span class="hl opt">,</span> server_n<span class="hl opt">);</span>

	<span class="hl kwd">zero_ip</span><span class="hl opt">(&amp;</span>ip<span class="hl opt">);</span>

	<span class="hl com">/* have to open a new connection */</span>
	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">cli_initialise</span><span class="hl opt">(&amp;</span>c<span class="hl opt">)) {</span>
		errno <span class="hl opt">=</span> ENOMEM<span class="hl opt">;</span>
		<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>context<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> SMB_CTX_FLAG_USE_KERBEROS<span class="hl opt">) {</span>
		c<span class="hl opt">.</span>use_kerberos <span class="hl opt">=</span> True<span class="hl opt">;</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>context<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> SMB_CTX_FLAG_FALLBACK_AFTER_KERBEROS<span class="hl opt">) {</span>
		c<span class="hl opt">.</span>fallback_after_kerberos <span class="hl opt">=</span> True<span class="hl opt">;</span>
	<span class="hl opt">}</span>

	c<span class="hl opt">.</span>timeout <span class="hl opt">=</span> context<span class="hl opt">-&gt;</span>timeout<span class="hl opt">;</span>

        <span class="hl com">/*</span>
<span class="hl com">         * Force use of port 139 for first try if share is $IPC, empty, or</span>
<span class="hl com">         * null, so browse lists can work</span>
<span class="hl com">         */</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>share <span class="hl opt">==</span> NULL <span class="hl opt">|| *</span>share <span class="hl opt">==</span> <span class="hl str">&#39;\0&#39;</span> <span class="hl opt">||</span> <span class="hl kwd">strcmp</span><span class="hl opt">(</span>share<span class="hl opt">,</span> <span class="hl str">&quot;IPC$&quot;</span><span class="hl opt">) ==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
                port_try_first <span class="hl opt">=</span> <span class="hl num">139</span><span class="hl opt">;</span>
                port_try_next <span class="hl opt">=</span> <span class="hl num">445</span><span class="hl opt">;</span>
        <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
                port_try_first <span class="hl opt">=</span> <span class="hl num">445</span><span class="hl opt">;</span>
                port_try_next <span class="hl opt">=</span> <span class="hl num">139</span><span class="hl opt">;</span>
        <span class="hl opt">}</span>

        c<span class="hl opt">.</span>port <span class="hl opt">=</span> port_try_first<span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">cli_connect</span><span class="hl opt">(&amp;</span>c<span class="hl opt">,</span> server_n<span class="hl opt">, &amp;</span>ip<span class="hl opt">)) {</span>

                <span class="hl com">/* First connection attempt failed.  Try alternate port. */</span>
                c<span class="hl opt">.</span>port <span class="hl opt">=</span> port_try_next<span class="hl opt">;</span>

                <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">cli_connect</span><span class="hl opt">(&amp;</span>c<span class="hl opt">,</span> server_n<span class="hl opt">, &amp;</span>ip<span class="hl opt">)) {</span>
                        <span class="hl kwd">cli_shutdown</span><span class="hl opt">(&amp;</span>c<span class="hl opt">);</span>
                        errno <span class="hl opt">=</span> ETIMEDOUT<span class="hl opt">;</span>
                        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
                <span class="hl opt">}</span>
 	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">cli_session_request</span><span class="hl opt">(&amp;</span>c<span class="hl opt">, &amp;</span>calling<span class="hl opt">, &amp;</span>called<span class="hl opt">)) {</span>
		<span class="hl kwd">cli_shutdown</span><span class="hl opt">(&amp;</span>c<span class="hl opt">);</span>
		<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">strcmp</span><span class="hl opt">(</span>called<span class="hl opt">.</span>name<span class="hl opt">,</span> <span class="hl str">&quot;*SMBSERVER&quot;</span><span class="hl opt">)) {</span>
			<span class="hl kwd">make_nmb_name</span><span class="hl opt">(&amp;</span>called <span class="hl opt">,</span> <span class="hl str">&quot;*SMBSERVER&quot;</span><span class="hl opt">,</span> <span class="hl num">0x20</span><span class="hl opt">);</span>
			<span class="hl kwa">goto</span> again<span class="hl opt">;</span>
		<span class="hl opt">}</span>
		<span class="hl kwa">else</span> <span class="hl opt">{</span>  <span class="hl com">/* Try one more time, but ensure we don&#39;t loop */</span>

		  <span class="hl com">/* Only try this if server is an IP address ... */</span>

		  <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">is_ipaddress</span><span class="hl opt">(</span>server<span class="hl opt">) &amp;&amp; !</span>tried_reverse<span class="hl opt">) {</span>
		    fstring remote_name<span class="hl opt">;</span>
		    <span class="hl kwb">struct</span> in_addr rem_ip<span class="hl opt">;</span>

		    <span class="hl kwa">if</span> <span class="hl opt">((</span>rem_ip<span class="hl opt">.</span>s_addr<span class="hl opt">=</span><span class="hl kwd">inet_addr</span><span class="hl opt">(</span>server<span class="hl opt">)) ==</span> INADDR_NONE<span class="hl opt">) {</span>
		      <span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">, (</span><span class="hl str">&quot;Could not convert IP address</span> <span class="hl ipl">%s</span> <span class="hl str">to struct in_addr</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> server<span class="hl opt">));</span>
		      errno <span class="hl opt">=</span> ETIMEDOUT<span class="hl opt">;</span>
		      <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
		    <span class="hl opt">}</span>

		    tried_reverse<span class="hl opt">++;</span> <span class="hl com">/* Yuck */</span>

		    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">name_status_find</span><span class="hl opt">(</span><span class="hl str">&quot;*&quot;</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> rem_ip<span class="hl opt">,</span> remote_name<span class="hl opt">)) {</span>
		      <span class="hl kwd">make_nmb_name</span><span class="hl opt">(&amp;</span>called<span class="hl opt">,</span> remote_name<span class="hl opt">,</span> <span class="hl num">0x20</span><span class="hl opt">);</span>
		      <span class="hl kwa">goto</span> again<span class="hl opt">;</span>
		    <span class="hl opt">}</span>


		  <span class="hl opt">}</span>
		<span class="hl opt">}</span>
		errno <span class="hl opt">=</span> ETIMEDOUT<span class="hl opt">;</span>
		<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
	<span class="hl opt">}</span>
  
	<span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">,(</span><span class="hl str">&quot; session request ok</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
  
	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">cli_negprot</span><span class="hl opt">(&amp;</span>c<span class="hl opt">)) {</span>
		<span class="hl kwd">cli_shutdown</span><span class="hl opt">(&amp;</span>c<span class="hl opt">);</span>
		errno <span class="hl opt">=</span> ETIMEDOUT<span class="hl opt">;</span>
		<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
	<span class="hl opt">}</span>

        username_used <span class="hl opt">=</span> username<span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">cli_session_setup</span><span class="hl opt">(&amp;</span>c<span class="hl opt">,</span> username_used<span class="hl opt">,</span> 
			       password<span class="hl opt">,</span> <span class="hl kwd">strlen</span><span class="hl opt">(</span>password<span class="hl opt">),</span>
			       password<span class="hl opt">,</span> <span class="hl kwd">strlen</span><span class="hl opt">(</span>password<span class="hl opt">),</span>
			       workgroup<span class="hl opt">)) {</span>
                
                <span class="hl com">/* Failed.  Try an anonymous login, if allowed by flags. */</span>
                username_used <span class="hl opt">=</span> <span class="hl str">&quot;&quot;</span><span class="hl opt">;</span>

                <span class="hl kwa">if</span> <span class="hl opt">((</span>context<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> SMBCCTX_FLAG_NO_AUTO_ANONYMOUS_LOGON<span class="hl opt">) ||</span>
                     <span class="hl opt">!</span><span class="hl kwd">cli_session_setup</span><span class="hl opt">(&amp;</span>c<span class="hl opt">,</span> username_used<span class="hl opt">,</span>
                                        password<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">,</span>
                                        password<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span>
                                        workgroup<span class="hl opt">)) {</span>

                        <span class="hl kwd">cli_shutdown</span><span class="hl opt">(&amp;</span>c<span class="hl opt">);</span>
                        errno <span class="hl opt">=</span> EPERM<span class="hl opt">;</span>
                        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
                <span class="hl opt">}</span>
	<span class="hl opt">}</span>

	<span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">,(</span><span class="hl str">&quot; session setup ok</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">cli_send_tconX</span><span class="hl opt">(&amp;</span>c<span class="hl opt">,</span> share<span class="hl opt">,</span> <span class="hl str">&quot;?????&quot;</span><span class="hl opt">,</span>
			    password<span class="hl opt">,</span> <span class="hl kwd">strlen</span><span class="hl opt">(</span>password<span class="hl opt">)+</span><span class="hl num">1</span><span class="hl opt">)) {</span>
		errno <span class="hl opt">=</span> <span class="hl kwd">smbc_errno</span><span class="hl opt">(</span>context<span class="hl opt">, &amp;</span>c<span class="hl opt">);</span>
		<span class="hl kwd">cli_shutdown</span><span class="hl opt">(&amp;</span>c<span class="hl opt">);</span>
		<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
	<span class="hl opt">}</span>
  
	<span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">,(</span><span class="hl str">&quot; tconx ok</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
  
	<span class="hl com">/*</span>
<span class="hl com">	 * Ok, we have got a nice connection</span>
<span class="hl com">	 * Let&#39;s allocate a server structure.</span>
<span class="hl com">	 */</span>

	srv <span class="hl opt">=</span> <span class="hl kwd">SMB_MALLOC_P</span><span class="hl opt">(</span>SMBCSRV<span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(!</span>srv<span class="hl opt">) {</span>
		errno <span class="hl opt">=</span> ENOMEM<span class="hl opt">;</span>
		<span class="hl kwa">goto</span> failed<span class="hl opt">;</span>
	<span class="hl opt">}</span>

	<span class="hl kwd">ZERO_STRUCTP</span><span class="hl opt">(</span>srv<span class="hl opt">);</span>
	srv<span class="hl opt">-&gt;</span>cli <span class="hl opt">=</span> c<span class="hl opt">;</span>
	srv<span class="hl opt">-&gt;</span>dev <span class="hl opt">= (</span>dev_t<span class="hl opt">)(</span><span class="hl kwd">str_checksum</span><span class="hl opt">(</span>server<span class="hl opt">) ^</span> <span class="hl kwd">str_checksum</span><span class="hl opt">(</span>share<span class="hl opt">));</span>
        srv<span class="hl opt">-&gt;</span>no_pathinfo <span class="hl opt">=</span> False<span class="hl opt">;</span>
        srv<span class="hl opt">-&gt;</span>no_pathinfo2 <span class="hl opt">=</span> False<span class="hl opt">;</span>
        srv<span class="hl opt">-&gt;</span>no_nt_session <span class="hl opt">=</span> False<span class="hl opt">;</span>

	<span class="hl com">/* now add it to the cache (internal or external)  */</span>
	<span class="hl com">/* Let the cache function set errno if it wants to */</span>
	errno <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>context<span class="hl opt">-&gt;</span>callbacks<span class="hl opt">.</span><span class="hl kwd">add_cached_srv_fn</span><span class="hl opt">(</span>context<span class="hl opt">,</span> srv<span class="hl opt">,</span> server<span class="hl opt">,</span> share<span class="hl opt">,</span> workgroup<span class="hl opt">,</span> username_used<span class="hl opt">)) {</span>
		<span class="hl kwb">int</span> saved_errno <span class="hl opt">=</span> errno<span class="hl opt">;</span>
		<span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">3</span><span class="hl opt">, (</span><span class="hl str">&quot; Failed to add server to cache</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
		errno <span class="hl opt">=</span> saved_errno<span class="hl opt">;</span>
		<span class="hl kwa">if</span> <span class="hl opt">(</span>errno <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
			errno <span class="hl opt">=</span> ENOMEM<span class="hl opt">;</span>
		<span class="hl opt">}</span>
		<span class="hl kwa">goto</span> failed<span class="hl opt">;</span>
	<span class="hl opt">}</span>
	
	<span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">2</span><span class="hl opt">, (</span><span class="hl str">&quot;Server connect ok: //</span><span class="hl ipl">%s</span><span class="hl str">/</span><span class="hl ipl">%s</span><span class="hl str">:</span> <span class="hl ipl">%p</span><span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> 
		  server<span class="hl opt">,</span> share<span class="hl opt">,</span> srv<span class="hl opt">));</span>

	<span class="hl kwd">DLIST_ADD</span><span class="hl opt">(</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_servers<span class="hl opt">,</span> srv<span class="hl opt">);</span>
	<span class="hl kwa">return</span> srv<span class="hl opt">;</span>

 failed<span class="hl opt">:</span>
	<span class="hl kwd">cli_shutdown</span><span class="hl opt">(&amp;</span>c<span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(!</span>srv<span class="hl opt">)</span> <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
  
	<span class="hl kwd">SAFE_FREE</span><span class="hl opt">(</span>srv<span class="hl opt">);</span>
	<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * Connect to a server for getting/setting attributes, possibly on an existing</span>
<span class="hl com"> * connection.  This works similarly to smbc_server().</span>
<span class="hl com"> */</span>
SMBCSRV <span class="hl opt">*</span><span class="hl kwd">smbc_attr_server</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">,</span>
                          <span class="hl kwb">const char</span> <span class="hl opt">*</span>server<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>share<span class="hl opt">,</span> 
                          fstring workgroup<span class="hl opt">,</span>
                          fstring username<span class="hl opt">,</span> fstring password<span class="hl opt">,</span>
                          POLICY_HND <span class="hl opt">*</span>pol<span class="hl opt">)</span>
<span class="hl opt">{</span>
        <span class="hl kwb">struct</span> in_addr ip<span class="hl opt">;</span>
	<span class="hl kwb">struct</span> cli_state <span class="hl opt">*</span>ipc_cli<span class="hl opt">;</span>
        NTSTATUS nt_status<span class="hl opt">;</span>
	SMBCSRV <span class="hl opt">*</span>ipc_srv<span class="hl opt">=</span>NULL<span class="hl opt">;</span>

        <span class="hl com">/*</span>
<span class="hl com">         * See if we&#39;ve already created this special connection.  Reference our</span>
<span class="hl com">         * &quot;special&quot; share name &#39;*IPC$&#39;, which is an impossible real share name</span>
<span class="hl com">         * due to the leading asterisk.</span>
<span class="hl com">         */</span>
        ipc_srv <span class="hl opt">=</span> <span class="hl kwd">find_server</span><span class="hl opt">(</span>context<span class="hl opt">,</span> server<span class="hl opt">,</span> <span class="hl str">&quot;*IPC$&quot;</span><span class="hl opt">,</span>
                              workgroup<span class="hl opt">,</span> username<span class="hl opt">,</span> password<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(!</span>ipc_srv<span class="hl opt">) {</span>

                <span class="hl com">/* We didn&#39;t find a cached connection.  Get the password */</span>
                <span class="hl kwa">if</span> <span class="hl opt">(*</span>password <span class="hl opt">==</span> <span class="hl str">&#39;\0&#39;</span><span class="hl opt">) {</span>
                        <span class="hl com">/* ... then retrieve it now. */</span>
                        context<span class="hl opt">-&gt;</span>callbacks<span class="hl opt">.</span><span class="hl kwd">auth_fn</span><span class="hl opt">(</span>server<span class="hl opt">,</span> share<span class="hl opt">,</span>
                                                   workgroup<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>fstring<span class="hl opt">),</span>
                                                   username<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>fstring<span class="hl opt">),</span>
                                                   password<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>fstring<span class="hl opt">));</span>
                <span class="hl opt">}</span>
        
                <span class="hl kwd">zero_ip</span><span class="hl opt">(&amp;</span>ip<span class="hl opt">);</span>
                nt_status <span class="hl opt">=</span> <span class="hl kwd">cli_full_connection</span><span class="hl opt">(&amp;</span>ipc_cli<span class="hl opt">,</span>
                                                <span class="hl kwd">global_myname</span><span class="hl opt">(),</span> server<span class="hl opt">,</span> 
                                                <span class="hl opt">&amp;</span>ip<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> <span class="hl str">&quot;IPC$&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;?????&quot;</span><span class="hl opt">,</span>  
                                                username<span class="hl opt">,</span> workgroup<span class="hl opt">,</span>
                                                password<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span>
                                                Undefined<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
                <span class="hl kwa">if</span> <span class="hl opt">(!</span> <span class="hl kwd">NT_STATUS_IS_OK</span><span class="hl opt">(</span>nt_status<span class="hl opt">)) {</span>
                        <span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">1</span><span class="hl opt">,(</span><span class="hl str">&quot;cli_full_connection failed! (</span><span class="hl ipl">%s</span><span class="hl str">)</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span>
                                 <span class="hl kwd">nt_errstr</span><span class="hl opt">(</span>nt_status<span class="hl opt">)));</span>
                        errno <span class="hl opt">=</span> ENOTSUP<span class="hl opt">;</span>
                        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
                <span class="hl opt">}</span>

                <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">cli_nt_session_open</span><span class="hl opt">(</span>ipc_cli<span class="hl opt">,</span> PI_LSARPC<span class="hl opt">)) {</span>
                        <span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">1</span><span class="hl opt">, (</span><span class="hl str">&quot;cli_nt_session_open fail!</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
                        errno <span class="hl opt">=</span> ENOTSUP<span class="hl opt">;</span>
                        <span class="hl kwd">cli_shutdown</span><span class="hl opt">(</span>ipc_cli<span class="hl opt">);</span>
                        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
                <span class="hl opt">}</span>

                <span class="hl com">/* Some systems don&#39;t support SEC_RIGHTS_MAXIMUM_ALLOWED,</span>
<span class="hl com">                   but NT sends 0x2000000 so we might as well do it too. */</span>
        
                nt_status <span class="hl opt">=</span> <span class="hl kwd">cli_lsa_open_policy</span><span class="hl opt">(</span>ipc_cli<span class="hl opt">,</span>
                                                ipc_cli<span class="hl opt">-&gt;</span>mem_ctx<span class="hl opt">,</span>
                                                True<span class="hl opt">,</span> 
                                                GENERIC_EXECUTE_ACCESS<span class="hl opt">,</span>
                                                pol<span class="hl opt">);</span>
        
                <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">NT_STATUS_IS_OK</span><span class="hl opt">(</span>nt_status<span class="hl opt">)) {</span>
                        errno <span class="hl opt">=</span> <span class="hl kwd">smbc_errno</span><span class="hl opt">(</span>context<span class="hl opt">,</span> ipc_cli<span class="hl opt">);</span>
                        <span class="hl kwd">cli_shutdown</span><span class="hl opt">(</span>ipc_cli<span class="hl opt">);</span>
                        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
                <span class="hl opt">}</span>

                ipc_srv <span class="hl opt">=</span> <span class="hl kwd">SMB_MALLOC_P</span><span class="hl opt">(</span>SMBCSRV<span class="hl opt">);</span>
                <span class="hl kwa">if</span> <span class="hl opt">(!</span>ipc_srv<span class="hl opt">) {</span>
                        errno <span class="hl opt">=</span> ENOMEM<span class="hl opt">;</span>
                        <span class="hl kwd">cli_shutdown</span><span class="hl opt">(</span>ipc_cli<span class="hl opt">);</span>
                        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
                <span class="hl opt">}</span>

                <span class="hl kwd">ZERO_STRUCTP</span><span class="hl opt">(</span>ipc_srv<span class="hl opt">);</span>
                ipc_srv<span class="hl opt">-&gt;</span>cli <span class="hl opt">= *</span>ipc_cli<span class="hl opt">;</span>

                <span class="hl kwd">free</span><span class="hl opt">(</span>ipc_cli<span class="hl opt">);</span>

                <span class="hl com">/* now add it to the cache (internal or external) */</span>

                errno <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>      <span class="hl com">/* let cache function set errno if it likes */</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>context<span class="hl opt">-&gt;</span>callbacks<span class="hl opt">.</span><span class="hl kwd">add_cached_srv_fn</span><span class="hl opt">(</span>context<span class="hl opt">,</span> ipc_srv<span class="hl opt">,</span>
                                                         server<span class="hl opt">,</span>
                                                         <span class="hl str">&quot;*IPC$&quot;</span><span class="hl opt">,</span>
                                                         workgroup<span class="hl opt">,</span>
                                                         username<span class="hl opt">)) {</span>
                        <span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">3</span><span class="hl opt">, (</span><span class="hl str">&quot; Failed to add server to cache</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
                        <span class="hl kwa">if</span> <span class="hl opt">(</span>errno <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
                                errno <span class="hl opt">=</span> ENOMEM<span class="hl opt">;</span>
                        <span class="hl opt">}</span>
                        <span class="hl kwd">cli_shutdown</span><span class="hl opt">(&amp;</span>ipc_srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">);</span>
                        <span class="hl kwd">free</span><span class="hl opt">(</span>ipc_srv<span class="hl opt">);</span>
                        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
                <span class="hl opt">}</span>

                <span class="hl kwd">DLIST_ADD</span><span class="hl opt">(</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_servers<span class="hl opt">,</span> ipc_srv<span class="hl opt">);</span>
        <span class="hl opt">}</span>

        <span class="hl kwa">return</span> ipc_srv<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * Routine to open() a file ...</span>
<span class="hl com"> */</span>

<span class="hl kwb">static</span> SMBCFILE <span class="hl opt">*</span><span class="hl kwd">smbc_open_ctx</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>fname<span class="hl opt">,</span> <span class="hl kwb">int</span> flags<span class="hl opt">,</span> mode_t mode<span class="hl opt">)</span>
<span class="hl opt">{</span>
	fstring server<span class="hl opt">,</span> share<span class="hl opt">,</span> user<span class="hl opt">,</span> password<span class="hl opt">,</span> workgroup<span class="hl opt">;</span>
	pstring path<span class="hl opt">;</span>
	SMBCSRV <span class="hl opt">*</span>srv   <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
	SMBCFILE <span class="hl opt">*</span>file <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
	<span class="hl kwb">int</span> fd<span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>context <span class="hl opt">|| !</span>context<span class="hl opt">-&gt;</span>internal <span class="hl opt">||</span>
	    <span class="hl opt">!</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_initialized<span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>  <span class="hl com">/* Best I can think of ... */</span>
		<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>fname<span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
		<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">smbc_parse_path</span><span class="hl opt">(</span>context<span class="hl opt">,</span> fname<span class="hl opt">,</span>
                            server<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>server<span class="hl opt">),</span>
                            share<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>share<span class="hl opt">),</span>
                            path<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>path<span class="hl opt">),</span>
                            user<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>user<span class="hl opt">),</span>
                            password<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>password<span class="hl opt">),</span>
                            NULL<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">)) {</span>
                errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
                <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
        <span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>user<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] == (</span><span class="hl kwb">char</span><span class="hl opt">)</span><span class="hl num">0</span><span class="hl opt">)</span> <span class="hl kwd">fstrcpy</span><span class="hl opt">(</span>user<span class="hl opt">,</span> context<span class="hl opt">-&gt;</span>user<span class="hl opt">);</span>

	<span class="hl kwd">fstrcpy</span><span class="hl opt">(</span>workgroup<span class="hl opt">,</span> context<span class="hl opt">-&gt;</span>workgroup<span class="hl opt">);</span>

	srv <span class="hl opt">=</span> <span class="hl kwd">smbc_server</span><span class="hl opt">(</span>context<span class="hl opt">,</span> server<span class="hl opt">,</span> share<span class="hl opt">,</span> workgroup<span class="hl opt">,</span> user<span class="hl opt">,</span> password<span class="hl opt">);</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>srv<span class="hl opt">) {</span>

		<span class="hl kwa">if</span> <span class="hl opt">(</span>errno <span class="hl opt">==</span> EPERM<span class="hl opt">)</span> errno <span class="hl opt">=</span> EACCES<span class="hl opt">;</span>
		<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>  <span class="hl com">/* smbc_server sets errno */</span>
    
	<span class="hl opt">}</span>

	<span class="hl com">/* Hmmm, the test for a directory is suspect here ... FIXME */</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">strlen</span><span class="hl opt">(</span>path<span class="hl opt">) &gt;</span> <span class="hl num">0</span> <span class="hl opt">&amp;&amp;</span> path<span class="hl opt">[</span><span class="hl kwd">strlen</span><span class="hl opt">(</span>path<span class="hl opt">) -</span> <span class="hl num">1</span><span class="hl opt">] ==</span> <span class="hl str">&#39;</span><span class="hl esc">\\</span><span class="hl str">&#39;</span><span class="hl opt">) {</span>
    
		fd <span class="hl opt">= -</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>
	<span class="hl kwa">else</span> <span class="hl opt">{</span>
	  
		file <span class="hl opt">=</span> <span class="hl kwd">SMB_MALLOC_P</span><span class="hl opt">(</span>SMBCFILE<span class="hl opt">);</span>

		<span class="hl kwa">if</span> <span class="hl opt">(!</span>file<span class="hl opt">) {</span>

			errno <span class="hl opt">=</span> ENOMEM<span class="hl opt">;</span>
			<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>

		<span class="hl opt">}</span>

		<span class="hl kwd">ZERO_STRUCTP</span><span class="hl opt">(</span>file<span class="hl opt">);</span>

		<span class="hl kwa">if</span> <span class="hl opt">((</span>fd <span class="hl opt">=</span> <span class="hl kwd">cli_open</span><span class="hl opt">(&amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> path<span class="hl opt">,</span> flags<span class="hl opt">,</span> DENY_NONE<span class="hl opt">)) &lt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>

			<span class="hl com">/* Handle the error ... */</span>

			<span class="hl kwd">SAFE_FREE</span><span class="hl opt">(</span>file<span class="hl opt">);</span>
			errno <span class="hl opt">=</span> <span class="hl kwd">smbc_errno</span><span class="hl opt">(</span>context<span class="hl opt">, &amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">);</span>
			<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>

		<span class="hl opt">}</span>

		<span class="hl com">/* Fill in file struct */</span>

		file<span class="hl opt">-&gt;</span>cli_fd  <span class="hl opt">=</span> fd<span class="hl opt">;</span>
		file<span class="hl opt">-&gt;</span>fname   <span class="hl opt">=</span> <span class="hl kwd">SMB_STRDUP</span><span class="hl opt">(</span>fname<span class="hl opt">);</span>
		file<span class="hl opt">-&gt;</span>srv     <span class="hl opt">=</span> srv<span class="hl opt">;</span>
		file<span class="hl opt">-&gt;</span>offset  <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
		file<span class="hl opt">-&gt;</span>file    <span class="hl opt">=</span> True<span class="hl opt">;</span>

		<span class="hl kwd">DLIST_ADD</span><span class="hl opt">(</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_files<span class="hl opt">,</span> file<span class="hl opt">);</span>

                <span class="hl com">/*</span>
<span class="hl com">                 * If the file was opened in O_APPEND mode, all write</span>
<span class="hl com">                 * operations should be appended to the file.  To do that,</span>
<span class="hl com">                 * though, using this protocol, would require a getattrE()</span>
<span class="hl com">                 * call for each and every write, to determine where the end</span>
<span class="hl com">                 * of the file is. (There does not appear to be an append flag</span>
<span class="hl com">                 * in the protocol.)  Rather than add all of that overhead of</span>
<span class="hl com">                 * retrieving the current end-of-file offset prior to each</span>
<span class="hl com">                 * write operation, we&#39;ll assume that most append operations</span>
<span class="hl com">                 * will continuously write, so we&#39;ll just set the offset to</span>
<span class="hl com">                 * the end of the file now and hope that&#39;s adequate.</span>
<span class="hl com">                 *</span>
<span class="hl com">                 * Note to self: If this proves inadequate, and O_APPEND</span>
<span class="hl com">                 * should, in some cases, be forced for each write, add a</span>
<span class="hl com">                 * field in the context options structure, for</span>
<span class="hl com">                 * &quot;strict_append_mode&quot; which would select between the current</span>
<span class="hl com">                 * behavior (if FALSE) or issuing a getattrE() prior to each</span>
<span class="hl com">                 * write and forcing the write to the end of the file (if</span>
<span class="hl com">                 * TRUE).  Adding that capability will likely require adding</span>
<span class="hl com">                 * an &quot;append&quot; flag into the _SMBCFILE structure to track</span>
<span class="hl com">                 * whether a file was opened in O_APPEND mode.  -- djl</span>
<span class="hl com">                 */</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>flags <span class="hl opt">&amp;</span> O_APPEND<span class="hl opt">) {</span>
                        <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">smbc_lseek_ctx</span><span class="hl opt">(</span>context<span class="hl opt">,</span> file<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> SEEK_END<span class="hl opt">) &lt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>
                                <span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">)</span> <span class="hl kwd">smbc_close_ctx</span><span class="hl opt">(</span>context<span class="hl opt">,</span> file<span class="hl opt">);</span>
                                errno <span class="hl opt">=</span> ENXIO<span class="hl opt">;</span>
                                <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
                        <span class="hl opt">}</span>
                <span class="hl opt">}</span>

		<span class="hl kwa">return</span> file<span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl com">/* Check if opendir needed ... */</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>fd <span class="hl opt">== -</span><span class="hl num">1</span><span class="hl opt">) {</span>
		<span class="hl kwb">int</span> eno <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>

		eno <span class="hl opt">=</span> <span class="hl kwd">smbc_errno</span><span class="hl opt">(</span>context<span class="hl opt">, &amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">);</span>
		file <span class="hl opt">=</span> context<span class="hl opt">-&gt;</span><span class="hl kwd">opendir</span><span class="hl opt">(</span>context<span class="hl opt">,</span> fname<span class="hl opt">);</span>
		<span class="hl kwa">if</span> <span class="hl opt">(!</span>file<span class="hl opt">)</span> errno <span class="hl opt">=</span> eno<span class="hl opt">;</span>
		<span class="hl kwa">return</span> file<span class="hl opt">;</span>

	<span class="hl opt">}</span>

	errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span> <span class="hl com">/* FIXME, correct errno ? */</span>
	<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>

<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * Routine to create a file </span>
<span class="hl com"> */</span>

<span class="hl kwb">static int</span> creat_bits <span class="hl opt">=</span> O_WRONLY <span class="hl opt">|</span> O_CREAT <span class="hl opt">|</span> O_TRUNC<span class="hl opt">;</span> <span class="hl com">/* FIXME: Do we need this */</span>

<span class="hl kwb">static</span> SMBCFILE <span class="hl opt">*</span><span class="hl kwd">smbc_creat_ctx</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>path<span class="hl opt">,</span> mode_t mode<span class="hl opt">)</span>
<span class="hl opt">{</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>context <span class="hl opt">|| !</span>context<span class="hl opt">-&gt;</span>internal <span class="hl opt">||</span>
	    <span class="hl opt">!</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_initialized<span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
		<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">return</span> <span class="hl kwd">smbc_open_ctx</span><span class="hl opt">(</span>context<span class="hl opt">,</span> path<span class="hl opt">,</span> creat_bits<span class="hl opt">,</span> mode<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * Routine to read() a file ...</span>
<span class="hl com"> */</span>

<span class="hl kwb">static</span> ssize_t <span class="hl kwd">smbc_read_ctx</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">,</span> SMBCFILE <span class="hl opt">*</span>file<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>buf<span class="hl opt">,</span> <span class="hl kwb">size_t</span> count<span class="hl opt">)</span>
<span class="hl opt">{</span>
	<span class="hl kwb">int</span> ret<span class="hl opt">;</span>

        <span class="hl com">/*</span>
<span class="hl com">         * offset:</span>
<span class="hl com">         *</span>
<span class="hl com">         * Compiler bug (possibly) -- gcc (GCC) 3.3.5 (Debian 1:3.3.5-2) --</span>
<span class="hl com">         * appears to pass file-&gt;offset (which is type off_t) differently than</span>
<span class="hl com">         * a local variable of type off_t.  Using local variable &quot;offset&quot; in</span>
<span class="hl com">         * the call to cli_read() instead of file-&gt;offset fixes a problem</span>
<span class="hl com">         * retrieving data at an offset greater than 4GB.</span>
<span class="hl com">         */</span>
        off_t offset <span class="hl opt">=</span> file<span class="hl opt">-&gt;</span>offset<span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>context <span class="hl opt">|| !</span>context<span class="hl opt">-&gt;</span>internal <span class="hl opt">||</span>
	    <span class="hl opt">!</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_initialized<span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">, (</span><span class="hl str">&quot;smbc_read(</span><span class="hl ipl">%p</span><span class="hl str">,</span> <span class="hl ipl">%d</span><span class="hl str">)</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> file<span class="hl opt">, (</span><span class="hl kwb">int</span><span class="hl opt">)</span>count<span class="hl opt">));</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>file <span class="hl opt">|| !</span><span class="hl kwd">DLIST_CONTAINS</span><span class="hl opt">(</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_files<span class="hl opt">,</span> file<span class="hl opt">)) {</span>

		errno <span class="hl opt">=</span> EBADF<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl com">/* Check that the buffer exists ... */</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>buf <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	ret <span class="hl opt">=</span> <span class="hl kwd">cli_read</span><span class="hl opt">(&amp;</span>file<span class="hl opt">-&gt;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> file<span class="hl opt">-&gt;</span>cli_fd<span class="hl opt">,</span> buf<span class="hl opt">,</span> offset<span class="hl opt">,</span> count<span class="hl opt">);</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>ret <span class="hl opt">&lt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> <span class="hl kwd">smbc_errno</span><span class="hl opt">(</span>context<span class="hl opt">, &amp;</span>file<span class="hl opt">-&gt;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">);</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	file<span class="hl opt">-&gt;</span>offset <span class="hl opt">+=</span> ret<span class="hl opt">;</span>

	<span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">, (</span><span class="hl str">&quot;  --&gt;</span> <span class="hl ipl">%d</span><span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> ret<span class="hl opt">));</span>

	<span class="hl kwa">return</span> ret<span class="hl opt">;</span>  <span class="hl com">/* Success, ret bytes of data ... */</span>

<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * Routine to write() a file ...</span>
<span class="hl com"> */</span>

<span class="hl kwb">static</span> ssize_t <span class="hl kwd">smbc_write_ctx</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">,</span> SMBCFILE <span class="hl opt">*</span>file<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>buf<span class="hl opt">,</span> <span class="hl kwb">size_t</span> count<span class="hl opt">)</span>
<span class="hl opt">{</span>
	<span class="hl kwb">int</span> ret<span class="hl opt">;</span>
        off_t offset <span class="hl opt">=</span> file<span class="hl opt">-&gt;</span>offset<span class="hl opt">;</span> <span class="hl com">/* See &quot;offset&quot; comment in smbc_read_ctx() */</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>context <span class="hl opt">|| !</span>context<span class="hl opt">-&gt;</span>internal <span class="hl opt">||</span>
	    <span class="hl opt">!</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_initialized<span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>file <span class="hl opt">|| !</span><span class="hl kwd">DLIST_CONTAINS</span><span class="hl opt">(</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_files<span class="hl opt">,</span> file<span class="hl opt">)) {</span>

		errno <span class="hl opt">=</span> EBADF<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>
    
	<span class="hl opt">}</span>

	<span class="hl com">/* Check that the buffer exists ... */</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>buf <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	ret <span class="hl opt">=</span> <span class="hl kwd">cli_write</span><span class="hl opt">(&amp;</span>file<span class="hl opt">-&gt;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> file<span class="hl opt">-&gt;</span>cli_fd<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> buf<span class="hl opt">,</span> offset<span class="hl opt">,</span> count<span class="hl opt">);</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>ret <span class="hl opt">&lt;=</span> <span class="hl num">0</span><span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> <span class="hl kwd">smbc_errno</span><span class="hl opt">(</span>context<span class="hl opt">, &amp;</span>file<span class="hl opt">-&gt;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">);</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	file<span class="hl opt">-&gt;</span>offset <span class="hl opt">+=</span> ret<span class="hl opt">;</span>

	<span class="hl kwa">return</span> ret<span class="hl opt">;</span>  <span class="hl com">/* Success, 0 bytes of data ... */</span>
<span class="hl opt">}</span>
 
<span class="hl com">/*</span>
<span class="hl com"> * Routine to close() a file ...</span>
<span class="hl com"> */</span>

<span class="hl kwb">static int</span> <span class="hl kwd">smbc_close_ctx</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">,</span> SMBCFILE <span class="hl opt">*</span>file<span class="hl opt">)</span>
<span class="hl opt">{</span>
        SMBCSRV <span class="hl opt">*</span>srv<span class="hl opt">;</span> 

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>context <span class="hl opt">|| !</span>context<span class="hl opt">-&gt;</span>internal <span class="hl opt">||</span>
	    <span class="hl opt">!</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_initialized<span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>file <span class="hl opt">|| !</span><span class="hl kwd">DLIST_CONTAINS</span><span class="hl opt">(</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_files<span class="hl opt">,</span> file<span class="hl opt">)) {</span>
   
		errno <span class="hl opt">=</span> EBADF<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl com">/* IS a dir ... */</span>
	<span class="hl kwa">if</span> <span class="hl opt">(!</span>file<span class="hl opt">-&gt;</span>file<span class="hl opt">) {</span>
		
		<span class="hl kwa">return</span> context<span class="hl opt">-&gt;</span><span class="hl kwd">closedir</span><span class="hl opt">(</span>context<span class="hl opt">,</span> file<span class="hl opt">);</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">cli_close</span><span class="hl opt">(&amp;</span>file<span class="hl opt">-&gt;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> file<span class="hl opt">-&gt;</span>cli_fd<span class="hl opt">)) {</span>

		<span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">3</span><span class="hl opt">, (</span><span class="hl str">&quot;cli_close failed on</span> <span class="hl ipl">%s</span><span class="hl str">. purging server.</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> 
			  file<span class="hl opt">-&gt;</span>fname<span class="hl opt">));</span>
		<span class="hl com">/* Deallocate slot and remove the server </span>
<span class="hl com">		 * from the server cache if unused */</span>
		errno <span class="hl opt">=</span> <span class="hl kwd">smbc_errno</span><span class="hl opt">(</span>context<span class="hl opt">, &amp;</span>file<span class="hl opt">-&gt;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">);</span>  
		srv <span class="hl opt">=</span> file<span class="hl opt">-&gt;</span>srv<span class="hl opt">;</span>
		<span class="hl kwd">DLIST_REMOVE</span><span class="hl opt">(</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_files<span class="hl opt">,</span> file<span class="hl opt">);</span>
		<span class="hl kwd">SAFE_FREE</span><span class="hl opt">(</span>file<span class="hl opt">-&gt;</span>fname<span class="hl opt">);</span>
		<span class="hl kwd">SAFE_FREE</span><span class="hl opt">(</span>file<span class="hl opt">);</span>
		context<span class="hl opt">-&gt;</span>callbacks<span class="hl opt">.</span><span class="hl kwd">remove_unused_server_fn</span><span class="hl opt">(</span>context<span class="hl opt">,</span> srv<span class="hl opt">);</span>

		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwd">DLIST_REMOVE</span><span class="hl opt">(</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_files<span class="hl opt">,</span> file<span class="hl opt">);</span>
	<span class="hl kwd">SAFE_FREE</span><span class="hl opt">(</span>file<span class="hl opt">-&gt;</span>fname<span class="hl opt">);</span>
	<span class="hl kwd">SAFE_FREE</span><span class="hl opt">(</span>file<span class="hl opt">);</span>

	<span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * Get info from an SMB server on a file. Use a qpathinfo call first</span>
<span class="hl com"> * and if that fails, use getatr, as Win95 sometimes refuses qpathinfo</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> BOOL <span class="hl kwd">smbc_getatr</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span> context<span class="hl opt">,</span> SMBCSRV <span class="hl opt">*</span>srv<span class="hl opt">,</span> <span class="hl kwb">char</span> <span class="hl opt">*</span>path<span class="hl opt">,</span> 
		 uint16 <span class="hl opt">*</span>mode<span class="hl opt">,</span> SMB_OFF_T <span class="hl opt">*</span>size<span class="hl opt">,</span> 
		 <span class="hl kwb">time_t</span> <span class="hl opt">*</span>c_time<span class="hl opt">,</span> <span class="hl kwb">time_t</span> <span class="hl opt">*</span>a_time<span class="hl opt">,</span> <span class="hl kwb">time_t</span> <span class="hl opt">*</span>m_time<span class="hl opt">,</span>
		 SMB_INO_T <span class="hl opt">*</span>ino<span class="hl opt">)</span>
<span class="hl opt">{</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>context <span class="hl opt">|| !</span>context<span class="hl opt">-&gt;</span>internal <span class="hl opt">||</span>
	    <span class="hl opt">!</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_initialized<span class="hl opt">) {</span>
 
		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
 		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>
 
 	<span class="hl opt">}</span>

	<span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">,(</span><span class="hl str">&quot;smbc_getatr: sending qpathinfo</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
  
	<span class="hl kwa">if</span> <span class="hl opt">(!</span>srv<span class="hl opt">-&gt;</span>no_pathinfo2 <span class="hl opt">&amp;&amp;</span>
	    <span class="hl kwd">cli_qpathinfo2</span><span class="hl opt">(&amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> path<span class="hl opt">,</span> c_time<span class="hl opt">,</span> a_time<span class="hl opt">,</span> m_time<span class="hl opt">,</span> NULL<span class="hl opt">,</span>
			   size<span class="hl opt">,</span> mode<span class="hl opt">,</span> ino<span class="hl opt">))</span> <span class="hl kwa">return</span> True<span class="hl opt">;</span>

	<span class="hl com">/* if this is NT then don&#39;t bother with the getatr */</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">.</span>capabilities <span class="hl opt">&amp;</span> CAP_NT_SMBS<span class="hl opt">) {</span>
                errno <span class="hl opt">=</span> EPERM<span class="hl opt">;</span>
                <span class="hl kwa">return</span> False<span class="hl opt">;</span>
        <span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">cli_getatr</span><span class="hl opt">(&amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> path<span class="hl opt">,</span> mode<span class="hl opt">,</span> size<span class="hl opt">,</span> m_time<span class="hl opt">)) {</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>m_time <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
                        <span class="hl kwa">if</span> <span class="hl opt">(</span>a_time <span class="hl opt">!=</span> NULL<span class="hl opt">) *</span>a_time <span class="hl opt">= *</span>m_time<span class="hl opt">;</span>
                        <span class="hl kwa">if</span> <span class="hl opt">(</span>c_time <span class="hl opt">!=</span> NULL<span class="hl opt">) *</span>c_time <span class="hl opt">= *</span>m_time<span class="hl opt">;</span>
                <span class="hl opt">}</span>
		srv<span class="hl opt">-&gt;</span>no_pathinfo2 <span class="hl opt">=</span> True<span class="hl opt">;</span>
		<span class="hl kwa">return</span> True<span class="hl opt">;</span>
	<span class="hl opt">}</span>

        errno <span class="hl opt">=</span> EPERM<span class="hl opt">;</span>
	<span class="hl kwa">return</span> False<span class="hl opt">;</span>

<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * Set file info on an SMB server.  Use setpathinfo call first.  If that</span>
<span class="hl com"> * fails, use setattrE..</span>
<span class="hl com"> *</span>
<span class="hl com"> * Access and modification time parameters are always used and must be</span>
<span class="hl com"> * provided.  Create time, if zero, will be determined from the actual create</span>
<span class="hl com"> * time of the file.  If non-zero, the create time will be set as well.</span>
<span class="hl com"> *</span>
<span class="hl com"> * &quot;mode&quot; (attributes) parameter may be set to -1 if it is not to be set.</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> BOOL <span class="hl kwd">smbc_setatr</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span> context<span class="hl opt">,</span> SMBCSRV <span class="hl opt">*</span>srv<span class="hl opt">,</span> <span class="hl kwb">char</span> <span class="hl opt">*</span>path<span class="hl opt">,</span> 
                        <span class="hl kwb">time_t</span> c_time<span class="hl opt">,</span> <span class="hl kwb">time_t</span> a_time<span class="hl opt">,</span> <span class="hl kwb">time_t</span> m_time<span class="hl opt">,</span>
                        uint16 mode<span class="hl opt">)</span>
<span class="hl opt">{</span>
        <span class="hl kwb">int</span> fd<span class="hl opt">;</span>
        <span class="hl kwb">int</span> ret<span class="hl opt">;</span>

        <span class="hl com">/*</span>
<span class="hl com">         * Get the create time of the file (if not provided); we&#39;ll need it in</span>
<span class="hl com">         * the set call.</span>
<span class="hl com">         */</span>
        <span class="hl kwa">if</span> <span class="hl opt">(!</span> srv<span class="hl opt">-&gt;</span>no_pathinfo <span class="hl opt">&amp;&amp;</span> c_time <span class="hl opt">!=</span> <span class="hl num">0</span><span class="hl opt">) {</span>
                <span class="hl kwa">if</span> <span class="hl opt">(!</span> <span class="hl kwd">cli_qpathinfo</span><span class="hl opt">(&amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> path<span class="hl opt">,</span>
                                    <span class="hl opt">&amp;</span>c_time<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">)) {</span>
                        <span class="hl com">/* qpathinfo not available */</span>
                        srv<span class="hl opt">-&gt;</span>no_pathinfo <span class="hl opt">=</span> True<span class="hl opt">;</span>
                <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
                        <span class="hl com">/*</span>
<span class="hl com">                         * We got a creation time.  For sanity sake, since</span>
<span class="hl com">                         * there is no POSIX function to set the create time</span>
<span class="hl com">                         * of a file, if the existing create time is greater</span>
<span class="hl com">                         * than either of access time or modification time,</span>
<span class="hl com">                         * set create time to the smallest of those.  This</span>
<span class="hl com">                         * ensure that the create time of a file is never</span>
<span class="hl com">                         * greater than its last access or modification time.</span>
<span class="hl com">                         */</span>
                        <span class="hl kwa">if</span> <span class="hl opt">(</span>c_time <span class="hl opt">&gt;</span> a_time<span class="hl opt">)</span> c_time <span class="hl opt">=</span> a_time<span class="hl opt">;</span>
                        <span class="hl kwa">if</span> <span class="hl opt">(</span>c_time <span class="hl opt">&gt;</span> m_time<span class="hl opt">)</span> c_time <span class="hl opt">=</span> m_time<span class="hl opt">;</span>
                <span class="hl opt">}</span>
        <span class="hl opt">}</span>

        <span class="hl com">/*</span>
<span class="hl com">         * First, try setpathinfo (if qpathinfo succeeded), for it is the</span>
<span class="hl com">         * modern function for &quot;new code&quot; to be using, and it works given a</span>
<span class="hl com">         * filename rather than requiring that the file be opened to have its</span>
<span class="hl com">         * attributes manipulated.</span>
<span class="hl com">         */</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>srv<span class="hl opt">-&gt;</span>no_pathinfo <span class="hl opt">||</span>
            <span class="hl opt">!</span> <span class="hl kwd">cli_setpathinfo</span><span class="hl opt">(&amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> path<span class="hl opt">,</span> c_time<span class="hl opt">,</span> a_time<span class="hl opt">,</span> m_time<span class="hl opt">,</span> mode<span class="hl opt">)) {</span>

                <span class="hl com">/*</span>
<span class="hl com">                 * setpathinfo is not supported; go to plan B. </span>
<span class="hl com">                 *</span>
<span class="hl com">                 * cli_setatr() does not work on win98, and it also doesn&#39;t</span>
<span class="hl com">                 * support setting the access time (only the modification</span>
<span class="hl com">                 * time), so in all cases, we open the specified file and use</span>
<span class="hl com">                 * cli_setattrE() which should work on all OS versions, and</span>
<span class="hl com">                 * supports both times.</span>
<span class="hl com">                 */</span>

                <span class="hl com">/* Don&#39;t try {q,set}pathinfo() again, with this server */</span>
                srv<span class="hl opt">-&gt;</span>no_pathinfo <span class="hl opt">=</span> True<span class="hl opt">;</span>

                <span class="hl com">/* Open the file */</span>
                <span class="hl kwa">if</span> <span class="hl opt">((</span>fd <span class="hl opt">=</span> <span class="hl kwd">cli_open</span><span class="hl opt">(&amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> path<span class="hl opt">,</span> O_RDWR<span class="hl opt">,</span> DENY_NONE<span class="hl opt">)) &lt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>

                        errno <span class="hl opt">=</span> <span class="hl kwd">smbc_errno</span><span class="hl opt">(</span>context<span class="hl opt">, &amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">);</span>
                        <span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>
                <span class="hl opt">}</span>

                <span class="hl com">/*</span>
<span class="hl com">                 * Get the creat time of the file (if it wasn&#39;t provided).</span>
<span class="hl com">                 * We&#39;ll need it in the set call</span>
<span class="hl com">                 */</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>c_time <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
                        ret <span class="hl opt">=</span> <span class="hl kwd">cli_getattrE</span><span class="hl opt">(&amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> fd<span class="hl opt">,</span>
                                           NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span>
                                           <span class="hl opt">&amp;</span>c_time<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
                <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
                        ret <span class="hl opt">=</span> True<span class="hl opt">;</span>
                <span class="hl opt">}</span>
                    
                <span class="hl com">/* If we got create time, set times */</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>ret<span class="hl opt">) {</span>
                        <span class="hl com">/* Some OS versions don&#39;t support create time */</span>
                        <span class="hl kwa">if</span> <span class="hl opt">(</span>c_time <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
                                c_time <span class="hl opt">=</span> <span class="hl kwd">time</span><span class="hl opt">(</span>NULL<span class="hl opt">);</span>
                        <span class="hl opt">}</span>

                        <span class="hl com">/*</span>
<span class="hl com">                         * For sanity sake, since there is no POSIX function</span>
<span class="hl com">                         * to set the create time of a file, if the existing</span>
<span class="hl com">                         * create time is greater than either of access time</span>
<span class="hl com">                         * or modification time, set create time to the</span>
<span class="hl com">                         * smallest of those.  This ensure that the create</span>
<span class="hl com">                         * time of a file is never greater than its last</span>
<span class="hl com">                         * access or modification time.</span>
<span class="hl com">                         */</span>
                        <span class="hl kwa">if</span> <span class="hl opt">(</span>c_time <span class="hl opt">&gt;</span> a_time<span class="hl opt">)</span> c_time <span class="hl opt">=</span> a_time<span class="hl opt">;</span>
                        <span class="hl kwa">if</span> <span class="hl opt">(</span>c_time <span class="hl opt">&gt;</span> m_time<span class="hl opt">)</span> c_time <span class="hl opt">=</span> m_time<span class="hl opt">;</span>
                        
                        <span class="hl com">/* Set the new attributes */</span>
                        ret <span class="hl opt">=</span> <span class="hl kwd">cli_setattrE</span><span class="hl opt">(&amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> fd<span class="hl opt">,</span>
                                           c_time<span class="hl opt">,</span> a_time<span class="hl opt">,</span> m_time<span class="hl opt">);</span>
                        <span class="hl kwd">cli_close</span><span class="hl opt">(&amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> fd<span class="hl opt">);</span>
                <span class="hl opt">}</span>

                <span class="hl com">/*</span>
<span class="hl com">                 * Unfortunately, setattrE() doesn&#39;t have a provision for</span>
<span class="hl com">                 * setting the access mode (attributes).  We&#39;ll have to try</span>
<span class="hl com">                 * cli_setatr() for that, and with only this parameter, it</span>
<span class="hl com">                 * seems to work on win98.</span>
<span class="hl com">                 */</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>ret <span class="hl opt">&amp;&amp;</span> mode <span class="hl opt">!= (</span>uint16<span class="hl opt">) -</span><span class="hl num">1</span><span class="hl opt">) {</span>
                        ret <span class="hl opt">=</span> <span class="hl kwd">cli_setatr</span><span class="hl opt">(&amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> path<span class="hl opt">,</span> mode<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">);</span>
                <span class="hl opt">}</span>

                <span class="hl kwa">if</span> <span class="hl opt">(!</span> ret<span class="hl opt">) {</span>
                        errno <span class="hl opt">=</span> <span class="hl kwd">smbc_errno</span><span class="hl opt">(</span>context<span class="hl opt">, &amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">);</span>
                        <span class="hl kwa">return</span> False<span class="hl opt">;</span>
                <span class="hl opt">}</span>
        <span class="hl opt">}</span>

        <span class="hl kwa">return</span> True<span class="hl opt">;</span>
<span class="hl opt">}</span>

 <span class="hl com">/*</span>
<span class="hl com">  * Routine to unlink() a file</span>
<span class="hl com">  */</span>

 <span class="hl kwb">static int</span> <span class="hl kwd">smbc_unlink_ctx</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>fname<span class="hl opt">)</span>
<span class="hl opt">{</span>
	fstring server<span class="hl opt">,</span> share<span class="hl opt">,</span> user<span class="hl opt">,</span> password<span class="hl opt">,</span> workgroup<span class="hl opt">;</span>
	pstring path<span class="hl opt">;</span>
	SMBCSRV <span class="hl opt">*</span>srv <span class="hl opt">=</span> NULL<span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>context <span class="hl opt">|| !</span>context<span class="hl opt">-&gt;</span>internal <span class="hl opt">||</span>
	    <span class="hl opt">!</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_initialized<span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>  <span class="hl com">/* Best I can think of ... */</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>fname<span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">smbc_parse_path</span><span class="hl opt">(</span>context<span class="hl opt">,</span> fname<span class="hl opt">,</span>
                            server<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>server<span class="hl opt">),</span>
                            share<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>share<span class="hl opt">),</span>
                            path<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>path<span class="hl opt">),</span>
                            user<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>user<span class="hl opt">),</span>
                            password<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>password<span class="hl opt">),</span>
                            NULL<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">)) {</span>
                errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
                <span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>
        <span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>user<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] == (</span><span class="hl kwb">char</span><span class="hl opt">)</span><span class="hl num">0</span><span class="hl opt">)</span> <span class="hl kwd">fstrcpy</span><span class="hl opt">(</span>user<span class="hl opt">,</span> context<span class="hl opt">-&gt;</span>user<span class="hl opt">);</span>

	<span class="hl kwd">fstrcpy</span><span class="hl opt">(</span>workgroup<span class="hl opt">,</span> context<span class="hl opt">-&gt;</span>workgroup<span class="hl opt">);</span>

	srv <span class="hl opt">=</span> <span class="hl kwd">smbc_server</span><span class="hl opt">(</span>context<span class="hl opt">,</span> server<span class="hl opt">,</span> share<span class="hl opt">,</span> workgroup<span class="hl opt">,</span> user<span class="hl opt">,</span> password<span class="hl opt">);</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>srv<span class="hl opt">) {</span>

		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>  <span class="hl com">/* smbc_server sets errno */</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">cli_unlink</span><span class="hl opt">(&amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> path<span class="hl opt">)) {</span>

		errno <span class="hl opt">=</span> <span class="hl kwd">smbc_errno</span><span class="hl opt">(</span>context<span class="hl opt">, &amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">);</span>

		<span class="hl kwa">if</span> <span class="hl opt">(</span>errno <span class="hl opt">==</span> EACCES<span class="hl opt">) {</span> <span class="hl com">/* Check if the file is a directory */</span>

			<span class="hl kwb">int</span> saverr <span class="hl opt">=</span> errno<span class="hl opt">;</span>
			SMB_OFF_T size <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
			uint16 mode <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
			<span class="hl kwb">time_t</span> m_time <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">,</span> a_time <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">,</span> c_time <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
			SMB_INO_T ino <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>

			<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">smbc_getatr</span><span class="hl opt">(</span>context<span class="hl opt">,</span> srv<span class="hl opt">,</span> path<span class="hl opt">, &amp;</span>mode<span class="hl opt">, &amp;</span>size<span class="hl opt">,</span>
					 <span class="hl opt">&amp;</span>c_time<span class="hl opt">, &amp;</span>a_time<span class="hl opt">, &amp;</span>m_time<span class="hl opt">, &amp;</span>ino<span class="hl opt">)) {</span>

				<span class="hl com">/* Hmmm, bad error ... What? */</span>

				errno <span class="hl opt">=</span> <span class="hl kwd">smbc_errno</span><span class="hl opt">(</span>context<span class="hl opt">, &amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">);</span>
				<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

			<span class="hl opt">}</span>
			<span class="hl kwa">else</span> <span class="hl opt">{</span>

				<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">IS_DOS_DIR</span><span class="hl opt">(</span>mode<span class="hl opt">))</span>
					errno <span class="hl opt">=</span> EISDIR<span class="hl opt">;</span>
				<span class="hl kwa">else</span>
					errno <span class="hl opt">=</span> saverr<span class="hl opt">;</span>  <span class="hl com">/* Restore this */</span>

			<span class="hl opt">}</span>
		<span class="hl opt">}</span>

		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>  <span class="hl com">/* Success ... */</span>

<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * Routine to rename() a file</span>
<span class="hl com"> */</span>

<span class="hl kwb">static int</span> <span class="hl kwd">smbc_rename_ctx</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>ocontext<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>oname<span class="hl opt">,</span> 
			   SMBCCTX <span class="hl opt">*</span>ncontext<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>nname<span class="hl opt">)</span>
<span class="hl opt">{</span>
	fstring server1<span class="hl opt">,</span> share1<span class="hl opt">,</span> server2<span class="hl opt">,</span> share2<span class="hl opt">,</span> user1<span class="hl opt">,</span> user2<span class="hl opt">,</span> password1<span class="hl opt">,</span> password2<span class="hl opt">,</span> workgroup<span class="hl opt">;</span>
	pstring path1<span class="hl opt">,</span> path2<span class="hl opt">;</span>
	SMBCSRV <span class="hl opt">*</span>srv <span class="hl opt">=</span> NULL<span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>ocontext <span class="hl opt">|| !</span>ncontext <span class="hl opt">||</span> 
	    <span class="hl opt">!</span>ocontext<span class="hl opt">-&gt;</span>internal <span class="hl opt">|| !</span>ncontext<span class="hl opt">-&gt;</span>internal <span class="hl opt">||</span>
	    <span class="hl opt">!</span>ocontext<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_initialized <span class="hl opt">||</span> 
	    <span class="hl opt">!</span>ncontext<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_initialized<span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>  <span class="hl com">/* Best I can think of ... */</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>
	
	<span class="hl kwa">if</span> <span class="hl opt">(!</span>oname <span class="hl opt">|| !</span>nname<span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>
	
	<span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">, (</span><span class="hl str">&quot;smbc_rename(</span><span class="hl ipl">%s</span><span class="hl str">,</span><span class="hl ipl">%s</span><span class="hl str">)</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> oname<span class="hl opt">,</span> nname<span class="hl opt">));</span>

	<span class="hl kwd">smbc_parse_path</span><span class="hl opt">(</span>ocontext<span class="hl opt">,</span> oname<span class="hl opt">,</span>
                        server1<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>server1<span class="hl opt">),</span>
                        share1<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>share1<span class="hl opt">),</span>
                        path1<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>path1<span class="hl opt">),</span>
                        user1<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>user1<span class="hl opt">),</span>
                        password1<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>password1<span class="hl opt">),</span>
                        NULL<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">);</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>user1<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] == (</span><span class="hl kwb">char</span><span class="hl opt">)</span><span class="hl num">0</span><span class="hl opt">)</span> <span class="hl kwd">fstrcpy</span><span class="hl opt">(</span>user1<span class="hl opt">,</span> ocontext<span class="hl opt">-&gt;</span>user<span class="hl opt">);</span>

	<span class="hl kwd">smbc_parse_path</span><span class="hl opt">(</span>ncontext<span class="hl opt">,</span> nname<span class="hl opt">,</span>
                        server2<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>server2<span class="hl opt">),</span>
                        share2<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>share2<span class="hl opt">),</span>
                        path2<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>path2<span class="hl opt">),</span>
                        user2<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>user2<span class="hl opt">),</span>
                        password2<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>password2<span class="hl opt">),</span>
                        NULL<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">);</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>user2<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] == (</span><span class="hl kwb">char</span><span class="hl opt">)</span><span class="hl num">0</span><span class="hl opt">)</span> <span class="hl kwd">fstrcpy</span><span class="hl opt">(</span>user2<span class="hl opt">,</span> ncontext<span class="hl opt">-&gt;</span>user<span class="hl opt">);</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">strcmp</span><span class="hl opt">(</span>server1<span class="hl opt">,</span> server2<span class="hl opt">) ||</span> <span class="hl kwd">strcmp</span><span class="hl opt">(</span>share1<span class="hl opt">,</span> share2<span class="hl opt">) ||</span>
	    <span class="hl kwd">strcmp</span><span class="hl opt">(</span>user1<span class="hl opt">,</span> user2<span class="hl opt">)) {</span>

		<span class="hl com">/* Can&#39;t rename across file systems, or users?? */</span>

		errno <span class="hl opt">=</span> EXDEV<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwd">fstrcpy</span><span class="hl opt">(</span>workgroup<span class="hl opt">,</span> ocontext<span class="hl opt">-&gt;</span>workgroup<span class="hl opt">);</span>
	<span class="hl com">/* HELP !!! Which workgroup should I use ? Or are they always the same -- Tom */</span> 
	srv <span class="hl opt">=</span> <span class="hl kwd">smbc_server</span><span class="hl opt">(</span>ocontext<span class="hl opt">,</span> server1<span class="hl opt">,</span> share1<span class="hl opt">,</span> workgroup<span class="hl opt">,</span> user1<span class="hl opt">,</span> password1<span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(!</span>srv<span class="hl opt">) {</span>

		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">cli_rename</span><span class="hl opt">(&amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> path1<span class="hl opt">,</span> path2<span class="hl opt">)) {</span>
		<span class="hl kwb">int</span> eno <span class="hl opt">=</span> <span class="hl kwd">smbc_errno</span><span class="hl opt">(</span>ocontext<span class="hl opt">, &amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">);</span>

		<span class="hl kwa">if</span> <span class="hl opt">(</span>eno <span class="hl opt">!=</span> EEXIST <span class="hl opt">||</span>
		    <span class="hl opt">!</span><span class="hl kwd">cli_unlink</span><span class="hl opt">(&amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> path2<span class="hl opt">) ||</span>
		    <span class="hl opt">!</span><span class="hl kwd">cli_rename</span><span class="hl opt">(&amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> path1<span class="hl opt">,</span> path2<span class="hl opt">)) {</span>

			errno <span class="hl opt">=</span> eno<span class="hl opt">;</span>
			<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

		<span class="hl opt">}</span>
	<span class="hl opt">}</span>

	<span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span> <span class="hl com">/* Success */</span>

<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * A routine to lseek() a file</span>
<span class="hl com"> */</span>

<span class="hl kwb">static</span> off_t <span class="hl kwd">smbc_lseek_ctx</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">,</span> SMBCFILE <span class="hl opt">*</span>file<span class="hl opt">,</span> off_t offset<span class="hl opt">,</span> <span class="hl kwb">int</span> whence<span class="hl opt">)</span>
<span class="hl opt">{</span>
	SMB_OFF_T size<span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>context <span class="hl opt">|| !</span>context<span class="hl opt">-&gt;</span>internal <span class="hl opt">||</span>
	    <span class="hl opt">!</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_initialized<span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>
		
	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>file <span class="hl opt">|| !</span><span class="hl kwd">DLIST_CONTAINS</span><span class="hl opt">(</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_files<span class="hl opt">,</span> file<span class="hl opt">)) {</span>

		errno <span class="hl opt">=</span> EBADF<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>file<span class="hl opt">-&gt;</span>file<span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>      <span class="hl com">/* Can&#39;t lseek a dir ... */</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">switch</span> <span class="hl opt">(</span>whence<span class="hl opt">) {</span>
	<span class="hl kwa">case</span> SEEK_SET<span class="hl opt">:</span>
		file<span class="hl opt">-&gt;</span>offset <span class="hl opt">=</span> offset<span class="hl opt">;</span>
		<span class="hl kwa">break</span><span class="hl opt">;</span>

	<span class="hl kwa">case</span> SEEK_CUR<span class="hl opt">:</span>
		file<span class="hl opt">-&gt;</span>offset <span class="hl opt">+=</span> offset<span class="hl opt">;</span>
		<span class="hl kwa">break</span><span class="hl opt">;</span>

	<span class="hl kwa">case</span> SEEK_END<span class="hl opt">:</span>
		<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">cli_qfileinfo</span><span class="hl opt">(&amp;</span>file<span class="hl opt">-&gt;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> file<span class="hl opt">-&gt;</span>cli_fd<span class="hl opt">,</span> NULL<span class="hl opt">, &amp;</span>size<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span>
				   NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">))</span> 
		<span class="hl opt">{</span>
		    SMB_BIG_UINT b_size <span class="hl opt">=</span> size<span class="hl opt">;</span>
		    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">cli_getattrE</span><span class="hl opt">(&amp;</span>file<span class="hl opt">-&gt;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> file<span class="hl opt">-&gt;</span>cli_fd<span class="hl opt">,</span> NULL<span class="hl opt">, &amp;</span>b_size<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span>
				      NULL<span class="hl opt">))</span> 
		    <span class="hl opt">{</span>
			errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
			<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>
		    <span class="hl opt">}</span> <span class="hl kwa">else</span>
			size <span class="hl opt">=</span> b_size<span class="hl opt">;</span>
		<span class="hl opt">}</span>
		file<span class="hl opt">-&gt;</span>offset <span class="hl opt">=</span> size <span class="hl opt">+</span> offset<span class="hl opt">;</span>
		<span class="hl kwa">break</span><span class="hl opt">;</span>

	<span class="hl kwa">default</span><span class="hl opt">:</span>
		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
		<span class="hl kwa">break</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">return</span> file<span class="hl opt">-&gt;</span>offset<span class="hl opt">;</span>

<span class="hl opt">}</span>

<span class="hl com">/* </span>
<span class="hl com"> * Generate an inode number from file name for those things that need it</span>
<span class="hl com"> */</span>

<span class="hl kwb">static</span>
ino_t <span class="hl kwd">smbc_inode</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">)</span>
<span class="hl opt">{</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>context <span class="hl opt">|| !</span>context<span class="hl opt">-&gt;</span>internal <span class="hl opt">||</span>
	    <span class="hl opt">!</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_initialized<span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!*</span>name<span class="hl opt">)</span> <span class="hl kwa">return</span> <span class="hl num">2</span><span class="hl opt">;</span> <span class="hl com">/* FIXME, why 2 ??? */</span>
	<span class="hl kwa">return</span> <span class="hl opt">(</span>ino_t<span class="hl opt">)</span><span class="hl kwd">str_checksum</span><span class="hl opt">(</span>name<span class="hl opt">);</span>

<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * Routine to put basic stat info into a stat structure ... Used by stat and</span>
<span class="hl com"> * fstat below.</span>
<span class="hl com"> */</span>

<span class="hl kwb">static</span>
<span class="hl kwb">int</span> <span class="hl kwd">smbc_setup_stat</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">,</span> <span class="hl kwb">struct</span> stat <span class="hl opt">*</span>st<span class="hl opt">,</span> <span class="hl kwb">char</span> <span class="hl opt">*</span>fname<span class="hl opt">,</span>
                    SMB_OFF_T size<span class="hl opt">,</span> <span class="hl kwb">int</span> mode<span class="hl opt">)</span>
<span class="hl opt">{</span>
	
	st<span class="hl opt">-&gt;</span>st_mode <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">IS_DOS_DIR</span><span class="hl opt">(</span>mode<span class="hl opt">)) {</span>
		st<span class="hl opt">-&gt;</span>st_mode <span class="hl opt">=</span> SMBC_DIR_MODE<span class="hl opt">;</span>
	<span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
		st<span class="hl opt">-&gt;</span>st_mode <span class="hl opt">=</span> SMBC_FILE_MODE<span class="hl opt">;</span>
	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">IS_DOS_ARCHIVE</span><span class="hl opt">(</span>mode<span class="hl opt">))</span> st<span class="hl opt">-&gt;</span>st_mode <span class="hl opt">|=</span> S_IXUSR<span class="hl opt">;</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">IS_DOS_SYSTEM</span><span class="hl opt">(</span>mode<span class="hl opt">))</span> st<span class="hl opt">-&gt;</span>st_mode <span class="hl opt">|=</span> S_IXGRP<span class="hl opt">;</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">IS_DOS_HIDDEN</span><span class="hl opt">(</span>mode<span class="hl opt">))</span> st<span class="hl opt">-&gt;</span>st_mode <span class="hl opt">|=</span> S_IXOTH<span class="hl opt">;</span>
	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">IS_DOS_READONLY</span><span class="hl opt">(</span>mode<span class="hl opt">))</span> st<span class="hl opt">-&gt;</span>st_mode <span class="hl opt">|=</span> S_IWUSR<span class="hl opt">;</span>

	st<span class="hl opt">-&gt;</span>st_size <span class="hl opt">=</span> size<span class="hl opt">;</span>
<span class="hl ppc">#ifdef HAVE_STAT_ST_BLKSIZE</span>
	st<span class="hl opt">-&gt;</span>st_blksize <span class="hl opt">=</span> <span class="hl num">512</span><span class="hl opt">;</span>
<span class="hl ppc">#endif</span>
<span class="hl ppc">#ifdef HAVE_STAT_ST_BLOCKS</span>
	st<span class="hl opt">-&gt;</span>st_blocks <span class="hl opt">= (</span>size<span class="hl opt">+</span><span class="hl num">511</span><span class="hl opt">)/</span><span class="hl num">512</span><span class="hl opt">;</span>
<span class="hl ppc">#endif</span>
	st<span class="hl opt">-&gt;</span>st_uid <span class="hl opt">=</span> <span class="hl kwd">getuid</span><span class="hl opt">();</span>
	st<span class="hl opt">-&gt;</span>st_gid <span class="hl opt">=</span> <span class="hl kwd">getgid</span><span class="hl opt">();</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">IS_DOS_DIR</span><span class="hl opt">(</span>mode<span class="hl opt">)) {</span>
		st<span class="hl opt">-&gt;</span>st_nlink <span class="hl opt">=</span> <span class="hl num">2</span><span class="hl opt">;</span>
	<span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
		st<span class="hl opt">-&gt;</span>st_nlink <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>st<span class="hl opt">-&gt;</span>st_ino <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
		st<span class="hl opt">-&gt;</span>st_ino <span class="hl opt">=</span> <span class="hl kwd">smbc_inode</span><span class="hl opt">(</span>context<span class="hl opt">,</span> fname<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	
	<span class="hl kwa">return</span> True<span class="hl opt">;</span>  <span class="hl com">/* FIXME: Is this needed ? */</span>

<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * Routine to stat a file given a name</span>
<span class="hl com"> */</span>

<span class="hl kwb">static int</span> <span class="hl kwd">smbc_stat_ctx</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>fname<span class="hl opt">,</span> <span class="hl kwb">struct</span> stat <span class="hl opt">*</span>st<span class="hl opt">)</span>
<span class="hl opt">{</span>
	SMBCSRV <span class="hl opt">*</span>srv<span class="hl opt">;</span>
	fstring server<span class="hl opt">,</span> share<span class="hl opt">,</span> user<span class="hl opt">,</span> password<span class="hl opt">,</span> workgroup<span class="hl opt">;</span>
	pstring path<span class="hl opt">;</span>
	<span class="hl kwb">time_t</span> m_time <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">,</span> a_time <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">,</span> c_time <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	SMB_OFF_T size <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	uint16 mode <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	SMB_INO_T ino <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>context <span class="hl opt">|| !</span>context<span class="hl opt">-&gt;</span>internal <span class="hl opt">||</span>
	    <span class="hl opt">!</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_initialized<span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>  <span class="hl com">/* Best I can think of ... */</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>
    
	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>fname<span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>
  
	<span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">, (</span><span class="hl str">&quot;smbc_stat(</span><span class="hl ipl">%s</span><span class="hl str">)</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> fname<span class="hl opt">));</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">smbc_parse_path</span><span class="hl opt">(</span>context<span class="hl opt">,</span> fname<span class="hl opt">,</span>
                            server<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>server<span class="hl opt">),</span>
                            share<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>share<span class="hl opt">),</span>
                            path<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>path<span class="hl opt">),</span>
                            user<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>user<span class="hl opt">),</span>
                            password<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>password<span class="hl opt">),</span>
                            NULL<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">)) {</span>
                errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
                <span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>
        <span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>user<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] == (</span><span class="hl kwb">char</span><span class="hl opt">)</span><span class="hl num">0</span><span class="hl opt">)</span> <span class="hl kwd">fstrcpy</span><span class="hl opt">(</span>user<span class="hl opt">,</span> context<span class="hl opt">-&gt;</span>user<span class="hl opt">);</span>

	<span class="hl kwd">fstrcpy</span><span class="hl opt">(</span>workgroup<span class="hl opt">,</span> context<span class="hl opt">-&gt;</span>workgroup<span class="hl opt">);</span>

	srv <span class="hl opt">=</span> <span class="hl kwd">smbc_server</span><span class="hl opt">(</span>context<span class="hl opt">,</span> server<span class="hl opt">,</span> share<span class="hl opt">,</span> workgroup<span class="hl opt">,</span> user<span class="hl opt">,</span> password<span class="hl opt">);</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>srv<span class="hl opt">) {</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>  <span class="hl com">/* errno set by smbc_server */</span>
	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">smbc_getatr</span><span class="hl opt">(</span>context<span class="hl opt">,</span> srv<span class="hl opt">,</span> path<span class="hl opt">, &amp;</span>mode<span class="hl opt">, &amp;</span>size<span class="hl opt">,</span> 
			 <span class="hl opt">&amp;</span>c_time<span class="hl opt">, &amp;</span>a_time<span class="hl opt">, &amp;</span>m_time<span class="hl opt">, &amp;</span>ino<span class="hl opt">)) {</span>

		errno <span class="hl opt">=</span> <span class="hl kwd">smbc_errno</span><span class="hl opt">(</span>context<span class="hl opt">, &amp;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">);</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>
		
	<span class="hl opt">}</span>

	st<span class="hl opt">-&gt;</span>st_ino <span class="hl opt">=</span> ino<span class="hl opt">;</span>

	<span class="hl kwd">smbc_setup_stat</span><span class="hl opt">(</span>context<span class="hl opt">,</span> st<span class="hl opt">,</span> path<span class="hl opt">,</span> size<span class="hl opt">,</span> mode<span class="hl opt">);</span>

	st<span class="hl opt">-&gt;</span>st_atime <span class="hl opt">=</span> a_time<span class="hl opt">;</span>
	st<span class="hl opt">-&gt;</span>st_ctime <span class="hl opt">=</span> c_time<span class="hl opt">;</span>
	st<span class="hl opt">-&gt;</span>st_mtime <span class="hl opt">=</span> m_time<span class="hl opt">;</span>
	st<span class="hl opt">-&gt;</span>st_dev   <span class="hl opt">=</span> srv<span class="hl opt">-&gt;</span>dev<span class="hl opt">;</span>

	<span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>

<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * Routine to stat a file given an fd</span>
<span class="hl com"> */</span>

<span class="hl kwb">static int</span> <span class="hl kwd">smbc_fstat_ctx</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">,</span> SMBCFILE <span class="hl opt">*</span>file<span class="hl opt">,</span> <span class="hl kwb">struct</span> stat <span class="hl opt">*</span>st<span class="hl opt">)</span>
<span class="hl opt">{</span>
	<span class="hl kwb">time_t</span> c_time<span class="hl opt">,</span> a_time<span class="hl opt">,</span> m_time<span class="hl opt">;</span>
	SMB_OFF_T size<span class="hl opt">;</span>
	uint16 mode<span class="hl opt">;</span>
	SMB_INO_T ino <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>context <span class="hl opt">|| !</span>context<span class="hl opt">-&gt;</span>internal <span class="hl opt">||</span>
	    <span class="hl opt">!</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_initialized<span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>file <span class="hl opt">|| !</span><span class="hl kwd">DLIST_CONTAINS</span><span class="hl opt">(</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_files<span class="hl opt">,</span> file<span class="hl opt">)) {</span>

		errno <span class="hl opt">=</span> EBADF<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>file<span class="hl opt">-&gt;</span>file<span class="hl opt">) {</span>

		<span class="hl kwa">return</span> context<span class="hl opt">-&gt;</span><span class="hl kwd">fstatdir</span><span class="hl opt">(</span>context<span class="hl opt">,</span> file<span class="hl opt">,</span> st<span class="hl opt">);</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">cli_qfileinfo</span><span class="hl opt">(&amp;</span>file<span class="hl opt">-&gt;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> file<span class="hl opt">-&gt;</span>cli_fd<span class="hl opt">,</span>
			   <span class="hl opt">&amp;</span>mode<span class="hl opt">, &amp;</span>size<span class="hl opt">, &amp;</span>c_time<span class="hl opt">, &amp;</span>a_time<span class="hl opt">, &amp;</span>m_time<span class="hl opt">,</span> NULL<span class="hl opt">, &amp;</span>ino<span class="hl opt">)) {</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">cli_getattrE</span><span class="hl opt">(&amp;</span>file<span class="hl opt">-&gt;</span>srv<span class="hl opt">-&gt;</span>cli<span class="hl opt">,</span> file<span class="hl opt">-&gt;</span>cli_fd<span class="hl opt">,</span>
			  <span class="hl opt">&amp;</span>mode<span class="hl opt">, &amp;</span>size<span class="hl opt">, &amp;</span>c_time<span class="hl opt">, &amp;</span>a_time<span class="hl opt">, &amp;</span>m_time<span class="hl opt">)) {</span>

		errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>
	    <span class="hl opt">}</span>
	<span class="hl opt">}</span>

	st<span class="hl opt">-&gt;</span>st_ino <span class="hl opt">=</span> ino<span class="hl opt">;</span>

	<span class="hl kwd">smbc_setup_stat</span><span class="hl opt">(</span>context<span class="hl opt">,</span> st<span class="hl opt">,</span> file<span class="hl opt">-&gt;</span>fname<span class="hl opt">,</span> size<span class="hl opt">,</span> mode<span class="hl opt">);</span>

	st<span class="hl opt">-&gt;</span>st_atime <span class="hl opt">=</span> a_time<span class="hl opt">;</span>
	st<span class="hl opt">-&gt;</span>st_ctime <span class="hl opt">=</span> c_time<span class="hl opt">;</span>
	st<span class="hl opt">-&gt;</span>st_mtime <span class="hl opt">=</span> m_time<span class="hl opt">;</span>
	st<span class="hl opt">-&gt;</span>st_dev <span class="hl opt">=</span> file<span class="hl opt">-&gt;</span>srv<span class="hl opt">-&gt;</span>dev<span class="hl opt">;</span>

	<span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>

<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * Routine to open a directory</span>
<span class="hl com"> * We accept the URL syntax explained in smbc_parse_path(), above.</span>
<span class="hl com"> */</span>

<span class="hl kwb">static void</span> <span class="hl kwd">smbc_remove_dir</span><span class="hl opt">(</span>SMBCFILE <span class="hl opt">*</span>dir<span class="hl opt">)</span>
<span class="hl opt">{</span>
	<span class="hl kwb">struct</span> smbc_dir_list <span class="hl opt">*</span>d<span class="hl opt">,*</span>f<span class="hl opt">;</span>

	d <span class="hl opt">=</span> dir<span class="hl opt">-&gt;</span>dir_list<span class="hl opt">;</span>
	<span class="hl kwa">while</span> <span class="hl opt">(</span>d<span class="hl opt">) {</span>

		f <span class="hl opt">=</span> d<span class="hl opt">;</span> d <span class="hl opt">=</span> d<span class="hl opt">-&gt;</span>next<span class="hl opt">;</span>

		<span class="hl kwd">SAFE_FREE</span><span class="hl opt">(</span>f<span class="hl opt">-&gt;</span>dirent<span class="hl opt">);</span>
		<span class="hl kwd">SAFE_FREE</span><span class="hl opt">(</span>f<span class="hl opt">);</span>

	<span class="hl opt">}</span>

	dir<span class="hl opt">-&gt;</span>dir_list <span class="hl opt">=</span> dir<span class="hl opt">-&gt;</span>dir_end <span class="hl opt">=</span> dir<span class="hl opt">-&gt;</span>dir_next <span class="hl opt">=</span> NULL<span class="hl opt">;</span>

<span class="hl opt">}</span>

<span class="hl kwb">static int</span> <span class="hl kwd">add_dirent</span><span class="hl opt">(</span>SMBCFILE <span class="hl opt">*</span>dir<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>comment<span class="hl opt">,</span> uint32 type<span class="hl opt">)</span>
<span class="hl opt">{</span>
	<span class="hl kwb">struct</span> smbc_dirent <span class="hl opt">*</span>dirent<span class="hl opt">;</span>
	<span class="hl kwb">int</span> size<span class="hl opt">;</span>
        <span class="hl kwb">int</span> name_length <span class="hl opt">= (</span>name <span class="hl opt">==</span> NULL <span class="hl opt">?</span> <span class="hl num">0</span> <span class="hl opt">:</span> <span class="hl kwd">strlen</span><span class="hl opt">(</span>name<span class="hl opt">));</span>
        <span class="hl kwb">int</span> comment_len <span class="hl opt">= (</span>comment <span class="hl opt">==</span> NULL <span class="hl opt">?</span> <span class="hl num">0</span> <span class="hl opt">:</span> <span class="hl kwd">strlen</span><span class="hl opt">(</span>comment<span class="hl opt">));</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Allocate space for the dirent, which must be increased by the </span>
<span class="hl com">	 * size of the name and the comment and 1 each for the null terminator.</span>
<span class="hl com">	 */</span>

	size <span class="hl opt">=</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span><span class="hl kwb">struct</span> smbc_dirent<span class="hl opt">) +</span> name_length <span class="hl opt">+</span> comment_len <span class="hl opt">+</span> <span class="hl num">2</span><span class="hl opt">;</span>
    
	dirent <span class="hl opt">=</span> <span class="hl kwd">SMB_MALLOC</span><span class="hl opt">(</span>size<span class="hl opt">);</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>dirent<span class="hl opt">) {</span>

		dir<span class="hl opt">-&gt;</span>dir_error <span class="hl opt">=</span> ENOMEM<span class="hl opt">;</span>
		<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwd">ZERO_STRUCTP</span><span class="hl opt">(</span>dirent<span class="hl opt">);</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>dir<span class="hl opt">-&gt;</span>dir_list <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>

		dir<span class="hl opt">-&gt;</span>dir_list <span class="hl opt">=</span> <span class="hl kwd">SMB_MALLOC_P</span><span class="hl opt">(</span><span class="hl kwb">struct</span> smbc_dir_list<span class="hl opt">);</span>
		<span class="hl kwa">if</span> <span class="hl opt">(!</span>dir<span class="hl opt">-&gt;</span>dir_list<span class="hl opt">) {</span>

			<span class="hl kwd">SAFE_FREE</span><span class="hl opt">(</span>dirent<span class="hl opt">);</span>
			dir<span class="hl opt">-&gt;</span>dir_error <span class="hl opt">=</span> ENOMEM<span class="hl opt">;</span>
			<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

		<span class="hl opt">}</span>
		<span class="hl kwd">ZERO_STRUCTP</span><span class="hl opt">(</span>dir<span class="hl opt">-&gt;</span>dir_list<span class="hl opt">);</span>

		dir<span class="hl opt">-&gt;</span>dir_end <span class="hl opt">=</span> dir<span class="hl opt">-&gt;</span>dir_next <span class="hl opt">=</span> dir<span class="hl opt">-&gt;</span>dir_list<span class="hl opt">;</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">else</span> <span class="hl opt">{</span>

		dir<span class="hl opt">-&gt;</span>dir_end<span class="hl opt">-&gt;</span>next <span class="hl opt">=</span> <span class="hl kwd">SMB_MALLOC_P</span><span class="hl opt">(</span><span class="hl kwb">struct</span> smbc_dir_list<span class="hl opt">);</span>
		
		<span class="hl kwa">if</span> <span class="hl opt">(!</span>dir<span class="hl opt">-&gt;</span>dir_end<span class="hl opt">-&gt;</span>next<span class="hl opt">) {</span>
			
			<span class="hl kwd">SAFE_FREE</span><span class="hl opt">(</span>dirent<span class="hl opt">);</span>
			dir<span class="hl opt">-&gt;</span>dir_error <span class="hl opt">=</span> ENOMEM<span class="hl opt">;</span>
			<span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

		<span class="hl opt">}</span>
		<span class="hl kwd">ZERO_STRUCTP</span><span class="hl opt">(</span>dir<span class="hl opt">-&gt;</span>dir_end<span class="hl opt">-&gt;</span>next<span class="hl opt">);</span>

		dir<span class="hl opt">-&gt;</span>dir_end <span class="hl opt">=</span> dir<span class="hl opt">-&gt;</span>dir_end<span class="hl opt">-&gt;</span>next<span class="hl opt">;</span>
	<span class="hl opt">}</span>

	dir<span class="hl opt">-&gt;</span>dir_end<span class="hl opt">-&gt;</span>next <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
	dir<span class="hl opt">-&gt;</span>dir_end<span class="hl opt">-&gt;</span>dirent <span class="hl opt">=</span> dirent<span class="hl opt">;</span>
	
	dirent<span class="hl opt">-&gt;</span>smbc_type <span class="hl opt">=</span> type<span class="hl opt">;</span>
	dirent<span class="hl opt">-&gt;</span>namelen <span class="hl opt">=</span> name_length<span class="hl opt">;</span>
	dirent<span class="hl opt">-&gt;</span>commentlen <span class="hl opt">=</span> comment_len<span class="hl opt">;</span>
	dirent<span class="hl opt">-&gt;</span>dirlen <span class="hl opt">=</span> size<span class="hl opt">;</span>
  
	<span class="hl kwd">strncpy</span><span class="hl opt">(</span>dirent<span class="hl opt">-&gt;</span>name<span class="hl opt">, (</span>name<span class="hl opt">?</span>name<span class="hl opt">:</span><span class="hl str">&quot;&quot;</span><span class="hl opt">),</span> dirent<span class="hl opt">-&gt;</span>namelen <span class="hl opt">+</span> <span class="hl num">1</span><span class="hl opt">);</span>

	dirent<span class="hl opt">-&gt;</span>comment <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)(&amp;</span>dirent<span class="hl opt">-&gt;</span>name <span class="hl opt">+</span> dirent<span class="hl opt">-&gt;</span>namelen <span class="hl opt">+</span> <span class="hl num">1</span><span class="hl opt">);</span>
	<span class="hl kwd">strncpy</span><span class="hl opt">(</span>dirent<span class="hl opt">-&gt;</span>comment<span class="hl opt">, (</span>comment<span class="hl opt">?</span>comment<span class="hl opt">:</span><span class="hl str">&quot;&quot;</span><span class="hl opt">),</span> dirent<span class="hl opt">-&gt;</span>commentlen <span class="hl opt">+</span> <span class="hl num">1</span><span class="hl opt">);</span>
	
	<span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>

<span class="hl opt">}</span>

<span class="hl kwb">static void</span>
<span class="hl kwd">list_unique_wg_fn</span><span class="hl opt">(</span><span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> uint32 type<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>comment<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>state<span class="hl opt">)</span>
<span class="hl opt">{</span>
	SMBCFILE <span class="hl opt">*</span>dir <span class="hl opt">= (</span>SMBCFILE <span class="hl opt">*)</span>state<span class="hl opt">;</span>
        <span class="hl kwb">struct</span> smbc_dir_list <span class="hl opt">*</span>dir_list<span class="hl opt">;</span>
        <span class="hl kwb">struct</span> smbc_dirent <span class="hl opt">*</span>dirent<span class="hl opt">;</span>
	<span class="hl kwb">int</span> dirent_type<span class="hl opt">;</span>
        <span class="hl kwb">int</span> do_remove <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>

	dirent_type <span class="hl opt">=</span> dir<span class="hl opt">-&gt;</span>dir_type<span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">add_dirent</span><span class="hl opt">(</span>dir<span class="hl opt">,</span> name<span class="hl opt">,</span> comment<span class="hl opt">,</span> dirent_type<span class="hl opt">) &lt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>

		<span class="hl com">/* An error occurred, what do we do? */</span>
		<span class="hl com">/* FIXME: Add some code here */</span>
	<span class="hl opt">}</span>

        <span class="hl com">/* Point to the one just added */</span>
        dirent <span class="hl opt">=</span> dir<span class="hl opt">-&gt;</span>dir_end<span class="hl opt">-&gt;</span>dirent<span class="hl opt">;</span>

        <span class="hl com">/* See if this was a duplicate */</span>
        <span class="hl kwa">for</span> <span class="hl opt">(</span>dir_list <span class="hl opt">=</span> dir<span class="hl opt">-&gt;</span>dir_list<span class="hl opt">;</span>
             dir_list <span class="hl opt">!=</span> dir<span class="hl opt">-&gt;</span>dir_end<span class="hl opt">;</span>
             dir_list <span class="hl opt">=</span> dir_list<span class="hl opt">-&gt;</span>next<span class="hl opt">) {</span>
                <span class="hl kwa">if</span> <span class="hl opt">(!</span> do_remove <span class="hl opt">&amp;&amp;</span>
                    <span class="hl kwd">strcmp</span><span class="hl opt">(</span>dir_list<span class="hl opt">-&gt;</span>dirent<span class="hl opt">-&gt;</span>name<span class="hl opt">,</span> dirent<span class="hl opt">-&gt;</span>name<span class="hl opt">) ==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
                        <span class="hl com">/* Duplicate.  End end of list need to be removed. */</span>
                        do_remove <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
                <span class="hl opt">}</span>

                <span class="hl kwa">if</span> <span class="hl opt">(</span>do_remove <span class="hl opt">&amp;&amp;</span> dir_list<span class="hl opt">-&gt;</span>next <span class="hl opt">==</span> dir<span class="hl opt">-&gt;</span>dir_end<span class="hl opt">) {</span>
                        <span class="hl com">/* Found the end of the list.  Remove it. */</span>
                        dir<span class="hl opt">-&gt;</span>dir_end <span class="hl opt">=</span> dir_list<span class="hl opt">;</span>
                        <span class="hl kwd">free</span><span class="hl opt">(</span>dir_list<span class="hl opt">-&gt;</span>next<span class="hl opt">);</span>
                        dir_list<span class="hl opt">-&gt;</span>next <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
                        <span class="hl kwa">break</span><span class="hl opt">;</span>
                <span class="hl opt">}</span>
        <span class="hl opt">}</span>
<span class="hl opt">}</span>

<span class="hl kwb">static void</span>
<span class="hl kwd">list_fn</span><span class="hl opt">(</span><span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> uint32 type<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>comment<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>state<span class="hl opt">)</span>
<span class="hl opt">{</span>
	SMBCFILE <span class="hl opt">*</span>dir <span class="hl opt">= (</span>SMBCFILE <span class="hl opt">*)</span>state<span class="hl opt">;</span>
	<span class="hl kwb">int</span> dirent_type<span class="hl opt">;</span>

	<span class="hl com">/* We need to process the type a little ... */</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>dir<span class="hl opt">-&gt;</span>dir_type <span class="hl opt">==</span> SMBC_FILE_SHARE<span class="hl opt">) {</span>
		
		<span class="hl kwa">switch</span> <span class="hl opt">(</span>type<span class="hl opt">) {</span>
		<span class="hl kwa">case</span> <span class="hl num">0</span><span class="hl opt">:</span> <span class="hl com">/* Directory tree */</span>
			dirent_type <span class="hl opt">=</span> SMBC_FILE_SHARE<span class="hl opt">;</span>
			<span class="hl kwa">break</span><span class="hl opt">;</span>

		<span class="hl kwa">case</span> <span class="hl num">1</span><span class="hl opt">:</span>
			dirent_type <span class="hl opt">=</span> SMBC_PRINTER_SHARE<span class="hl opt">;</span>
			<span class="hl kwa">break</span><span class="hl opt">;</span>

		<span class="hl kwa">case</span> <span class="hl num">2</span><span class="hl opt">:</span>
			dirent_type <span class="hl opt">=</span> SMBC_COMMS_SHARE<span class="hl opt">;</span>
			<span class="hl kwa">break</span><span class="hl opt">;</span>

		<span class="hl kwa">case</span> <span class="hl num">3</span><span class="hl opt">:</span>
			dirent_type <span class="hl opt">=</span> SMBC_IPC_SHARE<span class="hl opt">;</span>
			<span class="hl kwa">break</span><span class="hl opt">;</span>

		<span class="hl kwa">default</span><span class="hl opt">:</span>
			dirent_type <span class="hl opt">=</span> SMBC_FILE_SHARE<span class="hl opt">;</span> <span class="hl com">/* FIXME, error? */</span>
			<span class="hl kwa">break</span><span class="hl opt">;</span>
		<span class="hl opt">}</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">else</span> dirent_type <span class="hl opt">=</span> dir<span class="hl opt">-&gt;</span>dir_type<span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">add_dirent</span><span class="hl opt">(</span>dir<span class="hl opt">,</span> name<span class="hl opt">,</span> comment<span class="hl opt">,</span> dirent_type<span class="hl opt">) &lt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>

		<span class="hl com">/* An error occurred, what do we do? */</span>
		<span class="hl com">/* FIXME: Add some code here */</span>

	<span class="hl opt">}</span>
<span class="hl opt">}</span>

<span class="hl kwb">static void</span>
<span class="hl kwd">dir_list_fn</span><span class="hl opt">(</span><span class="hl kwb">const char</span> <span class="hl opt">*</span>mnt<span class="hl opt">,</span> file_info <span class="hl opt">*</span>finfo<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>mask<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>state<span class="hl opt">)</span>
<span class="hl opt">{</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">add_dirent</span><span class="hl opt">((</span>SMBCFILE <span class="hl opt">*)</span>state<span class="hl opt">,</span> finfo<span class="hl opt">-&gt;</span>name<span class="hl opt">,</span> <span class="hl str">&quot;&quot;</span><span class="hl opt">,</span> 
		       <span class="hl opt">(</span>finfo<span class="hl opt">-&gt;</span>mode<span class="hl opt">&amp;</span>aDIR<span class="hl opt">?</span>SMBC_DIR<span class="hl opt">:</span>SMBC_FILE<span class="hl opt">)) &lt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>

		<span class="hl com">/* Handle an error ... */</span>

		<span class="hl com">/* FIXME: Add some code ... */</span>

	<span class="hl opt">}</span> 

<span class="hl opt">}</span>

<span class="hl kwb">static</span> SMBCFILE <span class="hl opt">*</span><span class="hl kwd">smbc_opendir_ctx</span><span class="hl opt">(</span>SMBCCTX <span class="hl opt">*</span>context<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>fname<span class="hl opt">)</span>
<span class="hl opt">{</span>
	fstring server<span class="hl opt">,</span> share<span class="hl opt">,</span> user<span class="hl opt">,</span> password<span class="hl opt">,</span> options<span class="hl opt">;</span>
	pstring workgroup<span class="hl opt">;</span>
	pstring path<span class="hl opt">;</span>
        uint16 mode<span class="hl opt">;</span>
        <span class="hl kwb">char</span> <span class="hl opt">*</span>p<span class="hl opt">;</span>
	SMBCSRV <span class="hl opt">*</span>srv  <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
	SMBCFILE <span class="hl opt">*</span>dir <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
	<span class="hl kwb">struct</span> in_addr rem_ip<span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>context <span class="hl opt">|| !</span>context<span class="hl opt">-&gt;</span>internal <span class="hl opt">||</span>
	    <span class="hl opt">!</span>context<span class="hl opt">-&gt;</span>internal<span class="hl opt">-&gt;</span>_initialized<span class="hl opt">) {</span>
	        <span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">, (</span><span class="hl str">&quot;no valid context</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
		errno <span class="hl opt">=</span> EINVAL <span class="hl opt">+</span> <span class="hl num">8192</span><span class="hl opt">;</span>
		<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>fname<span class="hl opt">) {</span>
		<span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">, (</span><span class="hl str">&quot;no valid fname</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
		errno <span class="hl opt">=</span> EINVAL <span class="hl opt">+</span> <span class="hl num">8193</span><span class="hl opt">;</span>
		<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">smbc_parse_path</span><span class="hl opt">(</span>context<span class="hl opt">,</span> fname<span class="hl opt">,</span>
                            server<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>server<span class="hl opt">),</span>
                            share<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>share<span class="hl opt">),</span>
                            path<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>path<span class="hl opt">),</span>
                            user<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>user<span class="hl opt">),</span>
                            password<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>password<span class="hl opt">),</span>
                            options<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>options<span class="hl opt">))) {</span>
	        <span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">, (</span><span class="hl str">&quot;no valid path</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
		errno <span class="hl opt">=</span> EINVAL <span class="hl opt">+</span> <span class="hl num">8194</span><span class="hl opt">;</span>
		<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
	<span class="hl opt">}</span>

	<span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">, (</span><span class="hl str">&quot;parsed path: fname=&#39;</span><span class="hl ipl">%s</span><span class="hl str">&#39; server=&#39;</span><span class="hl ipl">%s</span><span class="hl str">&#39; share=&#39;</span><span class="hl ipl">%s</span><span class="hl str">&#39; path=&#39;</span><span class="hl ipl">%s</span><span class="hl str">&#39; options=&#39;</span><span class="hl ipl">%s</span><span class="hl str">&#39;</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> fname<span class="hl opt">,</span> server<span class="hl opt">,</span> share<span class="hl opt">,</span> path<span class="hl opt">,</span> options<span class="hl opt">));</span>

        <span class="hl com">/* Ensure the options are valid */</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">smbc_check_options</span><span class="hl opt">(</span>server<span class="hl opt">,</span> share<span class="hl opt">,</span> path<span class="hl opt">,</span> options<span class="hl opt">)) {</span>
                <span class="hl kwd">DEBUG</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">, (</span><span class="hl str">&quot;unacceptable options (</span><span class="hl ipl">%s</span><span class="hl str">)</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> options<span class="hl opt">));</span>
                errno <span class="hl opt">=</span> EINVAL <span class="hl opt">+</span> <span class="hl num">8195</span><span class="hl opt">;</span>
                <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
        <span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>user<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] == (</span><span class="hl kwb">char</span><span class="hl opt">)</span><span class="hl num">0</span><span class="hl opt">)</span> <span class="hl kwd">fstrcpy</span><span class="hl opt">(</span>user<span class="hl opt">,</span> context<span class="hl opt">-&gt;</span>user<span class="hl opt">);</span>

	<span class="hl kwd">pstrcpy</span><span class="hl opt">(</span>workgroup<span class="hl opt">,</span> context<span class="hl opt">-&gt;</span>workgroup<span class="hl opt">);</span>

	dir <span class="hl opt">=</span> <span class="hl kwd">SMB_MALLOC_P</span><span class="hl opt">(</span>SMBCFILE<span class="hl opt">);</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span>dir<span class="hl opt">) {</span>

		errno <span class="hl opt">=</span> ENOMEM<span class="hl opt">;</span>
		<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>

	<span class="hl opt">}</span>

	<span class="hl kwd">ZERO_STRUCTP</span><span class="hl opt">(</span>dir<span class="hl opt">);</span>

	dir<span class="hl opt">-&gt;</span>cli_fd   <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	dir<span class="hl opt">-&gt;</span>fname    <span class="hl opt">=</span> <span class="hl kwd">SMB_STRDUP</span><span class="hl opt">(</span>fname<span class="hl opt">);</span>
	dir<span class="hl opt">-&gt;</span>srv      <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
	dir<span class="hl opt">-&gt;</span>offset   <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	dir<span class="hl opt">-&gt;</span>file     <span class="hl opt">=</span> False<span class="hl opt">;</span>
	dir<span class="hl opt">-&gt;</span>dir_list <span class="hl opt">=</span> dir<span class="hl opt">-&gt;</span>dir_next <span class="hl opt">=</span> dir<span class="hl opt">-&gt;</span>dir_end <span class="hl opt">=</span> NULL<span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>server<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] == (</span><span class="hl kwb">char</span><span class="hl opt">)</span><span class="hl num">0</span><span class="hl opt">) {</span>

                <span class="hl kwb">int</span> i<span class="hl opt">;</span>
                <span class="hl kwb">int</span> count<span class="hl opt">;</span>
                <span class="hl kwb">int</span> max_lmb_count<span class="hl opt">;</span>
                <span class="hl kwb">struct</span> ip_service <span class="hl opt">*</span>ip_list<span class="hl opt">;</span>
                <span class="hl kwb">struct</span> ip_service server_addr<span class="hl opt">;</span>
                <span class="hl kwb">struct</span> user_auth_info u_info<span class="hl opt">;</span>
                <span class="hl kwb">struct</span> cli_state <span class="hl opt">*</span>cli<span class="hl opt">;</span>

		<span class="hl kwa">if</span> <span class="hl opt">(</span>share<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] != (</span><span class="hl kwb">char</span><span class="hl opt">)</span><span class="hl num">0</span> <span class="hl opt">||</span> path<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] != (</span><span class="hl kwb">char</span><span class="hl opt">)</span><span class="hl num">0</span><span class="hl opt">) {</span>

			errno <span class="hl opt">=</span> EINVAL <span class="hl opt">+</span> <span class="hl num">8196</span><span class="hl opt">;</span>
			<span class="hl kwa">if</span> <span class="hl opt">(</span>dir<span class="hl opt">) {</span>
				<span class="hl kwd">SAFE_FREE</span><span class="hl opt">(</span>dir<span class="hl opt">-&gt;</span>fname<span class="hl opt">);</span>
				<span class="hl kwd">SAFE_FREE</span><span class="hl opt">(</span>dir<span class="hl opt">);</span>
			<span class="hl opt">}</span>
			<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
		<span class="hl opt">}</span>

                <span class="hl com">/* Determine how many local master browsers to query */</span>
                max_lmb_count <span class="hl opt">= (</span>context<span class="hl opt">-&gt;</span>options<span class="hl opt">.</span>browse_max_lmb_count <span class="hl opt">==</span> <span class="hl num">0</span>
                                 <span class="hl opt">?</span> INT_MAX
                                 <span class="hl opt">:</span> context<span class="hl opt">-&gt;</span>options<span class="hl opt">.</span>browse_max_lmb_count<span class="hl opt">);</span>

                <span class="hl kwd">pstrcpy</span><span class="hl opt">(</span>u_info<span class="hl opt">.</span>username<span class="hl opt">,</span> user<span class="hl opt">);</span>
                <span class="hl kwd">pstrcpy</span><span class="hl opt">(</span>u_info<span class="hl opt">.</span>password<span class="hl opt">,</span> password<span class="hl opt">);</span>

		<span class="hl com">/*</span>
<span class="hl com">                 * We have server and share and path empty but options</span>
<span class="hl com">                 * requesting that we scan all master browsers for their list</span>
<span class="hl com">                 * of workgroups/domains.  This implies that we must first try</span>
<span class="hl com">                 * broadcast queries to find all master browsers, and if that</span>
<span class="hl com">                 * doesn&#39;t work, then try our other methods which return only</span>
<span class="hl com">                 * a single master browser.</span>
<span class="hl com">                 */</span>

                <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">name_resolve_bcast</span><span class="hl opt">(</span>MSBROWSE<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">, &amp;</span>ip_list<span class="hl opt">, &amp;</span>count<span class="hl opt">)) {</span>
                        <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">find_master_ip</span><span class="hl opt">(</span>workgroup<span class="hl opt">, &amp;</span>server_addr<span class="hl opt">.</span>ip<span class="hl opt">)) {</span>

                                errno <span class="hl opt">=</span> ENOENT<span class="hl opt">;</span>
                                <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
                        <span class="hl opt">}</span>

                        ip_list <span class="hl opt">= &amp;</span>server_addr<span class="hl opt">;