Retrieve details for a vulnerability.

 @param [String] vuln_id Nexpose vulnerability ID, such as 'windows-duqu-cve-2011-3402'.
 @return [VulnerabilityDetail] Details of the requested vulnerability.
427110
def vuln_details(vuln_id)
      xml = make_xml('VulnerabilityDetailsRequest', { 'vuln-id' => vuln_id })
      response = execute(xml, '1.2')
      if response.success
        response.res.elements.each('VulnerabilityDetailsResponse/Vulnerability') do |vuln|
          return XML::VulnerabilityDetail.parse(vuln)
        end
      end
    end
956063
function details(id) {
  return new Promise((resolve, reject) => {
    if (!id || id === '') throw new Error('id cannot be blank');

    const options = {
      method: 'GET',
      hostname: 'www.exploitalert.com',
      port: null,
      path: `/view-details.html?id=${id}`,
      headers: {},
    };

    const req = http.request(options, (res) => {
      const chunks = [];

      res.on('data', (chunk) => {
        chunks.push(chunk);
      });

      res.on('end', () => {
        const body = Buffer.concat(chunks);
        resolve(body.toString());
      });
    });
    req.on('error', reject);
    req.end();
  })
    .then((html) => {
      const $ = cheerio.load(html);
      return $('pre').text();
    })
    .catch(err => err);
}
960003
def details(address_id)
      details_url = File.join(DOMESTIC_URL, address_id.to_s)
      response = @connection.get details_url
      OpenStruct.new(response.parsed['address'])
    end
790982
def info(self, server_id):
        
        result = self._storage[server_id].info()
        result['id'] = server_id
        return result
124098
private void extractProtocolInfo(URI dsnUri) {
        String scheme = dsnUri.getScheme();
        if (scheme == null) {
            return;
        }
        String[] schemeDetails = scheme.split("\\+");
        protocolSettings.addAll(Arrays.asList(schemeDetails).subList(0, schemeDetails.length - 1));
        protocol = schemeDetails[schemeDetails.length - 1];
    }
274853
def get_id(self):
        
        if self._id is None:
            # FIXME: provide a better error message when key is not defined
            self._id = self.inspect(refresh=False)["Id"]
        return self._id
92043
def usable_id(cls, id):
        
        try:
            # id is maybe a hostname
            qry_id = cls.from_name(id)
            if not qry_id:
                # id is maybe an ip
                qry_id = cls.from_ip(id)
            if not qry_id:
                qry_id = cls.from_vhost(id)
        except Exception:
            qry_id = None

        if not qry_id:
            msg = 'unknown identifier %s' % id
            cls.error(msg)

        return qry_id
1319629
def wf_link_id?(id)
      return true if id.is_a?(String) && id =~ /^\w{16}$/
      raise Wavefront::Exception::InvalidExternalLinkId
    end
1176294
def get_details(operation_id, custom_headers:nil)
      response = get_details_async(operation_id, custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
643266
function preprocess(raw) {
  const entry = {
    type: 'vulnerability',
    id: `NSWG-ECO-${raw.id}`,
    cves: raw.cves || [],
    affected_versions: raw.vulnerable_versions,
    patched_versions: raw.patched_versions,
    cvss_vector: raw.cvss_vector,
    cvss_score: raw.cvss_score,
    title: raw.title,
    publish_date: raw.publish_date
      ? new Date(raw.publish_date)
      : undefined,
    recommendation: raw.recommendation,
    description: raw.overview,
    references: (raw.references || '').split('\n'),
    raw
  };
  if (raw.slug && raw.coordinating_vendor === '^Lift Security') {
    // There are duplicate slugs that break deduping.  Also, nodesecurity gives
    // a 500 error for those, so let's not use them
    // entry.references.push(`https://nodesecurity.io/advisories/${raw.slug}`);
  }
  return normalize.auto(entry);
}
1051744
def thread_details(io_handler, thread_id, max_depth=0):
        
        # Normalize maximum depth
        try:
            max_depth = int(max_depth)
            if max_depth < 1:
                max_depth = None
        except (ValueError, TypeError):
            max_depth = None

        # pylint: disable=W0212
        try:
            # Get the stack
            thread_id = int(thread_id)
            stack = sys._current_frames()[thread_id]
        except KeyError:
            io_handler.write_line("Unknown thread ID: {0}", thread_id)
        except ValueError:
            io_handler.write_line("Invalid thread ID: {0}", thread_id)
        except AttributeError:
            io_handler.write_line("sys._current_frames() is not available.")
        else:
            # Get the name
            try:
                name = threading._active[thread_id].name
            except KeyError:
                name = "<unknown>"

            lines = [
                "Thread ID: {0} - Name: {1}".format(thread_id, name),
                "Stack trace:",
            ]

            trace_lines = []
            depth = 0
            frame = stack
            while frame is not None and (
                max_depth is None or depth < max_depth
            ):
                # Store the line information
                trace_lines.append(format_frame_info(frame))

                # Previous frame...
                frame = frame.f_back
                depth += 1

            # Reverse the lines
            trace_lines.reverse()

            # Add them to the printed lines
            lines.extend(trace_lines)

            lines.append("")
            io_handler.write("\n".join(lines))
1098062
def with_debug_id(debug_id):
        """"""
        ctx = SpanContext(
            trace_id=None, span_id=None, parent_id=None, flags=None
        )
        ctx._debug_id = debug_id
        return ctx
747537
def get_plaintext(self, id): # pylint: disable=invalid-name,redefined-builtin
        
        return self.service.get_id(self.base, id, params={'format': 'text'}).text
428379
def html_id(prefix, index)
      prefix = prefix || self.engine_id
      prefix, index = prefix.to_s, index.to_s

      return nil if index.empty?
      return nil if prefix.empty?

      return "#{prefix}_#{index}"
    end
206472
def get_password_data(self, instance_id):
        

        params = {'InstanceId' : instance_id}
        rs = self.get_object('GetPasswordData', params, ResultSet, verb='POST')
        return rs.passwordData
428159
def get(self, oid):
        
        snmpsecurity = self._get_snmp_security()

        try:
            engine_error, pdu_error, pdu_error_index, objects = self._cmdgen.getCmd(
                snmpsecurity,
                cmdgen.UdpTransportTarget((self.host, self.port), timeout=self.timeout,
                                          retries=self.retries),
                oid,
            )

        except Exception as e:
            raise SNMPError(e)
        if engine_error:
            raise SNMPError(engine_error)
        if pdu_error:
            raise SNMPError(pdu_error.prettyPrint())

        _, value = objects[0]
        value = _convert_value_to_native(value)
        return value
1140362
function(jid_or_user_id) {
        var jid;
        if (typeof jid_or_user_id === 'string') {
            jid = jid_or_user_id;
        } else if (typeof jid_or_user_id === 'number') {
            jid = jid_or_user_id + '-' + config.creds.appId + '@' + config.endpoints.chat;
        } else {
            throw new Error('The method "jidOrUserId" may take jid or id');
        }
        return jid;
    }