pingo 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8e46197fce732659a1f29c737099474746d885f9
-  data.tar.gz: 543c8ec0bbdf0cdd48eeadb1b246d93ba427b6b4
+  metadata.gz: 371a37cd9c400853c5fa4e23e4fbe33ca6c1665c
+  data.tar.gz: 38d4970b71fc6c5bf5ae37e3b29ff219e6e0b6ee
 SHA512:
-  metadata.gz: 2bf5b2aa38d6c5441c256831ddcfa187948823cc99a05732ee635574adba466e273688bbc07932fb32b14ecad37cc11f918bb9b08fa1d0f757a9ab8f2a3cb6b3
-  data.tar.gz: 95e36f1837a12ca45133480a4309bc1c9ff287e8854adc6f8f819b051c3956df103572bda8c653e130b89c7932731543c23431a1adcd5bed6b2239308406ef53
+  metadata.gz: 723cb94874b30b16762d4d40ad8bf3f0b5c1ee8fdd7d096a95f06882e60b7a86aa8735372e9eb6ebb098c52c50cc16c51ef6f0382f86f5e740d6ca92d8e675da
+  data.tar.gz: 316322f0d1f131526dc3feca391ccee749c3e185a54ed5afe127fc19b5e4c322f056603a81455cd2f937879c2dff780e0298de1ef7790e635412236c9f9910de

data/.travis.yml

@@ -1,3 +1,8 @@
 language: ruby
 rvm:
-  - 2.1.1
+  - 2.4.1
+  - 2.3.4
+  - 2.2.7
+  - 2.1.10
+  - 2.0.0
+  - ruby-head

data/README.md

@@ -1,4 +1,4 @@
-# Pingo [![Gem Version](https://badge.fury.io/rb/pingo.svg)](http://badge.fury.io/rb/pingo) [![Code Climate](https://codeclimate.com/github/Kyuden/pingo/badges/gpa.svg)](https://codeclimate.com/github/Kyuden/pingo) [![wercker status](https://app.wercker.com/status/8fc989959ae4630aef746364c6ead94f/m/master "wercker status")](https://app.wercker.com/project/bykey/8fc989959ae4630aef746364c6ead94f)
+# Pingo [![Gem Version](https://badge.fury.io/rb/pingo.svg)](http://badge.fury.io/rb/pingo) [![Code Climate](https://codeclimate.com/github/Kyuden/pingo/badges/gpa.svg)](https://codeclimate.com/github/Kyuden/pingo) 
 
 <p><img width="400"src="http://www.fastpic.jp/images.php?file=8622347177.jpg"></p>
 Pingo provide a scatterbrain with a `pingo` command of sounding your iphone.
@@ -7,11 +7,19 @@ Pingo provide a scatterbrain with a `pingo` command of sounding your iphone.
 
 Install it yourself as:
 
-    $ gem install pingo
+```bash
+$ gem install pingo
+```
+
+If you've done Go development before and your $GOPATH/bin directory is already in your PATH, this is an alternative installation method that fetches `pingo` into your GOPATH and builds it automatically:
+
+```
+$ go get github.com/kyuden/pingo
+```
 
 ## Usage
 
-Set APPLE_ID and APPLE_PASSWORD in environment variables. 
+Set APPLE_ID and APPLE_PASSWORD in environment variables.
 
 ```bash
 # Set it in .zshrc, .bashrc etc...

data/lib/pingo.rb

@@ -1,20 +1,18 @@
+# frozen_string_literal: true
+
 require "pingo/version"
 require "pingo/cli"
 require "json"
 require "typhoeus"
 
 module Pingo
-  class Pingo
-    INIT_CLIENT = 'initClient'
-    PLAY_SOUND  = 'playSound'
+  class Client
+    INIT_CLIENT = 'initClient'.freeze
+    PLAY_SOUND  = 'playSound'.freeze
 
     class << self
       def run(model_name)
-        new(model_name).instance_eval do
-          partition  = request_partition
-          device_ids = request_device_ids(partition)
-          request_sound(partition, device_ids)
-        end
+        new(model_name).sound!
       end
     end
 
@@ -24,38 +22,35 @@ module Pingo
       @password = ENV['APPLE_PASSWORD']
     end
 
-    private
-      def request_partition
-        post(INIT_CLIENT).headers['X-Apple-MMe-Host']
-      end
+    def sound!
+      device_ids.each { |device_id| post(PLAY_SOUND, generate_body(device_id)) }
+    end
 
-      def request_device_ids(partition)
-        raise "partition is nil" unless partition
-        parse_device_ids(post(INIT_CLIENT, partition))
-      end
+    def device_ids
+      response = post(INIT_CLIENT)
+      raise "#{response.response_code}:#{response.status_message }" unless response.success?
+      parse_device_ids(response.body)
+    end
+
+    private
 
-      def parse_device_ids(data)
-        target_contents(data).map { |content| content["id"] }
+      def parse_device_ids(body)
+        target_contents(body).map { |content| content["id"] }
       end
 
-      def target_contents(data)
-        contents(data).find_all { |content| match_device?(content) }
+      def target_contents(body)
+        target = contents(body).find_all { |content| match_device?(content) }
+        target.empty? ? raise("Not found your device(iPhone#{@model_name})") : target
       end
 
-      def contents(data)
-        JSON.parse(data.body)['content']
+      def contents(body)
+        JSON.parse(body)['content']
       end
 
       def match_device?(params)
         params['deviceDisplayName'] =~ /#{@model_name}$/i
       end
 
-      def request_sound(partition, device_ids)
-        raise "partition is nil" unless partition
-        raise "device id is nil" if Array(device_ids).empty?
-        Array(device_ids).map { |device_id| post(PLAY_SOUND, partition, generate_body(device_id)) }
-      end
-
       def generate_body(device_id)
         JSON.generate(sound_body(device_id))
       end
@@ -72,8 +67,8 @@ module Pingo
         }
       end
 
-      def post(mode, partition="fmipmobile.icloud.com", body=nil)
-        Typhoeus::Request.post(uri(mode, partition),
+      def post(type, body=nil)
+        Typhoeus::Request.post(uri(type),
                                userpwd: "#{@username}:#{@password}",
                                headers: post_headers,
                                followlocation: true,
@@ -94,8 +89,8 @@ module Pingo
           }
       end
 
-      def uri(mode, partition)
-        "https://#{partition}/fmipservice/device/#{@username}/#{mode}"
+      def uri(type)
+        "https://fmipmobile.icloud.com/fmipservice/device/#{@username}/#{type}"
       end
   end
 end

data/lib/pingo/cli.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'thor'
 require 'pingo/cli/pingo'
 

data/lib/pingo/cli/pingo.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Pingo
   class CLI < Thor
     desc "[MODEL_NAME]", "Sound apple device"
@@ -9,7 +11,7 @@ module Pingo
     LONGDESC
 
     def pingo(model_name)
-      Pingo.run(model_name)
+      Client.run(model_name)
     end
   end
 end

data/lib/pingo/version.rb

@@ -1,3 +1,3 @@
 module Pingo
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/pin.go

@@ -0,0 +1,299 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+)
+
+const (
+	AppName    = "Pingo"
+	APIName    = "FindMyiphone"
+	APIVertion = "2.0.2"
+)
+
+const (
+	ExitOK = 0 + iota
+
+	ExitError = 9 + iota
+	ExitParseArgsError
+	ExitRequestDeviceError
+	ExitRequestSoundError
+)
+
+var HEADER_MAP = map[string][]string{
+	"Content-Type":          {"application/json; charset=utf-8"},
+	"X-Apple-Find-Api-Ver":  {"2.0"},
+	"X-Apple-Authscheme":    {"UserIdGuest"},
+	"X-Apple-Realm-Support": {"1.0"},
+	"Accept-Language":       {"en-us"},
+	"userAgent":             {"Pingo"},
+	"Connection":            {"keep-alive"},
+}
+
+type ClientContext struct {
+	AppName      string `json:"appName"`
+	AppVersion   string `json:"appVersion"`
+	ShouldLocate bool   `json:"shouldLocate"`
+}
+
+type SoundParams struct {
+	ClientContext `json:"clientContext"`
+	Device        string `json:"device"`
+	Subject       string `json:"subject"`
+}
+
+type Container struct {
+	Content []struct {
+		DeviceName string `json:"deviceDisplayName"`
+		DeviceId   string `json:"id"`
+	} `json:"content"`
+}
+
+func main() {
+	os.Exit(NewCLI().Run(os.Args))
+}
+
+type CLI struct {
+	outStream, errStream io.Writer
+}
+
+func NewCLI() *CLI {
+	return &CLI{
+		outStream: os.Stdout,
+		errStream: os.Stderr,
+	}
+}
+
+func (cli *CLI) PutOutStream(format string, args ...interface{}) {
+	fmt.Fprintf(cli.outStream, format, args...)
+}
+
+func (cli *CLI) PutErrStream(format string, args ...interface{}) {
+	fmt.Fprintf(cli.errStream, format, args...)
+}
+
+func (cli *CLI) Run(args []string) int {
+	appleAccount, err := cli.parseArgs(args)
+	if err != nil {
+		cli.PutErrStream("Failed to parse args:\n %s\n", err)
+		return ExitParseArgsError
+	}
+
+	client := &Client{AppleAccount: appleAccount}
+
+	deviceID, err := client.RequestDeviceID()
+	if err != nil {
+		cli.PutErrStream("Failed to request device id:\n %s\n", err)
+		return ExitRequestDeviceError
+	}
+
+	if err = client.RequestSound(deviceID); err != nil {
+		cli.PutErrStream("Failed to request sound:\n %s\n", err)
+		return ExitRequestSoundError
+	}
+
+	cli.PrintSuccessMessage()
+
+	return ExitOK
+}
+
+type AppleAccount struct {
+	ID        string
+	Pass      string
+	ModelName string
+}
+
+func (cli *CLI) parseArgs(args []string) (*AppleAccount, error) {
+	appleID := os.Getenv("APPLE_ID")
+	applePass := os.Getenv("APPLE_PASSWORD")
+
+	flags := flag.NewFlagSet(AppName, flag.ContinueOnError)
+
+	flags.StringVar(&appleID, "apple-id", appleID, "apple id to use")
+	flags.StringVar(&appleID, "i", appleID, "apple id to use (short)")
+	flags.StringVar(&applePass, "apple-password", applePass, "apple passwaord to to")
+	flags.StringVar(&applePass, "p", applePass, "apple passwaord to to (short)")
+
+	if err := flags.Parse(args[1:]); err != nil {
+		return nil, errors.New("Faild to parse flag")
+	}
+
+	if appleID == "" || applePass == "" {
+		return nil, errors.New("APPLE ID or APPLE PASSWORD are empty")
+	}
+
+	modelName := flags.Arg(0)
+
+	if modelName == "" {
+		return nil, errors.New("Device model name is empty")
+	}
+
+	return &AppleAccount{ID: appleID, Pass: applePass, ModelName: modelName}, nil
+}
+
+func (c *CLI) PrintSuccessMessage() {
+	fmt.Println(`
+	    888888ba  oo
+	    88    8b
+	   a88aaaa8P  dP 88d888b. .d8888b. .d8888b.
+	    88        88 88    88 88    88 88    88
+	    88        88 88    88 88.  .88 88.  .88
+	    dP        dP dP    dP .8888P88  88888P
+	                               .88
+	                           d8888P
+	`)
+	return
+}
+
+type Client struct {
+	*AppleAccount
+	debug bool
+}
+
+func (c *Client) requestDeviceIDURL() string {
+	return fmt.Sprintf("https://fmipmobile.icloud.com/fmipservice/device/%s/initClient", c.ModelName)
+}
+
+func (c *Client) requestSoundURL() string {
+	return fmt.Sprintf("https://fmipmobile.icloud.com/fmipservice/device/%s/playSound", c.ModelName)
+}
+
+func (c *Client) RequestDeviceID() (string, error) {
+	body, err := c.getBody("POST", c.requestDeviceIDURL(), nil)
+	if err != nil {
+		return "", errors.New("getBody: " + err.Error())
+	}
+
+	deviceID, err := c.parseDeviceID(body)
+	if err != nil {
+		return "", errors.New("parseDeviceID: " + err.Error())
+	}
+
+	return deviceID, nil
+}
+
+func (c *Client) getBody(method string, url string, params io.Reader) ([]byte, error) {
+	resp, err := c.httpExecute(method, url, params)
+	if err != nil {
+		return nil, errors.New("httpExecute: " + err.Error())
+	}
+
+	bodyBytes, err := ioutil.ReadAll(resp.Body)
+	defer resp.Body.Close()
+	if err != nil {
+		return nil, errors.New("ReadAll: " + err.Error())
+	}
+
+	if c.debug {
+		fmt.Printf("STATUS: %s\n", resp.Status)
+		fmt.Println("BODY RESPONSE: " + string(bodyBytes))
+	}
+
+	return bodyBytes, nil
+}
+
+type HTTPExecuteError struct {
+	RequestHeaders    string
+	ResponseBodyBytes []byte
+	Status            string
+	StatusCode        int
+}
+
+func (e HTTPExecuteError) Error() string {
+	return "HTTP response is not 200/OK as expected. Actual response: \n" +
+		"\tResponse Status: '" + e.Status + "'\n" +
+		"\tResponse Code: " + strconv.Itoa(e.StatusCode) + "\n" +
+		"\tRequest Headers: " + e.RequestHeaders + "\n" +
+		"\tResponse Body: " + string(e.ResponseBodyBytes)
+}
+
+func (c *Client) httpExecute(method string, url string, body io.Reader) (*http.Response, error) {
+	req, err := http.NewRequest(method, url, body)
+	if err != nil {
+		return nil, errors.New("NewRequest: " + err.Error())
+	}
+
+	req.Header = http.Header(HEADER_MAP)
+	req.SetBasicAuth(c.ID, c.Pass)
+
+	client := &http.Client{Timeout: time.Duration(10 * time.Second)}
+
+	if c.debug {
+		fmt.Printf("Request: %v\n", req)
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, errors.New("Do: " + err.Error())
+	}
+
+	if resp.StatusCode != 200 {
+		defer resp.Body.Close()
+		bytes, _ := ioutil.ReadAll(resp.Body)
+
+		debugHeader := ""
+		for k, vals := range req.Header {
+			for _, val := range vals {
+				debugHeader += "[key: " + k + ", val: " + val + "]"
+			}
+		}
+
+		return resp, HTTPExecuteError{
+			RequestHeaders:    debugHeader,
+			ResponseBodyBytes: bytes,
+			Status:            resp.Status,
+			StatusCode:        resp.StatusCode,
+		}
+	}
+
+	return resp, nil
+}
+
+func (c *Client) parseDeviceID(body []byte) (string, error) {
+
+	var cont Container
+	if err := json.Unmarshal(body, &cont); err != nil {
+		return "", errors.New("Unmarshal: " + err.Error())
+	}
+
+	var deviceId string
+	for _, v := range cont.Content {
+		if strings.HasSuffix(v.DeviceName, c.ModelName) {
+			deviceId = v.DeviceId
+			break
+		}
+	}
+
+	if deviceId == "" {
+		return "", errors.New("Not found device id")
+	}
+
+	return deviceId, nil
+}
+
+func (c *Client) RequestSound(deviceId string) error {
+	input, err := json.Marshal(SoundParams{
+		ClientContext: ClientContext{AppName: APIName, AppVersion: APIVertion},
+		Device:        deviceId,
+		Subject:       AppName,
+	})
+
+	if err != nil {
+		return errors.New("json.Marshal: " + err.Error())
+	}
+
+	if _, err := c.getBody("POST", c.requestSoundURL(), bytes.NewBuffer(input)); err != nil {
+		return errors.New("getBody: " + err.Error())
+	}
+
+	return nil
+}