Example #1
0
 def mkdir(self,dirname):#新建文件夹  dirname:需要创建的文件名
     try:
         conn = SMBConnection(self.username, self.password, self.my_name, self.remote_smb_IP, self.domain_name, use_ntlm_v2=True,is_direct_tcp = True) 
         conn.connect(self.remote_smb_IP,445) 
         conn.createDirectory(self.dir, self.display_path + '/' + dirname)
     except:
         return False     
    def _push_pictures(self):
        """ Push the new picture into the NAS for GP. """

        # Retrieve configuration
        smb_user = config.get('smb_user')
        smb_pass = config.get('smb_pwd')
        smb_ip = config.get('smb_ip')
        smb_port = int(config.get('smb_port', 0))
        if not (smb_user and smb_pass and smb_ip and smb_port):
            raise Warning('Config Error',
                          'Missing Samba configuration in conf file.')
        child = self.child_id

        date_pic = self.date.replace('-', '')
        gp_pic_path = "{0}{1}/".format(config.get('gp_pictures'),
                                       child.unique_id[:2])
        file_name = "{0}_{1}.jpg".format(child.unique_id, date_pic)
        picture_file = TemporaryFile()
        picture_file.write(base64.b64decode(self.fullshot))
        picture_file.flush()
        picture_file.seek(0)

        # Upload file to shared folder
        smb_conn = SMBConnection(smb_user, smb_pass, 'openerp', 'nas')
        if smb_conn.connect(smb_ip, smb_port):
            try:
                smb_conn.storeFile('GP', gp_pic_path + file_name, picture_file)
            except OperationFailure:
                # Directory may not exist
                smb_conn.createDirectory('GP', gp_pic_path)
                smb_conn.storeFile('GP', gp_pic_path + file_name, picture_file)
Example #3
0
 def mkdir(self):
     conn = SMBConnection(self.username.get(),
                          self.password.get(),
                          self.my_name,
                          self.domain_name,
                          use_ntlm_v2=True,
                          is_direct_tcp=True)
     conn.connect(self.remote_smb_IP.get(), int(self.port.get()))
     conn.createDirectory(self.dir,
                          self.display_path + '/' + self.message.get())
Example #4
0
 def make_directory(self, service_name, path):
     samba = SMBConnection(self.username, self.password, '', '')
     samba.connect(self.ip, self.port)
     try:
         samba.createDirectory(service_name, path)
     except Exception:
         print('create directory failure! ')
     else:
         print('create directory success! ')
     finally:
         samba.close()
Example #5
0
def _create_folder(connection: SMBConnection, share_folder: str,
                   folder_path: str) -> bool:
    # Avoid trying to create an already existing folder
    if folder_path in ["", "/"] or get_file_desc(connection, share_folder,
                                                 folder_path):
        return True

    try:
        # Create a temporary folder, then rename it for instant availability (Windows FS listeners for instance)
        connection.createDirectory(share_folder, f"{folder_path}temp")
        connection.rename(share_folder, f"{folder_path}temp", folder_path)
        return True
    except OperationFailure:
        # Silent failure as subsequent action will certainly fail anyway
        return False
Example #6
0
def smbtestdir(session_name):
    fullname = 'fxb04fs0301.filex.com'
    ip = socket.gethostbyname(fullname)
    hostname, domain = fullname.split('.', 1)
    share = 'everyone'
    directory = '{}'.format(session_name)
    con = SMBConnection('', '', 'client', hostname)
    con.connect(ip)
    con.createDirectory(share, directory)
    con.close()
    yield fullname, share, directory
    con = SMBConnection('', '', 'client', hostname)
    con.connect(ip)
    for path, dirs, files in walk(con, share, directory, topdown=True):
        for filename in files:
            con.deleteFiles(share, '{}\\{}'.format(path, filename))
        con.deleteDirectory(share, path)
    con.close()
Example #7
0
def upload_file(ticket_id):
    main, samba = set_samba_settings()
    path = main['local_storage']+delimiter()+str(ticket_id)+delimiter()+'for_deployment'\
           + delimiter()+'trunk'+delimiter() + 'maximotest'
    tree = []
    for item in os.walk(path):
        item = (item[0].replace(path, ''), item[1], item[2])
        if item[0].replace(path, '')[1:8] == 'SOURCES':
            continue
        tree.append(item)
    conn = SMBConnection(samba['smb_username'], samba['smb_password'], os.environ['COMPUTERNAME'], getBIOSName(samba['smb_server']), use_ntlm_v2 = True)
    conn.connect(samba['smb_server'], 139)
    action_log = []
    notes = open(main['local_storage']+delimiter()+str(ticket_id)+delimiter()+'notes.txt', 'a+')
    notes.write("-"*57+"Uploaded files"+"-"*57+"\n")
    notes.write('%-75s\t%9s\t%s\n%s\n' % ('Remote filename', 'Size(byte)', 'Timestamp', '-'*128))
    for i in tree:
        for k in i[1]:
            if k == 'SOURCES' or k == 'DB_OBJ': continue
            if k not in [x.filename for x in conn.listPath('c$', 'maximo'+i[0])]:
                # for testing using path temp/maximo for prod need remote temp
                ch_path = 'maximo'+i[0]+delimiter()+str(k)
                conn.createDirectory('c$', ch_path)
                print "[INFO]\t"+datetime.now().strftime('%H:%M:%S %d-%m-%y')+"\tCreate directory "+\
                      delimiter()+delimiter()+samba['smb_server']+delimiter()+"c$"+delimiter()+ch_path
                action_log.append(('mkdir', delimiter()+delimiter()+samba['smb_server']+delimiter()+'c$'+delimiter()+ch_path))
        if len(i[2]) > 0 and 'DB_OBJ' != i[0][1:]:
            for f in i[2]:
                f_path = 'maximo'+i[0]+delimiter()
                obj_file = str(path)+str(i[0])+delimiter()+str(f)
                file_size = conn.storeFile('c$', f_path+f, open(obj_file, 'rb'))
                notes.write('%-75s\t%9s\t%s\n' % (delimiter()+delimiter()+samba['smb_server']+delimiter()+"c$"+delimiter()+f_path+f, str(file_size), datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
                print "[INFO]\t"+datetime.now().strftime('%H:%M:%S %d-%m-%y')+"\tUploaded size in byte:"+str(file_size)+\
                      ", file: "+delimiter()+delimiter()+samba['smb_server']+delimiter()+"c$"+delimiter()+f_path+f
                action_log.append(('cp', delimiter()+delimiter()+samba['smb_server']+delimiter()+'c$'+delimiter()+f_path+f))
    # write rollback file
    with open((main['local_storage']+delimiter()+str(ticket_id)+delimiter()+'action.log'), 'w') as rollback:
        for line in action_log:
            rollback.write(line[0]+','+line[1]+'\n')
    conn.close()
    notes.close()
    return 0
Example #8
0
class Nas:
	def __init__(self, config, connection):
		conf = config[connection]
		self.ip = conf['ip']
		self.connection = SMBConnection(conf['user'], conf['password'], conf['local_name'], conf['nas_name'])
		self.connection.connect(self.ip)

	def set_root_directory(self, root):
 		self.root = root

	def list_directory(self, path):
		return self.connection.listPath(self.root, path)

	def list_directory_names(self, path):
		dir_raw = self.list_directory(path)
		return [x.filename for x in dir_raw]

	def create_dir(self, path):
		self.connection.createDirectory(self.root, path)
	
	def download_file(self, origin, destination):
		with open(destination, 'wb') as download_file:  # downloading file
			self.connection.retrieveFile(self.root, origin, download_file)

	def download_remote(self, path):
		filename = os.path.basename(path)
		file_obj = BytesIO()
		self.connection.retrieveFile(self.root, path, file_obj)
		return file_obj
 		
	def upload_remote(self, path, file_obj):
		self.connection.storeFile(self.root, path, file_obj)

	def delete_file(self, path):
		self.connection.deleteFiles(self.root, path)
	
	def rename_path(self, origin, destination):
		self.connection.rename(origin, destination)

	def close(self):
 		self.connection.close()
    def attach_pictures(self, cr, uid, ids, pictures_id, context=None):
        """ Push the new picture. """
        res = super(child_property, self).attach_pictures(
            cr, uid, ids, pictures_id, context)

        pictures = self.pool.get('compassion.child.pictures').browse(
            cr, uid, pictures_id, context)

        # Retrieve configuration
        smb_user = config.get('smb_user')
        smb_pass = config.get('smb_pwd')
        smb_ip = config.get('smb_ip')
        smb_port = int(config.get('smb_port', 0))
        if not (smb_user and smb_pass and smb_ip and smb_port):
            raise orm.except_orm(
                'Config Error',
                'Missing Samba configuration in conf file.')
        child = pictures.child_id

        date_pic = pictures.date.replace('-', '')
        gp_pic_path = "{0}{1}/".format(config.get('gp_pictures'),
                                       child.code[:2])
        file_name = "{0}_{1}.jpg".format(child.code, date_pic)
        picture_file = TemporaryFile()
        picture_file.write(base64.b64decode(pictures.fullshot))
        picture_file.flush()
        picture_file.seek(0)

        # Upload file to shared folder
        smb_conn = SMBConnection(smb_user, smb_pass, 'openerp', 'nas')
        if smb_conn.connect(smb_ip, smb_port):
            try:
                smb_conn.storeFile(
                    'GP', gp_pic_path + file_name, picture_file)
            except OperationFailure:
                # Directory may not exist
                smb_conn.createDirectory('GP', gp_pic_path)
                smb_conn.storeFile(
                    'GP', gp_pic_path + file_name, picture_file)
        return res
Example #10
0
    def create(self, cr, uid, vals, context=None):
        """Push a new picture to GP."""
        pic_id = super(child_pictures, self).create(cr, uid, vals, context)
        pic_data = self.get_picture(cr, uid, [pic_id], 'fullshot', '',
                                    context)[pic_id]

        if pic_data:
            # Retrieve configuration
            smb_user = config.get('smb_user')
            smb_pass = config.get('smb_pwd')
            smb_ip = config.get('smb_ip')
            child_obj = self.pool.get('compassion.child')
            child = child_obj.browse(cr, uid, vals['child_id'], context)
            # In GP, pictures are linked to Case Study
            if not child.case_study_ids:
                child_obj._get_case_study(cr, uid, child, context)
                child = child_obj.browse(cr, uid, child.id, context)
            date_cs = child.case_study_ids[0].info_date.replace('-', '')
            gp_pic_path = "{}{}/".format(config.get('gp_pictures'),
                                         child.code[:2])
            file_name = "{}_{}.jpg".format(child.code, date_cs)
            picture_file = TemporaryFile()
            picture_file.write(base64.b64decode(pic_data))
            picture_file.flush()
            picture_file.seek(0)

            # Upload file to shared folder
            smb_conn = SMBConnection(smb_user, smb_pass, 'openerp', 'nas')
            if smb_conn.connect(smb_ip, 139):
                try:
                    smb_conn.storeFile('GP', gp_pic_path + file_name,
                                       picture_file)
                except OperationFailure:
                    # Directory may not exist
                    smb_conn.createDirectory('GP', gp_pic_path)
                    smb_conn.storeFile('GP', gp_pic_path + file_name,
                                       picture_file)

        return pic_id
Example #11
0
def create_directory(conn: SMBConnection,
                     service_name: str,
                     path: str,
                     is_exist_ok=True) -> bool:
    """创建目录,支持递归创建"""
    last_result = None
    dir_list = list(Path(path).parents)
    # 丢弃已经存在的根目录
    dir_list.pop()
    # 将目录本身插入
    dir_list.insert(0, Path(path))
    while dir_list:
        _path = dir_list.pop()
        try:
            conn.createDirectory(service_name=service_name, path=str(_path))
        except Exception as e:
            last_result = False
            if not is_exist_ok:
                raise e
        else:
            last_result = True
    return last_result
Example #12
0
    def attach_pictures(self, cr, uid, ids, pictures_id, context=None):
        """ Push the new picture. """
        res = super(child_property,
                    self).attach_pictures(cr, uid, ids, pictures_id, context)

        pictures = self.pool.get('compassion.child.pictures').browse(
            cr, uid, pictures_id, context)

        # Retrieve configuration
        smb_user = config.get('smb_user')
        smb_pass = config.get('smb_pwd')
        smb_ip = config.get('smb_ip')
        smb_port = int(config.get('smb_port', 0))
        if not (smb_user and smb_pass and smb_ip and smb_port):
            raise orm.except_orm('Config Error',
                                 'Missing Samba configuration in conf file.')
        child = pictures.child_id

        date_pic = pictures.date.replace('-', '')
        gp_pic_path = "{0}{1}/".format(config.get('gp_pictures'),
                                       child.code[:2])
        file_name = "{0}_{1}.jpg".format(child.code, date_pic)
        picture_file = TemporaryFile()
        picture_file.write(base64.b64decode(pictures.fullshot))
        picture_file.flush()
        picture_file.seek(0)

        # Upload file to shared folder
        smb_conn = SMBConnection(smb_user, smb_pass, 'openerp', 'nas')
        if smb_conn.connect(smb_ip, smb_port):
            try:
                smb_conn.storeFile('GP', gp_pic_path + file_name, picture_file)
            except OperationFailure:
                # Directory may not exist
                smb_conn.createDirectory('GP', gp_pic_path)
                smb_conn.storeFile('GP', gp_pic_path + file_name, picture_file)
        return res
Example #13
0
    def do_out(self, source, params, folder):
        host, port, username, password, encrypt = parse_source(source)

        file = params.get('file')
        log.debug('file: "%s"', file)

        if file is None:
            raise ValueError("File name in params is mandatory!")

        filename = os.path.basename(file)
        filepath = os.path.join(folder, file)
        if not os.path.exists(filepath):
            raise Exception("File '%s' not found!" % filepath)

        log.info('lookup "%s" ...', host)
        ip = socket.gethostbyname(host)
        localhost = socket.gethostname()

        # connect smb share
        log.info('connect "%s" ...', ip)
        conn = SMBConnection(username,
                             password,
                             localhost,
                             host,
                             use_ntlm_v2=True,
                             is_direct_tcp=True)
        ready = conn.connect(ip, 445)
        if not ready:
            raise Exception("Connect failed, host, user or pass is not valid!")

        # create temp folder and move package to
        log.info('prepare ...')
        remote_dir = "temp\\%s" % temp_name()
        conn.createDirectory(ADMIN_SERVICE, remote_dir)

        # copy package remote
        file_obj = open(filepath, 'r')
        remote_filepath = "%s\\%s" % (remote_dir, filename)
        conn.storeFile(ADMIN_SERVICE, remote_filepath, file_obj)
        file_obj.close()

        # install package remotely
        log.info('install "%s" ...', filename)
        psexec = Client(ip,
                        username=username,
                        password=password,
                        encrypt=encrypt)
        psexec.connect()
        remote_logpath = remote_dir + "\\msiexec.log"
        try:
            psexec.create_service()
            msi_path = "%systemroot%\\" + remote_filepath
            log_path = "%systemroot%\\" + remote_logpath
            cmd = "msiexec /i %s /qn /norestart /L*v %s" % (msi_path, log_path)
            log.debug(cmd)
            stdout, stderr, rc = psexec.run_executable("cmd.exe",
                                                       arguments="/c " + cmd)
            log.debug("exit code: %s", rc)
        finally:
            psexec.remove_service()
            psexec.disconnect()

        # dump msi log content
        log.debug('read remote log "%s" content', remote_logpath)
        try:
            with tempfile.NamedTemporaryFile() as tmp_file:
                conn.retrieveFile(ADMIN_SERVICE, remote_logpath, tmp_file)
                tmp_file.seek(0)
                log.debug(codecs.decode(tmp_file.read(), 'utf-16'))
        except:
            log.error(str(e))  # non fatal

        if rc != 0:  # sorry, fatal
            raise Exception(stdout.decode('utf-16'))

        # version magick
        log.info('set version ...')
        with tempfile.NamedTemporaryFile() as ver_obj:
            conn.storeFile(ADMIN_SERVICE, MAGICK_FILENAME, ver_obj)
        attr = conn.getAttributes(ADMIN_SERVICE, MAGICK_FILENAME)
        version = attr.last_write_time

        # clean and diconnect
        conn.deleteFiles(ADMIN_SERVICE, remote_logpath)
        conn.deleteFiles(ADMIN_SERVICE, remote_filepath)
        conn.deleteDirectory(ADMIN_SERVICE, remote_dir)
        conn.close()

        return {"version": {"ref": format_version(version)}, "metadata": []}
Example #14
0
class SmbCommunicate(object):
    """
    smb连接客户端
    """
    user_name = ''
    pwd = ''
    ip = ''
    port = None
    status = False
    samba = None

    def __init__(self, user_name, pwd, ip, port=139):
        self.user_name = user_name
        self.pwd = pwd
        self.ip = ip
        self.port = port

    def connect(self):
        try:
            self.samba = SMBConnection(
                self.user_name, self.pwd, '', '', use_ntlm_v2=True)
            self.samba.connect(self.ip, self.port)
            self.status = self.samba.auth_result
            if self.status:
                print("Connect SMB server Success!")
            else:
                print("Connect SMB server Fail!")
        except Exception:
            traceback.print_exc()
            print("Connect SMB server Fail!")
            self.samba.close()

    def disconnect(self):
        if self.status:
            self.samba.close()

    def all_file_names_in_dir(self, service_name, dir_name):
        """
        列出文件夹内所有文件名
        :param service_name:
        :param dir_name:
        :return:
        """
        f_names = list()
        for e in self.samba.listPath(service_name, dir_name):
            if len(e.filename) > 3:
                f_names.append(e.filename)
        return f_names

    def download_file(self, file_path, upload_dir, upload_path):
        """
        下载文件
        :param upload_path:
        :param upload_dir:
        :param file_path: 保存到本地文件的路径
        :return:c
        """
        try:
            self.connect()
            with open(file_path, 'wb') as file_obj:
                self.samba.retrieveFile(upload_dir, upload_path, file_obj)
            print("Download Success!")
            return True
        except Exception:
            traceback.print_exc()
            print("Download Fail!")
            return False

    def upload_file(self, file_path, upload_dir, upload_path):
        """
        上传文件
        :param upload_dir:
        :param file_path:
        :param upload_path: 上传文件的路径
        :return:True or False
        """
        try:
            self.connect()
            with open(file_path, 'rb') as file_obj:
                print(
                    "Upload File from {0} to {1}/{2}".format(file_path, upload_dir, upload_path))
                self.samba.storeFile(upload_dir, upload_path, file_obj)

            print("Upload file success!")
            return True
        except Exception:
            traceback.print_exc()
            print("Upload file Fail!")
            return False

    def create_folder(self, service_dir, create_path):
        """
        添加文件夹
        :param service_dir : root dir
        :param create_path :target path
        """
        try:
            self.connect()
            self.samba.createDirectory(service_dir, create_path)
            print("Create folder Success!")
            return True
        except Exception:
            traceback.print_exc()
            print("Create folder Fail!")
            return False

    def list_path(self, service_name, path):
        try:
            self.connect()
            for file_name in self.samba.listSnapshots(service_name, path):
                print(file_name)
        except Exception:
            traceback.print_exc()
            print("Create Fail!")
            return False
Example #15
0
                if config['delete_pics']:
                    os.remove(picfile_location)
            else:
                # File sizes are different. Add to try_again[]
                try_again.append(picfile)


conn = SMBConnection(config['UserID'], config['password'],
                     config['client_machine_name'], config['server_name'])
assert conn.connect(config['server_ip'])

try:
    conn.listPath('Data', today_dir)
except smb_structs.OperationFailure:
    try:
        conn.createDirectory('Data', today_dir)
    except smb_structs.OperationFailure:
        conn.createDirectory('Data', year_dir)
        conn.createDirectory('Data', today_dir)

store_files_on_server(pics_dir)

if len(try_again) == 0:
    print('File transfer complete!')
    conn.close()
    if config['delete_pics']:
        os.rmdir(pics_dir)
else:
    print('File transfer incomplete! Attempting to transfer %d files...' %
          (len(try_again)))
    try_again = []
Example #16
0
class SMBClient:
    """
    SMB连接客户端
    """
    status = False
    samba = None

    def __init__(self, username: str, password: str, ip: str, port: int = 139):
        self.username = username
        self.password = password
        self.ip = ip
        self.port = port
        self.samba = SMBConnection(self.username, self.password, '', '', use_ntlm_v2=True)
        self.samba.connect(self.ip, self.port)
        self.status = self.samba.auth_result

    def close(self):
        if self.status:
            self.samba.close()

    def list_smb_dir(self, share_name, sub_dir=""):
        """列出文件夹内所有文件名
        :param share_name:  共享文件夹名称
        :param sub_dir:     相对共享文件夹的子目录
        """
        file_names = list()
        for e in self.samba.listPath(share_name, sub_dir):
            if e.filename[0] != '.':  # 过滤上级文件夹及影藏文件
                file_names.append(e.filename)
        return file_names

    def download(self, filename, local_dir, share_name, sub_dir=""):
        """下载文件
        :param filename:    文件名
        :param share_name:  共享文件夹名称
        :param sub_dir:     相对共享文件夹的子目录
        :param local_dir:   本地保存文件夹路径
        """
        assert isinstance(filename, str)
        with open(os.path.join(local_dir, filename), 'wb') as fp:
            self.samba.retrieveFile(share_name, os.path.join(sub_dir, filename), fp)

    def download_bytes(self, share_name, sub_file_path):
        """直接下载共享文件的Bytes数据
        :param share_name:      共享文件夹名称
        :param sub_file_path:   共享文件路径
        """

        fp = io.BytesIO()
        self.samba.retrieveFile(share_name, sub_file_path, fp)
        fp.seek(0)
        data = fp.read()
        fp.close()
        return data

    def upload(self, local_file_path, share_name, smb_save_path):
        """上传文件
        :param local_file_path:     本地文件路径
        :param share_name:          共享文件夹名称
        :param smb_save_path:       在共享文件夹的存放路径
        """
        with open(local_file_path, "rb") as fp:
            self.samba.storeFile(share_name, smb_save_path, fp)

    def upload_bytes(self, data, share_name, smb_save_path):
        """直接将Bytes类型的数据保存到共享文件
        :param data:            Bytes类型数据
        :param share_name:      共享文件夹名称
        :param smb_save_path:   在共享文件夹的存放路径
        """
        fp = io.BytesIO(data)
        self.samba.storeFile(share_name, smb_save_path, fp)
        fp.close()

    def create_dir(self, share_name, sub_dir):
        """创建文件夹
        :param share_name:      共享文件夹名称
        :param sub_dir:         相对共享文件夹的子目录
        """
        self.samba.createDirectory(share_name, sub_dir)

    def file_attrs(self, share_name, smb_file_path):
        attrs = {}
        try:
            file = self.samba.getAttributes(share_name, smb_file_path)
            for attr in ['alloc_size', 'create_time', 'file_attributes', 'file_id', 'file_size', 'filename',
                         'isDirectory', 'isNormal', 'isReadOnly', 'last_access_time', 'last_attr_change_time',
                         'last_write_time', 'short_name']:
                attrs[attr] = getattr(file, attr)
        except OperationFailure:
            pass
        return attrs

    def delete_file(self, share_name, smb_file_pattern):
        """删除文件, 默认都把传入的smb_file_pattern转换为Unicode字符串
        :param share_name:          共享文件夹名称
        :param smb_file_pattern:    文件的相对路径, 可以使用通配符
        """
        self.samba.deleteFiles(share_name, smb_file_pattern)
Example #17
0
class ProcessorSMB(BaseProcessorRemoteCP):
    smb_conn = None

    def __init__(self, **kwargs):
        super(ProcessorSMB, self).__init__(**kwargs)
        if not SMBConnection:
            log.error("No pySMB package please install")

    def __repr__(self):
        return "{0}@{1}:{2}".format(self.username, self.remote_host,
                                    self.remote_dir)

    def connect(self):
        try:
            self.smb_conn = SMBConnection(self.username, self.password,
                                          self.local_name, self.remote_name)
            print self.remote_host
            self.smb_conn.connect(self.remote_host)
        except Exception as e:
            log.error("{0}: Connect error to {1} {2}".format(
                self.name, self.remote_host, e))
            return False
        log.info("{0}: SMB Connected to {1} with {2}".format(
            self.name, self.remote_host, self.username))
        return True

    def disconnect(self):
        try:
            self.smb_conn.close()
        except Exception as e:
            log.error("{0}: Disconnect error to {1} {2}".format(
                self.name, self.remote_host, e))
            return False
        log.info("{0}: SMB Disconnected from {1} with {2}".format(
            self.name, self.remote_host, self.username))

    def create_path(self, remotepath):
        parts = remotepath.split('/')
        for n in range(2, len(parts)):
            path = '/'.join(parts[:n])
            try:
                self.smb_conn.createDirectory(self.remote_dir, path)
            except:
                pass

    def run(self, file_item):
        super(ProcessorSMB, self).run(file_item)
        try:
            assert_file_locked(file_item)
            rel_path = file_item.get_relative_path()
            remote_path = self.remote_dir + rel_path + file_item.name
            self.create_path(remote_path)
            fd = open(file_item.full_path, 'r')
            self.smb_conn.storeFile(self.remote_dir, remote_path, fd)
            fd.close()
            log.info("{0}: SMB Put file {1}".format(self.name, file_item))
        except Exception as e:
            log.error("{0}: SMB Put error to {1} file {2} :{3}".format(
                self.name, self.remote_host, file_item, e))
            return False
        log.debug("End Processing {0}".format(file_item))
        return True
Example #18
0
class EasyPySMB:
    def __init__(
        self,
        hostname,
        username="******",
        password=None,
        domain=None,
        client_name=None,
        port=139,
        share_name=None,
        file_path=None,
        netbios_name=None,
        nocheck=False,
    ):
        if hostname.startswith("smb://"):
            regex = "smb://(((.+);)?(.+):(.+)@)?([^/]+)(/([^/]+))?(/.*)?"
            m = re.match(regex, hostname)
            if not m:
                raise ValueError(
                    "Could not decompose smb path. The regex failed.")
            domain = m.group(3) if m.group(3) else ""
            username = m.group(4) if m.group(4) else "GUEST"
            password = m.group(5) if m.group(5) else ""
            hostname = m.group(6)
            share_name = m.group(8)
            file_path = m.group(9)
            logger.debug(
                "Domain: {} Username: {} Password: {} Server: {} Share: {} "
                "File Path: {}".format(domain, username, password, hostname,
                                       share_name, file_path))
        if not client_name:
            client_name = __name__
        if not netbios_name:
            netbios_name = get_netbios_name(hostname)
        self.conn = SMBConnection(
            domain=domain,
            username=username,
            password=password,
            my_name=client_name,
            remote_name=netbios_name,
            use_ntlm_v2=True,
        )
        if not self.conn.connect(hostname, port):
            logger.error("Could not connnect to SMB server. Please verify the "
                         "connection data")
        # tmpdir is a temp dir that holds the transfered files by default
        self.tmpdir = tempfile.mkdtemp(prefix="easypysmb_")
        self.share_name = share_name
        self.file_path = file_path
        if not nocheck:
            if self.share_name:
                available_shares = [x.lower() for x in self.list_shares()]
                if self.share_name.lower() not in available_shares:
                    logger.warning(
                        "Share {} does not exist on the server".format(
                            self.share_name))
            if self.file_path:
                dir_content = [
                    x.filename
                    for x in self.ls(os.path.dirname(self.file_path))
                ]
                if os.path.basename(self.file_path) not in dir_content:
                    logger.warning(
                        "File {} does not exist on the server".format(
                            self.file_path))

    def __decompose_smb_path(self, path):
        """
        Get the share name and filepath
        """
        split_path = path.split("/")
        return split_path[0], "/".join(split_path[1:])

    def __guess_share_name(self, path, share_name=None):
        if share_name:
            return share_name, path
        available_shares = [x.lower() for x in self.list_shares()]
        if not share_name:
            first_dir = path.split("/")[0].lower()
            if first_dir in available_shares:
                logger.info("Path {} matches share name {}".format(
                    path, first_dir))
                share_name, path = self.__decompose_smb_path(path)
            elif self.share_name:
                share_name = self.share_name
        return share_name, path

    def close(self):
        self.conn.close()

    def list_shares(self):
        return [x.name for x in self.conn.listShares()]

    def store_file(self, file_obj, dest_path=None, share_name=None, retries=3):
        if not dest_path:
            dest_path = self.file_path
        assert dest_path, "Destination path is unset"
        share_name, dest_path = self.__guess_share_name(dest_path, share_name)
        if type(file_obj) is str or type(file_obj) is str:
            file_obj = open(file_obj, "rb")
        logger.info("Attempt to store {} on {}:{}".format(
            file_obj.name, share_name, dest_path))
        for r in range(1, retries + 1):
            try:
                return self.conn.storeFile(share_name, dest_path, file_obj)
            except Exception as e:
                logger.error(
                    "Attempt {}/{} to store file on SMB share failed:\n{}".
                    format(r, retries, e))

    def retrieve_file(self, dest_path=None, file_obj=None, share_name=None):
        if not dest_path:
            dest_path = self.file_path
        assert dest_path, "Destination path is unset"
        share_name, dest_path = self.__guess_share_name(dest_path, share_name)
        if not file_obj:
            file_obj = open(
                os.path.join(self.tmpdir, os.path.basename(dest_path)), "w+b")
            # file_obj = tempfile.NamedTemporaryFile(
            #     prefix='py_',
            #     suffix=os.path.basename(dest_path),
            #     dir=self.tmpdir,
            #     delete=False
            # )
        elif type(file_obj) is str or type(file_obj) is str:
            file_obj = open(file_obj, "wb")
        bytes_transfered = self.conn.retrieveFile(share_name, dest_path,
                                                  file_obj)
        logger.info("Transfered {} bytes".format(bytes_transfered))
        file_obj.close()  # write file
        file_obj = open(file_obj.name)
        return file_obj

    def backup_file(
        self,
        backup_file_path,
        file_path=None,
        share_name=None,
        backup_share_name=None,
    ):
        if not file_path:
            file_path = self.file_path
        assert file_path, "Destination path is unset"
        share_name, file_path = self.__guess_share_name(file_path, share_name)
        backup_share_name, backup_file_path = self.__guess_share_name(
            backup_file_path, backup_share_name)
        logger.info("Back up file {}:{} to {}:{}".format(
            share_name, file_path, backup_share_name, backup_file_path))
        tmp_file = tempfile.NamedTemporaryFile(
            suffix=os.path.splitext(file_path)[1], delete=False)
        tmp_file = self.retrieve_file(share_name=share_name,
                                      dest_path=file_path,
                                      file_obj=tmp_file)
        res = self.store_file(
            share_name=backup_share_name,
            dest_path=backup_file_path,
            file_obj=tmp_file,
        )
        # Clean up
        os.remove(tmp_file.name)
        return res

    def mkdir(self, dir_path, share_name=None):
        share_name, dir_path = self.__guess_share_name(dir_path, share_name)
        # Recursively create directories, just like mkdir -p does
        directories = dir_path.split("/")
        tmp_path = ""
        for d in directories:
            dir_content = self.conn.listPath(share_name, tmp_path)
            if d not in [x.filename for x in dir_content if x.isDirectory]:
                logger.info("Directory {} is missing. Create it".format(d))
                self.conn.createDirectory(share_name,
                                          "{}/{}".format(tmp_path, d))
            tmp_path += "/{}".format(d)

    def rm(self, file_path, share_name=None):
        if not share_name:
            if self.share_name:
                share_name = self.share_name
            else:
                share_name, file_path = self.__decompose_smb_path(file_path)
        return self.conn.deleteFiles(share_name, file_path)

    def ls(self, path="", share_name=None):
        if not share_name:
            if self.share_name:
                share_name = self.share_name
            else:
                share_name, path = self.__decompose_smb_path(path)
        logger.info("List files in {}:{}".format(share_name, path))
        return self.conn.listPath(share_name, path=path)
Example #19
0
def smbsync(from_path,
            to_path,
            credentials=os.path.expanduser('~/.smbcredential.rz_storage'),
            server_ip=None,
            share="pastewka",
            domain="PUBLIC",
            username="******",
            password=None,
            server_name="ufr2.isi1.public.ads.uni-freiburg.de",
            server_port=445):

    # read credentials from file if specified and existant:
    if os.path.isfile(credentials):
        # create dumme section, otherwise ConfigParser throws exception:
        config_str = '[root]\n' + open(credentials, 'r').read()
        logger.info(
            "Found credentials at '{:s}', parsing...".format(credentials))
        config = configparser.ConfigParser()
        config.read_string(config_str)
        if 'username' in config['root']:
            logger.debug("Found username '{:s}' in credentials file.".format(
                config['root']['username']))
            if username is not None:
                logger.debug(
                    "Overriding previously specified username '{:s}'.".format(
                        username))
            username = config['root']['username']
        if 'password' in config['root']:
            logger.debug("Found password '{:s}' in credentials file.".format(
                config['root']['password']))
            if password is not None:
                logger.debug(
                    "Overriding previously specified password '{:s}'.".format(
                        password))
            password = config['root']['password']
    try:
        #nb = NetBIOS(broadcast=True)
        #if not server_name:
        #    server_name = nb.queryIPForName(server_ip)[0]
        if not server_ip:
            server_ip = socket.gethostbyname(server_name)
        #    server_ip = nb.queryName(server_name)

        # conn = SMBConnection(username, password, socket.gethostname(), server_name, use_ntlm_v2=True, domain=domain)
        host_name = socket.gethostname()
        conn = SMBConnection(username,
                             password,
                             host_name,
                             server_name,
                             domain=domain,
                             use_ntlm_v2=True,
                             is_direct_tcp=True)

        logger.info(("Connecting from '{host:s}' to "
                     "'smb://{user:s}@{ip:s}({server:s}):{port:d}', "
                     " DOMAIN '{domain:s}'").format(user=username,
                                                    ip=server_ip,
                                                    server=server_name,
                                                    port=server_port,
                                                    host=host_name,
                                                    domain=domain))

        # for testing, see types of arguments
        logger.debug(
            ("Types HOST '{host:s}', USER '{user:s}', IP '{ip:s}', "
             "SERVER '{server:s}', PORT '{port:s}', DOMAIN '{domain:s}', "
             "PASSWORD '{password:s}'").format(
                 user=type(username).__name__,
                 ip=type(server_ip).__name__,
                 server=type(server_name).__name__,
                 port=type(server_port).__name__,
                 host=type(host_name).__name__,
                 domain=type(domain).__name__,
                 password=type(password).__name__))

        # conn.connect(server_ip, 139, timeout=30)
        conn.connect(server_ip, port=server_port, timeout=30)

    except (NotReadyError, NotConnectedError) as e:
        logger.error('Could not connect: ' + e.__class__.__name__)
        return 2
    except Exception as e:
        logger.error('Could not connect:')
        logger.error(e.__class__.__name__ + " " + str(e))
        return 2
    logger.info("Connection established.")

    leading_path = os.path.normpath(to_path).split(os.sep)
    trailing_path = []
    while True:
        try:  # first check whether directory exists ...
            filelist = conn.listPath(share, os.path.join(*leading_path))
            logger.info("Remote directory '{:s}' exists.".format(
                os.path.join(*leading_path)))
            if len(trailing_path) == 0:
                break  # all nested direcories exist
            leading_path.append(trailing_path.pop(0))
        except:  # directory does not exist:
            try:  # try to create
                logger.info(
                    "Remote directory '{:s}' does not exist, trying to create."
                    .format(os.path.join(*leading_path)))
                conn.createDirectory(share, os.path.join(*leading_path))
            except:  # directory could not be created, go up in hierarchy
                logger.info("Failed to create remote directory '{:s}'.".format(
                    os.path.join(*leading_path)))
                trailing_path.insert(0, leading_path.pop())
                if len(
                        leading_path
                ) == 0:  # arrived at root of share and did not succeed in creating any directory
                    logger.error(
                        "Desired directory '{:s}' could not be created.".
                        format(to_path))
                    return 2

    filelist = [f for f in filelist if f.filename not in ['.', '..']]
    filename_index = dict()
    logger.info("Files currently stored on the server:")
    for sf in filelist:
        logger.info(info_for_SharedFile(sf))
        filename_index[sf.filename] = sf
    # Loop over local files
    logger.info("Files in local folder to sync:")
    for fn in os.listdir(from_path):
        if not os.path.isfile(os.path.join(from_path, fn)):
            logger.info('Skipping local folder: {}'.format(fn))
            continue
        if fn not in filename_index:
            logger.info("{} not yet on the server. uploading...".format(fn))
            conn.storeFile(share, os.path.join(to_path, fn),
                           open(os.path.join(from_path, fn), 'rb'))
        elif props_SharedFile(filename_index[fn])['size'] != props_LocalFile(
                os.path.join(from_path, fn))['size']:
            logger.info(
                "{} outdated or incomplete on the server. updating...".format(
                    fn))
            conn.storeFile(share, os.path.join(to_path, fn),
                           open(os.path.join(from_path, fn), 'rb'))
        else:
            logger.info("{} already on the server.".format(fn))

    return 0
Example #20
0
    def run():
        global running

        conn = SMBConnection(credentials['username'],
                             credentials['password'],
                             credentials['client_machine_name'],
                             credentials['server_name'],
                             use_ntlm_v2=True)
        assert conn.connect(settings['file_storage']['host'],
                            settings['file_storage']['port'])

        try:
            conn.createDirectory(settings['file_storage']['service_name'],
                                 '/logger/{}'.format(session_name))
        except:
            pass

        a = 0
        go_on = True
        while go_on:
            try:
                conn.createDirectory(
                    settings['file_storage']['service_name'],
                    '/logger/{}/{}-{}'.format(session_name, routing_key, a))
                go_on = False
            except:
                a += 1

        conn.close()
        log_file = '/logger/{}/{}-{}/data.{}'.format(
            session_name, routing_key, a, body.get('file_type', 'unknown'))
        print('[{}] streamer connected'.format(log_file))

        file_obj = tempfile.NamedTemporaryFile()
        file_obj.seek(0)

        context = zmq.Context()
        s = context.socket(zmq.SUB)
        s.setsockopt_string(zmq.SUBSCRIBE, '')
        s.RCVTIMEO = 10000
        s.connect(body['address'])

        t = time.time()

        while running:
            try:
                data = s.recv()
                msgdata, timestamp = msgpack.unpackb(data, use_list=False)
                file_obj.write(msgdata)

                if time.time() - t >= 2:
                    print('write', time.time() - t)
                    t = time.time()
                    file_obj.seek(0)
                    q.put((log_file, file_obj))
            except zmq.error.Again:
                break

        file_obj.seek(0)
        q.put((log_file, file_obj))
        s.close()
        print('[{}] streamer closed'.format(log_file))
Example #21
0
    publish.multiple(msgs, hostname="192.168.1.6")

    # Соединяемся с сервером
    conn = SMBConnection(username='******',
                         password='******',
                         my_name='',
                         remote_name='')
    assert (conn.connect('192.168.1.250'))

    # Создаем названия директории и файлов
    now = datetime.now()
    dir_name = now.strftime('53_1_%Y_%m_%d')
    file_name = now.strftime('%Y_%m_%d_%H_%M_%S.jpg')
    name_folder = conn.listPath('Lukoil', 'Label_Barrel/')

    # Перебираем директории
    listdir = []
    for name in name_folder:
        if name.filename is not listdir:
            listdir.append(name.filename)

    # Создаем новую директорию, если ее нет
    if dir_name not in listdir:
        conn.createDirectory('Lukoil', 'Label_Barrel/' + dir_name)

    # Открываем временный файл с обработанным изображением и записываем его, как файловый объект
    with open('temp_image.jpg', 'rb', buffering=0) as file_obj:
        conn.storeFile('Lukoil', 'Label_Barrel/' + dir_name + '/' + file_name,
                       file_obj)
    file_obj.close()
Example #22
0
class SmbStorage(Storage):
    def __init__(self,
                 name,
                 host,
                 share,
                 path,
                 user='',
                 password='',
                 port=139):
        super().__init__(name, path)
        self.share = share
        self.user = user
        self.password = password
        self.host = host
        self.port = port
        self.name_port = 137
        self.my_hostname = socket.gethostname()
        self.smbcon = SMBConnection(self.user, self.password, self.my_hostname,
                                    self.host)
        self.smbcon.connect(self.host)

    def connect(self):
        self.smbcon = SMBConnection(self.user, self.password, self.my_hostname,
                                    self.host)
        self.smbcon.connect(self.host)

    def close(self):
        self.smbcon.close()

    def create_dir(self, dir_name):
        smb_dir = self.path + '/' + dir_name
        self.smbcon.createDirectory(self.share, smb_dir)

    def put(self, dir_name, file):
        print('File: ', file)
        #self.shares = self.smbcon.listShares()
        #for s in self.shares:
        #    print(s.name)
        date_str = datetime.datetime.now().strftime("%d-%m-%Y")
        try:
            smb_dir = self.smbcon.getAttributes(self.share,
                                                self.path + '/' + dir_name)
            if smb_dir.isDirectory == False:
                self.create_dir(dir_name)
        except OperationFailure:
            self.create_dir(dir_name)

        try:
            smb_dir = self.smbcon.getAttributes(
                self.share, self.path + '/' + dir_name + '/' + date_str)
            if smb_dir.isDirectory == False:
                self.create_dir(dir_name + '/' + date_str)
        except OperationFailure:
            self.create_dir(dir_name + '/' + date_str)

        data = open(file, 'rb')
        file_name = file.split('/')
        file_name = file_name[-1]
        self.smbcon.storeFile(
            self.share,
            self.path + '/' + dir_name + '/' + date_str + '/' + file_name,
            data)
        data.close()
Example #23
0
    for lists in os.listdir(path):
        sub_path = os.path.join(path, lists)
        if os.path.isfile(sub_path):
            fileNum = fileNum + 1
        elif os.path.isdir(sub_path):
            visitDir(sub_path)

visitDir( root_path )
for h5Path in h5PathArr:

    connect = SMBConnection(h5Path['userName'], h5Path['passWord'], '', '', use_ntlm_v2=True)
    connect.connect(h5Path['ip'], 139)

    print( h5Path['ip'] + '/' + h5Path['shareFolderName'] )
    try:
        connect.createDirectory( h5Path['shareFolderName'],h5Path['path']+bankId )
    except OperationFailure:
        pass

    bar = build_tool.progress_bar( fileNum )
    uploadNum = 0

    deleteFile( h5Path['path']+bankId,h5Path )
    deleteDir( dirList,h5Path )
    uploadFile( root_path,h5Path )





Example #24
0
    def reduce(self, events):

        try:
            app_config = cli.getConfStanza('ep_general', 'settings')
            cmd_config = cli.getConfStanzas('ep_smb')
        except BaseException as e:
            raise Exception("Could not read configuration: " + repr(e))

        # Facility info - prepended to log lines
        facility = os.path.basename(__file__)
        facility = os.path.splitext(facility)[0]
        try:
            logger = setup_logger(app_config["log_level"],
                                  'export_everything.log', facility)
        except BaseException as e:
            raise Exception("Could not create logger: " + repr(e))

        logger.info('SMB Export search command initiated')
        logger.debug('search_ep_smb command: %s', self)  # logs command line

        # Enumerate proxy settings
        http_proxy = os.environ.get('HTTP_PROXY')
        https_proxy = os.environ.get('HTTPS_PROXY')
        proxy_exceptions = os.environ.get('NO_PROXY')

        if http_proxy is not None:
            logger.debug("HTTP proxy: %s" % http_proxy)
        if https_proxy is not None:
            logger.debug("HTTPS proxy: %s" % https_proxy)
        if proxy_exceptions is not None:
            logger.debug("Proxy Exceptions: %s" % proxy_exceptions)

        # Enumerate settings
        app = self._metadata.searchinfo.app
        user = self._metadata.searchinfo.username
        dispatch = self._metadata.searchinfo.dispatch_dir
        session_key = self._metadata.searchinfo.session_key

        if self.target is None and 'target=' in str(self):
            recover_parameters(self)
        # Replace all tokenized parameter strings
        replace_object_tokens(self)

        # Use the random number to support running multiple outputs in a single search
        random_number = str(random.randint(10000, 100000))

        try:
            target_config = get_config_from_alias(session_key, cmd_config,
                                                  self.target)
            if target_config is None:
                exit_error(
                    logger,
                    "Unable to find target configuration (%s)." % self.target,
                    100937)
        except BaseException as e:
            exit_error(logger,
                       "Error reading target server configuration: " + repr(e),
                       124812)

        # Get the local client hostname
        client_name = socket.gethostname()
        # Delete any domain from the client hostname string
        if '.' in client_name:
            client_name = client_name[0:client_name.index('.')]

        # Check to see if we have credentials
        valid_settings = []
        for l in list(target_config.keys()):
            if len(target_config[l]) > 0:
                valid_settings.append(l)
        if 'host' in valid_settings:
            # A target has been configured. Check for credentials.
            try:
                if 'credential_username' in valid_settings and 'credential_password' in valid_settings and 'share_name' in valid_settings:
                    domain = target_config[
                        'credential_realm'] if 'credential_realm' in list(
                            target_config.keys()) else target_config['host']

                    try:
                        # Try port 445 first
                        conn = SMBConnection(
                            target_config['credential_username'],
                            target_config['credential_password'],
                            client_name,
                            target_config['host'],
                            domain=domain,
                            use_ntlm_v2=True,
                            sign_options=SMBConnection.SIGN_WHEN_SUPPORTED,
                            is_direct_tcp=True)
                        connected = conn.connect(target_config['host'],
                                                 445,
                                                 timeout=5)

                        if target_config['share_name'] not in (
                                s.name for s in conn.listShares(timeout=10)):
                            exit_error(
                                logger,
                                "Unable to find the specified share name on the server",
                                553952)
                        '''
						p445_error = repr(e445)
						try:
							# Try port 139 if that didn't work
							conn = SMBConnection(target_config['credential_username'], target_config['credential_password'], client_name, 
							target_config['host'], domain=domain, use_ntlm_v2=True,
							sign_options = SMBConnection.SIGN_WHEN_SUPPORTED) 
							connected = conn.connect(target_config['host'], 139, timeout=5)
						except BaseException as e139:
							p139_error = repr(e139)
							raise Exception("Errors connecting to host: \\nPort 139: %s\\nPort 445: %s" % (p139_error, p445_error))

						conn = SMBConnection(target_config['credential_username'], target_config['credential_password'], client_name, 
							target_config['host'], domain=domain, use_ntlm_v2=True,
							sign_options = SMBConnection.SIGN_WHEN_SUPPORTED) 
						connected = conn.connect(target_config['host'], 139)
						shares = 
						share_exists = False
						for i in range(len(shares)):
							if shares[i].name == target_config['share_name']:
								share_exists = True
								break
						'''
                    except BaseException as e:
                        exit_error(
                            logger,
                            "Unable to setup SMB connection: " + repr(e),
                            921982)
                else:
                    exit_error(logger, "Required settings not found", 101926)
            except BaseException as e:
                exit_error(logger,
                           "Error reading the configuration: " + repr(e),
                           230494)
        else:
            exit_error(logger,
                       "Could not find required configuration settings",
                       2823874)

        file_extensions = {
            'raw': '.log',
            'kv': '.log',
            'pipe': '.log',
            'csv': '.csv',
            'tsv': '.tsv',
            'json': '.json'
        }

        if self.outputformat is None:
            self.outputformat = 'csv'
        # Create the default filename
        default_filename = ('export_' + user + '___now__' +
                            file_extensions[self.outputformat]).strip("'")

        folder, filename = event_file.parse_outputfile(self.outputfile,
                                                       default_filename,
                                                       target_config)

        if self.compress is not None:
            logger.debug('Compression: %s', self.compress)
        else:
            try:
                self.compress = target_config.get('compress')
            except:
                self.compress = False

        staging_filename = 'export_everything_staging_' + random_number + '.txt'
        local_output_file = os.path.join(dispatch, staging_filename)
        if self.compress:
            local_output_file = local_output_file + '.gz'

        # Append .gz to the output file if compress=true
        if not self.compress and len(filename) > 3:
            if filename[-3:] == '.gz':
                # We have a .gz extension when compression was not specified. Enable compression.
                self.compress = True
        elif self.compress and len(filename) > 3:
            if filename[-3:] != '.gz':
                filename = filename + '.gz'

        if conn is not None:
            # Use the credential to connect to the SFTP server
            try:
                # Check to see if the folder exists
                folder_attrs = conn.getAttributes(target_config['share_name'],
                                                  folder,
                                                  timeout=10)
            except BaseException:
                # Remote directory could not be loaded. It must not exist. Create it.
                # Create the folders required to store the file
                subfolders = ['/'] + folder.strip('/').split('/')
                if '' in subfolders:
                    subfolders.remove('')
                logger.debug("Folders list for dir creation: %s" %
                             str(subfolders))
                current_folder = ''
                folder_depth = len(subfolders) - 1
                for i, subfolder_name in enumerate(subfolders):
                    current_folder = (current_folder + '/' +
                                      subfolder_name).replace('//', '/')
                    logger.debug("Current folder = " + current_folder)
                    try:
                        conn.getAttributes(target_config['share_name'],
                                           current_folder,
                                           timeout=10)
                    except:
                        conn.createDirectory(target_config['share_name'],
                                             current_folder,
                                             timeout=10)
                try:
                    folder_attrs = conn.getAttributes(
                        target_config['share_name'], folder, timeout=10)
                except BaseException as e:
                    exit_error(
                        logger, "Could not load or create remote directory: " +
                        repr(e), 377890)

            # This should always be true
            if folder_attrs is not None:
                if folder_attrs.isReadOnly or not folder_attrs.isDirectory:
                    exit_error(
                        logger,
                        "Could not access the remote directory: " + repr(e),
                        184772)
                else:
                    try:
                        event_counter = 0
                        # Write the output file to disk in the dispatch folder
                        logger.debug(
                            "Writing events to dispatch file. file=\"%s\" format=%s compress=%s fields=%s",
                            local_output_file, self.outputformat,
                            self.compress, self.fields)
                        for event in event_file.write_events_to_file(
                                events, self.fields, local_output_file,
                                self.outputformat, self.compress):
                            yield event
                            event_counter += 1
                    except BaseException as e:
                        exit_error(logger,
                                   "Error writing file to upload: " + repr(e),
                                   296733)

                    # Write the file to the remote location
                    try:
                        with open(local_output_file, 'rb',
                                  buffering=0) as local_file:
                            bytes_uploaded = conn.storeFile(
                                target_config['share_name'],
                                folder + '/' + filename, local_file)
                    except BaseException as e:
                        exit_error(
                            logger,
                            "Error uploading file to SMB server: " + repr(e),
                            109693)

                    if bytes_uploaded > 0:
                        message = "SMB Export Status: Success. File name: %s" % (
                            folder + '/' + filename)
                        eprint(message)
                        logger.info(message)
                    else:
                        exit_error(logger, "Zero bytes uploaded", 771293)
        else:
            exit_error(logger, "Could not connect to server.", 159528)
Example #25
0
class SMB_client():
	def __init__(self,username=None,password=None,smb_name=None,print_errors=True):
		self.username     = username
		self.password     = password
		self.smb_name     = smb_name
		self.print_errors = print_errors
		self.smb_ip       = None
		self.conn         = None
		self.service_name = None
		self.my_name      = None
		self.error        = None
		self.tree         = []

	def getBIOSName(self, remote_smb_ip, timeout=5):			# unused if dynamic IP
		# ip -> smb name
		try:
			self.error = None
			bios = NetBIOS()
			srv_name = bios.queryIPForName(remote_smb_ip, timeout=timeout)
			return srv_name[0]
		except Exception as e:
			if self.print_errors:
				print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno), type(e).__name__, e)
			else:
				self.error = 'Error on line {}'.format(sys.exc_info()[-1].tb_lineno) + str(type(e).__name__) + str(e)
			return None
			
	def getIP(self):
		# smb name -> ip
		try:
			self.error = None
			bios = NetBIOS()
			ip = bios.queryName(self.smb_name)
			return ip[0]
		except Exception as e:
			if self.print_errors:
				print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno), type(e).__name__, e)
			else:
				self.error = 'Error on line {}'.format(sys.exc_info()[-1].tb_lineno) + str(type(e).__name__) + str(e)
			return None
			
	def connect(self):
		try:
			self.error = None
			self.my_name = gethostname()				# iDevice name
			self.smb_ip = self.getIP()
			smb_structs.SUPPORT_SMB2 = True
			self.conn = SMBConnection(self.username, self.password, self.my_name, self.smb_name, use_ntlm_v2 = True)
			self.conn.connect(self.smb_ip, 139)		#139=NetBIOS / 445=TCP
			if self.conn:
				shares = self.conn.listShares()
				for share in shares:
					if share.type == 0:		# 0 = DISK_TREE
						self.service_name = share.name  
		except Exception as e:
			if self.print_errors:
				print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno), type(e).__name__, e)
			else:
				self.error = 'Error on line {}'.format(sys.exc_info()[-1].tb_lineno) + str(type(e).__name__) + str(e)
			
	def close(self):
		try:
			self.error = None
			self.conn.close()
		except Exception as e:
			if self.print_errors:
				print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno), type(e).__name__, e)
			else:
				self.error = 'Error on line {}'.format(sys.exc_info()[-1].tb_lineno) + str(type(e).__name__) + str(e)
 
	def getRemoteDir(self, path, pattern):
		try:
			self.error = None
			files = self.conn.listPath(self.service_name, path, pattern=pattern)
			return files
		except Exception as e:
			if self.print_errors:
				print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno), type(e).__name__, e)
			else:
				self.error = 'Error on line {}'.format(sys.exc_info()[-1].tb_lineno) + str(type(e).__name__) + str(e)
			return None
				
	def getRemoteTree(self,path=''):
		try:
			self.error = None
			if path == '':
				w = ''
			else:
				w = path+'/'
			files = self.getRemoteDir(path, '*')
			if files:
				for file in files:
					if file.filename[0] == '.':
						continue
					self.tree.append({'name':w+file.filename, 'isdir':file.isDirectory, 'size':file.file_size})
					if file.isDirectory:
						self.getRemoteTree(path=w+file.filename)
			return self.tree
		except Exception as e:
			if self.print_errors:
				print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno), type(e).__name__, e)
			else:
				self.error = 'Error on line {}'.format(sys.exc_info()[-1].tb_lineno) + str(type(e).__name__) + str(e)
			return None

	def download(self, path, filename,buffersize=None,callback=None, local_path=None):
		try:
			self.error = None
			#print('Download = ' + path + filename)
			attr = self.conn.getAttributes(self.service_name, path+filename)
			#print('Size = %.1f kB' % (attr.file_size / 1024.0))
			#print('start download')
			file_obj = BytesIO()
			if local_path:
				fw = open(local_path+filename, 'wb')
			else:
				fw = open(filename, 'wb')
			offset = 0
			transmit =0
			while True:
				if not buffersize:
					file_attributes, filesize = self.conn.retrieveFile(self.service_name, path+filename, file_obj)
				else:
					file_attributes, filesize = self.conn.retrieveFileFromOffset(self.service_name, path+filename, file_obj,offset=offset,max_length=buffersize)
					if callback:
						transmit = transmit + filesize
						callback(transmit)
				file_obj.seek(offset)
				for line in file_obj:
					fw.write(line)
				offset = offset + filesize
				if (not buffersize) or (filesize == 0):
					break
			fw.close()
			#print('download finished')
		except Exception as e:
			if self.print_errors:
				print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno), type(e).__name__, e)
			else:
				self.error = 'Error on line {}'.format(sys.exc_info()[-1].tb_lineno) + str(type(e).__name__) + str(e)
			
	def upload(self, path, filename,buffersize=None,callback=None, local_path=None):
		try:
			self.error = None
			#print('Upload = ' + path + filename)
			#print('Size = %.1f kB' % (os.path.getsize(filename) / 1024.0))
			#print('start upload')
			if local_path:
				file_obj = open(local_path+filename, 'rb')
			else:
				file_obj = open(filename, 'rb')
			offset = 0
			while True:
				if not buffersize:
					filesize = self.conn.storeFile(self.service_name, path+filename, file_obj)
					break
				else:	
					buffer_obj = file_obj.read(buffersize)			
					if buffer_obj:
						buffer_fileobj = BytesIO()
						buffer_fileobj.write(buffer_obj)
						buffer_fileobj.seek(0)
						offset_new = self.conn.storeFileFromOffset(self.service_name, path+filename, buffer_fileobj, offset=offset, truncate=False)
						#return the file position where the next byte will be written.
						offset = offset_new
						if callback:
							callback(offset)
					else:
						break
			file_obj.close()
			#print('upload finished')
		except Exception as e:
			if self.print_errors:
				print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno), type(e).__name__, e)
			else:
				self.error = 'Error on line {}'.format(sys.exc_info()[-1].tb_lineno) + str(type(e).__name__) + str(e)

	def delete_remote_file(self,path, filename):
		try:
			self.error = None
			self.conn.deleteFiles(self.service_name, path+filename)
			#print('Remotefile ' + path + filename + ' deleted')
		except Exception as e:
			if self.print_errors:
				print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno), type(e).__name__, e)
			else:
				self.error = 'Error on line {}'.format(sys.exc_info()[-1].tb_lineno) + str(type(e).__name__) + str(e)

	def createRemoteDir(self, path):
		try:
			self.error = None
			self.conn.createDirectory(self.service_name, path)
		except Exception as e:
			if self.print_errors:
				print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno), type(e).__name__, e)
			else:
				self.error = 'Error on line {}'.format(sys.exc_info()[-1].tb_lineno) + str(type(e).__name__) + str(e)
  
	def removeRemoteDir(self,path):
		try:
			self.error = None
			self.conn.deleteDirectory(self.service_name, path)
		except Exception as e:
			if self.print_errors:
				print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno), type(e).__name__, e)
			else:
				self.error = 'Error on line {}'.format(sys.exc_info()[-1].tb_lineno) + str(type(e).__name__) + str(e)

	def renameRemoteFileOrDir(self,old_path, new_path):
		try:
			self.error = None
			self.conn.rename(self.service_name, old_path, new_path)
		except Exception as e:
			if self.print_errors:
				print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno), type(e).__name__, e)
			else:
				self.error = 'Error on line {}'.format(sys.exc_info()[-1].tb_lineno) + str(type(e).__name__) + str(e)
class SMB_client():
    def __init__(self,
                 username=None,
                 password=None,
                 smb_name=None,
                 print_errors=True):
        self.username = username
        self.password = password
        self.smb_name = smb_name
        self.print_errors = print_errors
        self.smb_ip = None
        self.conn = None
        self.service_name = None
        self.my_name = None
        self.error = None
        self.tree = []

    def getBIOSName(self, remote_smb_ip, timeout=5):  # unused if dynamic IP
        # ip -> smb name
        try:
            self.error = None
            bios = NetBIOS()
            srv_name = bios.queryIPForName(remote_smb_ip, timeout=timeout)
            return srv_name[0]
        except Exception as e:
            if self.print_errors:
                print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno),
                      type(e).__name__, e)
            else:
                self.error = 'Error on line {}'.format(
                    sys.exc_info()[-1].tb_lineno) + str(
                        type(e).__name__) + str(e)
            return None

    def getIP(self):
        # smb name -> ip
        try:
            self.error = None
            bios = NetBIOS()
            ip = bios.queryName(self.smb_name)
            return ip[0]
        except Exception as e:
            if self.print_errors:
                print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno),
                      type(e).__name__, e)
            else:
                self.error = 'Error on line {}'.format(
                    sys.exc_info()[-1].tb_lineno) + str(
                        type(e).__name__) + str(e)
            return None

    def connect(self):
        try:
            self.error = None
            self.my_name = gethostname()  # iDevice name
            self.smb_ip = self.getIP()
            smb_structs.SUPPORT_SMB2 = True
            self.conn = SMBConnection(self.username,
                                      self.password,
                                      self.my_name,
                                      self.smb_name,
                                      use_ntlm_v2=True)
            self.conn.connect(self.smb_ip, 139)  #139=NetBIOS / 445=TCP
            if self.conn:
                shares = self.conn.listShares()
                for share in shares:
                    if share.type == 0:  # 0 = DISK_TREE
                        self.service_name = share.name
        except Exception as e:
            if self.print_errors:
                print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno),
                      type(e).__name__, e)
            else:
                self.error = 'Error on line {}'.format(
                    sys.exc_info()[-1].tb_lineno) + str(
                        type(e).__name__) + str(e)

    def close(self):
        try:
            self.error = None
            self.conn.close()
        except Exception as e:
            if self.print_errors:
                print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno),
                      type(e).__name__, e)
            else:
                self.error = 'Error on line {}'.format(
                    sys.exc_info()[-1].tb_lineno) + str(
                        type(e).__name__) + str(e)

    def getRemoteDir(self, path, pattern):
        try:
            self.error = None
            files = self.conn.listPath(self.service_name,
                                       path,
                                       pattern=pattern)
            return files
        except Exception as e:
            if self.print_errors:
                print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno),
                      type(e).__name__, e)
            else:
                self.error = 'Error on line {}'.format(
                    sys.exc_info()[-1].tb_lineno) + str(
                        type(e).__name__) + str(e)
            return None

    def getRemoteTree(self, path=''):
        try:
            self.error = None
            if path == '':
                w = ''
            else:
                w = path + '/'
            files = self.getRemoteDir(path, '*')
            if files:
                for file in files:
                    if file.filename[0] == '.':
                        continue
                    self.tree.append({
                        'name': w + file.filename,
                        'isdir': file.isDirectory,
                        'size': file.file_size
                    })
                    if file.isDirectory:
                        self.getRemoteTree(path=w + file.filename)
            return self.tree
        except Exception as e:
            if self.print_errors:
                print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno),
                      type(e).__name__, e)
            else:
                self.error = 'Error on line {}'.format(
                    sys.exc_info()[-1].tb_lineno) + str(
                        type(e).__name__) + str(e)
            return None

    def download(self,
                 path,
                 filename,
                 buffersize=None,
                 callback=None,
                 local_path=None):
        try:
            self.error = None
            #print('Download = ' + path + filename)
            attr = self.conn.getAttributes(self.service_name, path + filename)
            #print('Size = %.1f kB' % (attr.file_size / 1024.0))
            #print('start download')
            file_obj = BytesIO()
            if local_path:
                fw = open(local_path + filename, 'wb')
            else:
                fw = open(filename, 'wb')
            offset = 0
            transmit = 0
            while True:
                if not buffersize:
                    file_attributes, filesize = self.conn.retrieveFile(
                        self.service_name, path + filename, file_obj)
                else:
                    file_attributes, filesize = self.conn.retrieveFileFromOffset(
                        self.service_name,
                        path + filename,
                        file_obj,
                        offset=offset,
                        max_length=buffersize)
                    if callback:
                        transmit = transmit + filesize
                        callback(transmit)
                file_obj.seek(offset)
                for line in file_obj:
                    fw.write(line)
                offset = offset + filesize
                if (not buffersize) or (filesize == 0):
                    break
            fw.close()
            #print('download finished')
        except Exception as e:
            if self.print_errors:
                print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno),
                      type(e).__name__, e)
            else:
                self.error = 'Error on line {}'.format(
                    sys.exc_info()[-1].tb_lineno) + str(
                        type(e).__name__) + str(e)

    def upload(self,
               path,
               filename,
               buffersize=None,
               callback=None,
               local_path=None):
        try:
            self.error = None
            #print('Upload = ' + path + filename)
            #print('Size = %.1f kB' % (os.path.getsize(filename) / 1024.0))
            #print('start upload')
            if local_path:
                file_obj = open(local_path + filename, 'rb')
            else:
                file_obj = open(filename, 'rb')
            offset = 0
            while True:
                if not buffersize:
                    filesize = self.conn.storeFile(self.service_name,
                                                   path + filename, file_obj)
                    break
                else:
                    buffer_obj = file_obj.read(buffersize)
                    if buffer_obj:
                        buffer_fileobj = BytesIO()
                        buffer_fileobj.write(buffer_obj)
                        buffer_fileobj.seek(0)
                        offset_new = self.conn.storeFileFromOffset(
                            self.service_name,
                            path + filename,
                            buffer_fileobj,
                            offset=offset,
                            truncate=False)
                        #return the file position where the next byte will be written.
                        offset = offset_new
                        if callback:
                            callback(offset)
                    else:
                        break
            file_obj.close()
            #print('upload finished')
        except Exception as e:
            if self.print_errors:
                print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno),
                      type(e).__name__, e)
            else:
                self.error = 'Error on line {}'.format(
                    sys.exc_info()[-1].tb_lineno) + str(
                        type(e).__name__) + str(e)

    def delete_remote_file(self, path, filename):
        try:
            self.error = None
            self.conn.deleteFiles(self.service_name, path + filename)
            #print('Remotefile ' + path + filename + ' deleted')
        except Exception as e:
            if self.print_errors:
                print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno),
                      type(e).__name__, e)
            else:
                self.error = 'Error on line {}'.format(
                    sys.exc_info()[-1].tb_lineno) + str(
                        type(e).__name__) + str(e)

    def createRemoteDir(self, path):
        try:
            self.error = None
            self.conn.createDirectory(self.service_name, path)
        except Exception as e:
            if self.print_errors:
                print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno),
                      type(e).__name__, e)
            else:
                self.error = 'Error on line {}'.format(
                    sys.exc_info()[-1].tb_lineno) + str(
                        type(e).__name__) + str(e)

    def removeRemoteDir(self, path):
        try:
            self.error = None
            self.conn.deleteDirectory(self.service_name, path)
        except Exception as e:
            if self.print_errors:
                print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno),
                      type(e).__name__, e)
            else:
                self.error = 'Error on line {}'.format(
                    sys.exc_info()[-1].tb_lineno) + str(
                        type(e).__name__) + str(e)

    def renameRemoteFileOrDir(self, old_path, new_path):
        try:
            self.error = None
            self.conn.rename(self.service_name, old_path, new_path)
        except Exception as e:
            if self.print_errors:
                print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno),
                      type(e).__name__, e)
            else:
                self.error = 'Error on line {}'.format(
                    sys.exc_info()[-1].tb_lineno) + str(
                        type(e).__name__) + str(e)