def load_login(_auth, _master):
try:
locale = 'en_US'
android_id = gm_api_mob.FROM_MAC_ADDRESS
is_mac = android_id is gm_api_mob.FROM_MAC_ADDRESS
if is_mac:
mac_int = getmac()
if (mac_int >> 40) % 2:
raise OSError("a valid MAC could not be determined."
" Provide an android_id (and be"
" sure to provide the same one on future runs).")
device_id = utils.create_mac_string(mac_int)
device_id = device_id.replace(':', '')
else:
device_id = android_id
gm_api_mob.session._master_token = _master
gm_api_mob.session._authtoken = _auth
gm_api_mob.session.is_authenticated = True
gm_api_mob.android_id = gm_api_mob._validate_device_id(device_id,
is_mac=is_mac)
gm_api_mob.logger.info("authenticated")
gm_api_mob.locale = locale
if gm_api_mob.is_subscribed:
gm_api_mob.logger.info("subscribed")
return True
except:
traceback.print_exc(file=sys.stdout)
return False
def __init__(self):
#Mac and hostname are used to identify our client.
self.mac = hex(getmac())[2:-1]
self.mac = ':'.join([self.mac[x:x + 2] for x in range(0, 10, 2)])
hostname = gethostname()
#Pre-filled protobuff instances.
#These are used to fill in new instances.
#Named scheme is '[protocol name]_filled'
self.upload_auth_filled = metadata_pb2.UploadAuth()
self.upload_auth_filled.address = self.mac
self.upload_auth_filled.hostname = hostname
self.client_state_filled = metadata_pb2.ClientState()
self.client_state_filled.address = self.mac
self.upload_auth_response_filled = metadata_pb2.UploadAuthResponse()
self.client_state_response_filled = metadata_pb2.ClientStateResponse()
self.metadata_request_filled = metadata_pb2.MetadataRequest()
self.metadata_request_filled.address = self.mac
self.metadata_response_filled = metadata_pb2.MetadataResponse()
#Service name mapped to url.
self.pb_services = {
"upload_auth": 'upauth',
"client_state": 'clientstate',
"metadata": 'metadata?version=1'
}
def __init__(self):
#Mac and hostname are used to identify our client.
self.mac = hex(getmac())[2:-1]
self.mac = ':'.join([self.mac[x:x+2] for x in range(0, 10, 2)])
hostname = gethostname()
#Pre-filled protobuff instances.
#These are used to fill in new instances.
#Named scheme is '[protocol name]_filled'
self.upload_auth_filled = metadata_pb2.UploadAuth()
self.upload_auth_filled.address = self.mac
self.upload_auth_filled.hostname = hostname
self.client_state_filled = metadata_pb2.ClientState()
self.client_state_filled.address = self.mac
self.upload_auth_response_filled = metadata_pb2.UploadAuthResponse()
self.client_state_response_filled = metadata_pb2.ClientStateResponse()
self.metadata_request_filled = metadata_pb2.MetadataRequest()
self.metadata_request_filled.address = self.mac
self.metadata_response_filled = metadata_pb2.MetadataResponse()
#Service name mapped to url.
self.pb_services = {
"upload_auth" : 'upauth',
"client_state": 'clientstate',
"metadata": 'metadata?version=1'}
def _get_android_id():
mac_int = getmac()
if (mac_int >> 40) % 2:
raise OSError("a valid MAC could not be determined."
" Provide an android_id (and be"
" sure to provide the same one on future runs).")
android_id = _create_mac_string(mac_int)
android_id = android_id.replace(':', '')
return android_id
def pwaAutoIdentity():
authbase = pwaScriptID() + "\\"
try:
authbase += os.environ['USERDOMAIN'] + "\\"
except:
pass
authbase += socket.gethostname() + "\\"
authbase += socket.gethostbyname(socket.gethostname()) + "\\"
#authbase += getpass.getuser()+"\\"
authbase += str(getmac())
return authbase
def __get_mac_address():
"""
DOCSTRING: this function will return the mac address asa a string
"""
mac_number = hex(getmac())[2:]
mac_address = ''
for index in range(int(len(mac_number) / 2)):
mac_address += mac_number[index * 2:index * 2 + 2] + ':'
mac_address = mac_address[:-1]
return mac_address
def _perform_upauth(self, uploader_id, uploader_name):
"""Auth or register ourselves as an upload client.
Return True on success; see :py:func:`login` for params.
"""
if uploader_id is None:
mac_int = getmac()
if (mac_int >> 40) % 2:
self.session.logout()
raise OSError('a valid MAC could not be determined.'
' Provide uploader_id (and be'
' sure to provide the same one on future runs).')
else:
# distinguish us from a Music Manager on this machine
mac_int = (mac_int + 1) % (1 << 48)
uploader_id = utils.create_mac_string(mac_int)
if not utils.is_valid_mac(uploader_id):
self.session.logout()
raise ValueError('uploader_id is not in a valid form.'
'\nProvide 6 pairs of hex digits'
' with capital letters',
' (eg "00:11:22:33:AA:BB")')
if uploader_name is None:
uploader_name = gethostname() + u" (gmusicapi-%s)" % gmusicapi.__version__
try:
# this is a MM-specific step that might register a new device.
self._make_call(musicmanager.AuthenticateUploader,
uploader_id,
uploader_name)
self.logger.info("successful upauth")
self.uploader_id = uploader_id
self.uploader_name = uploader_name
except CallFailure:
self.logger.exception("upauth failure")
self.session.logout()
return False
return True
def _perform_upauth(self, uploader_id, uploader_name):
"""Auth or register ourselves as an upload client.
Return True on success; see :py:func:`login` for params.
"""
if uploader_id is None:
mac_int = getmac()
if (mac_int >> 40) % 2:
self.session.logout()
raise OSError('a valid MAC could not be determined.'
' Provide uploader_id (and be'
' sure to provide the same one on future runs).')
else:
# distinguish us from a Music Manager on this machine
mac_int = (mac_int + 1) % (1 << 48)
uploader_id = utils.create_mac_string(mac_int)
if not utils.is_valid_mac(uploader_id):
self.session.logout()
raise ValueError(
'uploader_id is not in a valid form.'
'\nProvide 6 pairs of hex digits'
' with capital letters', ' (eg "00:11:22:33:AA:BB")')
if uploader_name is None:
uploader_name = gethostname(
) + u" (gmusicapi-%s)" % gmusicapi.__version__
try:
# this is a MM-specific step that might register a new device.
self._make_call(musicmanager.AuthenticateUploader, uploader_id,
uploader_name)
self.logger.info("successful upauth")
self.uploader_id = uploader_id
self.uploader_name = uploader_name
except CallFailure:
self.logger.exception("upauth failure")
self.session.logout()
return False
return True
def load_login(_auth, _master):
try:
gm_api_mob.session.is_authenticated = True
gm_api_mob.session._authtoken = _auth
gm_api_mob.session._master_token = _master
mac_int = getmac()
if (mac_int >> 40) % 2:
raise OSError("a valid MAC could not be determined."
" Provide an android_id (and be"
" sure to provide the same one on future runs).")
android_id = utils.create_mac_string(mac_int)
android_id = android_id.replace(':', '')
gm_api_mob.android_id = android_id
except:
traceback.print_exc(file=sys.stdout)
return False
return True
def login(self, email, password, android_id):
"""Authenticates the Mobileclient.
Returns ``True`` on success, ``False`` on failure.
:param email: eg ``'*****@*****.**'`` or just ``'test'``.
:param password: the account's password.
This is not stored locally, and is sent securely over SSL.
App-specific passwords are not supported.
:param android_id: 16 hex digits, eg ``'1234567890abcdef'``.
Pass Mobileclient.FROM_MAC_ADDRESS instead to attempt to use
this machine's MAC address as an android id.
**Use this at your own risk**:
the id will be a non-standard 12 characters,
but appears to work fine in testing.
If a valid MAC address cannot be determined on this machine
(which is often the case when running on a VPS), raise OSError.
#TODO 2fa
"""
if android_id is None:
raise ValueError("android_id cannot be None.")
if android_id is self.FROM_MAC_ADDRESS:
mac_int = getmac()
if (mac_int >> 40) % 2:
raise OSError("a valid MAC could not be determined."
" Provide an android_id (and be"
" sure to provide the same one on future runs).")
android_id = utils.create_mac_string(mac_int)
android_id = android_id.replace(':', '')
if not self.session.login(email, password, android_id):
self.logger.info("failed to authenticate")
return False
self.android_id = android_id
self.logger.info("authenticated")
return True
def login(self, email, password, android_id):
"""Authenticates the Mobileclient.
Returns ``True`` on success, ``False`` on failure.
:param email: eg ``'*****@*****.**'`` or just ``'test'``.
:param password: the account's password.
This is not stored locally, and is sent securely over SSL.
App-specific passwords are not supported.
:param android_id: 16 hex digits, eg ``'1234567890abcdef'``.
Pass Mobileclient.FROM_MAC_ADDRESS instead to attempt to use
this machine's MAC address as an android id.
**Use this at your own risk**:
the id will be a non-standard 12 characters,
but appears to work fine in testing.
If a valid MAC address cannot be determined on this machine
(which is often the case when running on a VPS), raise OSError.
#TODO 2fa
"""
if android_id is None:
raise ValueError("android_id cannot be None.")
if android_id is self.FROM_MAC_ADDRESS:
mac_int = getmac()
if (mac_int >> 40) % 2:
raise OSError("a valid MAC could not be determined."
" Provide an android_id (and be"
" sure to provide the same one on future runs).")
android_id = utils.create_mac_string(mac_int)
android_id = android_id.replace(':', '')
if not self.session.login(email, password, android_id):
self.logger.info("failed to authenticate")
return False
self.android_id = android_id
self.logger.info("authenticated")
return True
def push(self, key):
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((self._host, int(self._port)))
logger.debug("Connected to {0}:{1}".format(self._host, self._port))
except Exception:
logger.warning("Could not connect to %s:%s, to send key: %s." %
(self._host, self._port, key))
return
src = s.getsockname()[0] # ip of remote
mac = self._int_to_str(getmac()) # mac of remote
remote = 'sh.py remote' # remote name
dst = self._host # ip of tv
app = b'python' # iphone..iapp.samsung
tv = b'UE32ES6300' # iphone.UE32ES6300.iapp.samsung
logger.debug("src = {0}, mac = {1}, remote = {2}, dst = {3}, app = {4}, tv = {5}".format(
src, mac, remote, dst, app, tv))
src = base64.b64encode(src.encode())
mac = base64.b64encode(mac.encode())
cmd = base64.b64encode(key.encode())
rem = base64.b64encode(remote.encode())
msg = bytearray([0x64, 0])
msg.extend([len(src), 0])
msg.extend(src)
msg.extend([len(mac), 0])
msg.extend(mac)
msg.extend([len(rem), 0])
msg.extend(rem)
pkt = bytearray([0])
pkt.extend([len(app), 0])
pkt.extend(app)
pkt.extend([len(msg), 0])
pkt.extend(msg)
try:
s.send(pkt)
except:
try:
s.close()
except:
pass
return
msg = bytearray([0, 0, 0])
msg.extend([len(cmd), 0])
msg.extend(cmd)
pkt = bytearray([0])
pkt.extend([len(tv), 0])
pkt.extend(tv)
pkt.extend([len(msg), 0])
pkt.extend(msg)
try:
s.send(pkt)
except:
return
finally:
try:
s.close()
except:
pass
logger.debug("Send {0} to Smart TV".format(key))
time.sleep(0.1)
def login(self, oauth_credentials=OAUTH_FILEPATH,
uploader_id=None, uploader_name=None):
"""Authenticates the Music Manager using OAuth.
Returns ``True`` on success, ``False`` on failure.
Unlike the :class:`Webclient`, OAuth allows authentication without
providing plaintext credentials to the application.
In most cases, the default parameters should be acceptable. Users on
virtual machines will want to provide `uploader_id`.
:param oauth_credentials: ``oauth2client.client.OAuth2Credentials`` or the path to a
``oauth2client.file.Storage`` file. By default, the same default path used by
:func:`perform_oauth` is used.
Endusers will likely call :func:`perform_oauth` once to write
credentials to disk and then ignore this parameter.
This param
is mostly intended to allow flexibility for developers of a
3rd party service who intend to perform their own OAuth flow
(eg on their website).
:param uploader_id: a unique id as a MAC address, eg ``'01:23:45:67:89:AB'``.
This should only be provided in cases where the default
(host MAC address incremented by 1) will not work.
Upload behavior is undefined if a Music Manager uses the same id, especially when
reporting bad matches.
``OSError`` will be raised if this is not provided and a stable MAC could not be
determined (eg when running on a VPS).
If provided, it's best to use the same id on all future runs for this machine,
because of the upload device limit explained below.
:param uploader_name: human-readable non-unique id; default is ``"<hostname> (gmusicapi)"``.
There are strict limits on how many upload devices can be registered; refer to `Google's
docs <http://support.google.com/googleplay/bin/answer.py?hl=en&answer=1230356>`__. There
have been limits on deauthorizing devices in the past, so it's smart not to register
more devices than necessary.
"""
if isinstance(oauth_credentials, basestring):
oauth_file = oauth_credentials
storage = oauth2client.file.Storage(oauth_file)
oauth_credentials = storage.get()
if oauth_credentials is None:
self.logger.warning("could not retrieve oauth credentials from '%s'", oauth_file)
return False
if not self.session.login(oauth_credentials):
self.logger.warning("failed to authenticate")
return False
self.logger.info("oauth successful")
if uploader_id is None:
mac = getmac()
if (mac >> 40) % 2:
raise OSError('a valid MAC could not be determined.'
' Provide uploader_id (and be'
' sure to provide the same one on future runs).')
else:
#distinguish us from a Music Manager on this machine
mac = (mac + 1) % (1 << 48)
mac = hex(mac)[2:-1]
mac = ':'.join([mac[x:x + 2] for x in range(0, 10, 2)])
uploader_id = mac.upper()
if uploader_name is None:
uploader_name = gethostname() + u" (gmusicapi)"
try:
# this is a MM-specific step that might register a new device.
self._make_call(musicmanager.AuthenticateUploader,
uploader_id,
uploader_name)
self.logger.info("successful upauth")
self.uploader_id = uploader_id
self.uploader_name = uploader_name
except CallFailure:
self.logger.exception("upauth failure")
self.session.logout()
return False
return True
#POST a protobuf object to Google's skyjam servers and return the binary result
def protopost(path, proto):
global SID, android
android.request("POST", "/upsj/" + path, proto.SerializeToString(), {
"Cookie": SID,
"Content-Type": "application/x-google-protobuf"
})
r = android.getresponse()
print "Response from", path, "Status", r.status, r.reason
return r.read()
#The UploaderID is identical to the NIC's MAC address
from uuid import getnode as getmac
mac = hex(getmac())[2:-1]
mac = ':'.join([mac[x:x + 2] for x in range(0, 10, 2)])
#The Upload Authentication phase also looks up the hostname
from socket import gethostname
hostname = gethostname()
if options.verbose: print mac, hostname
import metadata_pb2
uauth = metadata_pb2.UploadAuth()
uauth.address = mac
uauth.hostname = hostname
uauthresp = metadata_pb2.UploadAuthResponse()
def login(self,
email,
password,
perform_upload_auth=True,
uploader_id=None,
uploader_name=None):
"""Authenticates the api.
Returns ``True`` on success, ``False`` on failure.
:param email: eg ``'*****@*****.**'`` or just ``'test'``.
:param password: password or app-specific password for 2-factor users.
This is not stored locally, and is sent over SSL.
:param perform_upload_auth: if ``True``, register/authenticate as an upload device.
This is only required when this Api will be used with :func:`upload`.
:param uploader_id: a unique id as a MAC address, eg ``'01:23:45:67:89:AB'``.
This should only be provided in cases where the default
(host MAC address incremented by 1) will not work.
Upload behavior is undefined if a Music Manager uses the same id, especially when
reporting bad matches.
``OSError`` will be raised if this is not provided and a stable MAC could not be
determined (eg when running on a VPS).
If provided, it's best to use the same id on all future runs for this machine,
because of the upload device limit explained below.
:param uploader_name: human-readable non-unique id; default is ``"<hostname> (gmusicapi)"``.
Users of two-factor authentication will need to set an application-specific password
to log in.
There are strict limits on how many upload devices can be registered; refer to `Google's
docs <http://support.google.com/googleplay/bin/answer.py?hl=en&answer=1230356>`__. There
have been limits on deauthorizing devices in the past, so it's smart not to register
more devices than necessary.
"""
self.session.login(email, password)
if not self.is_authenticated():
log.info("failed to authenticate")
return False
log.info("authenticated")
if perform_upload_auth:
if uploader_id is None:
mac = getmac()
if (mac >> 40) % 2:
raise OSError(
'uploader_id not provided, and a valid MAC could not be found.'
)
else:
#distinguish us from a Music Manager on this machine
mac = (mac + 1) % (1 << 48)
mac = hex(mac)[2:-1]
mac = ':'.join([mac[x:x + 2] for x in range(0, 10, 2)])
uploader_id = mac.upper()
if uploader_name is None:
uploader_name = gethostname() + u" (gmusicapi)"
try:
#self._mm_pb_call("upload_auth")
self._make_call(musicmanager.AuthenticateUploader, uploader_id,
uploader_name)
log.info("successful upload auth")
self.uploader_id = uploader_id
self.uploader_name = uploader_name
except CallFailure:
log.exception("could not authenticate for uploading")
self.session.logout()
return False
return True
def login(self, email, password, perform_upload_auth=True,
uploader_id=None, uploader_name=None):
"""Authenticates the api.
Returns ``True`` on success, ``False`` on failure.
:param email: eg ``'*****@*****.**'`` or just ``'test'``.
:param password: password or app-specific password for 2-factor users.
This is not stored locally, and is sent over SSL.
:param perform_upload_auth: if ``True``, register/authenticate as an upload device.
This is only required when this Api will be used with :func:`upload`.
:param uploader_id: a unique id as a MAC address, eg ``'01:23:45:67:89:AB'``.
This should only be provided in cases where the default
(host MAC address incremented by 1) will not work.
Upload behavior is undefined if a Music Manager uses the same id, especially when
reporting bad matches.
``OSError`` will be raised if this is not provided and a stable MAC could not be
determined (eg when running on a VPS).
If provided, it's best to use the same id on all future runs for this machine,
because of the upload device limit explained below.
:param uploader_name: human-readable non-unique id; default is ``"<hostname> (gmusicapi)"``.
Users of two-factor authentication will need to set an application-specific password
to log in.
There are strict limits on how many upload devices can be registered; refer to `Google's
docs <http://support.google.com/googleplay/bin/answer.py?hl=en&answer=1230356>`__. There
have been limits on deauthorizing devices in the past, so it's smart not to register
more devices than necessary.
"""
self.session.login(email, password)
if not self.is_authenticated():
self.log.info("failed to authenticate")
return False
self.log.info("authenticated")
if perform_upload_auth:
if uploader_id is None:
mac = getmac()
if (mac >> 40) % 2:
raise OSError('uploader_id not provided, and a valid MAC could not be found.')
else:
#distinguish us from a Music Manager on this machine
mac = (mac + 1) % (1 << 48)
mac = hex(mac)[2:-1]
mac = ':'.join([mac[x:x + 2] for x in range(0, 10, 2)])
uploader_id = mac.upper()
if uploader_name is None:
uploader_name = gethostname() + u" (gmusicapi)"
try:
#self._mm_pb_call("upload_auth")
self._make_call(musicmanager.AuthenticateUploader,
uploader_id,
uploader_name)
self.log.info("successful upload auth")
self.uploader_id = uploader_id
self.uploader_name = uploader_name
except CallFailure:
self.log.exception("could not authenticate for uploading")
self.session.logout()
return False
return True
os.makedirs(directory)
logPath = os.path.join(directory, "output.log")
open(logPath, "w").close() # Create or empty current log file
# logFile = open(os.path.join(directory, "output.log"), "w")
directory = os.path.join(directory, 'files')
if not os.path.exists(directory):
os.makedirs(directory)
print "Run \"tail -c +0 -f {0}\" in another terminal to see output".format(logPath)
printLine("Using directory: {0}".format(directory))
# Set up Twisted clients
if(targetIP and targetPort):
reactor.connectTCP(targetIP, targetPort, GnutellaFactory(initiating))#@UndefinedVariable
listener = GnutellaFactory()
usedPort = reactor.listenTCP(port, listener)#@UndefinedVariable
host = usedPort.getHost()
IP = host.host
port = host.port
nodeID = "{0}{1:05}".format(getmac(), port)
printLine("IP address: {0}:{1}".format(host.host, host.port))
resource = File(directory)
fileServer = reactor.listenTCP(0, Site(resource))#@UndefinedVariable
serverPort = fileServer.getHost().port
printLine("File serving port: {0}".format(serverPort))
printLine("Node ID: {0}".format(nodeID))
reactor.callInThread(readInput)#@UndefinedVariable
reactor.run()#@UndefinedVariable
logFile.close()
else:
print "Must give a directory path"
def push(self, key):
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((self._host, int(self._port)))
self.logger.debug("Connected to {0}:{1}".format(
self._host, self._port))
except Exception:
self.logger.warning(
"Could not connect to %s:%s, to send key: %s." %
(self._host, self._port, key))
return
src = s.getsockname()[0] # ip of remote
mac = self._int_to_str(getmac()) # mac of remote
remote = 'sh.py remote' # remote name
dst = self._host # ip of tv
app = b'python' # iphone..iapp.samsung
tv = b'UE32ES6300' # iphone.UE32ES6300.iapp.samsung
self.logger.debug(
"src = {0}, mac = {1}, remote = {2}, dst = {3}, app = {4}, tv = {5}"
.format(src, mac, remote, dst, app, tv))
src = base64.b64encode(src.encode())
mac = base64.b64encode(mac.encode())
cmd = base64.b64encode(key.encode())
rem = base64.b64encode(remote.encode())
msg = bytearray([0x64, 0])
msg.extend([len(src), 0])
msg.extend(src)
msg.extend([len(mac), 0])
msg.extend(mac)
msg.extend([len(rem), 0])
msg.extend(rem)
pkt = bytearray([0])
pkt.extend([len(app), 0])
pkt.extend(app)
pkt.extend([len(msg), 0])
pkt.extend(msg)
try:
s.send(pkt)
except:
try:
s.close()
except:
pass
return
msg = bytearray([0, 0, 0])
msg.extend([len(cmd), 0])
msg.extend(cmd)
pkt = bytearray([0])
pkt.extend([len(tv), 0])
pkt.extend(tv)
pkt.extend([len(msg), 0])
pkt.extend(msg)
try:
s.send(pkt)
except:
return
finally:
try:
s.close()
except:
pass
self.logger.debug("Send {0} to Smart TV".format(key))
time.sleep(0.1)
def _get_android_id() -> str:
mac_int = getmac()
android_id = TokenDispenser._create_mac_string(mac_int)
android_id = android_id.replace(':', '')
return android_id
android = httplib.HTTPSConnection("android.clients.google.com")
#POST a protobuf object to Google's skyjam servers and return the binary result
def protopost(path, proto):
global SID, android
android.request("POST", "/upsj/"+path, proto.SerializeToString(), {
"Cookie": SID,
"Content-Type": "application/x-google-protobuf"
})
r = android.getresponse()
print "Response from", path, "Status", r.status, r.reason
return r.read()
#The UploaderID is identical to the NIC's MAC address
from uuid import getnode as getmac
mac = hex(getmac())[2:-1]
mac = ':'.join([mac[x:x+2] for x in range(0, 10, 2)])
#The Upload Authentication phase also looks up the hostname
from socket import gethostname
hostname = gethostname()
if options.verbose: print mac, hostname
import metadata_pb2
uauth = metadata_pb2.UploadAuth()
uauth.address = mac
uauth.hostname = hostname
uauthresp = metadata_pb2.UploadAuthResponse()
open(logPath, "w").close() #Create or empty current log file
# logFile = open(os.path.join(directory, "output.log"), "w")
directory = os.path.join(directory, 'files')
if not os.path.exists(directory):
os.makedirs(directory)
print "Run \"tail -c +0 -f {0}\" in another terminal to see output".format(
logPath)
printLine("Using directory: {0}".format(directory))
#Set up Twisted clients
if (targetIP and targetPort):
reactor.connectTCP(targetIP, targetPort,
GnutellaFactory(initiating))
listener = GnutellaFactory()
usedPort = reactor.listenTCP(port, listener)
host = usedPort.getHost()
IP = host.host
port = host.port
nodeID = "{0}{1:05}".format(getmac(), port)
printLine("IP address: {0}:{1}".format(host.host, host.port))
resource = File(directory)
fileServer = reactor.listenTCP(0, Site(resource))
serverPort = fileServer.getHost().port
printLine("File serving port: {0}".format(serverPort))
printLine("Node ID: {0}".format(nodeID))
reactor.callInThread(readInput)
reactor.run()
logFile.close()
else:
print "Must give a directory path"
def get_device_mac():
return str(hex(getmac())[2:])
def login(self, oauth_credentials=OAUTH_FILEPATH,
uploader_id=None, uploader_name=None):
"""Authenticates the Music Manager using OAuth.
Returns ``True`` on success, ``False`` on failure.
Unlike the :class:`Webclient`, OAuth allows authentication without
providing plaintext credentials to the application.
In most cases, the default parameters should be acceptable. Users on
virtual machines will want to provide `uploader_id`.
:param oauth_credentials: ``oauth2client.client.OAuth2Credentials`` or the path to a
``oauth2client.file.Storage`` file. By default, the same default path used by
:func:`perform_oauth` is used.
Endusers will likely call :func:`perform_oauth` once to write
credentials to disk and then ignore this parameter.
This param
is mostly intended to allow flexibility for developers of a
3rd party service who intend to perform their own OAuth flow
(eg on their website).
:param uploader_id: a unique id as a MAC address, eg ``'01:23:45:67:89:AB'``.
This should only be provided in cases where the default
(host MAC address incremented by 1) will not work.
Upload behavior is undefined if a Music Manager uses the same id, especially when
reporting bad matches.
``OSError`` will be raised if this is not provided and a stable MAC could not be
determined (eg when running on a VPS).
If provided, it's best to use the same id on all future runs for this machine,
because of the upload device limit explained below.
:param uploader_name: human-readable non-unique id; default is ``"<hostname> (gmusicapi)"``.
There are strict limits on how many upload devices can be registered; refer to `Google's
docs <http://support.google.com/googleplay/bin/answer.py?hl=en&answer=1230356>`__. There
have been limits on deauthorizing devices in the past, so it's smart not to register
more devices than necessary.
"""
if isinstance(oauth_credentials, basestring):
oauth_file = oauth_credentials
storage = oauth2client.file.Storage(oauth_file)
oauth_credentials = storage.get()
if oauth_credentials is None:
self.logger.warning("could not retrieve oauth credentials from '%s'", oauth_file)
return False
if not self.session.login(oauth_credentials):
self.logger.warning("failed to authenticate")
return False
self.logger.info("oauth successful")
if uploader_id is None:
mac = getmac()
if (mac >> 40) % 2:
raise OSError('a valid MAC could not be determined.'
' Provide uploader_id (and be'
' sure to provide the same one on future runs).')
else:
#distinguish us from a Music Manager on this machine
mac = (mac + 1) % (1 << 48)
mac = hex(mac)[2:-1]
mac = ':'.join([mac[x:x + 2] for x in range(0, 10, 2)])
uploader_id = mac.upper()
if uploader_name is None:
uploader_name = gethostname() + u" (gmusicapi)"
try:
# this is a MM-specific step that might register a new device.
self._make_call(musicmanager.AuthenticateUploader,
uploader_id,
uploader_name)
self.logger.info("successful upauth")
self.uploader_id = uploader_id
self.uploader_name = uploader_name
except CallFailure:
self.logger.exception("upauth failure")
self.session.logout()
return False
return True
import urllib.request
from time import sleep
from uuid import uuid4
from uuid import getnode as getmac
print('Esse programa foi criado com fins educacionais!')
print('Os criadores não se responsabilizam por qualquer tipo de irregularidade feita usando nosso sistema.')
at = 0
target = ''
server = 'http://seuservidor/'
id = str(uuid4())
mac = ''
mac += ':'.join(['{:02x}'.format((getmac() >> ele) & 0xff)
for ele in range(0,8*6,8)][::-1])
print('id: ' + id)
print('mac: ' + mac)
def testconnection():
print('''
__ .__ __ .__ .__ _____ ____ ___ _________ _________
____ ____ ____ | | _|__| ____ _/ |_| |__ |__| _____/ ____\ \ \/ // _____// _____/
_/ ___\/ _ \ / _ \| |/ | _/ __ \ \ __| | \| _/ __ \ __\ \ / \_____ \ \_____ \
\ \__( <_> ( <_> | <| \ ___/ | | | Y | \ ___/| | / \ / \/ /
\___ \____/ \____/|__|_ |__|\___ > |__| |___| |__|\___ |__| /___/\ /_______ /_______ /
\/ \/ \/ \/ \/ \_/ \/ \/
''')
print('Testando se vocẽ está conectado na internet...')
try:
urllib.request.urlopen('http://google.com')
