Kaip paleisti twitch, livestream per vlc

# Žemiau aprašyta kaip lokaliai paleisti gyvas transliacijas, umix tipo OS, prie literatūros yra nuoroda, ten nurodymai kaip tą patį atlikti kitoms OS

# Pirmiausiai reikia instaliuoti pip ir livestreamer

$ apt-get install python-pip
$ sudo pip install livestreamer

# Dabar galime paleisti live stream

$ livestreamer http://www.twitch.tv/saltybet best

Literatūra:

https://github.com/chrippa/livestreamer

http://livestreamer.tanuki.se/en/latest/install.html - kaip paleisti livestreamer kitoms OS
screenshotas, jei kartais neveitų nuoroda

Shell

Vartotojas gali pasirinkti skirtingas shells, shells sarašas paprastai buna /etc/shells kataloge.

$ cat /etc/shells
# /etc/shells: valid login shells
/bin/sh
/bin/dash
/bin/bash
/bin/rbash


Kokią shell naudoja sistema?
Galime pasižiūrėti iškvietę aplinkos kintamuosius:

$ env| grep -i shell
SHELL=/bin/bash

Taip pat aplinkos kintamuosius galima iškviesti su 'echo' komanda.

$ echo $SHELL
/bin/bash


Arba atspausdinti visus aplikos kintamuosius ir prafiltuoti 'shell' su 'grep -i'

$ env|grep -i bash
SHELL=/bin/bash

Įvykdžius 'ps' komandą, be papildomų nustatymų, matome visus procesus. Taip pat matome, kad mųsų tty, naudoja bash shell.

$ ps
PID TTY TIME CMD
10219 pts/0 00:00:00 bash
11419 pts/0 00:00:00 ps


ps '-p' leidžia pasirinkti prosesus pagal id,
'$$' - atspausdins tik esamą procesą.

$ ps -p $$
PID TTY TIME CMD
11686 pts/0 00:00:00 bash


Taip pat galime sužinoti apie shell iš '/etc/passwd/' dokumento

$ cat /etc/passwd
....
sup:x:1000:1000:sup,,,:/home/sup:/bin/bash


Pakeisti shell galima įvedus shell pavadinimą.

$ sh
$ echo $0
sh
$ ps -p $$
PID TTY TIME CMD
13462 pts/2 00:00:00 sh
$ exit

Vienas įdomus failas tai  bash_completion.sh, randamas /etc/profile.d

Literatūra:

http://www.linfo.org/change_shell.html
http://www.softlab.ntua.gr/facilities/documentation/unix/shelldiff.html
http://www.freebsd.org/doc/en_US.ISO8859-1/books/handbook/shells.html

ką daro tty komanda?

# tty = teletype
# pty = pseudo terminal

# tty galima perjungti [Ctrl + Alt +F1] (galima keisti nuo F1 iki F6) komanda F7 sugražina į normalų darbalaukį

# Kuriame ttl šiuo metu dirbama

$ tty
/dev/pts/10

# Rodo kokie yra prisijungę vartotojai kartu su data kada jie prisijunge
# sup :0 - :0 reiškia grafinį darbalaukį

$ who
sup      :0           2014-07-10 14:05 (:0)
sup      pts/0        2014-07-11 17:03 (:0)
sup      pts/10       2014-07-11 11:47 (:0)


# Shell kitamasis, kuris parodo grafinį darbalaukį

$ echo $DISPLAY
:0

# who am i parodys dabartyines sesijos praplėstą informacija, taip pat tra whoami

$ who am i
sup      pts/10       2014-07-11 11:47 (:0)

 
# Matome, kad yra paleistas tty (paspaudus Ctrl + Alt + 1)
# Taip pat virsuje parodytas uptime, vartotojai.. Taip pat rodo cpu panaudojimą, taip pat matome pts/10, paleista w komandą
$ w
 18:06:47 up 1 day,  4:11,  5 users,  load average: 0,54, 0,52, 0,44
USER     TTY      FROM             LOGIN@   IDLE   JCPU   PCPU WHAT
sup      tty1                      17:49   31.00s  0.24s  0.21s -bash
sup      :0       :0                Kt14   ?xdm?   4:12m  0.37s init --user
sup      pts/0    :0               17:03   52:31   0.05s  0.00s python
sup      pts/10   :0               11:47    7.00s  0.39s  0.00s w
sup      pts/12   :0               17:58    7:35   0.06s  0.06s bash

# Dar karta tty parodo, naudojama teletype terminal
$ tty
/dev/pts/7

$ cd /dev/pts/
sup@sup-desktop /dev/pts $ ls -al
total 0
drwxr-xr-x  2 root root       0 Lie 22 17:30 .
drwxr-xr-x 16 root root    4160 Lie 22 17:30 ..
crw--w----  1 sup  tty  136,  0 Lie 23 16:41 0
crw--w----  1 root tty  136,  1 Lie 23 07:35 1
crw--w----  1 root tty  136, 19 Lie 22 17:30 19
crw--w----  1 sup  tty  136,  2 Lie 23 21:35 2
crw--w----  1 root tty  136,  3 Lie 22 17:30 3
crw--w----  1 root tty  136,  4 Lie 22 17:30 4
crw--w----  1 root tty  136,  5 Lie 22 17:31 5
crw--w----  1 root tty  136,  6 Lie 22 17:30 6
crw--w----  1 sup  tty  136,  7 Lie 23 21:47 7
crw--w----  1 sup  tty  136,  8 Lie 23 21:47 8
c---------  1 root root   5,  2 Lie 22 17:30 ptmx

# Atidarius nauja terminalo langa Ctrl+Shift+T ir parašius komandą tty, gauname nauja tty konsolę
$ tty
/dev/pts/8


Literatūra:

http://askubuntu.com/questions/27339/what-is-tty7-in-the-commandline

python3 dokumentacija

# help() iteraktyvi pagalba
# Parodo visus atributus

>>> dir()

# Parodo atributus sarašo objekte

>>> dir([])

# Parodo visus atributus išskyrus tuos, kurie prasideda '__'

>>> [x for x in dir([]) if x[0] != '_' ]

>>> len([x for x in dir([]) if not x.startswith('__') ])



>>> [a for a in dir(list) if not a.startswith('__')]
>>> [a for a in dir(dict) if not a.startswith('__')]

# Apksaičiuoja kiek yra moduliu, kurie neprasideda  '__'

>>> len(dir([])) - len([x for x in dir([]) if not x.startswith('__') ])
34


# __doc__ naudojamas, kad butu atspaustinti komentarai

def kv(x):
    """ Pakelimas
        kvadratu
    x**x
        """
    return x**2


print(kv.__doc__)
print(kv(8))

>>>
 Pakelimas
        kvadratu
    x**x
       
64

# IDE lange galima iškviesti komentarus prieš tai reikia importuoti faila šiuo atveju dokumento pavadinimas test1.py, pavyzdyje iškviečiami funkcijos kv komentarai

>>> print(test1.kv.__doc__)
 Pakelimas
        kvadratu
    x**x

>>> help(test1.kv)
Help on function kv in module test1:

kv(x)
    Pakelimas
        kvadratu
    x**x

>>>




# Galima pažiūrėti modulio dokumentacija
>>> import sys


>>> print(sys.__doc__)
  ....
>>> print(sys.version.__doc__)
  ....

 # Taip pat galima naudoti help funkcija
>>> help(sys)
  ....

#  Iškviečia dokumentacija ir pateikia naršyklėje

$ python3 -m pydoc -b

Python3

# print funkcijos suderinamumas tarp 2.x ir .3.x versijos

from __future__ import print_function

# string formavimas 3.x versijoje

>>> print('%s, diena , %s' %('Gera',  'Pasauli!') )
 
Gera, diena , Pasauli!

>>> print('{0}, rytas, {1}'.format('Labas', 'Pasauli!'))

Labas, rytas, Pasauli!

>>> print('Ats: ' + str(42))
 
Ats: 42

# Kintamųju priskirimo būdai

>>> a =b = c = 1
>>> a,b,c = 1,1,1
>>> a = 1; b = 1; c = 1


# Žodyno reišmių priskyrimas

>>> {reiksme:0 for reiksme in 'abc'}
{'b': 0, 'c': 0, 'a': 0}

# Pasirinkimas, su klaidos pranešimu

>>> D = {'vienas': 1, 'du': 2, 'trys': 3} 

>>> print(D.get('vienas', 'neteisingas pasirinkimas'))
1
>>> print(D.get('vienaZ', 'neteisingas pasirinkimas'))
neteisingas pasirinkimas

# If pasirinkimas su klaidos tikrinimu
 
>>> pasirinkimas = 11
>>> if pasirinkimas in D:
    print (D[pasirinkimas])
else:
    print('Neteisingas pasirinkimas')

  
Neteisingas pasirinkimas


# Tikrinimas su try

>>> try:
    print(D['pasirinkimas'])
except KeyError:
    print('neteisingas pasirinkimas')

   
neteisingas pasirinkimas

# Supaprastintas if/else išraiška

if X:
    A = Y
else:
    A = Z

# Tas pats kas 

A = Y if X else Z

>>> A = 'taip' if 'labas' else 'ne'
>>> A
'taip'
>>> A = 'taip' if '' else 'ne'
>>> A
'ne'

# Galima panaudoti žodyna, loginiame vertinime

>>> ['ne: 0', 'taip: 1'][bool('')]
'ne: 0'
>>> ['ne: 0', 'taip: 1'][bool('a')]
'taip: 1'


# Tik True reikšmių filtravimas ir sarašo

>>> L=[1,0,'test','','test3']
>>> L
[1, 0, 'test', '', 'test3']
[1, 'test', 'test3']

>>> list(filter(bool, L))
[1, 'test', 'test3']

 >>> [x for x in L if bool(x)]
[1, 'test', 'test3']

 >>> [x for x in L if x]
[1, 'test', 'test3']

# Tas pati galima atlikti su list comprehension

>>> [x for x in L if x]
[1, 'test', 'test3']


----
# Generuojamas lyginių skaičių sarašas

>>> [i for i in range(51) if i % 2 == 0]

# Tuple iteracija

>>> T = [(2,4),(6,8),(10,12)]
>>> for (x,y) in T:
    print(x,y)
  
2 4
6 8
10 12


# Žodyno iteracija, naudonat .items tuple formate

>>> D
{'b': 2, 'c': 3, 'a': 1}
>>> for key, value in D.items():
    print(key, value)
   
b 2
c 3
a 1

# Skaitymas iš dokumento po viena raide

>>> for raide in open('log.txt').read():
    print (raide, end='')

# Skaitymas iš dokumento po viena eilute

 >>> for eilute in open('log.txt').readlines():
    print (eilute, end='')

# Sarašo elementų keitimas su - for loop

>>> L
[2, 3, 4]
>>> for i in range(len(L)):
    L[i] += 1
>>> L
[3, 4, 5]

# Sarašo elementų keitimas su - while loop

>>> L = [1,2,3]
>>> i = 0
>>> while i <len(L):
    L[i] += 1
    i += 1
>>> L
[2, 3, 4]

# Sarašo elementų keitimas su list comprehension

>>> L
[2, 3, 4]
>>> [x + 1 for x in L]
[3, 4, 5]

# Dviejų sarašų reikšmių apjungimas į tuple
>>> L
[2, 3, 4]
>>> L1
['aaa', 'bbb', 'ccc', 'ddd']
>>> list(zip(L, L1))
[(2, 'aaa'), (3, 'bbb'), (4, 'ccc')]

# For ciklas naudojamas kartu su zip funkcija, kaip matome, galima atlikti aritmenius veiksmus
>>> L
[2, 3, 4]
>>> L1 = [7,8,9]
>>> for (x,y) in zip(L, L1):
    print(x, y,  '--', x+y)

   
2 7 -- 9
3 8 -- 11
4 9 -- 13

# Dviejų sarašų reikšmi sujungimas į žodyną naudojant zip ir for ciklą

>>> keys
[1, 3, 5]
>>> vals
['vienas', 'du', 'trys']

>>> D = {}
>>> for (k, v) in zip(keys, vals): D[v] = k

>>> D
{'du': 3, 'trys': 5, 'vienas': 1}
––
# Dar papraščiau tai galima atlikti iškar kuriant žodyną su dict(zip(L1,L2))

>>> D2 = dict(zip(keys, vals))
>>> keys
[1, 3, 5]
>>> vals
['vienas', 'du', 'trys']
>>> D2 = dict(zip(keys, vals))
>>> D2
{1: 'vienas', 3: 'du', 5: 'trys'}

# Dvienų sarašų sujungimas į žodyną naudojant list comprehension

>>> {k: v for (k,v) in zip(keys, vals)}
{1: 'vienas', 3: 'du', 5: 'trys'}

# Enumerate funkcija, kuri fiksuoja string buvimo vietą

>>> for (vieta, raide) in enumerate(S):
    print(raide, 'yra -', vieta, ' vietoje.')

   
z yra - 0  vietoje.
o yra - 1  vietoje.
d yra - 2  vietoje.
i yra - 3  vietoje.
s yra - 4  vietoje.




# Skaitimas iš failo su for ciklu

>>> for eilute in open('test1.py'):
    print(eilute.upper(), end='')

# f.__next__() funkcija naudojama skaityti po viena eilute 3.x, f.next() 2.x, next(nukreipimas_i_nustaityta_faila) veikia abiejose versijose

# Žodyno iteracija, kad galima būtų atlikti su sarašais ar žodynais butinai reikia priskirti iter(x)
>>> D
{'b': 2, 'a': 1, 'c': 3}
>>> I = iter(D)
>>> I
<dict_keyiterator object at 0x7f3a87561d68>
>>> next(I)
'b'
>>> next(I)
'a'
>>> next(I)
'c'
>>> next(I)

# Priešingai meta klaidos kodą

>>> next(D)
Traceback (most recent call last):
  File "<pyshell#153>", line 1, in <module>
    next(D)
TypeError: 'dict' object is not an iterator

# Kaip veikia enumerate funkcija

>>> S = 'zodis'
>>> E = enumerate(S)
>>> E
<enumerate object at 0x7f3a87564678>
>>> list(E)
[(0, 'z'), (1, 'o'), (2, 'd'), (3, 'i'), (4, 's')]
>>> next(E)
Traceback (most recent call last):
  File "<pyshell#195>", line 1, in <module>
    next(E)
StopIteration
>>> E = enumerate(S)
>>> next(E)
(0, 'z')
>>> next(E)
(1, 'o')
>>> E.__next__()
(2, 'd')


# Ieškojimas tekstiniame faile, jei pirmas simbolis atitinka raidei 'i', ta eilute atspausdinama, galima ieškoti paskutinio simbolio su x[-1]

[x.rstrip() for x in open('test1.py') if x[0] == 'i']

# Sarašų ciklą galima generuoti sutrumpinta forma, pavyzdyje kiekvienam x nariui priskirami visi y nariai.

>>> [(x, y) for x in '123' for y in 'abc']
[('1', 'a'), ('1', 'b'), ('1', 'c'), ('2', 'a'), ('2', 'b'), ('2', 'c'), ('3', 'a'), ('3', 'b'), ('3', 'c')]

# Failus galima iškart pateikti saraše, rušiuoti enumeruoti, sujungti, priskirti kintamuosius, logiškai patikrinti

sorted(open('test1.py'))
list(open('test1.py'))
tuple(open('test1.py'))
list(enumerate(open('test1.py')))
list(filter(bool, open('test1.py')))
'--'.join(open('test1.py'))
a, *b = open('test1.py')
aaa' in list(open('test1.py'))
L[:0] = [list(open('test1.py'))[0]]

>>> len(list(open('test1.py')))
8
>>> q,w,e,r,t,y,u,p = open('test1.py')

# Failo iteracija kai rezultatas žodyne

>>> set(open('test1.py')
>>> {x for x in open('test1.py')}



# Žodyno rušiavimas

>>> D
{'b': 2, 'a': 1, 'c': 3}
>>> for k in sorted(D): print(k, D[k])

a 1
b 2
c 3



# Kaip sužinoti python interpretatoriaus versiją?

>> import sys
>> sys.version
'2.7.3 (default, Apr 10 2012, 23:31:26)


# Kaip pažiūrėti kokie yra importuoti moduliai ir koks yra modulio turinys?

>>> dir ()
['__builtins__', '__doc__', '__name__', '__package__', 'math'] 
>>> import math
>>> dir (math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']


#  Kaip sužinoti ką daro funkcija?
>>> S
'labas'
>>> help(S.isalpha)

Strings

# Keičiami ryšiai tarp raidžių
>>> S
'Zodis'
>>> ' '.join(S)
'Z o d i s'
 
# Atskirų simbolių atvaizdavimas S[1:] nurodo S[1:len(S)]
 >>> S[1]
'o'
>>> S[1:]
'odis'



# Paieška (-1) reikia, kad tokios raidės nėra, kitu atveju atspausdina pirma raidės numeri, kuriame randama raidė.
>>> S
'Zodis'
>>> S.find('p')
-1
>>> S.find('Z')
0
>>> S.find('o')
1
>>> S.find('Zo')
0

# Simbolių keitimas

>>> S
'Zodis'
>>> S.replace('odis', 'irkles')
'Zirkles'
>>> S
'Zodis'

# Kaip atskirti pagal bendrą simbolį

>>> Skaiciai
'Vienas,du,trys,keturi'
>>> Skaiciai.split(',')
['Vienas', 'du', 'trys', 'keturi']


# Atvaizdavimas tekste
>>> '%s, eggs, and %s' % ('spam', 'SPAM!')
'spam, eggs, and SPAM!

>>> '{0}, eggs, and {1}'.format('spam', 'SPAM!')
'spam, eggs, and SPAM!'

>>> '{}, eggs, and {}'.format('spam', 'SPAM!')
'spam, eggs, and SPAM!'

 Lists

# Pridėjimas/ištraukimas iš sarašo append/pop

>>> Sarasas = ['Zeme', 2014, 'Jupiteris']
>>> Sarasas.append('Indraja')
>>> Sarasas
['Zeme', 2014, 'Jupiteris', 'Indraja']
>>> Sarasas.pop(1)
2014
>>> Sarasas
['Zeme', 'Jupiteris', 'Indraja']


# Kaip iš M sarašo ištraukti, visus pirmus narius
>>> M =[ [1,2,3], [4,5,6], [7,8,9] ]
>>> col2 = [row[0] for row in M]
>>> col2
[1, 4, 7]



# Kiekvieną narį pakelia kvadratu

>>> [row[0] ** 2 for row in M]
[1, 16, 49]

NetBios

GNU/Linux

# nbtscan reikia aptisiųsti komanda [sudo apt-get install nbtscan]
nbtscan 192.168.1.1-254

Doing NBT name scan for addresses from 192.168.1.1-254

IP address       NetBIOS Name     Server    User             MAC address     
------------------------------------------------------------------------------
192.168.1.68     NPI781027                  <unknown>        00:00:00:00:00:00
192.168.1.65     MINI-PC2         <server>  <unknown>        00:1c:bf:2d:cc:12

# Nmap komanda randanti OS, kompiuterio pavadinimą, NetBIOS, WorkGroup

nmap --script smb-os-discovery -p 445 192.168.1.1-254

Nmap scan report for 192.168.1.2
Host is up (0.025s latency).
PORT    STATE SERVICE
445/tcp open  microsoft-ds

Host script results:
| smb-os-discovery:
|   OS: Windows 7 Ultimate 7601 Service Pack 1 (Windows 7 Ultimate 6.1)
|   OS CPE: cpe:/o:microsoft:windows_7::sp1
|   NetBIOS computer name: User
|   Workgroup: WORKGROUP
|_  System time: 2014-07-04T11:48:10+03:00






# Panašiam rezultatui galima naudoti -sC parametrą
sudo nmap  -sC 192.168.1.x

# Parodis detalia kiekvieno kompiuterio informaciją, kokiai darbo grupei priklauso, kartu su serviso tipu
nbtscan -v 192.168.1.1-254

NetBIOS Name Table for Host 192.168.1.65:

Incomplete packet, 173 bytes long.
Name             Service          Type           
----------------------------------------
MINI-PC2         <00>             UNIQUE
MINI-PC2         <20>             UNIQUE
WORKGROUP        <00>              GROUP
WORKGROUP        <1e>              GROUP



Windows

# NetBIOS lentele su id kodais
nbtstat -a [net-bios-name]

# Rodis lokalias NetBIOS lentelę
nbtstat -n [net-bios-name]

# Rodis netbios kompiuterio cache, kur vardas yra susietas su ip adresu
nbtstat -c

# Atnaujina NetBIOS registruotus kompiuterio/ištrina ir pilnai atnaujina lentelę
nbtstat -RR
nbtstat -R


Literatūra:
http://www.hildrum.com/nbtstat.htm  - Bazines nbtstat komandos
https://pentestlab.wordpress.com/tag/nbtstat/ - nbtscan GNU/linux platformoms aprašymas
http://www.windowsnetworking.com/kbase/WindowsTips/WindowsNT/AdminTips/Utilities/Nbtstatrevealswhoisloggedon.html - Čia galima rasti NetBIOS reikšmes

Maršrutų lentelės

Windows:

# Atspausdina visą maršrutų lentelę
route print

# Atspausdina visas lenteles su 192.* adresasais
route  print 192.*  

# /p reikškia persisten route, lentelė bus įrašyta prie persistent routes laukelio
route add /p 0.0.0.0 mask 0.0.0.0 192.168.1.254 metric 1

# Komandos
route add
route change
route delete
route print

 # Persistent routes saugomi registruose :
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\PersistentRoutes



Literatūra:

http://www.allscoop.com/how-to-move-persistent-route-table-to-a-new-computer.php



Gnu/Linux:
Komanda 'route' arba 'netstat -r' atspausdina Kernel IP routing tables