docs: def _got_session(self, response):
          """Private function to navigate SOL payload activation
          """
          if 'error' in response:
              self._print_error(response['error'])
              return
          if not self.ipmi_session:
              self.callgotsession = response
              return
          # Send activate sol payload directive
          # netfn= 6 (application)
          # command = 0x48 (activate payload)
          # data = (1, sol payload type
          #        1, first instance
          #        0b11000000, -encrypt, authenticate,
          #                      disable serial/modem alerts, CTS fine
          #        0, 0, 0 reserved
          response = self.ipmi_session.raw_command(netfn=0x6, command=0x48,
                                                   data=(1, 1, 192, 0, 0, 0))
          # given that these are specific to the command,
          # it's probably best if one can grep the error
          # here instead of in constants
          sol_activate_codes = {
              0x81: 'SOL is disabled',
              0x82: 'Maximum SOL session count reached',
              0x83: 'Cannot activate payload with encryption',
              0x84: 'Cannot activate payload without encryption',
          }
          if 'code' in response and response['code']:
              if response['code'] in constants.ipmi_completion_codes:
                  self._print_error(
                      constants.ipmi_completion_codes[response['code']])
                  return
              elif response['code'] == 0x80:
                  if self.force_session and not self.retriedpayload:
                      self.retriedpayload = 1
                      sessrsp = self.ipmi_session.raw_command(
                          netfn=0x6,
                          command=0x49,
                          data=(1, 1, 0, 0, 0, 0))
                      self._got_session(sessrsp)
                      return
                  else:
                      self._print_error('SOL Session active for another client')
                      return
              elif response['code'] in sol_activate_codes:
                  self._print_error(sol_activate_codes[response['code']])
                  return
              else:
                  self._print_error(
                      'SOL encountered Unrecognized error code %d' %
                      response['code'])
                  return
          if 'error' in response:
              self._print_error(response['error'])
              return
          self.activated = True
          # data[0:3] is reserved except for the test mode, which we don't use
          data = response['data']
          self.maxoutcount = (data[5] << 8) + data[4]
          # BMC tells us this is the maximum allowed size
          # data[6:7] is the promise of how small packets are going to be, but we
          # don't have any reason to worry about it
          # some BMCs disagree on the endianness, so do both
          valid_ports = (self.port, struct.unpack(
              '<H', struct.pack('>H', self.port))[0])
          if (data[8] + (data[9] << 8)) not in valid_ports:
              # TODO(jbjohnso): support atypical SOL port number
              raise NotImplementedError("Non-standard SOL Port Number")
          # ignore data[10:11] for now, the vlan detail, shouldn't matter to this
          # code anyway...
          # NOTE(jbjohnso):
          # We will use a special purpose keepalive
          if self.ipmi_session.sol_handler is not None:
              # If there is erroneously another SOL handler already, notify
              # it of newly established session
              self.ipmi_session.sol_handler({'error': 'Session Disconnected'})
          self.keepaliveid = self.ipmi_session.register_keepalive(
              cmd={'netfn': 6, 'command': 0x4b, 'data': (1, 1)},
              callback=self._got_payload_instance_info)
          self.ipmi_session.sol_handler = self._got_sol_payload
          self.connected = True
          # self._sendpendingoutput() checks len(self._sendpendingoutput)
          self._sendpendingoutput()