docs: def _file_recv(self, load):
          '''
          Allows minions to send files to the master, files are sent to the
          master file cache
          '''
          if any(key not in load for key in ('id', 'path', 'loc')):
              return False
          if not isinstance(load['path'], list):
              return False
          if not self.opts['file_recv']:
              return False
          if not salt.utils.verify.valid_id(self.opts, load['id']):
              return False
          if 'loc' in load and load['loc'] < 0:
              log.error('Invalid file pointer: load[loc] < 0')
              return False
  
          if len(load['data']) + load.get('loc', 0) > self.opts['file_recv_max_size'] * 0x100000:
              log.error(
                  'file_recv_max_size limit of %d MB exceeded! %s will be '
                  'truncated. To successfully push this file, adjust '
                  'file_recv_max_size to an integer (in MB) large enough to '
                  'accommodate it.', self.opts['file_recv_max_size'], load['path']
              )
              return False
          if 'tok' not in load:
              log.error(
                  'Received incomplete call from %s for \'%s\', missing \'%s\'',
                  load['id'], inspect_stack()['co_name'], 'tok'
              )
              return False
          if not self.__verify_minion(load['id'], load['tok']):
              # The minion is not who it says it is!
              # We don't want to listen to it!
              log.warning('Minion id %s is not who it says it is!', load['id'])
              return {}
          load.pop('tok')
  
          # Join path
          sep_path = os.sep.join(load['path'])
  
          # Path normalization should have been done by the sending
          # minion but we can't guarantee it. Re-do it here.
          normpath = os.path.normpath(sep_path)
  
          # Ensure that this safety check is done after the path
          # have been normalized.
          if os.path.isabs(normpath) or '../' in load['path']:
              # Can overwrite master files!!
              return False
  
          cpath = os.path.join(
              self.opts['cachedir'],
              'minions',
              load['id'],
              'files',
              normpath)
          # One last safety check here
          if not os.path.normpath(cpath).startswith(self.opts['cachedir']):
              log.warning(
                  'Attempt to write received file outside of master cache '
                  'directory! Requested path: %s. Access denied.', cpath
              )
              return False
          cdir = os.path.dirname(cpath)
          if not os.path.isdir(cdir):
              try:
                  os.makedirs(cdir)
              except os.error:
                  pass
          if os.path.isfile(cpath) and load['loc'] != 0:
              mode = 'ab'
          else:
              mode = 'wb'
          with salt.utils.files.fopen(cpath, mode) as fp_:
              if load['loc']:
                  fp_.seek(load['loc'])
  
              fp_.write(salt.utils.stringutils.to_bytes(load['data']))
          return True